KiCad PCB EDA Suite
PNS::DIFF_PAIR_PLACER Class Reference

Class LINE_PLACER. More...

#include <pns_diff_pair_placer.h>

Inheritance diagram for PNS::DIFF_PAIR_PLACER:
PNS::PLACEMENT_ALGO PNS::ALGO_BASE

Public Member Functions

 DIFF_PAIR_PLACER (ROUTER *aRouter)
 
 ~DIFF_PAIR_PLACER ()
 
bool Start (const VECTOR2I &aP, ITEM *aStartItem) override
 Function Start() More...
 
bool Move (const VECTOR2I &aP, ITEM *aEndItem) override
 Function Move() More...
 
bool FixRoute (const VECTOR2I &aP, ITEM *aEndItem, bool aForceFinish) override
 Function FixRoute() More...
 
bool ToggleVia (bool aEnabled) override
 Function ToggleVia() More...
 
bool SetLayer (int aLayer) override
 Function SetLayer() 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...
 
NODECurrentNode (bool aLoopsRemoved=false) const override
 Function CurrentNode() More...
 
void FlipPosture () override
 Function FlipPosture() More...
 
void UpdateSizes (const SIZES_SETTINGS &aSizes) override
 Function UpdateSizes() More...
 
bool IsPlacingVia () const override
 Function IsPlacingVia() More...
 
void SetOrthoMode (bool aOrthoMode) override
 Function SetOrthoMode() More...
 
void GetModifiedNets (std::vector< int > &aNets) const override
 Function GetModifiedNets. More...
 
ROUTERRouter () const
 

Returns the instance of our router

More...
 
ROUTING_SETTINGSSettings () const
 

Returns current router settings

More...
 
virtual LOGGERLogger ()
 

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

More...
 
void SetDebugDecorator (DEBUG_DECORATOR *aDecorator)
 Function SetDebugDecorator. More...
 
DEBUG_DECORATORDbg () const
 

Private Types

enum  State { RT_START = 0, RT_ROUTE = 1, RT_FINISH = 2 }
 

Private Member Functions

int viaGap () const
 
int gap () const
 
bool route (const VECTOR2I &aP)
 Function route() More...
 
void updateLeadingRatLine ()
 Function updateLeadingRatLine() More...
 
void setWorld (NODE *aWorld)
 Function setWorld() More...
 
void initPlacement ()
 Function startPlacement() More...
 
void setInitialDirection (const DIRECTION_45 &aDirection)
 Function setInitialDirection() More...
 
bool routeHead (const VECTOR2I &aP)
 
bool tryWalkDp (NODE *aNode, DIFF_PAIR &aPair, bool aSolidsOnly)
 
bool rhWalkOnly (const VECTOR2I &aP)
 

route step, walkaround mode

More...
 
bool rhShoveOnly (const VECTOR2I &aP)
 

route step, shove mode

More...
 
bool rhMarkObstacles (const VECTOR2I &aP)
 

route step, mark obstacles mode

More...
 
const VIA makeVia (const VECTOR2I &aP, int aNet)
 
bool findDpPrimitivePair (const VECTOR2I &aP, ITEM *aItem, DP_PRIMITIVE_PAIR &aPair, wxString *aErrorMsg=nullptr)
 
OPT_VECTOR2I getDanglingAnchor (NODE *aNode, ITEM *aItem)
 
bool attemptWalk (NODE *aNode, DIFF_PAIR *aCurrent, DIFF_PAIR &aWalk, bool aPFirst, bool aWindCw, bool aSolidsOnly)
 
bool propagateDpHeadForces (const VECTOR2I &aP, VECTOR2I &aNewP)
 

Private Attributes

State m_state
 
bool m_chainedPlacement
 
bool m_initialDiagonal
 
bool m_startDiagonal
 
bool m_fitOk
 
int m_netP
 
int m_netN
 
DP_PRIMITIVE_PAIR m_start
 
OPT< DP_PRIMITIVE_PAIRm_prevPair
 
int m_iteration
 

current algorithm iteration

More...
 
NODEm_world
 

pointer to world to search colliding items

More...
 
VECTOR2I m_p_start
 

current routing start point (end of tail, beginning of head)

More...
 
SHOVEm_shove
 

The shove engine

More...
 
NODEm_currentNode
 

Current world state

More...
 
NODEm_lastNode
 

Postprocessed world state (including marked collisions & removed loops)

More...
 
SIZES_SETTINGS m_sizes
 
bool m_placingVia
 

Are we placing a via?

More...
 
int m_viaDiameter
 

current via diameter

More...
 
int m_viaDrill
 

current via drill

More...
 
int m_currentWidth
 

current track width

More...
 
int m_currentNet
 
int m_currentLayer
 
bool m_startsOnVia
 
bool m_orthoMode
 
bool m_snapOnTarget
 
VECTOR2I m_currentEnd
 
VECTOR2I m_currentStart
 
DIFF_PAIR m_currentTrace
 
ITEMm_currentEndItem
 
PNS_MODE m_currentMode
 
bool m_idle
 

Detailed Description

Class LINE_PLACER.

Single track placement algorithm. Interactively routes a track. Applies shove and walkaround algorithms when needed.

Definition at line 55 of file pns_diff_pair_placer.h.

Member Enumeration Documentation

Enumerator
RT_START 
RT_ROUTE 
RT_FINISH 

Definition at line 234 of file pns_diff_pair_placer.h.

Constructor & Destructor Documentation

PNS::DIFF_PAIR_PLACER::DIFF_PAIR_PLACER ( ROUTER aRouter)

Definition at line 38 of file pns_diff_pair_placer.cpp.

References m_chainedPlacement, m_currentEndItem, m_currentLayer, m_currentMode, m_currentNet, m_currentNode, m_currentWidth, m_fitOk, m_idle, m_initialDiagonal, m_iteration, m_lastNode, m_netN, m_netP, m_orthoMode, m_placingVia, m_shove, m_snapOnTarget, m_startDiagonal, m_startsOnVia, m_state, m_viaDiameter, m_viaDrill, m_world, PNS::RM_MarkObstacles, and RT_START.

38  :
39  PLACEMENT_ALGO( aRouter )
40 {
41  m_state = RT_START;
42  m_chainedPlacement = false;
43  m_initialDiagonal = false;
44  m_startDiagonal = false;
45  m_fitOk = false;
46  m_netP = 0;
47  m_netN = 0;
48  m_iteration = 0;
49  m_world = NULL;
50  m_shove = NULL;
51  m_currentNode = NULL;
52  m_lastNode = NULL;
53  m_placingVia = false;
54  m_viaDiameter = 0;
55  m_viaDrill = 0;
56  m_currentWidth = 0;
57  m_currentNet = 0;
58  m_currentLayer = 0;
59  m_startsOnVia = false;
60  m_orthoMode = false;
61  m_snapOnTarget = false;
62  m_currentEndItem = NULL;
64  m_idle = true;
65 }
int m_iteration
current algorithm iteration
SHOVE * m_shove
The shove engine
int m_viaDiameter
current via diameter
NODE * m_world
pointer to world to search colliding items
int m_viaDrill
current via drill
bool m_placingVia
Are we placing a via?
NODE * m_currentNode
Current world state
PLACEMENT_ALGO(ROUTER *aRouter)
int m_currentWidth
current track width
NODE * m_lastNode
Postprocessed world state (including marked collisions & removed loops)
PNS::DIFF_PAIR_PLACER::~DIFF_PAIR_PLACER ( )

Definition at line 67 of file pns_diff_pair_placer.cpp.

References m_shove.

68 {
69  if( m_shove )
70  delete m_shove;
71 }
SHOVE * m_shove
The shove engine

