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) 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)
 
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
 
boost::optional< 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::ROUTER::GetRuleResolver(), PNS::LINE::Line(), PNS::DIFF_PAIR::NetN(), PNS::DIFF_PAIR::NetP(), PNS::DIFF_PAIR::NLine(), PNS::RULE_RESOLVER::OverrideClearance(), 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 tryWalkDp().

163 {
164  WALKAROUND walkaround( aNode, Router() );
166 
168  aCurrent->NetP(), aCurrent->NetN(), aCurrent->Gap() );
169 
170  walkaround.SetSolidsOnly( aSolidsOnly );
171  walkaround.SetIterationLimit( Settings().WalkaroundIterationLimit() );
172 
173  SHOVE shove( aNode, Router() );
174  LINE walkP, walkN;
175 
176  aWalk = *aCurrent;
177 
178  int iter = 0;
179 
180  DIFF_PAIR cur( *aCurrent );
181 
182  bool currentIsP = aPFirst;
183 
184  int mask = aSolidsOnly ? ITEM::SOLID_T : ITEM::ANY_T;
185 
186  do
187  {
188  LINE preWalk = ( currentIsP ? cur.PLine() : cur.NLine() );
189  LINE preShove = ( currentIsP ? cur.NLine() : cur.PLine() );
190  LINE postWalk;
191 
192  if( !aNode->CheckColliding ( &preWalk, mask ) )
193  {
194  currentIsP = !currentIsP;
195 
196  if( !aNode->CheckColliding( &preShove, mask ) )
197  break;
198  else
199  continue;
200  }
201 
202  wf1 = walkaround.Route( preWalk, postWalk, false );
203 
204  if( wf1 != WALKAROUND::DONE )
205  return false;
206 
207  LINE postShove( preShove );
208 
209  shove.ForceClearance( true, cur.Gap() - 2 * PNS_HULL_MARGIN );
210 
212 
213  sh1 = shove.ProcessSingleLine( postWalk, preShove, postShove );
214 
215  if( sh1 != SHOVE::SH_OK )
216  return false;
217 
218  postWalk.Line().Simplify();
219  postShove.Line().Simplify();
220 
221  cur.SetShape( postWalk.CLine(), postShove.CLine(), !currentIsP );
222 
223  currentIsP = !currentIsP;
224 
225  if( !aNode->CheckColliding( &postShove, mask ) )
226  break;
227 
228  iter++;
229  }
230  while( iter < 3 );
231 
232  if( iter == 3 )
233  return false;
234 
235  aWalk.SetShape( cur.CP(), cur.CN() );
237 
238  return true;
239 }
#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
RULE_RESOLVER * GetRuleResolver() const
Definition: pns_router.h:163
virtual void OverrideClearance(bool aEnable, int aNetA=0, int aNetB=0, int aClearance=0)=0
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 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 m_currentLayer.

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 809 of file pns_diff_pair_placer.cpp.

References m_netN, and m_netP.

810 {
811  std::vector<int> rv;
812  rv.push_back( m_netP );
813  rv.push_back( m_netN );
814  return rv;
815 }
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 376 of file pns_diff_pair_placer.cpp.

References m_currentNode, and m_lastNode.

377 {
378  if( m_lastNode )
379  return m_lastNode;
380 
381  return m_currentNode;
382 }
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 
)
private

Definition at line 440 of file pns_diff_pair_placer.cpp.

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

Referenced by routeHead(), and Start().

