2015-02-18 00:29:54 +00:00
|
|
|
/*
|
|
|
|
* KiRouter - a push-and-(sometimes-)shove PCB router
|
|
|
|
*
|
|
|
|
* Copyright (C) 2013-2014 CERN
|
2016-08-29 14:38:11 +00:00
|
|
|
* Copyright (C) 2016 KiCad Developers, see AUTHORS.txt for contributors.
|
2015-02-18 00:29:54 +00:00
|
|
|
* Author: Tomasz Wlostowski <tomasz.wlostowski@cern.ch>
|
|
|
|
*
|
|
|
|
* This program is free software: you can redistribute it and/or modify it
|
|
|
|
* under the terms of the GNU General Public License as published by the
|
|
|
|
* Free Software Foundation, either version 3 of the License, or (at your
|
|
|
|
* option) any later version.
|
|
|
|
*
|
|
|
|
* This program is distributed in the hope that it will be useful, but
|
|
|
|
* WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
|
|
* General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU General Public License along
|
|
|
|
* with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
*/
|
|
|
|
|
2017-11-01 11:14:16 +00:00
|
|
|
#include <core/optional.h>
|
2015-02-18 00:29:54 +00:00
|
|
|
|
|
|
|
#include <base_units.h> // God forgive me doing this...
|
|
|
|
|
|
|
|
#include "pns_node.h"
|
|
|
|
#include "pns_itemset.h"
|
|
|
|
#include "pns_topology.h"
|
|
|
|
#include "pns_dp_meander_placer.h"
|
|
|
|
#include "pns_diff_pair.h"
|
|
|
|
#include "pns_router.h"
|
|
|
|
#include "pns_utils.h"
|
|
|
|
|
2016-08-29 14:38:11 +00:00
|
|
|
namespace PNS {
|
|
|
|
|
2016-08-29 17:31:13 +00:00
|
|
|
DP_MEANDER_PLACER::DP_MEANDER_PLACER( ROUTER* aRouter ) :
|
|
|
|
MEANDER_PLACER_BASE( aRouter )
|
2015-02-18 00:29:54 +00:00
|
|
|
{
|
|
|
|
m_world = NULL;
|
|
|
|
m_currentNode = NULL;
|
2015-05-15 12:49:11 +00:00
|
|
|
|
|
|
|
// Init temporary variables (do not leave uninitialized members)
|
|
|
|
m_initialSegment = NULL;
|
|
|
|
m_lastLength = 0;
|
|
|
|
m_lastStatus = TOO_SHORT;
|
2015-02-18 00:29:54 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2016-08-29 17:31:13 +00:00
|
|
|
DP_MEANDER_PLACER::~DP_MEANDER_PLACER()
|
2015-02-18 00:29:54 +00:00
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2015-02-18 16:53:46 +00:00
|
|
|
|
2016-08-29 17:31:13 +00:00
|
|
|
const LINE DP_MEANDER_PLACER::Trace() const
|
2015-02-18 00:29:54 +00:00
|
|
|
{
|
|
|
|
return m_currentTraceP;
|
|
|
|
}
|
|
|
|
|
2015-02-18 16:53:46 +00:00
|
|
|
|
2016-08-29 17:31:13 +00:00
|
|
|
NODE* DP_MEANDER_PLACER::CurrentNode( bool aLoopsRemoved ) const
|
2015-02-18 00:29:54 +00:00
|
|
|
{
|
2015-02-18 16:53:46 +00:00
|
|
|
if( !m_currentNode )
|
2015-02-18 00:29:54 +00:00
|
|
|
return m_world;
|
2015-02-18 16:53:46 +00:00
|
|
|
|
2015-02-18 00:29:54 +00:00
|
|
|
return m_currentNode;
|
|
|
|
}
|
|
|
|
|
2015-02-18 16:53:46 +00:00
|
|
|
|
2016-08-29 17:31:13 +00:00
|
|
|
bool DP_MEANDER_PLACER::Start( const VECTOR2I& aP, ITEM* aStartItem )
|
2015-02-18 00:29:54 +00:00
|
|
|
{
|
|
|
|
VECTOR2I p;
|
2015-02-18 16:53:46 +00:00
|
|
|
|
2016-08-29 17:31:13 +00:00
|
|
|
if( !aStartItem || !aStartItem->OfKind( ITEM::SEGMENT_T ) )
|
2015-02-18 00:29:54 +00:00
|
|
|
{
|
2015-02-18 16:53:46 +00:00
|
|
|
Router()->SetFailureReason( _( "Please select a track whose length you want to tune." ) );
|
2015-02-18 00:29:54 +00:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2016-08-29 17:31:13 +00:00
|
|
|
m_initialSegment = static_cast<SEGMENT*>( aStartItem );
|
2015-02-18 00:29:54 +00:00
|
|
|
|
|
|
|
p = m_initialSegment->Seg().NearestPoint( aP );
|
|
|
|
|
|
|
|
m_currentNode=NULL;
|
2015-02-18 16:53:46 +00:00
|
|
|
m_currentStart = p;
|
2015-02-18 00:29:54 +00:00
|
|
|
|
|
|
|
m_world = Router()->GetWorld()->Branch();
|
|
|
|
|
2016-08-29 17:31:13 +00:00
|
|
|
TOPOLOGY topo( m_world );
|
2015-02-18 00:29:54 +00:00
|
|
|
|
2015-02-18 16:53:46 +00:00
|
|
|
if( !topo.AssembleDiffPair( m_initialSegment, m_originPair ) )
|
2015-02-18 00:29:54 +00:00
|
|
|
{
|
|
|
|
Router()->SetFailureReason( _( "Unable to find complementary differential pair "
|
|
|
|
"net for length tuning. Make sure the names of the nets belonging "
|
|
|
|
"to a differential pair end with either _N/_P or +/-." ) );
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2015-07-02 14:10:02 +00:00
|
|
|
if( m_originPair.Gap() < 0 )
|
2015-07-02 14:11:15 +00:00
|
|
|
m_originPair.SetGap( Router()->Sizes().DiffPairGap() );
|
2015-02-18 00:29:54 +00:00
|
|
|
|
|
|
|
if( !m_originPair.PLine().SegmentCount() ||
|
|
|
|
!m_originPair.NLine().SegmentCount() )
|
|
|
|
return false;
|
|
|
|
|
2015-02-18 16:53:46 +00:00
|
|
|
m_tunedPathP = topo.AssembleTrivialPath( m_originPair.PLine().GetLink( 0 ) );
|
|
|
|
m_tunedPathN = topo.AssembleTrivialPath( m_originPair.NLine().GetLink( 0 ) );
|
|
|
|
|
|
|
|
m_world->Remove( m_originPair.PLine() );
|
|
|
|
m_world->Remove( m_originPair.NLine() );
|
2015-02-18 00:29:54 +00:00
|
|
|
|
|
|
|
m_currentWidth = m_originPair.Width();
|
2015-02-18 16:53:46 +00:00
|
|
|
|
2015-02-18 00:29:54 +00:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2016-08-29 17:31:13 +00:00
|
|
|
void DP_MEANDER_PLACER::release()
|
2015-02-18 00:29:54 +00:00
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2015-02-18 16:53:46 +00:00
|
|
|
|
2016-08-29 17:31:13 +00:00
|
|
|
int DP_MEANDER_PLACER::origPathLength() const
|
2015-02-18 00:29:54 +00:00
|
|
|
{
|
|
|
|
int totalP = 0;
|
|
|
|
int totalN = 0;
|
|
|
|
|
2016-08-29 17:31:13 +00:00
|
|
|
for( const ITEM* item : m_tunedPathP.CItems() )
|
2015-02-18 00:29:54 +00:00
|
|
|
{
|
2016-08-29 17:31:13 +00:00
|
|
|
if( const LINE* l = dyn_cast<const LINE*>( item ) )
|
2015-02-18 16:53:46 +00:00
|
|
|
totalP += l->CLine().Length();
|
|
|
|
|
2015-02-18 00:29:54 +00:00
|
|
|
}
|
2015-02-18 16:53:46 +00:00
|
|
|
|
2016-08-29 17:31:13 +00:00
|
|
|
for( const ITEM* item : m_tunedPathN.CItems() )
|
2015-02-18 00:29:54 +00:00
|
|
|
{
|
2016-08-29 17:31:13 +00:00
|
|
|
if( const LINE* l = dyn_cast<const LINE*>( item ) )
|
2015-02-18 16:53:46 +00:00
|
|
|
totalN += l->CLine().Length();
|
2015-02-18 00:29:54 +00:00
|
|
|
}
|
|
|
|
|
2015-02-18 16:53:46 +00:00
|
|
|
return std::max( totalP, totalN );
|
2015-02-18 00:29:54 +00:00
|
|
|
}
|
|
|
|
|
2015-02-18 16:53:46 +00:00
|
|
|
|
2016-08-29 17:31:13 +00:00
|
|
|
const SEG DP_MEANDER_PLACER::baselineSegment( const DIFF_PAIR::COUPLED_SEGMENTS& aCoupledSegs )
|
2015-02-18 00:29:54 +00:00
|
|
|
{
|
|
|
|
const VECTOR2I a( ( aCoupledSegs.coupledP.A + aCoupledSegs.coupledN.A ) / 2 );
|
|
|
|
const VECTOR2I b( ( aCoupledSegs.coupledP.B + aCoupledSegs.coupledN.B ) / 2 );
|
|
|
|
|
2015-02-18 16:53:46 +00:00
|
|
|
return SEG( a, b );
|
2015-02-18 00:29:54 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2016-08-29 17:31:13 +00:00
|
|
|
static bool pairOrientation( const DIFF_PAIR::COUPLED_SEGMENTS& aPair )
|
2015-02-18 00:29:54 +00:00
|
|
|
{
|
|
|
|
VECTOR2I midp = ( aPair.coupledP.A + aPair.coupledN.A ) / 2;
|
|
|
|
|
2016-08-15 15:16:53 +00:00
|
|
|
//DrawDebugPoint(midp, 6);
|
2015-02-18 00:29:54 +00:00
|
|
|
|
2015-02-18 16:53:46 +00:00
|
|
|
return aPair.coupledP.Side( midp ) > 0;
|
2015-02-18 00:29:54 +00:00
|
|
|
}
|
|
|
|
|
2015-02-18 16:53:46 +00:00
|
|
|
|
2016-08-29 17:31:13 +00:00
|
|
|
bool DP_MEANDER_PLACER::Move( const VECTOR2I& aP, ITEM* aEndItem )
|
2015-02-18 00:29:54 +00:00
|
|
|
{
|
|
|
|
// return false;
|
|
|
|
|
2016-08-29 17:31:13 +00:00
|
|
|
DIFF_PAIR::COUPLED_SEGMENTS_VEC coupledSegments;
|
2015-07-02 14:10:49 +00:00
|
|
|
|
2015-02-18 16:53:46 +00:00
|
|
|
if( m_currentNode )
|
2015-02-18 00:29:54 +00:00
|
|
|
delete m_currentNode;
|
|
|
|
|
|
|
|
m_currentNode = m_world->Branch();
|
2015-02-18 16:53:46 +00:00
|
|
|
|
2015-02-18 00:29:54 +00:00
|
|
|
SHAPE_LINE_CHAIN preP, tunedP, postP;
|
|
|
|
SHAPE_LINE_CHAIN preN, tunedN, postN;
|
|
|
|
|
2015-02-18 16:53:46 +00:00
|
|
|
cutTunedLine( m_originPair.CP(), m_currentStart, aP, preP, tunedP, postP );
|
|
|
|
cutTunedLine( m_originPair.CN(), m_currentStart, aP, preN, tunedN, postN );
|
|
|
|
|
2016-08-29 17:31:13 +00:00
|
|
|
DIFF_PAIR tuned( m_originPair );
|
2015-02-18 00:29:54 +00:00
|
|
|
|
2015-02-18 16:53:46 +00:00
|
|
|
tuned.SetShape( tunedP, tunedN );
|
2015-02-18 00:29:54 +00:00
|
|
|
|
2015-07-02 14:10:49 +00:00
|
|
|
tuned.CoupledSegmentPairs( coupledSegments );
|
2015-02-18 00:29:54 +00:00
|
|
|
|
2015-07-02 14:10:49 +00:00
|
|
|
if( coupledSegments.size() == 0 )
|
2015-02-18 00:29:54 +00:00
|
|
|
return false;
|
|
|
|
|
2016-08-15 15:16:53 +00:00
|
|
|
//Router()->DisplayDebugLine( tuned.CP(), 5, 20000 );
|
|
|
|
//Router()->DisplayDebugLine( tuned.CN(), 4, 20000 );
|
2015-02-18 00:29:54 +00:00
|
|
|
|
2016-08-15 15:16:53 +00:00
|
|
|
//Router()->DisplayDebugLine( m_originPair.CP(), 5, 20000 );
|
|
|
|
//Router()->DisplayDebugLine( m_originPair.CN(), 4, 20000 );
|
2015-02-18 00:29:54 +00:00
|
|
|
|
2016-08-29 17:31:13 +00:00
|
|
|
m_result = MEANDERED_LINE( this, true );
|
2015-02-18 16:53:46 +00:00
|
|
|
m_result.SetWidth( tuned.Width() );
|
2015-02-18 00:29:54 +00:00
|
|
|
|
2015-02-18 16:53:46 +00:00
|
|
|
int offset = ( tuned.Gap() + tuned.Width() ) / 2;
|
2015-02-18 00:29:54 +00:00
|
|
|
|
2015-07-02 14:10:49 +00:00
|
|
|
if( !pairOrientation( coupledSegments[0] ) )
|
2015-02-18 16:53:46 +00:00
|
|
|
offset *= -1;
|
2015-02-18 00:29:54 +00:00
|
|
|
|
2015-02-18 16:53:46 +00:00
|
|
|
m_result.SetBaselineOffset( offset );
|
2015-02-18 00:29:54 +00:00
|
|
|
|
2016-08-29 17:31:13 +00:00
|
|
|
for( const ITEM* item : m_tunedPathP.CItems() )
|
2015-02-18 00:29:54 +00:00
|
|
|
{
|
2016-08-29 17:31:13 +00:00
|
|
|
if( const LINE* l = dyn_cast<const LINE*>( item ) )
|
2016-08-15 15:16:48 +00:00
|
|
|
Dbg()->AddLine( l->CLine(), 5, 10000 );
|
2015-02-18 00:29:54 +00:00
|
|
|
}
|
2015-02-18 16:53:46 +00:00
|
|
|
|
2016-08-29 17:31:13 +00:00
|
|
|
for( const ITEM* item : m_tunedPathN.CItems() )
|
2015-02-18 00:29:54 +00:00
|
|
|
{
|
2016-08-29 17:31:13 +00:00
|
|
|
if( const LINE* l = dyn_cast<const LINE*>( item ) )
|
2016-08-15 15:16:48 +00:00
|
|
|
Dbg()->AddLine( l->CLine(), 5, 10000 );
|
2015-02-18 00:29:54 +00:00
|
|
|
}
|
|
|
|
|
2015-07-02 14:10:49 +00:00
|
|
|
int curIndexP = 0, curIndexN = 0;
|
|
|
|
|
2016-08-29 17:31:13 +00:00
|
|
|
for( const DIFF_PAIR::COUPLED_SEGMENTS& sp : coupledSegments )
|
2015-02-18 00:29:54 +00:00
|
|
|
{
|
2015-02-18 16:53:46 +00:00
|
|
|
SEG base = baselineSegment( sp );
|
|
|
|
|
2016-08-15 15:16:48 +00:00
|
|
|
Dbg()->AddSegment( base, 3 );
|
2015-07-02 14:10:49 +00:00
|
|
|
|
2015-07-02 14:11:15 +00:00
|
|
|
while( sp.indexP >= curIndexP )
|
2015-07-02 14:10:49 +00:00
|
|
|
{
|
2015-07-02 14:11:15 +00:00
|
|
|
m_result.AddCorner( tunedP.CPoint( curIndexP ), tunedN.CPoint( curIndexN ) );
|
2015-07-02 14:10:49 +00:00
|
|
|
curIndexP++;
|
|
|
|
}
|
|
|
|
|
2015-07-02 14:11:15 +00:00
|
|
|
while( sp.indexN >= curIndexN )
|
2015-07-02 14:10:49 +00:00
|
|
|
{
|
2015-07-02 14:11:15 +00:00
|
|
|
m_result.AddCorner( tunedP.CPoint( sp.indexP ), tunedN.CPoint( curIndexN ) );
|
2015-07-02 14:10:49 +00:00
|
|
|
curIndexN++;
|
|
|
|
}
|
2015-02-18 16:53:46 +00:00
|
|
|
|
|
|
|
m_result.MeanderSegment( base );
|
2015-02-18 00:29:54 +00:00
|
|
|
}
|
|
|
|
|
2015-07-02 14:11:15 +00:00
|
|
|
while( curIndexP < tunedP.PointCount() )
|
|
|
|
m_result.AddCorner( tunedP.CPoint( curIndexP++ ), tunedN.CPoint( curIndexN ) );
|
2015-07-02 14:10:49 +00:00
|
|
|
|
2015-07-02 14:11:15 +00:00
|
|
|
while( curIndexN < tunedN.PointCount() )
|
|
|
|
m_result.AddCorner( tunedP.CPoint( -1 ), tunedN.CPoint( curIndexN++ ) );
|
2015-07-02 14:10:49 +00:00
|
|
|
|
2015-02-18 00:29:54 +00:00
|
|
|
int dpLen = origPathLength();
|
|
|
|
|
|
|
|
m_lastStatus = TUNED;
|
|
|
|
|
2015-02-18 16:53:46 +00:00
|
|
|
if( dpLen - m_settings.m_targetLength > m_settings.m_lengthTolerance )
|
2015-02-18 00:29:54 +00:00
|
|
|
{
|
|
|
|
m_lastStatus = TOO_LONG;
|
|
|
|
m_lastLength = dpLen;
|
2015-02-18 16:53:46 +00:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
m_lastLength = dpLen - std::max( tunedP.Length(), tunedN.Length() );
|
|
|
|
tuneLineLength( m_result, m_settings.m_targetLength - dpLen );
|
2015-02-18 00:29:54 +00:00
|
|
|
}
|
|
|
|
|
2015-02-18 16:53:46 +00:00
|
|
|
if( m_lastStatus != TOO_LONG )
|
2015-02-18 00:29:54 +00:00
|
|
|
{
|
|
|
|
tunedP.Clear();
|
|
|
|
tunedN.Clear();
|
|
|
|
|
2016-08-29 17:31:13 +00:00
|
|
|
for( MEANDER_SHAPE* m : m_result.Meanders() )
|
2015-02-18 00:29:54 +00:00
|
|
|
{
|
|
|
|
if( m->Type() != MT_EMPTY )
|
|
|
|
{
|
2016-08-15 15:16:53 +00:00
|
|
|
tunedP.Append( m->CLine( 0 ) );
|
|
|
|
tunedN.Append( m->CLine( 1 ) );
|
2015-02-18 16:53:46 +00:00
|
|
|
}
|
2015-02-18 00:29:54 +00:00
|
|
|
}
|
|
|
|
|
2015-02-18 16:53:46 +00:00
|
|
|
m_lastLength += std::max( tunedP.Length(), tunedN.Length() );
|
|
|
|
|
|
|
|
int comp = compareWithTolerance( m_lastLength - m_settings.m_targetLength, 0, m_settings.m_lengthTolerance );
|
2015-02-18 00:29:54 +00:00
|
|
|
|
|
|
|
if( comp > 0 )
|
|
|
|
m_lastStatus = TOO_LONG;
|
|
|
|
else if( comp < 0 )
|
|
|
|
m_lastStatus = TOO_SHORT;
|
|
|
|
else
|
|
|
|
m_lastStatus = TUNED;
|
|
|
|
}
|
|
|
|
|
2015-02-18 16:53:46 +00:00
|
|
|
m_finalShapeP.Clear();
|
2015-02-18 00:29:54 +00:00
|
|
|
m_finalShapeP.Append( preP );
|
|
|
|
m_finalShapeP.Append( tunedP );
|
|
|
|
m_finalShapeP.Append( postP );
|
|
|
|
m_finalShapeP.Simplify();
|
2015-02-18 16:53:46 +00:00
|
|
|
|
|
|
|
m_finalShapeN.Clear();
|
2015-02-18 00:29:54 +00:00
|
|
|
m_finalShapeN.Append( preN );
|
|
|
|
m_finalShapeN.Append( tunedN );
|
|
|
|
m_finalShapeN.Append( postN );
|
|
|
|
m_finalShapeN.Simplify();
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2016-08-29 17:31:13 +00:00
|
|
|
bool DP_MEANDER_PLACER::FixRoute( const VECTOR2I& aP, ITEM* aEndItem )
|
2015-02-18 00:29:54 +00:00
|
|
|
{
|
2016-08-29 17:31:13 +00:00
|
|
|
LINE lP( m_originPair.PLine(), m_finalShapeP );
|
|
|
|
LINE lN( m_originPair.NLine(), m_finalShapeN );
|
2015-02-18 16:53:46 +00:00
|
|
|
|
2016-08-30 15:28:35 +00:00
|
|
|
m_currentNode->Add( lP );
|
|
|
|
m_currentNode->Add( lN );
|
2015-02-18 00:29:54 +00:00
|
|
|
|
|
|
|
Router()->CommitRouting( m_currentNode );
|
2015-02-18 16:53:46 +00:00
|
|
|
|
2015-02-18 00:29:54 +00:00
|
|
|
return true;
|
|
|
|
}
|
2015-02-18 16:53:46 +00:00
|
|
|
|
|
|
|
|
2016-08-29 17:31:13 +00:00
|
|
|
bool DP_MEANDER_PLACER::CheckFit( MEANDER_SHAPE* aShape )
|
2015-02-18 00:29:54 +00:00
|
|
|
{
|
2016-08-29 17:31:13 +00:00
|
|
|
LINE l1( m_originPair.PLine(), aShape->CLine( 0 ) );
|
|
|
|
LINE l2( m_originPair.NLine(), aShape->CLine( 1 ) );
|
2015-02-18 16:53:46 +00:00
|
|
|
|
2015-02-18 00:29:54 +00:00
|
|
|
if( m_currentNode->CheckColliding( &l1 ) )
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if( m_currentNode->CheckColliding( &l2 ) )
|
|
|
|
return false;
|
|
|
|
|
|
|
|
int w = aShape->Width();
|
|
|
|
int clearance = w + m_settings.m_spacing;
|
|
|
|
|
|
|
|
return m_result.CheckSelfIntersections( aShape, clearance );
|
|
|
|
}
|
|
|
|
|
2015-02-18 16:53:46 +00:00
|
|
|
|
2016-08-29 17:31:13 +00:00
|
|
|
const ITEM_SET DP_MEANDER_PLACER::Traces()
|
2015-02-18 00:29:54 +00:00
|
|
|
{
|
2016-08-29 17:31:13 +00:00
|
|
|
m_currentTraceP = LINE( m_originPair.PLine(), m_finalShapeP );
|
|
|
|
m_currentTraceN = LINE( m_originPair.NLine(), m_finalShapeN );
|
2015-02-18 00:29:54 +00:00
|
|
|
|
2016-08-29 17:31:13 +00:00
|
|
|
ITEM_SET traces;
|
2015-02-18 16:53:46 +00:00
|
|
|
|
|
|
|
traces.Add( &m_currentTraceP );
|
|
|
|
traces.Add( &m_currentTraceN );
|
|
|
|
|
2015-02-18 00:29:54 +00:00
|
|
|
return traces;
|
|
|
|
}
|
|
|
|
|
2015-02-18 16:53:46 +00:00
|
|
|
|
2016-08-29 17:31:13 +00:00
|
|
|
const VECTOR2I& DP_MEANDER_PLACER::CurrentEnd() const
|
2015-02-18 00:29:54 +00:00
|
|
|
{
|
|
|
|
return m_currentEnd;
|
|
|
|
}
|
2015-02-18 16:53:46 +00:00
|
|
|
|
|
|
|
|
2016-08-29 17:31:13 +00:00
|
|
|
int DP_MEANDER_PLACER::CurrentLayer() const
|
2015-02-18 00:29:54 +00:00
|
|
|
{
|
|
|
|
return m_initialSegment->Layers().Start();
|
|
|
|
}
|
|
|
|
|
2015-02-18 16:53:46 +00:00
|
|
|
|
2016-08-29 17:31:13 +00:00
|
|
|
const wxString DP_MEANDER_PLACER::TuningInfo() const
|
2015-02-18 00:29:54 +00:00
|
|
|
{
|
|
|
|
wxString status;
|
|
|
|
|
2015-02-18 16:53:46 +00:00
|
|
|
switch( m_lastStatus )
|
2015-02-18 00:29:54 +00:00
|
|
|
{
|
2015-10-05 16:28:41 +00:00
|
|
|
case TOO_LONG:
|
|
|
|
status = _( "Too long: " );
|
|
|
|
break;
|
|
|
|
case TOO_SHORT:
|
|
|
|
status = _("Too short: " );
|
|
|
|
break;
|
|
|
|
case TUNED:
|
|
|
|
status = _( "Tuned: " );
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
return _( "?" );
|
2015-02-18 00:29:54 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
status += LengthDoubleToString( (double) m_lastLength, false );
|
|
|
|
status += "/";
|
|
|
|
status += LengthDoubleToString( (double) m_settings.m_targetLength, false );
|
2015-07-02 14:10:49 +00:00
|
|
|
status += " (gap: ";
|
|
|
|
status += LengthDoubleToString( (double) m_originPair.Gap(), false );
|
|
|
|
status += ")";
|
2015-02-18 16:53:46 +00:00
|
|
|
|
2015-02-18 00:29:54 +00:00
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
2015-02-18 16:53:46 +00:00
|
|
|
|
2016-08-29 17:31:13 +00:00
|
|
|
DP_MEANDER_PLACER::TUNING_STATUS DP_MEANDER_PLACER::TuningStatus() const
|
2015-02-18 00:29:54 +00:00
|
|
|
{
|
|
|
|
return m_lastStatus;
|
|
|
|
}
|
2015-08-21 14:35:34 +00:00
|
|
|
|
2016-08-29 17:31:13 +00:00
|
|
|
const std::vector<int> DP_MEANDER_PLACER::CurrentNets() const
|
2015-08-21 14:35:34 +00:00
|
|
|
{
|
|
|
|
std::vector<int> rv;
|
|
|
|
rv.push_back( m_originPair.NetP() );
|
|
|
|
rv.push_back( m_originPair.NetN() );
|
|
|
|
return rv;
|
|
|
|
}
|
2016-08-29 14:38:11 +00:00
|
|
|
|
|
|
|
}
|