Member Function Documentation

bool PNS::DIFF_PAIR_PLACER::attemptWalk ( NODE aNode,
DIFF_PAIR aCurrent,
DIFF_PAIR aWalk,
bool  aPFirst,
bool  aWindCw,
bool  aSolidsOnly 
)
private

Definition at line 161 of file pns_diff_pair_placer.cpp.

References PNS::ITEM::ANY_T, PNS::NODE::CheckColliding(), PNS::LINE::CLine(), PNS::DIFF_PAIR::CN(), PNS::DIFF_PAIR::CP(), PNS::WALKAROUND::DONE, PNS::SHOVE::ForceClearance(), PNS::DIFF_PAIR::Gap(), PNS::LINE::Line(), PNS::DIFF_PAIR::NLine(), PNS::DIFF_PAIR::PLine(), PNS_HULL_MARGIN, PNS::SHOVE::ProcessSingleLine(), PNS::WALKAROUND::Route(), PNS::ALGO_BASE::Router(), PNS::WALKAROUND::SetIterationLimit(), PNS::DIFF_PAIR::SetShape(), PNS::WALKAROUND::SetSolidsOnly(), PNS::ALGO_BASE::Settings(), PNS::SHOVE::SH_OK, SHAPE_LINE_CHAIN::Simplify(), and PNS::ITEM::SOLID_T.

Referenced by IsPlacingVia(), and tryWalkDp().

163 {
164  WALKAROUND walkaround( aNode, Router() );
166 
167  walkaround.SetSolidsOnly( aSolidsOnly );
168  walkaround.SetIterationLimit( Settings().WalkaroundIterationLimit() );
169 
170  SHOVE shove( aNode, Router() );
171  LINE walkP, walkN;
172 
173  aWalk = *aCurrent;
174 
175  int iter = 0;
176 
177  DIFF_PAIR cur( *aCurrent );
178 
179  bool currentIsP = aPFirst;
180 
181  int mask = aSolidsOnly ? ITEM::SOLID_T : ITEM::ANY_T;
182 
183  do
184  {
185  LINE preWalk = ( currentIsP ? cur.PLine() : cur.NLine() );
186  LINE preShove = ( currentIsP ? cur.NLine() : cur.PLine() );
187  LINE postWalk;
188 
189  if( !aNode->CheckColliding ( &preWalk, mask ) )
190  {
191  currentIsP = !currentIsP;
192 
193  if( !aNode->CheckColliding( &preShove, mask ) )
194  break;
195  else
196  continue;
197  }
198 
199  wf1 = walkaround.Route( preWalk, postWalk, false );
200 
201  if( wf1 != WALKAROUND::DONE )
202  return false;
203 
204  LINE postShove( preShove );
205 
206  shove.ForceClearance( true, cur.Gap() - 2 * PNS_HULL_MARGIN );
207 
209 
210  sh1 = shove.ProcessSingleLine( postWalk, preShove, postShove );
211 
212  if( sh1 != SHOVE::SH_OK )
213  return false;
214 
215  postWalk.Line().Simplify();
216  postShove.Line().Simplify();
217 
218  cur.SetShape( postWalk.CLine(), postShove.CLine(), !currentIsP );
219 
220  currentIsP = !currentIsP;
221 
222  if( !aNode->CheckColliding( &postShove, mask ) )
223  break;
224 
225  iter++;
226  }
227  while( iter < 3 );
228 
229  if( iter == 3 )
230  return false;
231 
232  aWalk.SetShape( cur.CP(), cur.CN() );
233 
234  return true;
235 }
#define PNS_HULL_MARGIN
Class LINE.
Definition: pns_line.h:58
ROUTING_SETTINGS & Settings() const
Returns current router settings
ROUTER * Router() const
Returns the instance of our router
Definition: pns_algo_base.h:49
const VECTOR2I& PNS::DIFF_PAIR_PLACER::CurrentEnd ( ) const
inlineoverridevirtual

Function CurrentEnd()

Returns the current end of the line being placed. It may not be equal to the cursor position due to collisions.

Implements PNS::PLACEMENT_ALGO.

Definition at line 116 of file pns_diff_pair_placer.h.

References CurrentNets(), and m_currentEnd.

117  {
118  return m_currentEnd;
119  }
int PNS::DIFF_PAIR_PLACER::CurrentLayer ( ) const
inlineoverridevirtual

Function CurrentLayer()

Returns the layer of currently routed track.

Implements PNS::PLACEMENT_ALGO.

Definition at line 133 of file pns_diff_pair_placer.h.

References CurrentNode(), FlipPosture(), m_currentLayer, and UpdateSizes().

134  {
135  return m_currentLayer;
136  }
const std::vector< int > PNS::DIFF_PAIR_PLACER::CurrentNets ( ) const
overridevirtual

Function CurrentNets()

Returns the net code of currently routed track.

Implements PNS::PLACEMENT_ALGO.

Definition at line 833 of file pns_diff_pair_placer.cpp.

References m_netN, and m_netP.

Referenced by CurrentEnd().

834 {
835  std::vector<int> rv;
836  rv.push_back( m_netP );
837  rv.push_back( m_netN );
838  return rv;
839 }
NODE * PNS::DIFF_PAIR_PLACER::CurrentNode ( bool  aLoopsRemoved = false) const
overridevirtual

Function CurrentNode()

Returns the most recent world state.

Implements PNS::PLACEMENT_ALGO.

Definition at line 372 of file pns_diff_pair_placer.cpp.

References m_currentNode, and m_lastNode.

Referenced by CurrentLayer().

373 {
374  if( m_lastNode )
375  return m_lastNode;
376 
377  return m_currentNode;
378 }
NODE * m_currentNode
Current world state
NODE * m_lastNode
Postprocessed world state (including marked collisions & removed loops)
bool PNS::DIFF_PAIR_PLACER::findDpPrimitivePair ( const VECTOR2I aP,
ITEM aItem,
DP_PRIMITIVE_PAIR aPair,
wxString *  aErrorMsg = nullptr 
)
private

Definition at line 437 of file pns_diff_pair_placer.cpp.

References PNS::NODE::AllItemsInNet(), dist, PNS::RULE_RESOLVER::DpNetPair(), EuclideanNorm(), Format(), getDanglingAnchor(), PNS::NODE::GetRuleResolver(), PNS::ITEM::Kind(), PNS::ITEM::Layers(), m_currentNode, m_world, max, PNS::ITEM::Net(), PNS::RULE_RESOLVER::NetName(), PNS::DP_PRIMITIVE_PAIR::SetAnchors(), and PNS::ITEM::SOLID_T.

Referenced by IsPlacingVia(), routeHead(), and Start().