441 {
442  int netP, netN;
443 
444  wxLogTrace( "PNS", "world %p", m_world );
445 
446  bool result = m_world->GetRuleResolver()->DpNetPair( aItem, netP, netN );
447 
448  if( !result )
449  return false;
450 
451  int refNet = aItem->Net();
452  int coupledNet = ( refNet == netP ) ? netN : netP;
453 
454  wxLogTrace( "PNS", "result %d", !!result );
455 
456  OPT_VECTOR2I refAnchor = getDanglingAnchor( m_currentNode, aItem );
457  ITEM* primRef = aItem;
458 
459  wxLogTrace( "PNS", "refAnchor %p", aItem );
460 
461  if( !refAnchor )
462  return false;
463 
464  std::set<ITEM*> coupledItems;
465 
466  m_currentNode->AllItemsInNet( coupledNet, coupledItems );
467  double bestDist = std::numeric_limits<double>::max();
468  bool found = false;
469 
470  for( ITEM* item : coupledItems )
471  {
472  if( item->Kind() == aItem->Kind() )
473  {
474  OPT_VECTOR2I anchor = getDanglingAnchor( m_currentNode, item );
475  if( !anchor )
476  continue;
477 
478  double dist = ( *anchor - *refAnchor ).EuclideanNorm();
479 
480  bool shapeMatches = true;
481 
482  if( item->OfKind( ITEM::SOLID_T ) && item->Layers() != aItem->Layers() )
483  {
484  shapeMatches = false;
485  }
486 
487  if( dist < bestDist && shapeMatches )
488  {
489  found = true;
490  bestDist = dist;
491 
492  if( refNet == netP )
493  {
494  aPair = DP_PRIMITIVE_PAIR ( item, primRef );
495  aPair.SetAnchors( *anchor, *refAnchor );
496  }
497  else
498  {
499  aPair = DP_PRIMITIVE_PAIR( primRef, item );
500  aPair.SetAnchors( *refAnchor, *anchor );
501  }
502  }
503  }
504  }
505 
506  return found;
507 }
double EuclideanNorm(const wxPoint &vector)
Euclidean norm of a 2D vector.
Definition: trigo.h:104
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
virtual bool DpNetPair(ITEM *aItem, int &aNetP, int &aNetN)=0
NODE * m_currentNode
Current world state
RULE_RESOLVER * GetRuleResolver()
Definition: pns_node.h:168
#define max(a, b)
Definition: auxiliary.h:86
OPT_VECTOR2I getDanglingAnchor(NODE *aNode, ITEM *aItem)
bool PNS::DIFF_PAIR_PLACER::FixRoute ( const VECTOR2I aP,
ITEM aEndItem 
)
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 717 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().

718 {
719  if( !m_fitOk )
720  return false;
721 
722  if( m_currentTrace.CP().SegmentCount() < 1 ||
723  m_currentTrace.CN().SegmentCount() < 1 )
724  return false;
725 
726  if( m_currentTrace.CP().SegmentCount() > 1 )
727  m_initialDiagonal = !DIRECTION_45( m_currentTrace.CP().CSegment( -2 ) ).IsDiagonal();
728 
729  TOPOLOGY topo( m_lastNode );
730 
732  {
735 
736  if( newP.SegmentCount() > 1 && newN.SegmentCount() > 1 )
737  {
738  newP.Remove( -1, -1 );
739  newN.Remove( -1, -1 );
740  }
741 
742  m_currentTrace.SetShape( newP, newN );
743  }
744 
746  {
749  m_chainedPlacement = false;
750  }
751  else
752  {
754  }
755 
756  LINE lineP( m_currentTrace.PLine() );
757  LINE lineN( m_currentTrace.NLine() );
758 
759  m_lastNode->Add( lineP );
760  m_lastNode->Add( lineN );
761 
762  topo.SimplifyLine( &lineP );
763  topo.SimplifyLine( &lineN );
764 
766 
768 
769  m_lastNode = NULL;
770  m_placingVia = false;
771 
772  if( m_snapOnTarget )
773  {
774  m_idle = true;
775  return true;
776  }
777  else
778  {
779  initPlacement();
780  return false;
781  }
782 }
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:33
boost::optional< DP_PRIMITIVE_PAIR > m_prevPair
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:367
void CommitRouting(NODE *aNode)
Definition: pns_router.cpp:326
Class SHAPE_LINE_CHAIN.
void initPlacement()
Function startPlacement()
void Add(std::unique_ptr< SEGMENT > aSegment, bool aAllowRedundant=false)
Function Add()
Definition: pns_node.cpp:596
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 367 of file pns_diff_pair_placer.cpp.

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

368 {
370 
371  if( !m_idle )
372  Move( m_currentEnd, NULL );
373 }
bool Move(const VECTOR2I &aP, ITEM *aEndItem) override
Function Move()
int PNS::DIFF_PAIR_PLACER::gap ( ) const
private

Definition at line 516 of file pns_diff_pair_placer.cpp.

References PNS::SIZES_SETTINGS::DiffPairGap(), PNS::SIZES_SETTINGS::DiffPairWidth(), and m_sizes.