439 {
440  int netP, netN;
441 
442  wxLogTrace( "PNS", "world %p", m_world );
443 
444  bool result = m_world->GetRuleResolver()->DpNetPair( aItem, netP, netN );
445 
446  if( !result )
447  {
448  if( aErrorMsg )
449  {
450  *aErrorMsg = _( "Unable to find complementary differential pair "
451  "nets. Make sure the names of the nets belonging "
452  "to a differential pair end with either _N/_P or +/-." );
453  }
454  return false;
455  }
456 
457  int refNet = aItem->Net();
458  int coupledNet = ( refNet == netP ) ? netN : netP;
459 
460  wxLogTrace( "PNS", "result %d", !!result );
461 
462  OPT_VECTOR2I refAnchor = getDanglingAnchor( m_currentNode, aItem );
463  ITEM* primRef = aItem;
464 
465  wxLogTrace( "PNS", "refAnchor %p", aItem );
466 
467  if( !refAnchor )
468  {
469  if( aErrorMsg )
470  {
471  *aErrorMsg = _( "Can't find a suitable starting point. If starting "
472  "from an existing differential pair make sure you are "
473  "at the end. " );
474  }
475  return false;
476  }
477 
478  std::set<ITEM*> coupledItems;
479 
480  m_currentNode->AllItemsInNet( coupledNet, coupledItems );
481  double bestDist = std::numeric_limits<double>::max();
482  bool found = false;
483 
484  for( ITEM* item : coupledItems )
485  {
486  if( item->Kind() == aItem->Kind() )
487  {
488  OPT_VECTOR2I anchor = getDanglingAnchor( m_currentNode, item );
489  if( !anchor )
490  continue;
491 
492  double dist = ( *anchor - *refAnchor ).EuclideanNorm();
493 
494  bool shapeMatches = true;
495 
496  if( item->OfKind( ITEM::SOLID_T ) && item->Layers() != aItem->Layers() )
497  {
498  shapeMatches = false;
499  }
500 
501  if( dist < bestDist && shapeMatches )
502  {
503  found = true;
504  bestDist = dist;
505 
506  if( refNet == netP )
507  {
508  aPair = DP_PRIMITIVE_PAIR ( item, primRef );
509  aPair.SetAnchors( *anchor, *refAnchor );
510  }
511  else
512  {
513  aPair = DP_PRIMITIVE_PAIR( primRef, item );
514  aPair.SetAnchors( *refAnchor, *anchor );
515  }
516  }
517  }
518  }
519 
520  if( !found )
521  {
522  if( aErrorMsg )
523  {
524  *aErrorMsg = wxString::Format( _( "Can't find a suitable starting point "
525  "for coupled net \"%s\"." ),
526  m_world->GetRuleResolver()->NetName( coupledNet ) );
527  }
528  return false;
529  }
530 
531  return true;
532 }
double EuclideanNorm(const wxPoint &vector)
Euclidean norm of a 2D vector.
Definition: trigo.h:112
void AllItemsInNet(int aNet, std::set< ITEM * > &aItems)
Definition: pns_node.cpp:1234
static const int dist[10][10]
Definition: dist.cpp:57
NODE * m_world
pointer to world to search colliding items
OPT< VECTOR2I > OPT_VECTOR2I
Definition: seg.h:34
virtual bool DpNetPair(ITEM *aItem, int &aNetP, int &aNetN)=0
NODE * m_currentNode
Current world state
RULE_RESOLVER * GetRuleResolver()
Definition: pns_node.h:167
void Format(OUTPUTFORMATTER *out, int aNestLevel, int aCtl, CPTREE &aTree)
Function Format outputs a PTREE into s-expression format via an OUTPUTFORMATTER derivative.
Definition: ptree.cpp:205
#define max(a, b)
Definition: auxiliary.h:86
virtual wxString NetName(int aNet)=0
OPT_VECTOR2I getDanglingAnchor(NODE *aNode, ITEM *aItem)
bool PNS::DIFF_PAIR_PLACER::FixRoute ( const VECTOR2I aP,
ITEM aEndItem,
bool  aForceFinish 
)
overridevirtual

Function FixRoute()

Commits 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 commited. May return false if the routing result is violating design rules - in such case, the track is only committed if Settings.CanViolateDRC() is on.

Implements PNS::PLACEMENT_ALGO.

Definition at line 741 of file pns_diff_pair_placer.cpp.

References PNS::NODE::Add(), PNS::Clone(), PNS::DIFF_PAIR::CN(), PNS::ROUTER::CommitRouting(), PNS::DIFF_PAIR::CP(), SHAPE_LINE_CHAIN::CSegment(), PNS::DIFF_PAIR::EndingPrimitives(), PNS::DIFF_PAIR::EndsWithVias(), initPlacement(), m_chainedPlacement, m_currentTrace, m_fitOk, m_idle, m_initialDiagonal, m_lastNode, m_placingVia, m_prevPair, m_snapOnTarget, PNS::DIFF_PAIR::NLine(), PNS::DIFF_PAIR::PLine(), SHAPE_LINE_CHAIN::Remove(), PNS::ALGO_BASE::Router(), SHAPE_LINE_CHAIN::SegmentCount(), PNS::DIFF_PAIR::SetShape(), PNS::TOPOLOGY::SimplifyLine(), and PNS::LINE::Via().

742 {
743  if( !m_fitOk )
744  return false;
745 
746  if( m_currentTrace.CP().SegmentCount() < 1 ||
747  m_currentTrace.CN().SegmentCount() < 1 )
748  return false;
749 
750  if( m_currentTrace.CP().SegmentCount() > 1 )
751  m_initialDiagonal = !DIRECTION_45( m_currentTrace.CP().CSegment( -2 ) ).IsDiagonal();
752 
753  TOPOLOGY topo( m_lastNode );
754 
755  if( !m_snapOnTarget && !m_currentTrace.EndsWithVias() && !aForceFinish )
756  {
759 
760  if( newP.SegmentCount() > 1 && newN.SegmentCount() > 1 )
761  {
762  newP.Remove( -1, -1 );
763  newN.Remove( -1, -1 );
764  }
765 
766  m_currentTrace.SetShape( newP, newN );
767  }
768 
770  {
773  m_chainedPlacement = false;
774  }
775  else
776  {
777  m_chainedPlacement = !m_snapOnTarget && !aForceFinish;
778  }
779 
780  LINE lineP( m_currentTrace.PLine() );
781  LINE lineN( m_currentTrace.NLine() );
782 
783  m_lastNode->Add( lineP );
784  m_lastNode->Add( lineN );
785 
786  topo.SimplifyLine( &lineP );
787  topo.SimplifyLine( &lineN );
788 
790 
792 
793  m_lastNode = NULL;
794  m_placingVia = false;
795 
796  if( m_snapOnTarget || aForceFinish )
797  {
798  m_idle = true;
799  return true;
800  }
801  else
802  {
803  initPlacement();
804  return false;
805  }
806 }
const VIA & Via() const
Definition: pns_line.h:253
void SetShape(const SHAPE_LINE_CHAIN &aP, const SHAPE_LINE_CHAIN &aN, bool aSwapLanes=false)
const SHAPE_LINE_CHAIN & CN() const
const SEG CSegment(int aIndex) const
Function CSegment()
Class DIRECTION_45.
Definition: direction45.h:36
bool EndsWithVias() const
bool m_placingVia
Are we placing a via?
void Remove(int aStartIndex, int aEndIndex)
Function Remove()
ROUTER * Router() const
Returns the instance of our router
Definition: pns_algo_base.h:49
std::unique_ptr< typename std::remove_const< T >::type > Clone(const T &aItem)
Definition: pns_item.h:380
void CommitRouting(NODE *aNode)
Definition: pns_router.cpp:347
Class SHAPE_LINE_CHAIN.
void initPlacement()
Function startPlacement()
OPT< DP_PRIMITIVE_PAIR > m_prevPair
bool Add(std::unique_ptr< SEGMENT > aSegment, bool aAllowRedundant=false)
Function Add()
Definition: pns_node.cpp:594
int SegmentCount() const
Function SegmentCount()
DP_PRIMITIVE_PAIR EndingPrimitives()
const SHAPE_LINE_CHAIN & CP() const
NODE * m_lastNode
Postprocessed world state (including marked collisions & removed loops)
void PNS::DIFF_PAIR_PLACER::FlipPosture ( )
overridevirtual

Function FlipPosture()

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

Reimplemented from PNS::PLACEMENT_ALGO.

Definition at line 363 of file pns_diff_pair_placer.cpp.

References m_currentEnd, m_idle, m_startDiagonal, and Move().