Referenced by routeHead().

517 {
519 }
int DiffPairWidth() const
OPT_VECTOR2I PNS::DIFF_PAIR_PLACER::getDanglingAnchor ( NODE aNode,
ITEM aItem 
)
private

Definition at line 409 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().

410 {
411  switch( aItem->Kind() )
412  {
413  case ITEM::VIA_T:
414  case ITEM::SOLID_T:
415  return aItem->Anchor( 0 );
416 
417  case ITEM::SEGMENT_T:
418  {
419  SEGMENT* s =static_cast<SEGMENT*>( aItem );
420 
421  JOINT* jA = aNode->FindJoint( s->Seg().A, s );
422  JOINT* jB = aNode->FindJoint( s->Seg().B, s );
423 
424  if( jA->LinkCount() == 1 )
425  return s->Seg().A;
426  else if( jB->LinkCount() == 1 )
427  return s->Seg().B;
428  else
429  return OPT_VECTOR2I();
430  }
431 
432  default:
433  return OPT_VECTOR2I();
434  break;
435  }
436 }
boost::optional< VECTOR2I > OPT_VECTOR2I
Definition: seg.h:35
Struct SEGMENT is a simple container used when filling areas with segments.
Definition: class_zone.h:57
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 785 of file pns_diff_pair_placer.cpp.

References m_netN, and m_netP.

786 {
787  aNets.push_back( m_netP );
788  aNets.push_back( m_netN );
789 }
void PNS::DIFF_PAIR_PLACER::initPlacement ( )
private

Function startPlacement()

Initializes placement of a new line with given parameters.

Definition at line 580 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(), SetLayer(), Start(), and UpdateSizes().

581 {
582  m_idle = false;
583  m_orthoMode = false;
584  m_currentEndItem = NULL;
586 
587  NODE* world = Router()->GetWorld();
588 
589  world->KillChildren();
590  NODE* rootNode = world->Branch();
591 
592  setWorld( rootNode );
593 
594  m_lastNode = NULL;
595  m_currentNode = rootNode;
597 
598  if( m_shove )
599  delete m_shove;
600 
601  m_shove = NULL;
602 
604  {
605  m_shove = new SHOVE( m_currentNode, Router() );
606  }
607 }
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

Function IsPlacingVia()

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

Reimplemented from PNS::PLACEMENT_ALGO.

Definition at line 161 of file pns_diff_pair_placer.h.

References m_placingVia.

161 { return m_placingVia; }
bool m_placingVia
Are we placing a via?
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.

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

683 {
684  m_currentEndItem = aEndItem;
685  m_fitOk = false;
686 
687  delete m_lastNode;
688  m_lastNode = NULL;
689 
690  if( !route( aP ) )
691  return false;
692 
693  NODE* latestNode = m_currentNode;
694  m_lastNode = latestNode->Branch();
695 
696  assert( m_lastNode != NULL );
697  m_currentEnd = aP;
698 
700 
701  return true;
702 }
bool route(const VECTOR2I &aP)
Function route()
NODE * Branch()
Function Branch()
Definition: pns_node.cpp:109
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 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 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:427
bool PNS::DIFF_PAIR_PLACER::rhShoveOnly ( const VECTOR2I aP)
private

route step, shove mode

Definition at line 316 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 route().

317 {
319 
320  bool ok = routeHead( aP );
321 
322  m_fitOk = false;
323 
324  if( !ok )
325  return false;
326 
327  if( !tryWalkDp( m_currentNode, m_currentTrace, true ) )
328  return false;
329 
330  LINE pLine( m_currentTrace.PLine() );
331  LINE nLine( m_currentTrace.NLine() );
332  ITEM_SET head;
333 
334  head.Add( &pLine );
335  head.Add( &nLine );
336 
337  SHOVE::SHOVE_STATUS status = m_shove->ShoveMultiLines( head );
338 
340 
341  if( status == SHOVE::SH_OK )
342  {
344 
347  {
348  m_fitOk = true;
349  }
350  }
351 
352  return m_fitOk;
353 }
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:427
bool tryWalkDp(NODE *aNode, DIFF_PAIR &aPair, bool aSolidsOnly)
SHOVE_STATUS ShoveMultiLines(const ITEM_SET &aHeadSet)
Definition: pns_shove.cpp:1179
NODE * CurrentNode()
Definition: pns_shove.cpp:1393
bool PNS::DIFF_PAIR_PLACER::rhWalkOnly ( const VECTOR2I aP)
private

route step, walkaround mode

Definition at line 287 of file pns_diff_pair_placer.cpp.

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

Referenced by route().

288 {
289  if( !routeHead ( aP ) )
290  return false;
291 
293 
294  return m_fitOk;
295 }
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 298 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 Move().

299 {
300  switch( m_currentMode )
301  {
302  case RM_MarkObstacles:
303  return rhMarkObstacles( aP );
304  case RM_Walkaround:
305  return rhWalkOnly( aP );
306  case RM_Shove:
307  return rhShoveOnly( aP );
308  default:
309  break;
310  }
311 
312  return false;
313 }
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 610 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 rhMarkObstacles(), rhShoveOnly(), and rhWalkOnly().

611 {
612  m_fitOk = false;
613 
614  DP_GATEWAYS gwsEntry( gap() );
615  DP_GATEWAYS gwsTarget( gap() );
616 
617  if( !m_prevPair )
619 
620  gwsEntry.BuildFromPrimitivePair( *m_prevPair, m_startDiagonal );
621 
622  DP_PRIMITIVE_PAIR target;
623 
624  if( findDpPrimitivePair( aP, m_currentEndItem, target ) )
625  {
626  gwsTarget.BuildFromPrimitivePair( target, m_startDiagonal );
627  m_snapOnTarget = true;
628  }
629  else
630  {
631  VECTOR2I fp;
632 
633  if( !propagateDpHeadForces( aP, fp ) )
634  return false;
635 
636  VECTOR2I midp, dirV;
637  m_prevPair->CursorOrientation( fp, midp, dirV );
638 
639  VECTOR2I fpProj = SEG( midp, midp + dirV ).LineProject( fp );
640  int lead_dist = ( fpProj - fp ).EuclideanNorm();
641 
642  gwsTarget.SetFitVias( m_placingVia, m_sizes.ViaDiameter(), viaGap() );
643 
644  if( lead_dist > m_sizes.DiffPairGap() + m_sizes.DiffPairWidth() )
645  {
646  gwsTarget.BuildForCursor( fp );
647  }
648  else
649  {
650  gwsTarget.BuildForCursor( fpProj );
651  gwsTarget.FilterByOrientation( DIRECTION_45::ANG_STRAIGHT | DIRECTION_45::ANG_HALF_FULL, DIRECTION_45( dirV ) );
652  }
653 
654  m_snapOnTarget = false;
655  }
656 
657  m_currentTrace = DIFF_PAIR();
660 
661  bool result = gwsEntry.FitGateways( gwsEntry, gwsTarget, m_startDiagonal, m_currentTrace );
662 
663  if( result )
664  {
668 
669  if( m_placingVia )
670  {
672  makeVia( m_currentTrace.CN().CPoint( -1 ), m_netN ) );
673  }
674 
675  return true;
676  }
677 
678  return false;
679 }
double EuclideanNorm(const wxPoint &vector)
Euclidean norm of a 2D vector.
Definition: trigo.h:104
void SetLayer(int aLayer)
Function SetLayer()
Definition: pns_item.h:197
void AppendVias(const VIA &aViaP, const VIA &aViaN)
VECTOR2I LineProject(const VECTOR2I &aP) const
Function LineProject()
Definition: seg.h:322
const SHAPE_LINE_CHAIN & CN() const
const VIA makeVia(const VECTOR2I &aP, int aNet)
void SetGap(int aGap)
bool propagateDpHeadForces(const VECTOR2I &aP, VECTOR2I &aNewP)
Class DIRECTION_45.
Definition: direction45.h:33
boost::optional< DP_PRIMITIVE_PAIR > m_prevPair
bool m_placingVia
Are we placing a via?
void SetWidth(int aWidth)
Definition: seg.h:37
bool findDpPrimitivePair(const VECTOR2I &aP, ITEM *aItem, DP_PRIMITIVE_PAIR &aPair)
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.

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

Function SetLayer()

Sets the current routing layer.

Reimplemented from PNS::PLACEMENT_ALGO.

Definition at line 385 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.