Referenced by CurrentLayer().

364 {
366 
367  if( !m_idle )
368  Move( m_currentEnd, NULL );
369 }
bool Move(const VECTOR2I &aP, ITEM *aEndItem) override
Function Move()
int PNS::DIFF_PAIR_PLACER::gap ( ) const
private
OPT_VECTOR2I PNS::DIFF_PAIR_PLACER::getDanglingAnchor ( NODE aNode,
ITEM aItem 
)
private

Definition at line 406 of file pns_diff_pair_placer.cpp.

References SEG::A, PNS::ITEM::Anchor(), SEG::B, PNS::NODE::FindJoint(), PNS::ITEM::Kind(), PNS::JOINT::LinkCount(), PNS::SEGMENT::Seg(), PNS::ITEM::SEGMENT_T, PNS::ITEM::SOLID_T, and PNS::ITEM::VIA_T.

Referenced by findDpPrimitivePair(), and IsPlacingVia().

407 {
408  switch( aItem->Kind() )
409  {
410  case ITEM::VIA_T:
411  case ITEM::SOLID_T:
412  return aItem->Anchor( 0 );
413 
414  case ITEM::SEGMENT_T:
415  {
416  SEGMENT* s =static_cast<SEGMENT*>( aItem );
417 
418  JOINT* jA = aNode->FindJoint( s->Seg().A, s );
419  JOINT* jB = aNode->FindJoint( s->Seg().B, s );
420 
421  if( jA->LinkCount() == 1 )
422  return s->Seg().A;
423  else if( jB->LinkCount() == 1 )
424  return s->Seg().B;
425  else
426  return OPT_VECTOR2I();
427  }
428 
429  default:
430  return OPT_VECTOR2I();
431  break;
432  }
433 }
OPT< VECTOR2I > OPT_VECTOR2I
Definition: seg.h:34
void PNS::DIFF_PAIR_PLACER::GetModifiedNets ( std::vector< int > &  aNets) const
overridevirtual

Function GetModifiedNets.

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

Reimplemented from PNS::PLACEMENT_ALGO.

Definition at line 809 of file pns_diff_pair_placer.cpp.

References m_netN, and m_netP.

Referenced by IsPlacingVia().

810 {
811  aNets.push_back( m_netP );
812  aNets.push_back( m_netN );
813 }
void PNS::DIFF_PAIR_PLACER::initPlacement ( )
private

Function startPlacement()

Initializes placement of a new line with given parameters.

Definition at line 604 of file pns_diff_pair_placer.cpp.

References PNS::NODE::Branch(), PNS::ROUTER::GetWorld(), PNS::NODE::KillChildren(), m_currentEndItem, m_currentMode, m_currentNode, m_idle, m_initialDiagonal, m_lastNode, m_orthoMode, m_shove, m_startDiagonal, PNS::ROUTING_SETTINGS::Mode(), PNS::RM_Shove, PNS::RM_Smart, PNS::ALGO_BASE::Router(), PNS::ALGO_BASE::Settings(), and setWorld().

Referenced by FixRoute(), IsPlacingVia(), SetLayer(), Start(), and UpdateSizes().

605 {
606  m_idle = false;
607  m_orthoMode = false;
608  m_currentEndItem = NULL;
610 
611  NODE* world = Router()->GetWorld();
612 
613  world->KillChildren();
614  NODE* rootNode = world->Branch();
615 
616  setWorld( rootNode );
617 
618  m_lastNode = NULL;
619  m_currentNode = rootNode;
621 
622  if( m_shove )
623  delete m_shove;
624 
625  m_shove = NULL;
626 
628  {
629  m_shove = new SHOVE( m_currentNode, Router() );
630  }
631 }
PNS_MODE Mode() const
Returns the routing mode.
Ignore collisions, mark obstacles
SHOVE * m_shove
The shove engine
ROUTING_SETTINGS & Settings() const
Returns current router settings
NODE * GetWorld() const
Definition: pns_router.h:143
void KillChildren()
Destroys all child nodes. Applicable only to the root node.
Definition: pns_node.cpp:1227
ROUTER * Router() const
Returns the instance of our router
Definition: pns_algo_base.h:49
Only walkaround
NODE * m_currentNode
Current world state
void setWorld(NODE *aWorld)
Function setWorld()
NODE * m_lastNode
Postprocessed world state (including marked collisions & removed loops)
bool PNS::DIFF_PAIR_PLACER::IsPlacingVia ( ) const
inlineoverridevirtual
LOGGER * PNS::ALGO_BASE::Logger ( )
virtualinherited

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

Reimplemented in PNS::LINE_PLACER, PNS::WALKAROUND, PNS::DRAGGER, and PNS::SHOVE.

Definition at line 34 of file pns_algo_base.cpp.

Referenced by PNS::ALGO_BASE::Router().

35 {
36  return NULL;
37 }
const VIA PNS::DIFF_PAIR_PLACER::makeVia ( const VECTOR2I aP,
int  aNet 
)
private

Definition at line 79 of file pns_diff_pair_placer.cpp.

References PNS::SIZES_SETTINGS::GetLayerBottom(), PNS::SIZES_SETTINGS::GetLayerTop(), m_sizes, PNS::ITEM::SetNet(), PNS::SIZES_SETTINGS::ViaDiameter(), PNS::SIZES_SETTINGS::ViaDrill(), and PNS::SIZES_SETTINGS::ViaType().

Referenced by IsPlacingVia(), propagateDpHeadForces(), and routeHead().

80 {
82 
83  VIA v( aP, layers, m_sizes.ViaDiameter(), m_sizes.ViaDrill(), -1, m_sizes.ViaType() );
84  v.SetNet( aNet );
85 
86  return v;
87 }
VIATYPE_T ViaType() const
void SetNet(NETINFO_ITEM *aNetInfo)
Function SetNet Sets a NET_INFO object for the item.
Class LAYER_RANGE.
Definition: pns_layerset.h:32
bool PNS::DIFF_PAIR_PLACER::Move ( const VECTOR2I aP,
ITEM aEndItem 
)
overridevirtual

Function Move()

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

Implements PNS::PLACEMENT_ALGO.

Definition at line 706 of file pns_diff_pair_placer.cpp.

References PNS::NODE::Branch(), m_currentEnd, m_currentEndItem, m_currentNode, m_fitOk, m_lastNode, route(), and updateLeadingRatLine().

Referenced by FlipPosture(), SetLayer(), SetOrthoMode(), ToggleVia(), and UpdateSizes().

707 {
708  m_currentEndItem = aEndItem;
709  m_fitOk = false;
710 
711  delete m_lastNode;
712  m_lastNode = NULL;
713 
714  if( !route( aP ) )
715  return false;
716 
717  NODE* latestNode = m_currentNode;
718  m_lastNode = latestNode->Branch();
719 
720  assert( m_lastNode != NULL );
721  m_currentEnd = aP;
722 
724 
725  return true;
726 }
bool route(const VECTOR2I &aP)
Function route()
NODE * Branch()
Function Branch()
Definition: pns_node.cpp:107
NODE * m_currentNode
Current world state
void updateLeadingRatLine()
Function updateLeadingRatLine()
NODE * m_lastNode
Postprocessed world state (including marked collisions & removed loops)
bool PNS::DIFF_PAIR_PLACER::propagateDpHeadForces ( const VECTOR2I aP,
VECTOR2I aNewP 
)
private

Definition at line 124 of file pns_diff_pair_placer.cpp.

References PNS::VIA::Diameter(), PNS::SIZES_SETTINGS::DiffPairGap(), m_currentLayer, m_currentMode, m_currentNode, m_placingVia, m_sizes, makeVia(), PNS::VIA::PushoutForce(), PNS::RM_MarkObstacles, PNS::RM_Walkaround, PNS::VIA::SetDiameter(), PNS::ITEM::SetLayer(), PNS::SIZES_SETTINGS::TrackWidth(), and viaGap().

Referenced by IsPlacingVia(), and routeHead().

125 {
126  VIA virtHead = makeVia( aP, -1 );
127 
128  if( m_placingVia )
129  virtHead.SetDiameter( viaGap() + 2 * virtHead.Diameter() );
130  else
131  {
132  virtHead.SetLayer( m_currentLayer );
133  virtHead.SetDiameter( m_sizes.DiffPairGap() + 2 * m_sizes.TrackWidth() );
134  }
135 
136  VECTOR2I lead( 0, 0 );// = aP - m_currentStart ;
137  VECTOR2I force;
138  bool solidsOnly = true;
139 
141  {
142  aNewP = aP;
143  return true;
144  }
145  else if( m_currentMode == RM_Walkaround )
146  {
147  solidsOnly = false;
148  }
149 
150  // fixme: I'm too lazy to do it well. Circular approximaton will do for the moment.
151  if( virtHead.PushoutForce( m_currentNode, lead, force, solidsOnly, 40 ) )
152  {
153  aNewP = aP + force;
154  return true;
155  }
156 
157  return false;
158 }
virtual void SetLayer(PCB_LAYER_ID aLayer)
Function SetLayer sets the layer this item is on.
const VIA makeVia(const VECTOR2I &aP, int aNet)
bool m_placingVia
Are we placing a via?
NODE * m_currentNode
Current world state
bool PNS::DIFF_PAIR_PLACER::rhMarkObstacles ( const VECTOR2I aP)
private

route step, mark obstacles mode

Definition at line 110 of file pns_diff_pair_placer.cpp.

References PNS::NODE::CheckColliding(), m_currentNode, m_currentTrace, m_fitOk, PNS::DIFF_PAIR::NLine(), PNS::DIFF_PAIR::PLine(), and routeHead().

Referenced by IsPlacingVia(), and route().

111 {
112  if( !routeHead( aP ) )
113  return false;
114 
115  bool collP = static_cast<bool>( m_currentNode->CheckColliding( &m_currentTrace.PLine() ) );
116  bool collN = static_cast<bool>( m_currentNode->CheckColliding( &m_currentTrace.NLine() ) );
117 
118  m_fitOk = !( collP || collN ) ;
119 
120  return m_fitOk;
121 }
bool routeHead(const VECTOR2I &aP)
NODE * m_currentNode
Current world state
OPT_OBSTACLE CheckColliding(const ITEM *aItem, int aKindMask=ITEM::ANY_T)
Function CheckColliding()
Definition: pns_node.cpp:425
bool PNS::DIFF_PAIR_PLACER::rhShoveOnly ( const VECTOR2I aP)
private

route step, shove mode

Definition at line 312 of file pns_diff_pair_placer.cpp.

References PNS::ITEM_SET::Add(), PNS::NODE::CheckColliding(), PNS::SHOVE::CurrentNode(), m_currentNode, m_currentTrace, m_fitOk, m_shove, PNS::DIFF_PAIR::NLine(), PNS::DIFF_PAIR::PLine(), routeHead(), PNS::SHOVE::SH_OK, PNS::SHOVE::ShoveMultiLines(), and tryWalkDp().

Referenced by IsPlacingVia(), and route().

313 {
315 
316  bool ok = routeHead( aP );
317 
318  m_fitOk = false;
319 
320  if( !ok )
321  return false;
322 
323  if( !tryWalkDp( m_currentNode, m_currentTrace, true ) )
324  return false;
325 
326  LINE pLine( m_currentTrace.PLine() );
327  LINE nLine( m_currentTrace.NLine() );
328  ITEM_SET head;
329 
330  head.Add( &pLine );
331  head.Add( &nLine );
332 
333  SHOVE::SHOVE_STATUS status = m_shove->ShoveMultiLines( head );
334 
336 
337  if( status == SHOVE::SH_OK )
338  {
340 
343  {
344  m_fitOk = true;
345  }
346  }
347 
348  return m_fitOk;
349 }
SHOVE * m_shove
The shove engine
bool routeHead(const VECTOR2I &aP)
NODE * m_currentNode
Current world state
OPT_OBSTACLE CheckColliding(const ITEM *aItem, int aKindMask=ITEM::ANY_T)
Function CheckColliding()
Definition: pns_node.cpp:425
bool tryWalkDp(NODE *aNode, DIFF_PAIR &aPair, bool aSolidsOnly)
SHOVE_STATUS ShoveMultiLines(const ITEM_SET &aHeadSet)
Definition: pns_shove.cpp:1188
NODE * CurrentNode()
Definition: pns_shove.cpp:1402
bool PNS::DIFF_PAIR_PLACER::rhWalkOnly ( const VECTOR2I aP)
private

route step, walkaround mode

Definition at line 283 of file pns_diff_pair_placer.cpp.

References m_currentNode, m_currentTrace, m_fitOk, routeHead(), and tryWalkDp().

Referenced by IsPlacingVia(), and route().

284 {
285  if( !routeHead ( aP ) )
286  return false;
287 
289 
290  return m_fitOk;
291 }
bool routeHead(const VECTOR2I &aP)
NODE * m_currentNode
Current world state
bool tryWalkDp(NODE *aNode, DIFF_PAIR &aPair, bool aSolidsOnly)
bool PNS::DIFF_PAIR_PLACER::route ( const VECTOR2I aP)
private

Function route()

Re-routes the current track to point aP. Returns true, when routing has completed successfully (i.e. the trace end has reached point aP), and false if the trace was stuck somewhere on the way. May call routeStep() repetitively due to mouse smoothing.

Parameters
aPending point of current route.
Returns
true, if the routing is complete.

Definition at line 294 of file pns_diff_pair_placer.cpp.

References m_currentMode, rhMarkObstacles(), rhShoveOnly(), rhWalkOnly(), PNS::RM_MarkObstacles, PNS::RM_Shove, and PNS::RM_Walkaround.

Referenced by IsPlacingVia(), and Move().

295 {
296  switch( m_currentMode )
297  {
298  case RM_MarkObstacles:
299  return rhMarkObstacles( aP );
300  case RM_Walkaround:
301  return rhWalkOnly( aP );
302  case RM_Shove:
303  return rhShoveOnly( aP );
304  default:
305  break;
306  }
307 
308  return false;
309 }
bool rhWalkOnly(const VECTOR2I &aP)
route step, walkaround mode
bool rhShoveOnly(const VECTOR2I &aP)
route step, shove mode
Ignore collisions, mark obstacles
bool rhMarkObstacles(const VECTOR2I &aP)
route step, mark obstacles mode
bool PNS::DIFF_PAIR_PLACER::routeHead ( const VECTOR2I aP)
private

Definition at line 634 of file pns_diff_pair_placer.cpp.

References DIRECTION_45::ANG_HALF_FULL, DIRECTION_45::ANG_STRAIGHT, PNS::DIFF_PAIR::AppendVias(), PNS::DP_GATEWAYS::BuildForCursor(), PNS::DP_GATEWAYS::BuildFromPrimitivePair(), PNS::DIFF_PAIR::CN(), PNS::DIFF_PAIR::CP(), SHAPE_LINE_CHAIN::CPoint(), PNS::SIZES_SETTINGS::DiffPairGap(), PNS::SIZES_SETTINGS::DiffPairWidth(), EuclideanNorm(), PNS::DP_GATEWAYS::FilterByOrientation(), findDpPrimitivePair(), PNS::DP_GATEWAYS::FitGateways(), gap(), SEG::LineProject(), m_currentEndItem, m_currentLayer, m_currentTrace, m_fitOk, m_netN, m_netP, m_placingVia, m_prevPair, m_sizes, m_snapOnTarget, m_start, m_startDiagonal, makeVia(), propagateDpHeadForces(), PNS::DP_GATEWAYS::SetFitVias(), PNS::DIFF_PAIR::SetGap(), PNS::ITEM::SetLayer(), PNS::DIFF_PAIR::SetNets(), PNS::DIFF_PAIR::SetWidth(), PNS::SIZES_SETTINGS::ViaDiameter(), and viaGap().

Referenced by IsPlacingVia(), rhMarkObstacles(), rhShoveOnly(), and rhWalkOnly().

635 {
636  m_fitOk = false;
637 
638  DP_GATEWAYS gwsEntry( gap() );
639  DP_GATEWAYS gwsTarget( gap() );
640 
641  if( !m_prevPair )
643 
644  gwsEntry.BuildFromPrimitivePair( *m_prevPair, m_startDiagonal );
645 
646  DP_PRIMITIVE_PAIR target;
647 
648  if( findDpPrimitivePair( aP, m_currentEndItem, target ) )
649  {
650  gwsTarget.BuildFromPrimitivePair( target, m_startDiagonal );
651  m_snapOnTarget = true;
652  }
653  else
654  {
655  VECTOR2I fp;
656 
657  if( !propagateDpHeadForces( aP, fp ) )
658  return false;
659 
660  VECTOR2I midp, dirV;
661  m_prevPair->CursorOrientation( fp, midp, dirV );
662 
663  VECTOR2I fpProj = SEG( midp, midp + dirV ).LineProject( fp );
664  int lead_dist = ( fpProj - fp ).EuclideanNorm();
665 
666  gwsTarget.SetFitVias( m_placingVia, m_sizes.ViaDiameter(), viaGap() );
667 
668  if( lead_dist > m_sizes.DiffPairGap() + m_sizes.DiffPairWidth() )
669  {
670  gwsTarget.BuildForCursor( fp );
671  }
672  else
673  {
674  gwsTarget.BuildForCursor( fpProj );
675  gwsTarget.FilterByOrientation( DIRECTION_45::ANG_STRAIGHT | DIRECTION_45::ANG_HALF_FULL, DIRECTION_45( dirV ) );
676  }
677 
678  m_snapOnTarget = false;
679  }
680 
681  m_currentTrace = DIFF_PAIR();
684 
685  bool result = gwsEntry.FitGateways( gwsEntry, gwsTarget, m_startDiagonal, m_currentTrace );
686 
687  if( result )
688  {
692 
693  if( m_placingVia )
694  {
696  makeVia( m_currentTrace.CN().CPoint( -1 ), m_netN ) );
697  }
698 
699  return true;
700  }
701 
702  return false;
703 }
double EuclideanNorm(const wxPoint &vector)
Euclidean norm of a 2D vector.
Definition: trigo.h:112
void SetLayer(int aLayer)
Function SetLayer()
Definition: pns_item.h:199
void AppendVias(const VIA &aViaP, const VIA &aViaN)
VECTOR2I LineProject(const VECTOR2I &aP) const
Function LineProject()
Definition: seg.h:337
const SHAPE_LINE_CHAIN & CN() const
const VIA makeVia(const VECTOR2I &aP, int aNet)
bool findDpPrimitivePair(const VECTOR2I &aP, ITEM *aItem, DP_PRIMITIVE_PAIR &aPair, wxString *aErrorMsg=nullptr)
void SetGap(int aGap)
bool propagateDpHeadForces(const VECTOR2I &aP, VECTOR2I &aNewP)
Class DIRECTION_45.
Definition: direction45.h:36
bool m_placingVia
Are we placing a via?
void SetWidth(int aWidth)
Definition: seg.h:36
OPT< DP_PRIMITIVE_PAIR > m_prevPair
int DiffPairWidth() const
const VECTOR2I & CPoint(int aIndex) const
Function CPoint()
const SHAPE_LINE_CHAIN & CP() const
void SetNets(int aP, int aN)
void PNS::ALGO_BASE::SetDebugDecorator ( DEBUG_DECORATOR aDecorator)
inlineinherited

Function SetDebugDecorator.

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

Definition at line 65 of file pns_algo_base.h.

References PNS::ALGO_BASE::m_debugDecorator.

66  {
67  m_debugDecorator = aDecorator;
68  }
DEBUG_DECORATOR * m_debugDecorator
Definition: pns_algo_base.h:76
void PNS::DIFF_PAIR_PLACER::setInitialDirection ( const DIRECTION_45 aDirection)
private

Function setInitialDirection()

Sets preferred direction of the very first track segment to be laid. Used by posture switching mechanism.

Referenced by IsPlacingVia().

bool PNS::DIFF_PAIR_PLACER::SetLayer ( int  aLayer)
overridevirtual

Function SetLayer()

Sets the current routing layer.

Reimplemented from PNS::PLACEMENT_ALGO.

Definition at line 381 of file pns_diff_pair_placer.cpp.

References initPlacement(), m_chainedPlacement, m_currentEnd, m_currentLayer, m_idle, m_prevPair, m_start, Move(), and PNS::ITEM::VIA_T.

382 {
383  if( m_idle )
384  {
385  m_currentLayer = aLayer;
386  return true;
387  }
388  else if( m_chainedPlacement || !m_prevPair )
389  {
390  return false;
391  }
392  else if( !m_prevPair->PrimP() || ( m_prevPair->PrimP()->OfKind( ITEM::VIA_T ) &&
393  m_prevPair->PrimP()->Layers().Overlaps( aLayer ) ) )
394  {
395  m_currentLayer = aLayer;
396  m_start = *m_prevPair;
397  initPlacement();
398  Move( m_currentEnd, NULL );
399  return true;
400  }
401 
402  return false;
403 }
bool Move(const VECTOR2I &aP, ITEM *aEndItem) override
Function Move()
void initPlacement()
Function startPlacement()
OPT< DP_PRIMITIVE_PAIR > m_prevPair
void PNS::DIFF_PAIR_PLACER::SetOrthoMode ( bool  aOrthoMode)
overridevirtual

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 from PNS::PLACEMENT_ALGO.

Definition at line 90 of file pns_diff_pair_placer.cpp.

References m_currentEnd, m_idle, m_orthoMode, and Move().

Referenced by IsPlacingVia().

91 {
92  m_orthoMode = aOrthoMode;
93 
94  if( !m_idle )
95  Move( m_currentEnd, NULL );
96 }
bool Move(const VECTOR2I &aP, ITEM *aEndItem) override
Function Move()
void PNS::DIFF_PAIR_PLACER::setWorld ( NODE aWorld)
private

Function setWorld()

Sets the board to route.

Definition at line 74 of file pns_diff_pair_placer.cpp.

References m_world.

Referenced by initPlacement(), IsPlacingVia(), and Start().

75 {
76  m_world = aWorld;
77 }
NODE * m_world
pointer to world to search colliding items
bool PNS::DIFF_PAIR_PLACER::Start ( const VECTOR2I aP,
ITEM aStartItem 
)
overridevirtual

Function Start()

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

Implements PNS::PLACEMENT_ALGO.

Definition at line 547 of file pns_diff_pair_placer.cpp.

References PNS::SIZES_SETTINGS::DiffPairGap(), PNS::SIZES_SETTINGS::DiffPairViaGap(), PNS::SIZES_SETTINGS::DiffPairWidth(), findDpPrimitivePair(), BOARD::FindNet(), BOARD::GetDesignSettings(), NETINFO_ITEM::GetNetClass(), initPlacement(), m_chainedPlacement, m_currentEnd, m_currentNode, m_currentStart, m_netN, m_netP, m_placingVia, m_sizes, m_start, BOARD_DESIGN_SETTINGS::m_TrackMinWidth, m_world, min, PNS::ITEM::Net(), PNS::DP_PRIMITIVE_PAIR::PrimN(), PNS::DP_PRIMITIVE_PAIR::PrimP(), PNS::ALGO_BASE::Router(), PNS::ROUTER::SetFailureReason(), and setWorld().

548 {
549  VECTOR2I p( aP );
550  wxString msg;
551 
552  if( !aStartItem )
553  {
554  Router()->SetFailureReason( _( "Can't start a differential pair "
555  " in the middle of nowhere." ) );
556  return false;
557  }
558 
559  setWorld( Router()->GetWorld() );
561 
562  if( !findDpPrimitivePair( aP, aStartItem, m_start, &msg ) )
563  {
564  Router()->SetFailureReason( msg );
565  return false;
566  }
567 
568  m_netP = m_start.PrimP()->Net();
569  m_netN = m_start.PrimN()->Net();
570 
571  #if 0
572  // FIXME: this also needs to be factored out but not so important right now
573  // Check if the current track/via gap & track width settings are violated
574  BOARD* brd = NULL; // FIXME Router()->GetBoard();
575  NETCLASSPTR netclassP = brd->FindNet( m_netP )->GetNetClass();
576  NETCLASSPTR netclassN = brd->FindNet( m_netN )->GetNetClass();
577  int clearance = std::min( m_sizes.DiffPairGap(), m_sizes.DiffPairViaGap() );
578 
579  if( clearance < netclassP->GetClearance() || clearance < netclassN->GetClearance() )
580  {
581  Router()->SetFailureReason( _( "Current track/via gap setting violates "
582  "design rules for this net." ) );
583  return false;
584  }
585 
587  {
588  Router()->SetFailureReason( _( "Current track width setting violates design rules." ) );
589  return false;
590  }
591  #endif
592 
593  m_currentStart = p;
594  m_currentEnd = p;
595  m_placingVia = false;
596  m_chainedPlacement = false;
597 
598  initPlacement();
599 
600  return true;
601 }
NODE * m_world
pointer to world to search colliding items
ITEM * PrimP() const
ITEM * PrimN() const
bool findDpPrimitivePair(const VECTOR2I &aP, ITEM *aItem, DP_PRIMITIVE_PAIR &aPair, wxString *aErrorMsg=nullptr)
int m_TrackMinWidth
track min value for width ((min copper size value
void SetFailureReason(const wxString &aReason)
Definition: pns_router.h:213
BOARD_DESIGN_SETTINGS & GetDesignSettings() const
Function GetDesignSettings.
Definition: class_board.h:537
bool m_placingVia
Are we placing a via?
int DiffPairViaGap() const
ROUTER * Router() const
Returns the instance of our router
Definition: pns_algo_base.h:49
NODE * m_currentNode
Current world state
Class BOARD holds information pertinent to a Pcbnew printed circuit board.
Definition: class_board.h:169
NETCLASSPTR GetNetClass()
Definition: netinfo.h:122
void initPlacement()
Function startPlacement()
NETINFO_ITEM * FindNet(int aNetcode) const
Function FindNet searches for a net with the given netcode.
int Net() const
Function Net()
Definition: pns_item.h:179
void setWorld(NODE *aWorld)
Function setWorld()
int DiffPairWidth() const
#define min(a, b)
Definition: auxiliary.h:85
bool PNS::DIFF_PAIR_PLACER::ToggleVia ( bool  aEnabled)
overridevirtual

Function ToggleVia()

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

Reimplemented from PNS::PLACEMENT_ALGO.

Definition at line 99 of file pns_diff_pair_placer.cpp.

References m_currentEnd, m_idle, m_placingVia, and Move().

100 {
101  m_placingVia = aEnabled;
102 
103  if( !m_idle )
104  Move( m_currentEnd, NULL );
105 
106  return true;
107 }
bool m_placingVia
Are we placing a via?
bool Move(const VECTOR2I &aP, ITEM *aEndItem) override
Function Move()
const ITEM_SET PNS::DIFF_PAIR_PLACER::Traces ( )
overridevirtual

Function Traces()

Returns the complete routed line, as a single-member ITEM_SET.

Implements PNS::PLACEMENT_ALGO.

Definition at line 352 of file pns_diff_pair_placer.cpp.

References PNS::ITEM_SET::Add(), m_currentTrace, PNS::DIFF_PAIR::NLine(), and PNS::DIFF_PAIR::PLine().

353 {
354  ITEM_SET t;
355 
356  t.Add( const_cast<LINE*>( &m_currentTrace.PLine() ) );
357  t.Add( const_cast<LINE*>( &m_currentTrace.NLine() ) );
358 
359  return t;
360 }
bool PNS::DIFF_PAIR_PLACER::tryWalkDp ( NODE aNode,
DIFF_PAIR aPair,
bool  aSolidsOnly 
)
private

Definition at line 238 of file pns_diff_pair_placer.cpp.

References attemptWalk(), PNS::NODE::Branch(), PNS::DIFF_PAIR::CoupledLength(), m_currentNode, PNS::OPTIMIZER::Optimize(), PNS::DIFF_PAIR::SetShape(), and PNS::DIFF_PAIR::Skew().

Referenced by IsPlacingVia(), rhShoveOnly(), and rhWalkOnly().

239 {
240  DIFF_PAIR best;
241  double bestScore = 100000000000000.0;
242 
243  for( int attempt = 0; attempt <= 3; attempt++ )
244  {
245  DIFF_PAIR p;
246  NODE *tmp = m_currentNode->Branch();
247 
248  bool pfirst = ( attempt & 1 ) ? true : false;
249  bool wind_cw = ( attempt & 2 ) ? true : false;
250 
251  if( attemptWalk( tmp, &aPair, p, pfirst, wind_cw, aSolidsOnly ) )
252  {
253  // double len = p.TotalLength();
254  double cl = p.CoupledLength();
255  double skew = p.Skew();
256 
257  double score = cl + fabs( skew ) * 3.0;
258 
259  if( score < bestScore )
260  {
261  bestScore = score;
262  best = p;
263  }
264  }
265 
266  delete tmp;
267  }
268 
269  if( bestScore > 0.0 )
270  {
271  OPTIMIZER optimizer( m_currentNode );
272 
273  aPair.SetShape( best );
274  optimizer.Optimize( &aPair );
275 
276  return true;
277  }
278 
279  return false;
280 }
bool attemptWalk(NODE *aNode, DIFF_PAIR *aCurrent, DIFF_PAIR &aWalk, bool aPFirst, bool aWindCw, bool aSolidsOnly)
NODE * Branch()
Function Branch()
Definition: pns_node.cpp:107
NODE * m_currentNode
Current world state
void PNS::DIFF_PAIR_PLACER::updateLeadingRatLine ( )
private

Function updateLeadingRatLine()

Draws the "leading" ratsnest line, which connects the end of currently routed track and the nearest yet unrouted item. If the routing for current net is complete, draws nothing.

Definition at line 816 of file pns_diff_pair_placer.cpp.

References PNS::DEBUG_DECORATOR::AddLine(), PNS::ALGO_BASE::Dbg(), PNS::TOPOLOGY::LeadingRatLine(), m_currentTrace, m_lastNode, PNS::DIFF_PAIR::NLine(), and PNS::DIFF_PAIR::PLine().

Referenced by IsPlacingVia(), and Move().

817 {
818  SHAPE_LINE_CHAIN ratLineN, ratLineP;
819  TOPOLOGY topo( m_lastNode );
820 
821  if( topo.LeadingRatLine( &m_currentTrace.PLine(), ratLineP ) )
822  {
823  Dbg()->AddLine( ratLineP, 1, 10000 );
824  }
825 
826  if( topo.LeadingRatLine ( &m_currentTrace.NLine(), ratLineN ) )
827  {
828  Dbg()->AddLine( ratLineN, 3, 10000 );
829  }
830 }
DEBUG_DECORATOR * Dbg() const
Definition: pns_algo_base.h:70
virtual void AddLine(const SHAPE_LINE_CHAIN &aLine, int aType=0, int aWidth=0)
Class SHAPE_LINE_CHAIN.
NODE * m_lastNode
Postprocessed world state (including marked collisions & removed loops)
void PNS::DIFF_PAIR_PLACER::UpdateSizes ( const SIZES_SETTINGS aSizes)
overridevirtual

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 from PNS::PLACEMENT_ALGO.

Definition at line 729 of file pns_diff_pair_placer.cpp.

References initPlacement(), m_currentEnd, m_idle, m_sizes, and Move().

Referenced by CurrentLayer().

730 {
731  m_sizes = aSizes;
732 
733  if( !m_idle )
734  {
735  initPlacement();
736  Move( m_currentEnd, NULL );
737  }
738 }
bool Move(const VECTOR2I &aP, ITEM *aEndItem) override
Function Move()
void initPlacement()
Function startPlacement()
int PNS::DIFF_PAIR_PLACER::viaGap ( ) const
private

Definition at line 535 of file pns_diff_pair_placer.cpp.

References PNS::SIZES_SETTINGS::DiffPairViaGap(), and m_sizes.

Referenced by IsPlacingVia(), propagateDpHeadForces(), and routeHead().

536 {
537  return m_sizes.DiffPairViaGap();
538 }
int DiffPairViaGap() const

Member Data Documentation

bool PNS::DIFF_PAIR_PLACER::m_chainedPlacement
private

Definition at line 242 of file pns_diff_pair_placer.h.

Referenced by DIFF_PAIR_PLACER(), FixRoute(), SetLayer(), and Start().

VECTOR2I PNS::DIFF_PAIR_PLACER::m_currentEnd
private
ITEM* PNS::DIFF_PAIR_PLACER::m_currentEndItem
private

Definition at line 294 of file pns_diff_pair_placer.h.

Referenced by DIFF_PAIR_PLACER(), initPlacement(), Move(), and routeHead().

int PNS::DIFF_PAIR_PLACER::m_currentLayer
private
PNS_MODE PNS::DIFF_PAIR_PLACER::m_currentMode
private
int PNS::DIFF_PAIR_PLACER::m_currentNet
private

Definition at line 284 of file pns_diff_pair_placer.h.

Referenced by DIFF_PAIR_PLACER().

NODE* PNS::DIFF_PAIR_PLACER::m_currentNode
private
VECTOR2I PNS::DIFF_PAIR_PLACER::m_currentStart
private

Definition at line 291 of file pns_diff_pair_placer.h.

Referenced by Start().

DIFF_PAIR PNS::DIFF_PAIR_PLACER::m_currentTrace
private
int PNS::DIFF_PAIR_PLACER::m_currentWidth
private

current track width

Definition at line 282 of file pns_diff_pair_placer.h.

Referenced by DIFF_PAIR_PLACER().

bool PNS::DIFF_PAIR_PLACER::m_fitOk
private
bool PNS::DIFF_PAIR_PLACER::m_idle
private
bool PNS::DIFF_PAIR_PLACER::m_initialDiagonal
private

Definition at line 243 of file pns_diff_pair_placer.h.

Referenced by DIFF_PAIR_PLACER(), FixRoute(), and initPlacement().

int PNS::DIFF_PAIR_PLACER::m_iteration
private

current algorithm iteration

Definition at line 253 of file pns_diff_pair_placer.h.

Referenced by DIFF_PAIR_PLACER().

NODE* PNS::DIFF_PAIR_PLACER::m_lastNode
private

Postprocessed world state (including marked collisions & removed loops)

Definition at line 268 of file pns_diff_pair_placer.h.

Referenced by CurrentNode(), DIFF_PAIR_PLACER(), FixRoute(), initPlacement(), Move(), and updateLeadingRatLine().

int PNS::DIFF_PAIR_PLACER::m_netN
private
int PNS::DIFF_PAIR_PLACER::m_netP
private
bool PNS::DIFF_PAIR_PLACER::m_orthoMode
private

Definition at line 288 of file pns_diff_pair_placer.h.

Referenced by DIFF_PAIR_PLACER(), initPlacement(), and SetOrthoMode().

VECTOR2I PNS::DIFF_PAIR_PLACER::m_p_start
private

current routing start point (end of tail, beginning of head)

Definition at line 259 of file pns_diff_pair_placer.h.

bool PNS::DIFF_PAIR_PLACER::m_placingVia
private

Are we placing a via?

Definition at line 273 of file pns_diff_pair_placer.h.

Referenced by DIFF_PAIR_PLACER(), FixRoute(), IsPlacingVia(), propagateDpHeadForces(), routeHead(), Start(), and ToggleVia().

OPT<DP_PRIMITIVE_PAIR> PNS::DIFF_PAIR_PLACER::m_prevPair
private

Definition at line 250 of file pns_diff_pair_placer.h.

Referenced by FixRoute(), routeHead(), and SetLayer().

SHOVE* PNS::DIFF_PAIR_PLACER::m_shove
private

The shove engine

Definition at line 262 of file pns_diff_pair_placer.h.

Referenced by DIFF_PAIR_PLACER(), initPlacement(), rhShoveOnly(), and ~DIFF_PAIR_PLACER().

SIZES_SETTINGS PNS::DIFF_PAIR_PLACER::m_sizes
private
bool PNS::DIFF_PAIR_PLACER::m_snapOnTarget
private

Definition at line 289 of file pns_diff_pair_placer.h.

Referenced by DIFF_PAIR_PLACER(), FixRoute(), and routeHead().

DP_PRIMITIVE_PAIR PNS::DIFF_PAIR_PLACER::m_start
private

Definition at line 249 of file pns_diff_pair_placer.h.

Referenced by routeHead(), SetLayer(), and Start().

bool PNS::DIFF_PAIR_PLACER::m_startDiagonal
private

Definition at line 244 of file pns_diff_pair_placer.h.

Referenced by DIFF_PAIR_PLACER(), FlipPosture(), initPlacement(), and routeHead().

bool PNS::DIFF_PAIR_PLACER::m_startsOnVia
private

Definition at line 287 of file pns_diff_pair_placer.h.

Referenced by DIFF_PAIR_PLACER().

State PNS::DIFF_PAIR_PLACER::m_state
private

Definition at line 240 of file pns_diff_pair_placer.h.

Referenced by DIFF_PAIR_PLACER().

int PNS::DIFF_PAIR_PLACER::m_viaDiameter
private

current via diameter

Definition at line 276 of file pns_diff_pair_placer.h.

Referenced by DIFF_PAIR_PLACER().

int PNS::DIFF_PAIR_PLACER::m_viaDrill
private

current via drill

Definition at line 279 of file pns_diff_pair_placer.h.

Referenced by DIFF_PAIR_PLACER().

NODE* PNS::DIFF_PAIR_PLACER::m_world
private

pointer to world to search colliding items

Definition at line 256 of file pns_diff_pair_placer.h.

Referenced by DIFF_PAIR_PLACER(), findDpPrimitivePair(), setWorld(), and Start().


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