386 {
387  if( m_idle )
388  {
389  m_currentLayer = aLayer;
390  return true;
391  } else if( m_chainedPlacement )
392  return false;
393  else if( !m_prevPair )
394  return false;
395  else if( m_prevPair->PrimP() || ( m_prevPair->PrimP()->OfKind( ITEM::VIA_T ) &&
396  m_prevPair->PrimP()->Layers().Overlaps( aLayer ) ) )
397  {
398  m_currentLayer = aLayer;
399  m_start = *m_prevPair;
400  initPlacement();
401  Move( m_currentEnd, NULL );
402  return true;
403  }
404 
405  return false;
406 }
boost::optional< DP_PRIMITIVE_PAIR > m_prevPair
bool Move(const VECTOR2I &aP, ITEM *aEndItem) override
Function Move()
void initPlacement()
Function startPlacement()
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().

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

523 {
524  VECTOR2I p( aP );
525 
526  if( !aStartItem )
527  {
528  Router()->SetFailureReason( _( "Can't start a differential pair "
529  " in the middle of nowhere." ) );
530  return false;
531  }
532 
533  setWorld( Router()->GetWorld() );
535 
536  if( !findDpPrimitivePair( aP, aStartItem, m_start ) )
537  {
538  Router()->SetFailureReason( _( "Unable to find complementary differential pair "
539  "net. Make sure the names of the nets belonging "
540  "to a differential pair end with either _N/_P or +/-." ) );
541  return false;
542  }
543 
544  m_netP = m_start.PrimP()->Net();
545  m_netN = m_start.PrimN()->Net();
546 
547  #if 0
548  // FIXME: this also needs to be factored out but not so important right now
549  // Check if the current track/via gap & track width settings are violated
550  BOARD* brd = NULL; // FIXME Router()->GetBoard();
551  NETCLASSPTR netclassP = brd->FindNet( m_netP )->GetNetClass();
552  NETCLASSPTR netclassN = brd->FindNet( m_netN )->GetNetClass();
553  int clearance = std::min( m_sizes.DiffPairGap(), m_sizes.DiffPairViaGap() );
554 
555  if( clearance < netclassP->GetClearance() || clearance < netclassN->GetClearance() )
556  {
557  Router()->SetFailureReason( _( "Current track/via gap setting violates "
558  "design rules for this net." ) );
559  return false;
560  }
561 
563  {
564  Router()->SetFailureReason( _( "Current track width setting violates design rules." ) );
565  return false;
566  }
567  #endif
568 
569  m_currentStart = p;
570  m_currentEnd = p;
571  m_placingVia = false;
572  m_chainedPlacement = false;
573 
574  initPlacement();
575 
576  return true;
577 }
NODE * m_world
pointer to world to search colliding items
ITEM * PrimP() const
ITEM * PrimN() const
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:524
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
bool findDpPrimitivePair(const VECTOR2I &aP, ITEM *aItem, DP_PRIMITIVE_PAIR &aPair)
NODE * m_currentNode
Current world state
Class BOARD holds information pertinent to a Pcbnew printed circuit board.
Definition: class_board.h:169
NETCLASSPTR GetNetClass()
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:177
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 356 of file pns_diff_pair_placer.cpp.

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

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

Definition at line 242 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 rhShoveOnly(), and rhWalkOnly().

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

793 {
794  SHAPE_LINE_CHAIN ratLineN, ratLineP;
795  TOPOLOGY topo( m_lastNode );
796 
797  if( topo.LeadingRatLine( &m_currentTrace.PLine(), ratLineP ) )
798  {
799  Dbg()->AddLine( ratLineP, 1, 10000 );
800  }
801 
802  if( topo.LeadingRatLine ( &m_currentTrace.NLine(), ratLineN ) )
803  {
804  Dbg()->AddLine( ratLineN, 3, 10000 );
805  }
806 }
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 705 of file pns_diff_pair_placer.cpp.

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

706 {
707  m_sizes = aSizes;
708 
709  if( !m_idle )
710  {
711  initPlacement();
712  Move( m_currentEnd, NULL );
713  }
714 }
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 510 of file pns_diff_pair_placer.cpp.

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

Referenced by propagateDpHeadForces(), and routeHead().

511 {
512  return m_sizes.DiffPairViaGap();
513 }
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().

boost::optional<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: