CONNECTION_GRAPH Class Reference

Calculates the connectivity of a schematic and generates netlists. More...

#include <connection_graph.h>

Public Member Functions
	CONNECTION_GRAPH (SCHEMATIC *aSchematic=nullptr)
	~CONNECTION_GRAPH ()
void	Reset ()
void	SetSchematic (SCHEMATIC *aSchematic)
void	Recalculate (const SCH_SHEET_LIST &aSheetList, bool aUnconditional=false, std::function< void(SCH_ITEM *)> *aChangedItemHandler=nullptr)
	Updates the connection graph for the given list of sheets. More...
std::shared_ptr< BUS_ALIAS >	GetBusAlias (const wxString &aName)
	Returns a bus alias pointer for the given name if it exists (from cache) More...
std::vector< const CONNECTION_SUBGRAPH * >	GetBusesNeedingMigration ()
	Determines which subgraphs have more than one conflicting bus label. More...
int	RunERC ()
	Runs electrical rule checks on the connectivity graph. More...
const NET_MAP &	GetNetMap () const
CONNECTION_SUBGRAPH *	FindSubgraphByName (const wxString &aNetName, const SCH_SHEET_PATH &aPath)
	Returns the subgraph for a given net name on a given sheet. More...
CONNECTION_SUBGRAPH *	FindFirstSubgraphByName (const wxString &aNetName)
	Retrieves a subgraph for the given net name, if one exists. More...
CONNECTION_SUBGRAPH *	GetSubgraphForItem (SCH_ITEM *aItem)

Static Public Attributes
static bool	m_allowRealTime = true

Private Member Functions
void	updateItemConnectivity (const SCH_SHEET_PATH &aSheet, const std::vector< SCH_ITEM * > &aItemList)
	Updates the graphical connectivity between items (i.e. More...
void	buildConnectionGraph ()
	Generates the connection graph (after all item connectivity has been updated) More...
void	buildItemSubGraphs ()
	Generates individual item subgraphs on a per-sheet basis. More...
void	resolveAllDrivers ()
	Finds all subgraphs in the connection graph and calls ResolveDrivers() in parallel. More...
void	collectAllDriverValues ()
	Maps the driver values for each subgraph. More...
void	generateInvisiblePinSubGraphs ()
	Iterate through the invisible power pins to collect the global labels as drivers. More...
void	processSubGraphs ()
	Process all subgraphs to assign netcodes and merge subgraphs based on labels. More...
int	assignNewNetCode (SCH_CONNECTION &aConnection)
	Helper to assign a new net code to a connection. More...
void	assignNetCodesToBus (SCH_CONNECTION *aConnection)
	Ensures all members of the bus connection have a valid net code assigned. More...
void	propagateToNeighbors (CONNECTION_SUBGRAPH *aSubgraph)
	Updates all neighbors of a subgraph with this one's connectivity info. More...
std::shared_ptr< SCH_CONNECTION >	getDefaultConnection (SCH_ITEM *aItem, CONNECTION_SUBGRAPH *aSubgraph)
	Builds a new default connection for the given item based on its properties. More...
void	recacheSubgraphName (CONNECTION_SUBGRAPH *aSubgraph, const wxString &aOldName)
bool	ercCheckMultipleDrivers (const CONNECTION_SUBGRAPH *aSubgraph)
	If the subgraph has multiple drivers of equal priority that are graphically connected, ResolveDrivers() will have stored the second driver for use by this function, which actually creates the markers. More...
bool	ercCheckBusToNetConflicts (const CONNECTION_SUBGRAPH *aSubgraph)
	Checks one subgraph for conflicting connections between net and bus labels. More...
bool	ercCheckBusToBusConflicts (const CONNECTION_SUBGRAPH *aSubgraph)
	Checks one subgraph for conflicting connections between two bus items. More...
bool	ercCheckBusToBusEntryConflicts (const CONNECTION_SUBGRAPH *aSubgraph)
	Checks one subgraph for conflicting bus entry to bus connections. More...
bool	ercCheckNoConnects (const CONNECTION_SUBGRAPH *aSubgraph)
	Checks one subgraph for proper presence or absence of no-connect symbols. More...
bool	ercCheckFloatingWires (const CONNECTION_SUBGRAPH *aSubgraph)
	Checks one subgraph for floating wires. More...
bool	ercCheckLabels (const CONNECTION_SUBGRAPH *aSubgraph)
	Checks one subgraph for proper connection of labels. More...
int	ercCheckHierSheets ()
	Checks that a hierarchical sheet has at least one matching label inside the sheet for each port on the parent sheet object. More...

Static Private Member Functions
static SCH_CONNECTION *	matchBusMember (SCH_CONNECTION *aBusConnection, SCH_CONNECTION *aSearch)
	Search for a matching bus member inside a bus connection. More...

Private Attributes
SCH_SHEET_LIST	m_sheetList
std::vector< SCH_ITEM * >	m_items
std::vector< CONNECTION_SUBGRAPH * >	m_subgraphs
std::vector< CONNECTION_SUBGRAPH * >	m_driver_subgraphs
std::unordered_map< SCH_SHEET_PATH, std::vector< CONNECTION_SUBGRAPH * > >	m_sheet_to_subgraphs_map
std::vector< std::pair< SCH_SHEET_PATH, SCH_PIN * > >	m_invisible_power_pins
std::unordered_map< wxString, std::shared_ptr< BUS_ALIAS > >	m_bus_alias_cache
std::map< wxString, int >	m_net_name_to_code_map
std::map< wxString, int >	m_bus_name_to_code_map
std::map< wxString, std::vector< const CONNECTION_SUBGRAPH * > >	m_global_label_cache
std::map< std::pair< SCH_SHEET_PATH, wxString >, std::vector< const CONNECTION_SUBGRAPH * > >	m_local_label_cache
std::unordered_map< wxString, std::vector< CONNECTION_SUBGRAPH * > >	m_net_name_to_subgraphs_map
std::map< SCH_ITEM *, CONNECTION_SUBGRAPH * >	m_item_to_subgraph_map
NET_MAP	m_net_code_to_subgraphs_map
int	m_last_net_code
int	m_last_bus_code
int	m_last_subgraph_code
SCHEMATIC *	m_schematic
	The schematic this graph represents. More...

Detailed Description

Calculates the connectivity of a schematic and generates netlists.

Definition at line 248 of file connection_graph.h.

Constructor & Destructor Documentation

CONNECTION_GRAPH()

CONNECTION_GRAPH::CONNECTION_GRAPH ( SCHEMATIC *  aSchematic = nullptr )

inline

Definition at line 251 of file connection_graph.h.

 :
 m_last_net_code( 1 ),
 m_last_bus_code( 1 ),
 m_last_subgraph_code( 1 ),
 m_schematic( aSchematic )
 {}

~CONNECTION_GRAPH()

CONNECTION_GRAPH::~CONNECTION_GRAPH ( )

inline

Definition at line 258 of file connection_graph.h.

 {
 Reset();
 }

References Reset().

Member Function Documentation

assignNetCodesToBus()

void CONNECTION_GRAPH::assignNetCodesToBus ( SCH_CONNECTION *  aConnection )

private

Ensures all members of the bus connection have a valid net code assigned.

Parameters

aConnection

is a bus connection

Definition at line 1690 of file connection_graph.cpp.

{
 auto connections_to_check( aConnection->Members() );

 for( unsigned i = 0; i < connections_to_check.size(); i++ )
 {
 auto member = connections_to_check[i];

 if( member->IsBus() )
 {
 connections_to_check.insert( connections_to_check.end(),
 member->Members().begin(),
 member->Members().end() );
 continue;
 }

 assignNewNetCode( *member );
 }
}

References assignNewNetCode(), and SCH_CONNECTION::Members().

Referenced by processSubGraphs().

assignNewNetCode()

int CONNECTION_GRAPH::assignNewNetCode ( SCH_CONNECTION &  aConnection )

private

Helper to assign a new net code to a connection.

Returns

the assigned code

Definition at line 1668 of file connection_graph.cpp.

{
 int code;

 auto it = m_net_name_to_code_map.find( aConnection.Name() );

 if( it == m_net_name_to_code_map.end() )
 {
 code = m_last_net_code++;
 m_net_name_to_code_map[ aConnection.Name() ] = code;
 }
 else
 {
 code = it->second;
 }

 aConnection.SetNetCode( code );

 return code;
}

References m_last_net_code, m_net_name_to_code_map, SCH_CONNECTION::Name(), and SCH_CONNECTION::SetNetCode().

Referenced by assignNetCodesToBus(), generateInvisiblePinSubGraphs(), and processSubGraphs().

buildConnectionGraph()

void CONNECTION_GRAPH::buildConnectionGraph ( )

private

Generates the connection graph (after all item connectivity has been updated)

In the first phase, the algorithm iterates over all items, and then over all items that are connected (graphically) to each item, placing them into CONNECTION_SUBGRAPHs. Items that can potentially drive connectivity (i.e. labels, pins, etc.) are added to the m_drivers vector of the subgraph.

In the second phase, each subgraph is resolved. To resolve a subgraph, the driver is first selected by CONNECTION_SUBGRAPH::ResolveDrivers(), and then the connection for the chosen driver is propagated to all the other items in the subgraph.

TODO(JE): Net codes are non-deterministic. Fortunately, they are also not really used for anything. We should consider removing them entirely and just using net names everywhere.

Definition at line 1356 of file connection_graph.cpp.

{
 // Recache all bus aliases for later use
 wxCHECK_RET( m_schematic, wxT( "Connection graph cannot be built without schematic pointer" ) );

 SCH_SHEET_LIST all_sheets = m_schematic->GetSheets();

 for( unsigned i = 0; i < all_sheets.size(); i++ )
 {
 for( const auto& alias : all_sheets[i].LastScreen()->GetBusAliases() )
 m_bus_alias_cache[ alias->GetName() ] = alias;
 }

 PROF_TIMER sub_graph( "buildItemSubGraphs" );
 buildItemSubGraphs();

 if( wxLog::IsAllowedTraceMask( ConnProfileMask ) )
 sub_graph.Show();


 resolveAllDrivers();

 collectAllDriverValues();

 generateInvisiblePinSubGraphs();

 PROF_TIMER proc_sub_graph( "ProcessSubGraphs" );
 processSubGraphs();

 if( wxLog::IsAllowedTraceMask( ConnProfileMask ) )
 proc_sub_graph.Show();

 // Absorbed subgraphs should no longer be considered
 alg::delete_if( m_driver_subgraphs, [&]( const CONNECTION_SUBGRAPH* candidate ) -> bool
 {
 return candidate->m_absorbed;
 } );

 // Store global subgraphs for later reference
 std::vector<CONNECTION_SUBGRAPH*> global_subgraphs;
 std::copy_if( m_driver_subgraphs.begin(), m_driver_subgraphs.end(),
 std::back_inserter( global_subgraphs ),
 [&] ( const CONNECTION_SUBGRAPH* candidate ) -> bool
 {
 return !candidate->m_local_driver;
 } );

 // Recache remaining valid subgraphs by sheet path
 m_sheet_to_subgraphs_map.clear();

 for( CONNECTION_SUBGRAPH* subgraph : m_driver_subgraphs )
 m_sheet_to_subgraphs_map[ subgraph->m_sheet ].emplace_back( subgraph );

 // Update item connections at this point so that neighbor propagation works
 std::atomic<size_t> nextSubgraph( 0 );

 // We don't want to spin up a new thread for fewer than 8 nets (overhead costs)
 size_t parallelThreadCount = std::min<size_t>( std::thread::hardware_concurrency(),
 ( m_subgraphs.size() + 3 ) / 4 );

 std::vector<std::future<size_t>> returns( parallelThreadCount );

 auto preliminaryUpdateTask =
 [&]() -> size_t
 {
 for( size_t subgraphId = nextSubgraph++;
 subgraphId < m_driver_subgraphs.size();
 subgraphId = nextSubgraph++ )
 {
 m_driver_subgraphs[subgraphId]->UpdateItemConnections();
 }

 return 1;
 };

 if( parallelThreadCount == 1 )
 preliminaryUpdateTask();
 else
 {
 for( size_t ii = 0; ii < parallelThreadCount; ++ii )
 returns[ii] = std::async( std::launch::async, preliminaryUpdateTask );

 // Finalize the threads
 for( size_t ii = 0; ii < parallelThreadCount; ++ii )
 returns[ii].wait();
 }

 // Next time through the subgraphs, we do some post-processing to handle things like
 // connecting bus members to their neighboring subgraphs, and then propagate connections
 // through the hierarchy

 for( CONNECTION_SUBGRAPH* subgraph : m_driver_subgraphs )
 {
 if( !subgraph->m_dirty )
 continue;

 wxLogTrace( ConnTrace, wxT( "Processing %lu (%s) for propagation" ), subgraph->m_code,
 subgraph->m_driver_connection->Name() );

 // For subgraphs that are driven by a global (power port or label) and have more
 // than one global driver, we need to seek out other subgraphs driven by the
 // same name as the non-chosen driver and update them to match the chosen one.

 if( !subgraph->m_local_driver && subgraph->m_multiple_drivers )
 {
 for( SCH_ITEM* driver : subgraph->m_drivers )
 {
 if( driver == subgraph->m_driver )
 continue;

 wxString secondary_name = subgraph->GetNameForDriver( driver );

 if( secondary_name == subgraph->m_driver_connection->Name() )
 continue;

 bool secondary_is_global = CONNECTION_SUBGRAPH::GetDriverPriority( driver )
 >= CONNECTION_SUBGRAPH::PRIORITY::POWER_PIN;

 for( CONNECTION_SUBGRAPH* candidate : global_subgraphs )
 {
 if( candidate == subgraph )
 continue;

 if( !secondary_is_global && candidate->m_sheet != subgraph->m_sheet )
 continue;

 SCH_CONNECTION* conn = candidate->m_driver_connection;

 if( conn->Name() == secondary_name )
 {
 wxLogTrace( ConnTrace, wxT( "Global %lu (%s) promoted to %s" ), candidate->m_code,
 conn->Name(), subgraph->m_driver_connection->Name() );

 conn->Clone( *subgraph->m_driver_connection );

 candidate->m_dirty = false;
 }
 }
 }
 }

 // This call will handle descending the hierarchy and updating child subgraphs
 propagateToNeighbors( subgraph );
 }

 // Handle buses that have been linked together somewhere by member (net) connections.
 // This feels a bit hacky, perhaps this algorithm should be revisited in the future.

 // For net subgraphs that have more than one bus parent, we need to ensure that those
 // buses are linked together in the final netlist. The final name of each bus might not
 // match the local name that was used to establish the parent-child relationship, because
 // the bus may have been renamed by a hierarchical connection. So, for each of these cases,
 // we need to identify the appropriate bus members to link together (and their final names),
 // and then update all instances of the old name in the hierarchy.

 for( CONNECTION_SUBGRAPH* subgraph : m_driver_subgraphs )
 {
 // All SGs should have been processed by propagateToNeighbors above
 wxASSERT_MSG( !subgraph->m_dirty, wxT( "Subgraph not processed by propagateToNeighbors!" ) );

 if( subgraph->m_bus_parents.size() < 2 )
 continue;

 SCH_CONNECTION* conn = subgraph->m_driver_connection;

 wxLogTrace( ConnTrace, wxT( "%lu (%s) has multiple bus parents" ),
 subgraph->m_code, conn->Name() );

 wxASSERT( conn->IsNet() );

 for( const auto& ii : subgraph->m_bus_parents )
 {
 SCH_CONNECTION* link_member = ii.first.get();

 for( CONNECTION_SUBGRAPH* parent : ii.second )
 {
 while( parent->m_absorbed )
 parent = parent->m_absorbed_by;

 SCH_CONNECTION* match = matchBusMember( parent->m_driver_connection, link_member );

 if( !match )
 {
 wxLogTrace( ConnTrace, wxT( "Warning: could not match %s inside %lu (%s)" ),
 conn->Name(), parent->m_code, parent->m_driver_connection->Name() );
 continue;
 }

 if( conn->Name() != match->Name() )
 {
 wxString old_name = match->Name();

 wxLogTrace( ConnTrace, wxT( "Updating %lu (%s) member %s to %s" ), parent->m_code,
 parent->m_driver_connection->Name(), old_name, conn->Name() );

 match->Clone( *conn );

 auto jj = m_net_name_to_subgraphs_map.find( old_name );

 if( jj == m_net_name_to_subgraphs_map.end() )
 continue;

 for( CONNECTION_SUBGRAPH* old_sg : jj->second )
 {
 while( old_sg->m_absorbed )
 old_sg = old_sg->m_absorbed_by;

 old_sg->m_driver_connection->Clone( *conn );
 }
 }
 }
 }
 }

 nextSubgraph.store( 0 );

 auto updateItemConnectionsTask =
 [&]() -> size_t
 {
 for( size_t subgraphId = nextSubgraph++;
 subgraphId < m_driver_subgraphs.size();
 subgraphId = nextSubgraph++ )
 {
 CONNECTION_SUBGRAPH* subgraph = m_driver_subgraphs[subgraphId];

 // Make sure weakly-driven single-pin nets get the unconnected_ prefix
 if( !subgraph->m_strong_driver && subgraph->m_drivers.size() == 1 &&
 subgraph->m_driver->Type() == SCH_PIN_T )
 {
 SCH_PIN* pin = static_cast<SCH_PIN*>( subgraph->m_driver );
 wxString name = pin->GetDefaultNetName( subgraph->m_sheet, true );

 subgraph->m_driver_connection->ConfigureFromLabel( name );
 }

 subgraph->m_dirty = false;
 subgraph->UpdateItemConnections();

 // No other processing to do on buses
 if( subgraph->m_driver_connection->IsBus() )
 continue;

 // As a visual aid, we can check sheet pins that are driven by themselves to see
 // if they should be promoted to buses

 if( subgraph->m_driver->Type() == SCH_SHEET_PIN_T )
 {
 SCH_SHEET_PIN* pin = static_cast<SCH_SHEET_PIN*>( subgraph->m_driver );

 if( SCH_SHEET* sheet = pin->GetParent() )
 {
 wxString pinText = pin->GetText();
 SCH_SCREEN* screen = sheet->GetScreen();

 for( SCH_ITEM* item : screen->Items().OfType( SCH_HIER_LABEL_T ) )
 {
 SCH_HIERLABEL* label = static_cast<SCH_HIERLABEL*>( item );

 if( label->GetText() == pinText )
 {
 SCH_SHEET_PATH path = subgraph->m_sheet;
 path.push_back( sheet );

 SCH_CONNECTION* parent_conn = label->Connection( &path );

 if( parent_conn && parent_conn->IsBus() )
 subgraph->m_driver_connection->SetType( CONNECTION_TYPE::BUS );

  break;
 }
 }

 if( subgraph->m_driver_connection->IsBus() )
 continue;
 }
 }
 }

 return 1;
 };

 if( parallelThreadCount == 1 )
 updateItemConnectionsTask();
 else
 {
 for( size_t ii = 0; ii < parallelThreadCount; ++ii )
 returns[ii] = std::async( std::launch::async, updateItemConnectionsTask );

 // Finalize the threads
 for( size_t ii = 0; ii < parallelThreadCount; ++ii )
 returns[ii].wait();
 }

 m_net_code_to_subgraphs_map.clear();
 m_net_name_to_subgraphs_map.clear();

 for( CONNECTION_SUBGRAPH* subgraph : m_driver_subgraphs )
 {
 auto key = std::make_pair( subgraph->GetNetName(),
 subgraph->m_driver_connection->NetCode() );
 m_net_code_to_subgraphs_map[ key ].push_back( subgraph );

 m_net_name_to_subgraphs_map[subgraph->m_driver_connection->Name()].push_back( subgraph );
 }
}

References buildItemSubGraphs(), BUS, SCH_CONNECTION::Clone(), collectAllDriverValues(), SCH_CONNECTION::ConfigureFromLabel(), SCH_ITEM::Connection(), ConnProfileMask, ConnTrace, alg::delete_if(), generateInvisiblePinSubGraphs(), CONNECTION_SUBGRAPH::GetDriverPriority(), SCHEMATIC::GetSheets(), EDA_TEXT::GetText(), SCH_CONNECTION::IsBus(), SCH_CONNECTION::IsNet(), SCH_SCREEN::Items(), CONNECTION_SUBGRAPH::m_absorbed, CONNECTION_SUBGRAPH::m_absorbed_by, m_bus_alias_cache, CONNECTION_SUBGRAPH::m_code, CONNECTION_SUBGRAPH::m_dirty, CONNECTION_SUBGRAPH::m_driver, CONNECTION_SUBGRAPH::m_driver_connection, m_driver_subgraphs, CONNECTION_SUBGRAPH::m_drivers, CONNECTION_SUBGRAPH::m_local_driver, m_net_code_to_subgraphs_map, m_net_name_to_subgraphs_map, m_schematic, CONNECTION_SUBGRAPH::m_sheet, m_sheet_to_subgraphs_map, CONNECTION_SUBGRAPH::m_strong_driver, m_subgraphs, matchBusMember(), name, SCH_CONNECTION::Name(), EE_RTREE::OfType(), path, pin, CONNECTION_SUBGRAPH::POWER_PIN, processSubGraphs(), propagateToNeighbors(), resolveAllDrivers(), SCH_HIER_LABEL_T, SCH_PIN_T, SCH_SHEET_PIN_T, SCH_CONNECTION::SetType(), PROF_TIMER::Show(), EDA_ITEM::Type(), and CONNECTION_SUBGRAPH::UpdateItemConnections().

Referenced by Recalculate().

buildItemSubGraphs()

void CONNECTION_GRAPH::buildItemSubGraphs ( )

private

Generates individual item subgraphs on a per-sheet basis.

Definition at line 730 of file connection_graph.cpp.

{
 // Build subgraphs from items (on a per-sheet basis)

 for( SCH_ITEM* item : m_items )
 {
 for( const auto& it : item->m_connection_map )
 {
 const SCH_SHEET_PATH& sheet = it.first;
 SCH_CONNECTION* connection = it.second;

 if( connection->SubgraphCode() == 0 )
 {
 CONNECTION_SUBGRAPH* subgraph = new CONNECTION_SUBGRAPH( this );

 subgraph->m_code = m_last_subgraph_code++;
 subgraph->m_sheet = sheet;

 subgraph->AddItem( item );

 connection->SetSubgraphCode( subgraph->m_code );
 m_item_to_subgraph_map[item] = subgraph;

 std::list<SCH_ITEM*> memberlist;

 auto get_items =
 [&]( SCH_ITEM* aItem ) -> bool
 {
 SCH_CONNECTION* conn = aItem->GetOrInitConnection( sheet, this );
 bool unique = !( aItem->GetFlags() & CANDIDATE );

 if( conn && !conn->SubgraphCode() )
 aItem->SetFlags( CANDIDATE );

 return ( unique && conn && ( conn->SubgraphCode() == 0 ) );
 };

 std::copy_if( item->ConnectedItems( sheet ).begin(),
 item->ConnectedItems( sheet ).end(),
 std::back_inserter( memberlist ), get_items );

 for( SCH_ITEM* connected_item : memberlist )
 {
 if( connected_item->Type() == SCH_NO_CONNECT_T )
 subgraph->m_no_connect = connected_item;

 SCH_CONNECTION* connected_conn = connected_item->Connection( &sheet );

 wxASSERT( connected_conn );

 if( connected_conn->SubgraphCode() == 0 )
 {
 connected_conn->SetSubgraphCode( subgraph->m_code );
 m_item_to_subgraph_map[connected_item] = subgraph;
 subgraph->AddItem( connected_item );
 SCH_ITEM_SET& citemset = connected_item->ConnectedItems( sheet );

 for( SCH_ITEM* citem : citemset )
 {
 if( citem->HasFlag( CANDIDATE ) )
 continue;

 if( get_items( citem ) )
 memberlist.push_back( citem );
 }
 }
 }

 for( SCH_ITEM* connected_item : memberlist )
 connected_item->ClearFlags( CANDIDATE );

 subgraph->m_dirty = true;
 m_subgraphs.push_back( subgraph );
 }
 }
 }

}

References CONNECTION_SUBGRAPH::AddItem(), CANDIDATE, CONNECTION_SUBGRAPH::m_code, CONNECTION_SUBGRAPH::m_dirty, m_item_to_subgraph_map, m_items, m_last_subgraph_code, CONNECTION_SUBGRAPH::m_no_connect, CONNECTION_SUBGRAPH::m_sheet, m_subgraphs, SCH_NO_CONNECT_T, SCH_CONNECTION::SetSubgraphCode(), and SCH_CONNECTION::SubgraphCode().

Referenced by buildConnectionGraph().

collectAllDriverValues()

void CONNECTION_GRAPH::collectAllDriverValues ( )

private

Maps the driver values for each subgraph.

Definition at line 893 of file connection_graph.cpp.

{
 // Check for subgraphs with the same net name but only weak drivers.
 // For example, two wires that are both connected to hierarchical
 // sheet pins that happen to have the same name, but are not the same.

 for( auto&& subgraph : m_driver_subgraphs )
 {
 wxString full_name = subgraph->m_driver_connection->Name();
 wxString name = subgraph->m_driver_connection->Name( true );
 m_net_name_to_subgraphs_map[full_name].emplace_back( subgraph );

 // For vector buses, we need to cache the prefix also, as two different instances of the
 // weakly driven pin may have the same prefix but different vector start and end. We need
 // to treat those as needing renaming also, because otherwise if they end up on a sheet with
 // common usage, they will be incorrectly merged.
 if( subgraph->m_driver_connection->Type() == CONNECTION_TYPE::BUS )
 {
 wxString prefixOnly = full_name.BeforeFirst( '[' ) + wxT( "[]" );
 m_net_name_to_subgraphs_map[prefixOnly].emplace_back( subgraph );
 }

 subgraph->m_dirty = true;

 if( subgraph->m_strong_driver )
 {
 SCH_ITEM* driver = subgraph->m_driver;
 SCH_SHEET_PATH sheet = subgraph->m_sheet;

 switch( driver->Type() )
 {
 case SCH_LABEL_T:
 case SCH_HIER_LABEL_T:
 {
 m_local_label_cache[std::make_pair( sheet, name )].push_back( subgraph );
 break;
 }
 case SCH_GLOBAL_LABEL_T:
 {
 m_global_label_cache[name].push_back( subgraph );
 break;
 }
 case SCH_PIN_T:
 {
 SCH_PIN* pin = static_cast<SCH_PIN*>( driver );
 wxASSERT( pin->IsPowerConnection() );
 m_global_label_cache[name].push_back( subgraph );
 break;
 }
 default:
 wxLogTrace( ConnTrace, wxT( "Unexpected strong driver %s" ),
 driver->GetSelectMenuText( EDA_UNITS::MILLIMETRES ) );
 break;
 }
 }
 }
}

References BUS, ConnTrace, EDA_ITEM::GetSelectMenuText(), m_driver_subgraphs, m_global_label_cache, m_local_label_cache, m_net_name_to_subgraphs_map, MILLIMETRES, name, pin, SCH_GLOBAL_LABEL_T, SCH_HIER_LABEL_T, SCH_LABEL_T, SCH_PIN_T, and EDA_ITEM::Type().

Referenced by buildConnectionGraph().

ercCheckBusToBusConflicts()

bool CONNECTION_GRAPH::ercCheckBusToBusConflicts ( const CONNECTION_SUBGRAPH *  aSubgraph )

private

Checks one subgraph for conflicting connections between two bus items.

For example, a labeled bus wire connected to a hierarchical sheet pin where the labeled bus doesn't contain any of the same bus members as the sheet pin

Parameters

aSubgraph

is the subgraph to examine

Returns

true for no errors, false for errors

Definition at line 2461 of file connection_graph.cpp.

{
 wxString msg;
 const SCH_SHEET_PATH& sheet = aSubgraph->m_sheet;
 SCH_SCREEN* screen = sheet.LastScreen();

 SCH_ITEM* label = nullptr;
 SCH_ITEM* port = nullptr;

 for( auto item : aSubgraph->m_items )
 {
 switch( item->Type() )
 {
 case SCH_TEXT_T:
 case SCH_GLOBAL_LABEL_T:
 {
 if( !label && item->Connection( &sheet )->IsBus() )
 label = item;
 break;
 }

 case SCH_SHEET_PIN_T:
 case SCH_HIER_LABEL_T:
 {
 if( !port && item->Connection( &sheet )->IsBus() )
 port = item;
 break;
 }

 default:
 break;
 }
 }

 if( label && port )
 {
 bool match = false;

 for( const auto& member : label->Connection( &sheet )->Members() )
 {
 for( const auto& test : port->Connection( &sheet )->Members() )
 {
 if( test != member && member->Name() == test->Name() )
 {
 match = true;
 break;
 }
 }

 if( match )
 break;
 }

 if( !match )
 {
 std::shared_ptr<ERC_ITEM> ercItem = ERC_ITEM::Create( ERCE_BUS_TO_BUS_CONFLICT );
 ercItem->SetItems( label, port );

 SCH_MARKER* marker = new SCH_MARKER( ercItem, label->GetPosition() );
 screen->Append( marker );

 return false;
 }
 }

 return true;
}

References SCH_SCREEN::Append(), SCH_ITEM::Connection(), ERC_ITEM::Create(), ERCE_BUS_TO_BUS_CONFLICT, EDA_ITEM::GetPosition(), SCH_CONNECTION::IsBus(), SCH_SHEET_PATH::LastScreen(), CONNECTION_SUBGRAPH::m_items, CONNECTION_SUBGRAPH::m_sheet, SCH_CONNECTION::Members(), SCH_GLOBAL_LABEL_T, SCH_HIER_LABEL_T, SCH_SHEET_PIN_T, and SCH_TEXT_T.

Referenced by RunERC().

ercCheckBusToBusEntryConflicts()

bool CONNECTION_GRAPH::ercCheckBusToBusEntryConflicts ( const CONNECTION_SUBGRAPH *  aSubgraph )

private

Checks one subgraph for conflicting bus entry to bus connections.

For example, a wire with label "A0" is connected to a bus labeled "D[8..0]"

Will also check for mistakes related to bus group names, for example: A bus group named "USB{DP DM}" should have bus entry connections like "USB.DP" but someone might accidentally just enter "DP"

Parameters

aSubgraph

is the subgraph to examine

Returns

true for no errors, false for errors

Definition at line 2530 of file connection_graph.cpp.

{
 bool conflict = false;
 const SCH_SHEET_PATH& sheet = aSubgraph->m_sheet;
 SCH_SCREEN* screen = sheet.LastScreen();

 SCH_BUS_WIRE_ENTRY* bus_entry = nullptr;
 SCH_ITEM* bus_wire = nullptr;
 wxString bus_name;

 if( !aSubgraph->m_driver_connection )
 {
 // Incomplete bus entry. Let the unconnected tests handle it.
 return true;
 }

 for( SCH_ITEM* item : aSubgraph->m_items )
 {
 switch( item->Type() )
 {
 case SCH_BUS_WIRE_ENTRY_T:
 {
 if( !bus_entry )
 bus_entry = static_cast<SCH_BUS_WIRE_ENTRY*>( item );
 break;
 }

 default:
 break;
 }
 }

 if( bus_entry && bus_entry->m_connected_bus_item )
 {
 bus_wire = bus_entry->m_connected_bus_item;

 wxASSERT( bus_wire->Type() == SCH_LINE_T );

 // In some cases, the connection list (SCH_CONNECTION*) can be null.
 // Skip null connections.
 if( bus_entry->Connection( &sheet )
 && bus_wire->Type() == SCH_LINE_T
 && bus_wire->Connection( &sheet ) )
 {
 conflict = true; // Assume a conflict; we'll reset if we find it's OK

 bus_name = bus_wire->Connection( &sheet )->Name();

 wxString test_name = bus_entry->Connection( &sheet )->Name();

 for( const auto& member : bus_wire->Connection( &sheet )->Members() )
 {
  if( member->Type() == CONNECTION_TYPE::BUS )
 {
 for( const auto& sub_member : member->Members() )
 {
 if( sub_member->Name() == test_name )
 conflict = false;
 }
 }
 else if( member->Name() == test_name )
 {
 conflict = false;
 }
 }
 }
 }

 // Don't report warnings if this bus member has been overridden by a higher priority power pin
 // or global label
 if( conflict && CONNECTION_SUBGRAPH::GetDriverPriority( aSubgraph->m_driver )
 >= CONNECTION_SUBGRAPH::PRIORITY::POWER_PIN )
 {
 conflict = false;
 }

 if( conflict )
 {
 wxString netName = aSubgraph->m_driver_connection->Name();
 wxString msg = wxString::Format( _( "Net %s is graphically connected to bus %s but is not a"
 " member of that bus" ),
 UnescapeString( netName ),
 UnescapeString( bus_name ) );
 std::shared_ptr<ERC_ITEM> ercItem = ERC_ITEM::Create( ERCE_BUS_ENTRY_CONFLICT );
 ercItem->SetItems( bus_entry, bus_wire );
 ercItem->SetErrorMessage( msg );

 SCH_MARKER* marker = new SCH_MARKER( ercItem, bus_entry->GetPosition() );
 screen->Append( marker );

 return false;
 }

 return true;
}

References _, SCH_SCREEN::Append(), BUS, SCH_ITEM::Connection(), ERC_ITEM::Create(), ERCE_BUS_ENTRY_CONFLICT, Format(), CONNECTION_SUBGRAPH::GetDriverPriority(), SCH_BUS_ENTRY_BASE::GetPosition(), SCH_SHEET_PATH::LastScreen(), SCH_BUS_WIRE_ENTRY::m_connected_bus_item, CONNECTION_SUBGRAPH::m_driver, CONNECTION_SUBGRAPH::m_driver_connection, CONNECTION_SUBGRAPH::m_items, CONNECTION_SUBGRAPH::m_sheet, SCH_CONNECTION::Members(), SCH_CONNECTION::Name(), CONNECTION_SUBGRAPH::POWER_PIN, SCH_BUS_WIRE_ENTRY_T, SCH_LINE_T, EDA_ITEM::Type(), and UnescapeString().

Referenced by RunERC().

ercCheckBusToNetConflicts()

bool CONNECTION_GRAPH::ercCheckBusToNetConflicts ( const CONNECTION_SUBGRAPH *  aSubgraph )

private

Checks one subgraph for conflicting connections between net and bus labels.

For example, a net wire connected to a bus port/pin, or vice versa

Parameters

aSubgraph

is the subgraph to examine

Returns

true for no errors, false for errors

Definition at line 2404 of file connection_graph.cpp.

{
 const SCH_SHEET_PATH& sheet = aSubgraph->m_sheet;
 SCH_SCREEN* screen = sheet.LastScreen();

 SCH_ITEM* net_item = nullptr;
 SCH_ITEM* bus_item = nullptr;
 SCH_CONNECTION conn( this );

 for( SCH_ITEM* item : aSubgraph->m_items )
 {
 switch( item->Type() )
 {
 case SCH_LINE_T:
 {
 if( item->GetLayer() == LAYER_BUS )
 bus_item = ( !bus_item ) ? item : bus_item;
 else
 net_item = ( !net_item ) ? item : net_item;
 break;
 }

 case SCH_LABEL_T:
 case SCH_GLOBAL_LABEL_T:
 case SCH_SHEET_PIN_T:
 case SCH_HIER_LABEL_T:
 {
 SCH_TEXT* text = static_cast<SCH_TEXT*>( item );
 conn.ConfigureFromLabel( EscapeString( text->GetShownText(), CTX_NETNAME ) );

 if( conn.IsBus() )
 bus_item = ( !bus_item ) ? item : bus_item;
 else
 net_item = ( !net_item ) ? item : net_item;
 break;
 }

 default:
 break;
 }
 }

 if( net_item && bus_item )
 {
 std::shared_ptr<ERC_ITEM> ercItem = ERC_ITEM::Create( ERCE_BUS_TO_NET_CONFLICT );
 ercItem->SetItems( net_item, bus_item );

 SCH_MARKER* marker = new SCH_MARKER( ercItem, net_item->GetPosition() );
 screen->Append( marker );

 return false;
 }

 return true;
}

References SCH_SCREEN::Append(), SCH_CONNECTION::ConfigureFromLabel(), ERC_ITEM::Create(), CTX_NETNAME, ERCE_BUS_TO_NET_CONFLICT, EscapeString(), SCH_ITEM::GetLayer(), EDA_ITEM::GetPosition(), SCH_CONNECTION::IsBus(), SCH_SHEET_PATH::LastScreen(), LAYER_BUS, CONNECTION_SUBGRAPH::m_items, CONNECTION_SUBGRAPH::m_sheet, SCH_GLOBAL_LABEL_T, SCH_HIER_LABEL_T, SCH_LABEL_T, SCH_LINE_T, SCH_SHEET_PIN_T, text, and EDA_ITEM::Type().

Referenced by RunERC().

ercCheckFloatingWires()

bool CONNECTION_GRAPH::ercCheckFloatingWires ( const CONNECTION_SUBGRAPH *  aSubgraph )

private

Checks one subgraph for floating wires.

Will throw an error for any subgraph that consists of just wires with no driver

Parameters

aSubgraph

is the subgraph to examine

Returns

true for no errors, false for errors

Definition at line 2801 of file connection_graph.cpp.

{
 if( aSubgraph->m_driver )
 return true;

 std::vector<SCH_ITEM*> wires;

 // We've gotten this far, so we know we have no valid driver. All we need to do is check
 // for a wire that we can place the error on.

 for( SCH_ITEM* item : aSubgraph->m_items )
 {
 if( item->Type() == SCH_LINE_T && item->GetLayer() == LAYER_WIRE )
 wires.emplace_back( item );
 else if( item->Type() == SCH_BUS_WIRE_ENTRY_T )
 wires.emplace_back( item );
 }

 if( !wires.empty() )
 {
 SCH_SCREEN* screen = aSubgraph->m_sheet.LastScreen();

 std::shared_ptr<ERC_ITEM> ercItem = ERC_ITEM::Create( ERCE_WIRE_DANGLING );
 ercItem->SetItems( wires[0],
 wires.size() > 1 ? wires[1] : nullptr,
 wires.size() > 2 ? wires[2] : nullptr,
 wires.size() > 3 ? wires[3] : nullptr );

 SCH_MARKER* marker = new SCH_MARKER( ercItem, wires[0]->GetPosition() );
 screen->Append( marker );

 return false;
 }

 return true;
}

References SCH_SCREEN::Append(), ERC_ITEM::Create(), ERCE_WIRE_DANGLING, SCH_ITEM::GetLayer(), SCH_SHEET_PATH::LastScreen(), LAYER_WIRE, CONNECTION_SUBGRAPH::m_driver, CONNECTION_SUBGRAPH::m_items, CONNECTION_SUBGRAPH::m_sheet, SCH_BUS_WIRE_ENTRY_T, SCH_LINE_T, and EDA_ITEM::Type().

Referenced by RunERC().

ercCheckHierSheets()

int CONNECTION_GRAPH::ercCheckHierSheets ( )

private

Checks that a hierarchical sheet has at least one matching label inside the sheet for each port on the parent sheet object.

Parameters

aSubgraph

is the subgraph to examine

Returns

the number of errors found

Definition at line 2993 of file connection_graph.cpp.

{
 int errors = 0;

 ERC_SETTINGS& settings = m_schematic->ErcSettings();

 for( const SCH_SHEET_PATH& sheet : m_sheetList )
 {
 for( SCH_ITEM* item : sheet.LastScreen()->Items() )
 {
 if( item->Type() != SCH_SHEET_T )
 continue;

 SCH_SHEET* parentSheet = static_cast<SCH_SHEET*>( item );

 std::map<wxString, SCH_SHEET_PIN*> pins;
 std::map<wxString, SCH_HIERLABEL*> labels;

 for( SCH_SHEET_PIN* pin : parentSheet->GetPins() )
 {
 if( settings.IsTestEnabled( ERCE_HIERACHICAL_LABEL ) )
 pins[pin->GetText()] = pin;

 if( pin->IsDangling() && settings.IsTestEnabled( ERCE_PIN_NOT_CONNECTED ) )
 {
 std::shared_ptr<ERC_ITEM> ercItem = ERC_ITEM::Create( ERCE_PIN_NOT_CONNECTED );
 ercItem->SetItems( pin );

 SCH_MARKER* marker = new SCH_MARKER( ercItem, pin->GetPosition() );
 sheet.LastScreen()->Append( marker );

 errors++;
 }
 }

 if( settings.IsTestEnabled( ERCE_HIERACHICAL_LABEL ) )
 {
 std::set<wxString> matchedPins;

 for( SCH_ITEM* subItem : parentSheet->GetScreen()->Items() )
 {
 if( subItem->Type() == SCH_HIER_LABEL_T )
 {
 SCH_HIERLABEL* label = static_cast<SCH_HIERLABEL*>( subItem );

 if( !pins.count( label->GetText() ) )
 labels[label->GetText()] = label;
 else
 matchedPins.insert( label->GetText() );
 }
 }

 for( const wxString& matched : matchedPins )
 pins.erase( matched );

 for( const std::pair<const wxString, SCH_SHEET_PIN*>& unmatched : pins )
 {
 wxString msg = wxString::Format( _( "Sheet pin %s has no matching hierarchical "
 "label inside the sheet" ),
 UnescapeString( unmatched.first ) );

 std::shared_ptr<ERC_ITEM> ercItem = ERC_ITEM::Create( ERCE_HIERACHICAL_LABEL );
 ercItem->SetItems( unmatched.second );
 ercItem->SetErrorMessage( msg );
 ercItem->SetIsSheetSpecific();

 SCH_MARKER* marker = new SCH_MARKER( ercItem, unmatched.second->GetPosition() );
 sheet.LastScreen()->Append( marker );

 errors++;
 }

 for( const std::pair<const wxString, SCH_HIERLABEL*>& unmatched : labels )
 {
 wxString msg = wxString::Format( _( "Hierarchical label %s has no matching "
 "sheet pin in the parent sheet" ),
 UnescapeString( unmatched.first ) );

 std::shared_ptr<ERC_ITEM> ercItem = ERC_ITEM::Create( ERCE_HIERACHICAL_LABEL );
 ercItem->SetItems( unmatched.second );
 ercItem->SetErrorMessage( msg );
 ercItem->SetIsSheetSpecific();

 SCH_MARKER* marker = new SCH_MARKER( ercItem, unmatched.second->GetPosition() );
 parentSheet->GetScreen()->Append( marker );

 errors++;
 }
 }
 }
 }

 return errors;
}

References _, SCH_SCREEN::Append(), ERC_ITEM::Create(), ERCE_HIERACHICAL_LABEL, ERCE_PIN_NOT_CONNECTED, SCHEMATIC::ErcSettings(), Format(), SCH_SHEET::GetPins(), SCH_SHEET::GetScreen(), EDA_TEXT::GetText(), ERC_SETTINGS::IsTestEnabled(), SCH_SCREEN::Items(), m_schematic, m_sheetList, pin, SCH_HIER_LABEL_T, SCH_SHEET_T, and UnescapeString().

Referenced by RunERC().

ercCheckLabels()

bool CONNECTION_GRAPH::ercCheckLabels ( const CONNECTION_SUBGRAPH *  aSubgraph )

private

Checks one subgraph for proper connection of labels.

Labels should be connected to something

Parameters

aSubgraph	is the subgraph to examine
aCheckGlobalLabels	is true if global labels should be checked for loneliness

Returns

true for no errors, false for errors

Definition at line 2839 of file connection_graph.cpp.

{
 // Label connection rules:
 // Local labels are flagged if they don't connect to any pins and don't have a no-connect
 // Global labels are flagged if they appear only once, don't connect to any local labels,
 // and don't have a no-connect marker

 // So, if there is a no-connect, we will never generate a warning here
 if( aSubgraph->m_no_connect )
 return true;

 if( !aSubgraph->m_driver_connection )
 return true;

 // Buses are excluded from this test: many users create buses with only a single instance
 // and it's not really a problem as long as the nets in the bus pass ERC
 if( aSubgraph->m_driver_connection->IsBus() )
 return true;

 ERC_SETTINGS& settings = m_schematic->ErcSettings();
 bool ok = true;
 SCH_TEXT* text = nullptr;
 bool hasOtherConnections = false;
 int pinCount = 0;

 auto hasPins =
 []( const CONNECTION_SUBGRAPH* aLocSubgraph )
 {
 for( const SCH_ITEM* item : aLocSubgraph->m_items )
 {
 switch( item->Type() )
 {
 case SCH_PIN_T:
 case SCH_SHEET_PIN_T:
 return true;

 default: break;
 }
 }

 return false;
 };

 for( SCH_ITEM* item : aSubgraph->m_items )
 {
 switch( item->Type() )
 {
 case SCH_LABEL_T:
 case SCH_GLOBAL_LABEL_T:
 case SCH_HIER_LABEL_T:
 {
 text = static_cast<SCH_TEXT*>( item );

 // Below, we'll create an ERC if the whole subgraph is unconnected. But, additionally,
 // we want to error if an individual label in the subgraph is floating, even if it's
 // connected to other valid things by way of another label on the same sheet.

 if( text->IsDangling() && settings.IsTestEnabled( ERCE_LABEL_NOT_CONNECTED ) )
 {
 std::shared_ptr<ERC_ITEM> ercItem = ERC_ITEM::Create( ERCE_LABEL_NOT_CONNECTED );
 ercItem->SetItems( text );

 SCH_MARKER* marker = new SCH_MARKER( ercItem, text->GetPosition() );
 aSubgraph->m_sheet.LastScreen()->Append( marker );
 ok = false;
 }

 break;
 }

 case SCH_PIN_T:
 case SCH_SHEET_PIN_T:
 hasOtherConnections = true;
 pinCount++;
 break;

 default:
 break;
 }
 }

 if( !text )
 return true;

 bool isGlobal = text->Type() == SCH_GLOBAL_LABEL_T;
 int errCode = isGlobal ? ERCE_GLOBLABEL : ERCE_LABEL_NOT_CONNECTED;

 wxCHECK_MSG( m_schematic, true, wxT( "Null m_schematic in CONNECTION_GRAPH::ercCheckLabels" ) );

 wxString name = EscapeString( text->GetShownText(), CTX_NETNAME );

 if( isGlobal )
 {
 // This will be set to true if the global is connected to a pin above, but we want to
 // reset this to false so that globals get flagged if they only have a single instance
 // connected to a single pin
 hasOtherConnections = ( pinCount > 1 );

 auto it = m_net_name_to_subgraphs_map.find( name );

 if( it != m_net_name_to_subgraphs_map.end() )
 {
 if( it->second.size() > 1 || aSubgraph->m_multiple_drivers )
 hasOtherConnections = true;
 }
 }
 else if( text->Type() == SCH_HIER_LABEL_T )
 {
 // For a hier label, check if the parent pin is connected
 if( aSubgraph->m_hier_parent
 && ( aSubgraph->m_hier_parent->m_strong_driver
 || aSubgraph->m_hier_parent->m_drivers.size() > 1) )
 {
 // For now, a simple check: if there is more than one driver, the parent is probably
 // connected elsewhere (because at least one driver will be the hier pin itself)
 hasOtherConnections = true;
 }
 }
 else
 {
 auto pair = std::make_pair( aSubgraph->m_sheet, name );
 auto it = m_local_label_cache.find( pair );

 if( it != m_local_label_cache.end() && it->second.size() > 1 )
 {
 for( const CONNECTION_SUBGRAPH* neighbor : it->second )
 {
 if( neighbor == aSubgraph )
 continue;

 if( hasPins( neighbor ) )
 {
 hasOtherConnections = true;
 break;
 }
 }
 }
 }

 if( !hasOtherConnections && settings.IsTestEnabled( errCode ) )
 {
 std::shared_ptr<ERC_ITEM> ercItem = ERC_ITEM::Create( errCode );
 ercItem->SetItems( text );

 SCH_MARKER* marker = new SCH_MARKER( ercItem, text->GetPosition() );
 aSubgraph->m_sheet.LastScreen()->Append( marker );

 return false;
 }

 return ok;
}

References SCH_SCREEN::Append(), ERC_ITEM::Create(), CTX_NETNAME, ERCE_GLOBLABEL, ERCE_LABEL_NOT_CONNECTED, SCHEMATIC::ErcSettings(), EscapeString(), SCH_CONNECTION::IsBus(), ERC_SETTINGS::IsTestEnabled(), SCH_SHEET_PATH::LastScreen(), CONNECTION_SUBGRAPH::m_driver_connection, CONNECTION_SUBGRAPH::m_drivers, CONNECTION_SUBGRAPH::m_hier_parent, CONNECTION_SUBGRAPH::m_items, m_local_label_cache, CONNECTION_SUBGRAPH::m_multiple_drivers, m_net_name_to_subgraphs_map, CONNECTION_SUBGRAPH::m_no_connect, m_schematic, CONNECTION_SUBGRAPH::m_sheet, CONNECTION_SUBGRAPH::m_strong_driver, name, SCH_GLOBAL_LABEL_T, SCH_HIER_LABEL_T, SCH_LABEL_T, SCH_PIN_T, SCH_SHEET_PIN_T, text, and EDA_ITEM::Type().

Referenced by RunERC().

ercCheckMultipleDrivers()

bool CONNECTION_GRAPH::ercCheckMultipleDrivers ( const CONNECTION_SUBGRAPH *  aSubgraph )

private

If the subgraph has multiple drivers of equal priority that are graphically connected, ResolveDrivers() will have stored the second driver for use by this function, which actually creates the markers.

Parameters

aSubgraph

is the subgraph to examine

Returns

true for no errors, false for errors

Definition at line 2331 of file connection_graph.cpp.

{
 wxCHECK( aSubgraph, false );
 /*
 * This was changed late in 6.0 to fix https://gitlab.com/kicad/code/kicad/-/issues/9367
 * so I'm going to leave the original code in for just a little while. If anyone comes
 * across this in 7.0 development (or later), feel free to delete.
 */
#if 0
 if( aSubgraph->m_second_driver )
 {
 SCH_ITEM* primary = aSubgraph->m_first_driver;
 SCH_ITEM* secondary = aSubgraph->m_second_driver;

 wxPoint pos = primary->Type() == SCH_PIN_T ?
 static_cast<SCH_PIN*>( primary )->GetTransformedPosition() :
 primary->GetPosition();

 wxString primaryName = aSubgraph->GetNameForDriver( primary );
 wxString secondaryName = aSubgraph->GetNameForDriver( secondary );

 wxString msg = wxString::Format( _( "Both %s and %s are attached to the same "
 "items; %s will be used in the netlist" ),
 primaryName, secondaryName, primaryName );

 std::shared_ptr<ERC_ITEM> ercItem = ERC_ITEM::Create( ERCE_DRIVER_CONFLICT );
 ercItem->SetItems( primary, secondary );
 ercItem->SetErrorMessage( msg );

 SCH_MARKER* marker = new SCH_MARKER( ercItem, pos );
 aSubgraph->m_sheet.LastScreen()->Append( marker );

 return false;
 }
#else
 if( aSubgraph->m_multiple_drivers )
 {
 for( SCH_ITEM* driver : aSubgraph->m_drivers )
 {
 if( driver == aSubgraph->m_driver )
 continue;

 if( driver->Type() == SCH_GLOBAL_LABEL_T
 || driver->Type() == SCH_HIER_LABEL_T
 || driver->Type() == SCH_LABEL_T )
 {
 wxString primaryName = aSubgraph->GetNameForDriver( aSubgraph->m_driver );
 wxString secondaryName = aSubgraph->GetNameForDriver( driver );

 if( primaryName == secondaryName )
 continue;

 wxString msg = wxString::Format( _( "Both %s and %s are attached to the same "
 "items; %s will be used in the netlist" ),
 primaryName, secondaryName, primaryName );

 std::shared_ptr<ERC_ITEM> ercItem = ERC_ITEM::Create( ERCE_DRIVER_CONFLICT );
 ercItem->SetItems( aSubgraph->m_driver, driver );
 ercItem->SetErrorMessage( msg );

 SCH_MARKER* marker = new SCH_MARKER( ercItem, driver->GetPosition() );
 aSubgraph->m_sheet.LastScreen()->Append( marker );

 return false;
 }
 }
 }
#endif

 return true;
}

References _, SCH_SCREEN::Append(), ERC_ITEM::Create(), ERCE_DRIVER_CONFLICT, Format(), CONNECTION_SUBGRAPH::GetNameForDriver(), EDA_ITEM::GetPosition(), SCH_SHEET_PATH::LastScreen(), CONNECTION_SUBGRAPH::m_driver, CONNECTION_SUBGRAPH::m_drivers, CONNECTION_SUBGRAPH::m_first_driver, CONNECTION_SUBGRAPH::m_multiple_drivers, CONNECTION_SUBGRAPH::m_second_driver, CONNECTION_SUBGRAPH::m_sheet, SCH_GLOBAL_LABEL_T, SCH_HIER_LABEL_T, SCH_LABEL_T, SCH_PIN_T, and EDA_ITEM::Type().

Referenced by RunERC().

ercCheckNoConnects()

bool CONNECTION_GRAPH::ercCheckNoConnects ( const CONNECTION_SUBGRAPH *  aSubgraph )

private

Checks one subgraph for proper presence or absence of no-connect symbols.

A pin with a no-connect symbol should not have any connections A pin without a no-connect symbol should have at least one connection

Parameters

aSubgraph

is the subgraph to examine

Returns

true for no errors, false for errors

Definition at line 2628 of file connection_graph.cpp.

{
 ERC_SETTINGS& settings = m_schematic->ErcSettings();
 wxString msg;
 const SCH_SHEET_PATH& sheet = aSubgraph->m_sheet;
 SCH_SCREEN* screen = sheet.LastScreen();
 bool ok = true;

 if( aSubgraph->m_no_connect != nullptr )
 {
 bool has_invalid_items = false;
 bool has_other_items = false;
 SCH_PIN* pin = nullptr;
 std::vector<SCH_ITEM*> invalid_items;
 wxPoint noConnectPos = aSubgraph->m_no_connect->GetPosition();
 double minDist = 0;

 // Any subgraph that contains both a pin and a no-connect should not
 // contain any other driving items.

 for( SCH_ITEM* item : aSubgraph->m_items )
 {
 switch( item->Type() )
 {
 case SCH_PIN_T:
 {
 SCH_PIN* candidate = static_cast<SCH_PIN*>( item );
 double dist = VECTOR2I( candidate->GetTransformedPosition() - noConnectPos )
 .SquaredEuclideanNorm();

 if( !pin || dist < minDist )
 {
 pin = candidate;
 minDist = dist;
 }

 has_invalid_items |= has_other_items;
 has_other_items = true;
 break;
 }

 case SCH_LINE_T:
 case SCH_JUNCTION_T:
 case SCH_NO_CONNECT_T:
 break;

 default:
 has_invalid_items = true;
 has_other_items = true;
 invalid_items.push_back( item );
 }
 }

 if( pin && has_invalid_items && settings.IsTestEnabled( ERCE_NOCONNECT_CONNECTED ) )
 {
 std::shared_ptr<ERC_ITEM> ercItem = ERC_ITEM::Create( ERCE_NOCONNECT_CONNECTED );
 ercItem->SetItems( pin );

 SCH_MARKER* marker = new SCH_MARKER( ercItem, pin->GetTransformedPosition() );
 screen->Append( marker );

 ok = false;
 }

 if( !has_other_items && settings.IsTestEnabled( ERCE_NOCONNECT_NOT_CONNECTED ) )
 {
 std::shared_ptr<ERC_ITEM> ercItem = ERC_ITEM::Create( ERCE_NOCONNECT_NOT_CONNECTED );
 ercItem->SetItems( aSubgraph->m_no_connect );

 SCH_MARKER* marker = new SCH_MARKER( ercItem, aSubgraph->m_no_connect->GetPosition() );
 screen->Append( marker );

 ok = false;
 }
 }
 else
 {
 bool has_other_connections = false;
 std::vector<SCH_PIN*> pins;

 // Any subgraph that lacks a no-connect and contains a pin should also
 // contain at least one other potential driver

 for( SCH_ITEM* item : aSubgraph->m_items )
 {
 switch( item->Type() )
 {
 case SCH_PIN_T:
 {
 if( !pins.empty() )
 has_other_connections = true;

 pins.emplace_back( static_cast<SCH_PIN*>( item ) );

  break;
 }

 default:
 if( aSubgraph->GetDriverPriority( item ) != CONNECTION_SUBGRAPH::PRIORITY::NONE )
 has_other_connections = true;

 break;
 }
 }

 // For many checks, we can just use the first pin
 SCH_PIN* pin = pins.empty() ? nullptr : pins[0];

 // Check if invisible power input pins connect to anything else via net name,
 // but not for power symbols as the ones in the standard library all have invisible pins
 // and we want to throw unconnected errors for those even if they are connected to other
 // net items by name, because usually failing to connect them graphically is a mistake
 if( pin && !has_other_connections
 && pin->GetType() == ELECTRICAL_PINTYPE::PT_POWER_IN
 && !pin->IsVisible()
 && !pin->GetLibPin()->GetParent()->IsPower() )
 {
 wxString name = pin->Connection( &sheet )->Name();
 wxString local_name = pin->Connection( &sheet )->Name( true );

 if( m_global_label_cache.count( name )
 || m_local_label_cache.count( std::make_pair( sheet, local_name ) ) )
 {
 has_other_connections = true;
 }
 }

 // Only one pin, and it's not a no-connect pin
 if( pin && !has_other_connections
 && pin->GetType() != ELECTRICAL_PINTYPE::PT_NC
 && pin->GetType() != ELECTRICAL_PINTYPE::PT_NIC
 && settings.IsTestEnabled( ERCE_PIN_NOT_CONNECTED ) )
 {
 std::shared_ptr<ERC_ITEM> ercItem = ERC_ITEM::Create( ERCE_PIN_NOT_CONNECTED );
 ercItem->SetItems( pin );

 SCH_MARKER* marker = new SCH_MARKER( ercItem, pin->GetTransformedPosition() );
 screen->Append( marker );

 ok = false;
 }

 // If there are multiple pins in this SG, they might be indirectly connected (by netname)
 // rather than directly connected (by wires). We want to flag dangling pins even if they
 // join nets with another pin, as it's often a mistake
 if( pins.size() > 1 )
 {
 for( SCH_PIN* testPin : pins )
 {
 // We only apply this test to power symbols, because other symbols have invisible
 // pins that are meant to be dangling, but the KiCad standard library power symbols
 // have invisible pins that are *not* meant to be dangling.
 if( testPin->GetLibPin()->GetParent()->IsPower()
 && testPin->ConnectedItems( sheet ).empty()
 && settings.IsTestEnabled( ERCE_PIN_NOT_CONNECTED ) )
 {
 std::shared_ptr<ERC_ITEM> ercItem = ERC_ITEM::Create( ERCE_PIN_NOT_CONNECTED );
 ercItem->SetItems( testPin );

 SCH_MARKER* marker = new SCH_MARKER( ercItem,
 testPin->GetTransformedPosition() );
 screen->Append( marker );

 ok = false;
 }
 }
 }
 }

 return ok;
}

References SCH_SCREEN::Append(), ERC_ITEM::Create(), ERCE_NOCONNECT_CONNECTED, ERCE_NOCONNECT_NOT_CONNECTED, ERCE_PIN_NOT_CONNECTED, SCHEMATIC::ErcSettings(), CONNECTION_SUBGRAPH::GetDriverPriority(), EDA_ITEM::GetPosition(), SCH_PIN::GetTransformedPosition(), ERC_SETTINGS::IsTestEnabled(), SCH_SHEET_PATH::LastScreen(), m_global_label_cache, CONNECTION_SUBGRAPH::m_items, m_local_label_cache, CONNECTION_SUBGRAPH::m_no_connect, m_schematic, CONNECTION_SUBGRAPH::m_sheet, name, CONNECTION_SUBGRAPH::NONE, pin, PT_NC, PT_NIC, PT_POWER_IN, SCH_JUNCTION_T, SCH_LINE_T, SCH_NO_CONNECT_T, SCH_PIN_T, and EDA_ITEM::Type().

Referenced by RunERC().

FindFirstSubgraphByName()

CONNECTION_SUBGRAPH * CONNECTION_GRAPH::FindFirstSubgraphByName

(

const wxString &

aNetName

)

Retrieves a subgraph for the given net name, if one exists.

Searches every sheet

Parameters

aNetName

is the full net name to search for

Returns

the subgraph matching the query, or nullptr if none is found

Definition at line 2208 of file connection_graph.cpp.

{
 auto it = m_net_name_to_subgraphs_map.find( aNetName );

 if( it == m_net_name_to_subgraphs_map.end() )
 return nullptr;

 wxASSERT( !it->second.empty() );

 return it->second[0];
}

References m_net_name_to_subgraphs_map.

FindSubgraphByName()

CONNECTION_SUBGRAPH * CONNECTION_GRAPH::FindSubgraphByName	(	const wxString &	aNetName,
		const SCH_SHEET_PATH &	aPath
	)

Returns the subgraph for a given net name on a given sheet.

Parameters

aNetName	is the local net name to look for
aPath	is a sheet path to look on

Returns

the subgraph matching the query, or nullptr if none is found

Definition at line 2187 of file connection_graph.cpp.

{
 auto it = m_net_name_to_subgraphs_map.find( aNetName );

 if( it == m_net_name_to_subgraphs_map.end() )
 return nullptr;

 for( CONNECTION_SUBGRAPH* sg : it->second )
 {
 // Cache is supposed to be valid by now
 wxASSERT( sg && !sg->m_absorbed && sg->m_driver_connection );

 if( sg->m_sheet == aPath && sg->m_driver_connection->Name() == aNetName )
 return sg;
 }

 return nullptr;
}

References CONNECTION_SUBGRAPH::m_absorbed, CONNECTION_SUBGRAPH::m_driver_connection, m_net_name_to_subgraphs_map, CONNECTION_SUBGRAPH::m_sheet, and SCH_CONNECTION::Name().

Referenced by NETLIST_EXPORTER_BASE::CreatePinList(), and NETLIST_EXPORTER_BASE::findAllUnitsOfSymbol().

generateInvisiblePinSubGraphs()

void CONNECTION_GRAPH::generateInvisiblePinSubGraphs ( )

private

Iterate through the invisible power pins to collect the global labels as drivers.

Definition at line 952 of file connection_graph.cpp.

{
 // Generate subgraphs for invisible power pins. These will be merged with other subgraphs
 // on the same sheet in the next loop.

 std::unordered_map<int, CONNECTION_SUBGRAPH*> invisible_pin_subgraphs;

 for( const auto& it : m_invisible_power_pins )
 {
 SCH_SHEET_PATH sheet = it.first;
 SCH_PIN* pin = it.second;

 if( !pin->ConnectedItems( sheet ).empty() && !pin->GetLibPin()->GetParent()->IsPower() )
 {
 // ERC will warn about this: user has wired up an invisible pin
 continue;
 }

 SCH_CONNECTION* connection = pin->GetOrInitConnection( sheet, this );

 // If this pin already has a subgraph, don't need to process
 if( !connection || connection->SubgraphCode() > 0 )
 continue;

 connection->SetName( pin->GetShownName() );

 int code = assignNewNetCode( *connection );

 connection->SetNetCode( code );

 CONNECTION_SUBGRAPH* subgraph;
 auto jj = invisible_pin_subgraphs.find( code );

 if( jj != invisible_pin_subgraphs.end() )
 {
 subgraph = jj->second;
 subgraph->AddItem( pin );
 }
 else
 {
 subgraph = new CONNECTION_SUBGRAPH( this );

 subgraph->m_code = m_last_subgraph_code++;
 subgraph->m_sheet = sheet;

 subgraph->AddItem( pin );
 subgraph->ResolveDrivers();

 auto key = std::make_pair( subgraph->GetNetName(), code );
 m_net_code_to_subgraphs_map[ key ].push_back( subgraph );
 m_subgraphs.push_back( subgraph );
 m_driver_subgraphs.push_back( subgraph );

 invisible_pin_subgraphs[code] = subgraph;
 }

 connection->SetSubgraphCode( subgraph->m_code );
 }
}

References CONNECTION_SUBGRAPH::AddItem(), assignNewNetCode(), CONNECTION_SUBGRAPH::GetNetName(), CONNECTION_SUBGRAPH::m_code, m_driver_subgraphs, m_invisible_power_pins, m_last_subgraph_code, m_net_code_to_subgraphs_map, CONNECTION_SUBGRAPH::m_sheet, m_subgraphs, pin, CONNECTION_SUBGRAPH::ResolveDrivers(), SCH_CONNECTION::SetName(), SCH_CONNECTION::SetNetCode(), SCH_CONNECTION::SetSubgraphCode(), and SCH_CONNECTION::SubgraphCode().

Referenced by buildConnectionGraph().

GetBusAlias()

std::shared_ptr< BUS_ALIAS > CONNECTION_GRAPH::GetBusAlias

(

const wxString &

aName

)

Returns a bus alias pointer for the given name if it exists (from cache)

CONNECTION_GRAPH caches these, they are owned by the SCH_SCREEN that the alias was defined on. The cache is only used to update the graph.

Definition at line 2132 of file connection_graph.cpp.

{
 auto it = m_bus_alias_cache.find( aName );

 return it != m_bus_alias_cache.end() ? it->second : nullptr;
}

References m_bus_alias_cache.

Referenced by SCH_CONNECTION::AppendInfoToMsgPanel(), and SCH_CONNECTION::ConfigureFromLabel().

GetBusesNeedingMigration()

std::vector< const CONNECTION_SUBGRAPH * > CONNECTION_GRAPH::GetBusesNeedingMigration

(

)

Determines which subgraphs have more than one conflicting bus label.

See also

DIALOG_MIGRATE_BUSES

Returns

a list of subgraphs that need migration

Definition at line 2140 of file connection_graph.cpp.

{
 std::vector<const CONNECTION_SUBGRAPH*> ret;

 for( CONNECTION_SUBGRAPH* subgraph : m_subgraphs )
 {
 // Graph is supposed to be up-to-date before calling this
 wxASSERT( !subgraph->m_dirty );

 if( !subgraph->m_driver )
 continue;

 SCH_CONNECTION* connection = subgraph->m_driver->Connection( &subgraph->m_sheet );

 if( !connection->IsBus() )
 continue;

 auto labels = subgraph->GetBusLabels();

 if( labels.size() > 1 )
 {
 bool different = false;
 wxString first = static_cast<SCH_TEXT*>( labels.at( 0 ) )->GetShownText();

 for( unsigned i = 1; i < labels.size(); ++i )
 {
 if( static_cast<SCH_TEXT*>( labels.at( i ) )->GetShownText() != first )
 {
 different = true;
 break;
 }
 }

 if( !different )
 continue;

 wxLogTrace( ConnTrace, wxT( "SG %ld (%s) has multiple bus labels" ), subgraph->m_code,
 connection->Name() );

 ret.push_back( subgraph );
 }
 }

 return ret;
}

References SCH_ITEM::Connection(), ConnTrace, SCH_CONNECTION::IsBus(), SCH_CONNECTION::m_driver, m_subgraphs, and SCH_CONNECTION::Name().

Referenced by DIALOG_MIGRATE_BUSES::loadGraphData().

getDefaultConnection()

std::shared_ptr< SCH_CONNECTION > CONNECTION_GRAPH::getDefaultConnection ( SCH_ITEM *  aItem, CONNECTION_SUBGRAPH *  aSubgraph  )

private

Builds a new default connection for the given item based on its properties.

Handles strong drivers (power pins and labels) only

Parameters

aItem	is an item that can generate a connection name
aSubgraph	is used to determine the sheet to use and retrieve the cached name

Returns

a connection generated from the item, or nullptr if item is not valid

Definition at line 2023 of file connection_graph.cpp.

{
 std::shared_ptr<SCH_CONNECTION> c = std::shared_ptr<SCH_CONNECTION>( nullptr );

 switch( aItem->Type() )
 {
 case SCH_PIN_T:
 {
 SCH_PIN* pin = static_cast<SCH_PIN*>( aItem );

 if( pin->IsPowerConnection() )
 c = std::make_shared<SCH_CONNECTION>( aItem, aSubgraph->m_sheet );

 break;
 }

 case SCH_GLOBAL_LABEL_T:
 case SCH_HIER_LABEL_T:
 case SCH_LABEL_T:
 {
 c = std::make_shared<SCH_CONNECTION>( aItem, aSubgraph->m_sheet );
 break;
 }

 default:
 break;
 }

 if( c )
 {
 c->SetGraph( this );
 c->ConfigureFromLabel( aSubgraph->GetNameForDriver( aItem ) );
 }

 return c;
}

References CONNECTION_SUBGRAPH::GetNameForDriver(), CONNECTION_SUBGRAPH::m_sheet, pin, SCH_GLOBAL_LABEL_T, SCH_HIER_LABEL_T, SCH_LABEL_T, SCH_PIN_T, and EDA_ITEM::Type().

Referenced by processSubGraphs(), and propagateToNeighbors().

GetNetMap()

const NET_MAP& CONNECTION_GRAPH::GetNetMap ( ) const

inline

Definition at line 306 of file connection_graph.h.

{ return m_net_code_to_subgraphs_map; }

References m_net_code_to_subgraphs_map.

Referenced by SCHEMATIC::GetNetClassAssignmentCandidates(), NETLIST_EXPORTER_XML::makeListOfNets(), ERC_TESTER::TestMultUnitPinConflicts(), ERC_TESTER::TestPinToPin(), ERC_TESTER::TestSimilarLabels(), and NETLIST_EXPORTER_CADSTAR::writeListOfNets().

GetSubgraphForItem()

CONNECTION_SUBGRAPH * CONNECTION_GRAPH::GetSubgraphForItem

(

SCH_ITEM *

aItem

)

Definition at line 2221 of file connection_graph.cpp.

{
 auto it = m_item_to_subgraph_map.find( aItem );
 CONNECTION_SUBGRAPH* ret = it != m_item_to_subgraph_map.end() ? it->second : nullptr;

 while( ret && ret->m_absorbed )
 ret = ret->m_absorbed_by;

 return ret;
}

References CONNECTION_SUBGRAPH::m_absorbed, CONNECTION_SUBGRAPH::m_absorbed_by, and m_item_to_subgraph_map.

Referenced by inheritNetclass(), and SCH_EDITOR_CONTROL::UpdateNetHighlighting().

matchBusMember()

SCH_CONNECTION * CONNECTION_GRAPH::matchBusMember ( SCH_CONNECTION *  aBusConnection, SCH_CONNECTION *  aSearch  )

staticprivate

Search for a matching bus member inside a bus connection.

For bus groups, this returns a bus member that matches aSearch by name. For bus vectors, this returns a bus member that matches by vector index.

Parameters

aBusConnection	is the bus connection to search
aSearch	is the net connection to search for

Returns

a member of aBusConnection that matches aSearch

Definition at line 2062 of file connection_graph.cpp.

{
 wxASSERT( aBusConnection->IsBus() );

 SCH_CONNECTION* match = nullptr;

 if( aBusConnection->Type() == CONNECTION_TYPE::BUS )
 {
 // Vector bus: compare against index, because we allow the name
 // to be different

 for( const std::shared_ptr<SCH_CONNECTION>& bus_member : aBusConnection->Members() )
 {
 if( bus_member->VectorIndex() == aSearch->VectorIndex() )
 {
 match = bus_member.get();
 break;
 }
 }
 }
 else
 {
 // Group bus
 for( const std::shared_ptr<SCH_CONNECTION>& c : aBusConnection->Members() )
 {
 // Vector inside group: compare names, because for bus groups
 // we expect the naming to be consistent across all usages
 // TODO(JE) explain this in the docs
 if( c->Type() == CONNECTION_TYPE::BUS )
 {
 for( const std::shared_ptr<SCH_CONNECTION>& bus_member : c->Members() )
 {
 if( bus_member->LocalName() == aSearch->LocalName() )
 {
 match = bus_member.get();
 break;
 }
 }
 }
 else if( c->LocalName() == aSearch->LocalName() )
 {
 match = c.get();
 break;
 }
 }
 }

 return match;
}

References BUS, SCH_CONNECTION::IsBus(), SCH_CONNECTION::LocalName(), SCH_CONNECTION::Members(), SCH_CONNECTION::Type(), and SCH_CONNECTION::VectorIndex().

Referenced by buildConnectionGraph(), and propagateToNeighbors().

processSubGraphs()

void CONNECTION_GRAPH::processSubGraphs ( )

private

Process all subgraphs to assign netcodes and merge subgraphs based on labels.

Definition at line 1013 of file connection_graph.cpp.

{
 // Here we do all the local (sheet) processing of each subgraph, including assigning net
 // codes, merging subgraphs together that use label connections, etc.

 // Cache remaining valid subgraphs by sheet path
 for( CONNECTION_SUBGRAPH* subgraph : m_driver_subgraphs )
 m_sheet_to_subgraphs_map[ subgraph->m_sheet ].emplace_back( subgraph );

 std::unordered_set<CONNECTION_SUBGRAPH*> invalidated_subgraphs;

 for( CONNECTION_SUBGRAPH* subgraph : m_driver_subgraphs )
 {
 if( subgraph->m_absorbed )
 continue;

 SCH_CONNECTION* connection = subgraph->m_driver_connection;
 SCH_SHEET_PATH sheet = subgraph->m_sheet;
 wxString name = connection->Name();

 // Test subgraphs with weak drivers for net name conflicts and fix them
 unsigned suffix = 1;

 auto create_new_name =
 [&suffix]( SCH_CONNECTION* aConn ) -> wxString
 {
 wxString newName;

 // For group buses with a prefix, we can add the suffix to the prefix.
 // If they don't have a prefix, we force the creation of a prefix so that
 // two buses don't get inadvertently shorted together.
 if( aConn->Type() == CONNECTION_TYPE::BUS_GROUP )
 {
 wxString prefix = aConn->BusPrefix();

 if( prefix.empty() )
 prefix = wxT( "BUS" ); // So result will be "BUS_1{...}"

 wxString oldName = aConn->Name().AfterFirst( '{' );

 newName = wxString::Format( wxT( "%s_%u{%s" ), prefix, suffix, oldName );

 aConn->ConfigureFromLabel( newName );
 }
 else
 {
 newName = wxString::Format( wxT( "%s_%u" ), aConn->Name(), suffix );
 aConn->SetSuffix( wxString::Format( wxT( "_%u" ), suffix ) );
 }

 suffix++;
 return newName;
 };

 if( !subgraph->m_strong_driver )
 {
 std::vector<CONNECTION_SUBGRAPH*>* vec = &m_net_name_to_subgraphs_map.at( name );

 // If we are a unique bus vector, check if we aren't actually unique because of another
 // subgraph with a similar bus vector
 if( vec->size() <= 1 && subgraph->m_driver_connection->Type() == CONNECTION_TYPE::BUS )
 {
 wxString prefixOnly = name.BeforeFirst( '[' ) + wxT( "[]" );
 vec = &m_net_name_to_subgraphs_map.at( prefixOnly );
 }

 if( vec->size() > 1 )
 {
 wxString new_name = create_new_name( connection );

 while( m_net_name_to_subgraphs_map.count( new_name ) )
 new_name = create_new_name( connection );

 wxLogTrace( ConnTrace, wxT( "%ld (%s) is weakly driven and not unique. Changing to %s." ),
 subgraph->m_code, name, new_name );

 alg::delete_matching( *vec, subgraph );

 m_net_name_to_subgraphs_map[new_name].emplace_back( subgraph );

 name = new_name;
 }
 else
 {
 // If there is no conflict, promote sheet pins to be strong drivers so that they
 // will be considered below for propagation/merging.

 // It is possible for this to generate a conflict if the sheet pin has the same
 // name as a global label on the same sheet, because global merging will then treat
 // this subgraph as if it had a matching local label. So, for those cases, we
 // don't apply this promotion

 if( subgraph->m_driver->Type() == SCH_SHEET_PIN_T )
 {
 bool conflict = false;
 wxString global_name = connection->Name( true );
 auto kk = m_net_name_to_subgraphs_map.find( global_name );

 if( kk != m_net_name_to_subgraphs_map.end() )
 {
 // A global will conflict if it is on the same sheet as this subgraph, since
 // it would be connected by implicit local label linking
 std::vector<CONNECTION_SUBGRAPH*>& candidates = kk->second;

 for( const CONNECTION_SUBGRAPH* candidate : candidates )
 {
 if( candidate->m_sheet == sheet )
 conflict = true;
 }
 }

 if( conflict )
 {
 wxLogTrace( ConnTrace,
 wxT( "%ld (%s) skipped for promotion due to potential conflict" ),
 subgraph->m_code, name );
 }
 else
 {
 wxLogTrace( ConnTrace,
 wxT( "%ld (%s) weakly driven by unique sheet pin %s, promoting" ),
 subgraph->m_code, name,
 subgraph->m_driver->GetSelectMenuText( EDA_UNITS::MILLIMETRES ) );

 subgraph->m_strong_driver = true;
 }
 }
 }
 }

 // Assign net codes

 if( connection->IsBus() )
 {
 int code = -1;
 auto it = m_bus_name_to_code_map.find( name );

 if( it != m_bus_name_to_code_map.end() )
 {
 code = it->second;
 }
 else
 {
 code = m_last_bus_code++;
 m_bus_name_to_code_map[ name ] = code;
 }

 connection->SetBusCode( code );
 assignNetCodesToBus( connection );
 }
 else
 {
 assignNewNetCode( *connection );
 }

 // Reset the flag for the next loop below
 subgraph->m_dirty = true;

 // Next, we merge together subgraphs that have label connections, and create
 // neighbor links for subgraphs that are part of a bus on the same sheet.
 // For merging, we consider each possible strong driver.

 // If this subgraph doesn't have a strong driver, let's skip it, since there is no
 // way it will be merged with anything.

 if( !subgraph->m_strong_driver )
 continue;

 // candidate_subgraphs will contain each valid, non-bus subgraph on the same sheet
 // as the subgraph we are considering that has a strong driver.
 // Weakly driven subgraphs are not considered since they will never be absorbed or
 // form neighbor links.

 std::vector<CONNECTION_SUBGRAPH*> candidate_subgraphs;
 std::copy_if( m_sheet_to_subgraphs_map[ subgraph->m_sheet ].begin(),
 m_sheet_to_subgraphs_map[ subgraph->m_sheet ].end(),
 std::back_inserter( candidate_subgraphs ),
 [&] ( const CONNECTION_SUBGRAPH* candidate )
 {
 return ( !candidate->m_absorbed &&
 candidate->m_strong_driver &&
 candidate != subgraph );
 } );

 // This is a list of connections on the current subgraph to compare to the
 // drivers of each candidate subgraph. If the current subgraph is a bus,
 // we should consider each bus member.
 std::vector< std::shared_ptr<SCH_CONNECTION> > connections_to_check;

 // Also check the main driving connection
 connections_to_check.push_back( std::make_shared<SCH_CONNECTION>( *connection ) );

 auto add_connections_to_check = [&] ( CONNECTION_SUBGRAPH* aSubgraph ) {
 for( SCH_ITEM* possible_driver : aSubgraph->m_items )
 {
 if( possible_driver == aSubgraph->m_driver )
 continue;

 auto c = getDefaultConnection( possible_driver, aSubgraph );

 if( c )
 {
 if( c->Type() != aSubgraph->m_driver_connection->Type() )
 continue;

 if( c->Name( true ) == aSubgraph->m_driver_connection->Name( true ) )
 continue;

 connections_to_check.push_back( c );
 wxLogTrace( ConnTrace,
 wxT( "%lu (%s): Adding secondary driver %s" ), aSubgraph->m_code,
 aSubgraph->m_driver_connection->Name( true ), c->Name( true ) );
 }
 }
 };

 // Now add other strong drivers
 // The actual connection attached to these items will have been overwritten
 // by the chosen driver of the subgraph, so we need to create a dummy connection
 add_connections_to_check( subgraph );

 for( unsigned i = 0; i < connections_to_check.size(); i++ )
 {
 auto member = connections_to_check[i];

 if( member->IsBus() )
 {
 connections_to_check.insert( connections_to_check.end(),
 member->Members().begin(),
 member->Members().end() );
 }

 wxString test_name = member->Name( true );

 for( auto candidate : candidate_subgraphs )
 {
 if( candidate->m_absorbed )
 continue;

 bool match = false;

 if( candidate->m_driver_connection->Name( true ) == test_name )
 {
 match = true;
 }
 else
 {
 if( !candidate->m_multiple_drivers )
 continue;

 for( SCH_ITEM *driver : candidate->m_drivers )
 {
 if( driver == candidate->m_driver )
 continue;

 // Sheet pins are not candidates for merging
 if( driver->Type() == SCH_SHEET_PIN_T )
 continue;

 if( driver->Type() == SCH_PIN_T )
 {
 auto pin = static_cast<SCH_PIN*>( driver );

 if( pin->IsPowerConnection() && pin->GetShownName() == test_name )
 {
 match = true;
 break;
 }
 }
  else
 {
 wxASSERT( driver->Type() == SCH_LABEL_T ||
 driver->Type() == SCH_GLOBAL_LABEL_T ||
 driver->Type() == SCH_HIER_LABEL_T );

 if( subgraph->GetNameForDriver( driver ) == test_name )
 {
 match = true;
 break;
 }
 }
 }
 }

 if( match )
 {
 if( connection->IsBus() && candidate->m_driver_connection->IsNet() )
 {
 wxLogTrace( ConnTrace, wxT( "%lu (%s) has bus child %lu (%s)" ), subgraph->m_code,
 connection->Name(), candidate->m_code, member->Name() );

 subgraph->m_bus_neighbors[member].insert( candidate );
 candidate->m_bus_parents[member].insert( subgraph );
 }
 else
 {
 wxLogTrace( ConnTrace, wxT( "%lu (%s) absorbs neighbor %lu (%s)" ),
 subgraph->m_code, connection->Name(),
 candidate->m_code, candidate->m_driver_connection->Name() );

 // Candidate may have other non-chosen drivers we need to follow
 add_connections_to_check( candidate );

 subgraph->Absorb( candidate );
 invalidated_subgraphs.insert( subgraph );
 }
 }
 }
 }
 }

 // Update any subgraph that was invalidated above
 for( CONNECTION_SUBGRAPH* subgraph : invalidated_subgraphs )
 {
 if( subgraph->m_absorbed )
 continue;

 subgraph->ResolveDrivers();

 if( subgraph->m_driver_connection->IsBus() )
 assignNetCodesToBus( subgraph->m_driver_connection );
 else
 assignNewNetCode( *subgraph->m_driver_connection );

 wxLogTrace( ConnTrace, wxT( "Re-resolving drivers for %lu (%s)" ), subgraph->m_code,
 subgraph->m_driver_connection->Name() );
 }

}

References assignNetCodesToBus(), assignNewNetCode(), BUS, BUS_GROUP, ConnTrace, alg::delete_matching(), Format(), getDefaultConnection(), SCH_CONNECTION::IsBus(), m_bus_name_to_code_map, m_driver_subgraphs, m_last_bus_code, m_net_name_to_subgraphs_map, m_sheet_to_subgraphs_map, MILLIMETRES, name, SCH_CONNECTION::Name(), pin, SCH_GLOBAL_LABEL_T, SCH_HIER_LABEL_T, SCH_LABEL_T, SCH_PIN_T, SCH_SHEET_PIN_T, SCH_CONNECTION::SetBusCode(), and EDA_ITEM::Type().

Referenced by buildConnectionGraph().

propagateToNeighbors()

void CONNECTION_GRAPH::propagateToNeighbors ( CONNECTION_SUBGRAPH *  aSubgraph )

private

Updates all neighbors of a subgraph with this one's connectivity info.

If this subgraph contains hierarchical links, this method will descent the hierarchy and propagate the connectivity across all linked sheets.

Definition at line 1711 of file connection_graph.cpp.

{
 SCH_CONNECTION* conn = aSubgraph->m_driver_connection;
 std::vector<CONNECTION_SUBGRAPH*> search_list;
 std::unordered_set<CONNECTION_SUBGRAPH*> visited;
 std::vector<SCH_CONNECTION*> stale_bus_members;

 auto visit =
 [&]( CONNECTION_SUBGRAPH* aParent )
 {
 for( SCH_SHEET_PIN* pin : aParent->m_hier_pins )
 {
 SCH_SHEET_PATH path = aParent->m_sheet;
 path.push_back( pin->GetParent() );

 auto it = m_sheet_to_subgraphs_map.find( path );

 if( it == m_sheet_to_subgraphs_map.end() )
 continue;

 for( CONNECTION_SUBGRAPH* candidate : it->second )
 {
 if( !candidate->m_strong_driver
 || candidate->m_hier_ports.empty()
 || visited.count( candidate ) )
 {
 continue;
 }

 for( SCH_HIERLABEL* label : candidate->m_hier_ports )
 {
 if( candidate->GetNameForDriver( label ) == aParent->GetNameForDriver( pin ) )
 {
 wxLogTrace( ConnTrace, wxT( "%lu: found child %lu (%s)" ), aParent->m_code,
 candidate->m_code, candidate->m_driver_connection->Name() );

 candidate->m_hier_parent = aParent;

 search_list.push_back( candidate );
 break;
 }
 }
 }
 }

 for( SCH_HIERLABEL* label : aParent->m_hier_ports )
 {
 SCH_SHEET_PATH path = aParent->m_sheet;
 path.pop_back();

 auto it = m_sheet_to_subgraphs_map.find( path );

 if( it == m_sheet_to_subgraphs_map.end() )
 continue;

 for( CONNECTION_SUBGRAPH* candidate : it->second )
 {
 if( candidate->m_hier_pins.empty()
 || visited.count( candidate )
 || candidate->m_driver_connection->Type() != aParent->m_driver_connection->Type() )
 {
 continue;
 }

 for( SCH_SHEET_PIN* pin : candidate->m_hier_pins )
 {
 SCH_SHEET_PATH pin_path = path;
  pin_path.push_back( pin->GetParent() );

 if( pin_path != aParent->m_sheet )
 continue;

 if( aParent->GetNameForDriver( label ) == candidate->GetNameForDriver( pin ) )
 {
 wxLogTrace( ConnTrace, wxT( "%lu: found additional parent %lu (%s)" ),
 aParent->m_code, candidate->m_code,
 candidate->m_driver_connection->Name() );

 search_list.push_back( candidate );
 break;
 }
 }
 }
 }
 };

 auto propagate_bus_neighbors = [&]( CONNECTION_SUBGRAPH* aParentGraph ) {
 for( const auto& kv : aParentGraph->m_bus_neighbors )
 {
 for( CONNECTION_SUBGRAPH* neighbor : kv.second )
 {
 // May have been absorbed but won't have been deleted
 while( neighbor->m_absorbed )
 neighbor = neighbor->m_absorbed_by;

 SCH_CONNECTION* parent = aParentGraph->m_driver_connection;

 // Now member may be out of date, since we just cloned the
 // connection from higher up in the hierarchy. We need to
 // figure out what the actual new connection is.
 SCH_CONNECTION* member = matchBusMember( parent, kv.first.get() );

 if( !member )
 {
 // Try harder: we might match on a secondary driver
 for( CONNECTION_SUBGRAPH* sg : kv.second )
 {
 if( sg->m_multiple_drivers )
 {
 SCH_SHEET_PATH sheet = sg->m_sheet;

 for( SCH_ITEM* driver : sg->m_drivers )
 {
 auto c = getDefaultConnection( driver, sg );
 member = matchBusMember( parent, c.get() );

 if( member )
 break;
 }
 }

 if( member )
 break;
 }
 }

 // This is bad, probably an ERC error
 if( !member )
 {
 wxLogTrace( ConnTrace, wxT( "Could not match bus member %s in %s" ),
 kv.first->Name(), parent->Name() );
 continue;
 }

 auto neighbor_conn = neighbor->m_driver_connection;
 auto neighbor_name = neighbor_conn->Name();

 // Matching name: no update needed
 if( neighbor_name == member->Name() )
 continue;

 // Was this neighbor already updated from a different sheet? Don't rename it again
 if( neighbor_conn->Sheet() != neighbor->m_sheet )
 continue;

 // Safety check against infinite recursion
 wxASSERT( neighbor_conn->IsNet() );

 wxLogTrace( ConnTrace, wxT( "%lu (%s) connected to bus member %s (local %s)" ),
 neighbor->m_code, neighbor_name, member->Name(), member->LocalName() );

 // Take whichever name is higher priority
 if( CONNECTION_SUBGRAPH::GetDriverPriority( neighbor->m_driver )
 >= CONNECTION_SUBGRAPH::PRIORITY::POWER_PIN )
 {
 member->Clone( *neighbor_conn );
 stale_bus_members.push_back( member );
 }
 else
 {
 neighbor_conn->Clone( *member );

 recacheSubgraphName( neighbor, neighbor_name );

 // Recurse onto this neighbor in case it needs to re-propagate
 neighbor->m_dirty = true;
 propagateToNeighbors( neighbor );
 }
 }
 }
 };

 // If we are a bus, we must propagate to local neighbors and then the hierarchy
 if( conn->IsBus() )
 propagate_bus_neighbors( aSubgraph );

 // If we have both ports and pins, skip processing as we'll be visited by a parent or child.
 // If we only have one or the other, process (we can either go bottom-up or top-down depending
 // on which subgraph comes up first)
 if( !aSubgraph->m_hier_ports.empty() && !aSubgraph->m_hier_pins.empty() )
 {
 wxLogTrace( ConnTrace, wxT( "%lu (%s) has both hier ports and pins; deferring processing" ),
 aSubgraph->m_code, conn->Name() );
 return;
 }
 else if( aSubgraph->m_hier_ports.empty() && aSubgraph->m_hier_pins.empty() )
 {
 wxLogTrace( ConnTrace, wxT( "%lu (%s) has no hier pins or ports; marking clean" ),
 aSubgraph->m_code, conn->Name() );
 aSubgraph->m_dirty = false;
 return;
 }

 visited.insert( aSubgraph );

 wxLogTrace( ConnTrace, wxT( "Propagating %lu (%s) to subsheets" ),
 aSubgraph->m_code, aSubgraph->m_driver_connection->Name() );

 visit( aSubgraph );

 for( unsigned i = 0; i < search_list.size(); i++ )
 {
 auto child = search_list[i];

 visited.insert( child );

 visit( child );

 child->m_dirty = false;
 }

 // Now, find the best driver for this chain of subgraphs
 CONNECTION_SUBGRAPH* bestDriver = aSubgraph;
 CONNECTION_SUBGRAPH::PRIORITY highest =
 CONNECTION_SUBGRAPH::GetDriverPriority( aSubgraph->m_driver );
 bool bestIsStrong = ( highest >= CONNECTION_SUBGRAPH::PRIORITY::HIER_LABEL );
 wxString bestName = aSubgraph->m_driver_connection->Name();

 // Check if a subsheet has a higher-priority connection to the same net
 if( highest < CONNECTION_SUBGRAPH::PRIORITY::POWER_PIN )
 {
 for( CONNECTION_SUBGRAPH* subgraph : visited )
 {
 if( subgraph == aSubgraph )
 continue;

 CONNECTION_SUBGRAPH::PRIORITY priority =
 CONNECTION_SUBGRAPH::GetDriverPriority( subgraph->m_driver );

 bool candidateStrong = ( priority >= CONNECTION_SUBGRAPH::PRIORITY::HIER_LABEL );
 wxString candidateName = subgraph->m_driver_connection->Name();
 bool shorterPath = subgraph->m_sheet.size() < bestDriver->m_sheet.size();
 bool asGoodPath = subgraph->m_sheet.size() <= bestDriver->m_sheet.size();

 // Pick a better driving subgraph if it:
 // a) has a power pin or global driver
 // b) is a strong driver and we're a weak driver
 // c) is a higher priority strong driver
 // d) matches our priority, is a strong driver, and has a shorter path
 // e) matches our strength and is at least as short, and is alphabetically lower

 if( ( priority >= CONNECTION_SUBGRAPH::PRIORITY::POWER_PIN ) ||
 ( !bestIsStrong && candidateStrong ) ||
 ( priority > highest && candidateStrong ) ||
 ( priority == highest && candidateStrong && shorterPath ) ||
 ( ( bestIsStrong == candidateStrong ) && asGoodPath && ( priority == highest ) &&
 ( candidateName < bestName ) ) )
 {
 bestDriver = subgraph;
 highest = priority;
 bestIsStrong = candidateStrong;
 bestName = candidateName;
 }
 }
 }

 if( bestDriver != aSubgraph )
 {
 wxLogTrace( ConnTrace, wxT( "%lu (%s) overridden by new driver %lu (%s)" ),
 aSubgraph->m_code, aSubgraph->m_driver_connection->Name(), bestDriver->m_code,
 bestDriver->m_driver_connection->Name() );
 }

 conn = bestDriver->m_driver_connection;

 for( CONNECTION_SUBGRAPH* subgraph : visited )
 {
 wxString old_name = subgraph->m_driver_connection->Name();

 subgraph->m_driver_connection->Clone( *conn );

 if( old_name != conn->Name() )
 recacheSubgraphName( subgraph, old_name );

 if( conn->IsBus() )
 propagate_bus_neighbors( subgraph );
 }

 // Somewhere along the way, a bus member may have been upgraded to a global or power label.
 // Because this can happen anywhere, we need a second pass to update all instances of that bus
 // member to have the correct connection info
 if( conn->IsBus() && !stale_bus_members.empty() )
 {
 for( SCH_CONNECTION* stale_member : stale_bus_members )
 {
 for( CONNECTION_SUBGRAPH* subgraph : visited )
 {
 SCH_CONNECTION* member = matchBusMember( subgraph->m_driver_connection,
 stale_member );

 if( !member )
 {
 wxLogTrace( ConnTrace, wxT( "WARNING: failed to match stale member %s in %s." ),
 stale_member->Name(), subgraph->m_driver_connection->Name() );
 continue;
 }

 wxLogTrace( ConnTrace, wxT( "Updating %lu (%s) member %s to %s" ), subgraph->m_code,
 subgraph->m_driver_connection->Name(), member->LocalName(),
 stale_member->Name() );

 member->Clone( *stale_member );

 propagate_bus_neighbors( subgraph );
 }
 }
 }

 aSubgraph->m_dirty = false;
}

References SCH_CONNECTION::Clone(), ConnTrace, getDefaultConnection(), CONNECTION_SUBGRAPH::GetDriverPriority(), CONNECTION_SUBGRAPH::GetNameForDriver(), CONNECTION_SUBGRAPH::HIER_LABEL, SCH_CONNECTION::IsBus(), kv, SCH_CONNECTION::LocalName(), CONNECTION_SUBGRAPH::m_absorbed, CONNECTION_SUBGRAPH::m_absorbed_by, CONNECTION_SUBGRAPH::m_code, CONNECTION_SUBGRAPH::m_dirty, CONNECTION_SUBGRAPH::m_driver, CONNECTION_SUBGRAPH::m_driver_connection, CONNECTION_SUBGRAPH::m_drivers, CONNECTION_SUBGRAPH::m_hier_parent, CONNECTION_SUBGRAPH::m_hier_pins, CONNECTION_SUBGRAPH::m_hier_ports, CONNECTION_SUBGRAPH::m_multiple_drivers, CONNECTION_SUBGRAPH::m_sheet, m_sheet_to_subgraphs_map, CONNECTION_SUBGRAPH::m_strong_driver, matchBusMember(), SCH_CONNECTION::Name(), path, pin, CONNECTION_SUBGRAPH::POWER_PIN, SCH_SHEET_PATH::push_back(), recacheSubgraphName(), SCH_SHEET_PATH::size(), and SCH_CONNECTION::Type().

Referenced by buildConnectionGraph().

recacheSubgraphName()

void CONNECTION_GRAPH::recacheSubgraphName ( CONNECTION_SUBGRAPH *  aSubgraph, const wxString &  aOldName  )

private

Definition at line 2114 of file connection_graph.cpp.

{
 auto it = m_net_name_to_subgraphs_map.find( aOldName );

 if( it != m_net_name_to_subgraphs_map.end() )
 {
 std::vector<CONNECTION_SUBGRAPH*>& vec = it->second;
 alg::delete_matching( vec, aSubgraph );
 }

 wxLogTrace( ConnTrace, wxT( "recacheSubgraphName: %s => %s" ), aOldName,
 aSubgraph->m_driver_connection->Name() );

 m_net_name_to_subgraphs_map[aSubgraph->m_driver_connection->Name()].push_back( aSubgraph );
}

References ConnTrace, alg::delete_matching(), CONNECTION_SUBGRAPH::m_driver_connection, m_net_name_to_subgraphs_map, and SCH_CONNECTION::Name().

Referenced by propagateToNeighbors().

Recalculate()

void CONNECTION_GRAPH::Recalculate	(	const SCH_SHEET_LIST &	aSheetList,
		bool	aUnconditional = false,
		std::function< void(SCH_ITEM *)> *	aChangedItemHandler = nullptr
	)

Updates the connection graph for the given list of sheets.

Parameters

aSheetList	is the list of possibly modified sheets
aUnconditional	is true if an unconditional full recalculation should be done
aChangedItemHandler	an optional handler to receive any changed items

Definition at line 440 of file connection_graph.cpp.

{
 PROF_TIMER recalc_time( "CONNECTION_GRAPH::Recalculate" );

 if( aUnconditional )
 Reset();

 PROF_TIMER update_items( "updateItemConnectivity" );

 m_sheetList = aSheetList;

 for( const SCH_SHEET_PATH& sheet : aSheetList )
 {
 std::vector<SCH_ITEM*> items;

 for( SCH_ITEM* item : sheet.LastScreen()->Items() )
 {
 if( item->IsConnectable() && ( aUnconditional || item->IsConnectivityDirty() ) )
 items.push_back( item );
 }

 m_items.reserve( m_items.size() + items.size() );

 updateItemConnectivity( sheet, items );

 // UpdateDanglingState() also adds connected items for SCH_TEXT
 sheet.LastScreen()->TestDanglingEnds( &sheet, aChangedItemHandler );
 }

 if( wxLog::IsAllowedTraceMask( ConnProfileMask ) )
 update_items.Show();

 PROF_TIMER build_graph( "buildConnectionGraph" );

 buildConnectionGraph();

 if( wxLog::IsAllowedTraceMask( ConnProfileMask ) )
 build_graph.Show();

 recalc_time.Stop();

 if( wxLog::IsAllowedTraceMask( ConnProfileMask ) )
 recalc_time.Show();

#ifndef DEBUG
 // Pressure relief valve for release builds
 const double max_recalc_time_msecs = 250.;

 if( m_allowRealTime && ADVANCED_CFG::GetCfg().m_RealTimeConnectivity &&
 recalc_time.msecs() > max_recalc_time_msecs )
 {
 m_allowRealTime = false;
 }
#endif
}

References buildConnectionGraph(), ConnProfileMask, ADVANCED_CFG::GetCfg(), m_allowRealTime, m_items, m_sheetList, PROF_TIMER::msecs(), Reset(), PROF_TIMER::Show(), PROF_TIMER::Stop(), and updateItemConnectivity().

Referenced by TEST_NETLISTS_FIXTURE::loadSchematic(), SCH_EDIT_FRAME::RecalculateConnections(), and SCH_SCREENS::UpdateSymbolLinks().

Reset()

void CONNECTION_GRAPH::Reset

(

)

Definition at line 416 of file connection_graph.cpp.

{
 for( auto& subgraph : m_subgraphs )
 delete subgraph;

 m_items.clear();
 m_subgraphs.clear();
 m_driver_subgraphs.clear();
 m_sheet_to_subgraphs_map.clear();
 m_invisible_power_pins.clear();
 m_bus_alias_cache.clear();
 m_net_name_to_code_map.clear();
 m_bus_name_to_code_map.clear();
 m_net_code_to_subgraphs_map.clear();
 m_net_name_to_subgraphs_map.clear();
 m_item_to_subgraph_map.clear();
 m_local_label_cache.clear();
 m_global_label_cache.clear();
 m_last_net_code = 1;
 m_last_bus_code = 1;
 m_last_subgraph_code = 1;
}

References m_bus_alias_cache, m_bus_name_to_code_map, m_driver_subgraphs, m_global_label_cache, m_invisible_power_pins, m_item_to_subgraph_map, m_items, m_last_bus_code, m_last_net_code, m_last_subgraph_code, m_local_label_cache, m_net_code_to_subgraphs_map, m_net_name_to_code_map, m_net_name_to_subgraphs_map, m_sheet_to_subgraphs_map, and m_subgraphs.

Referenced by SCH_EDIT_FRAME::OpenProjectFiles(), Recalculate(), SCHEMATIC::Reset(), SCHEMATIC::SetRoot(), and ~CONNECTION_GRAPH().

resolveAllDrivers()

void CONNECTION_GRAPH::resolveAllDrivers ( )

private

Finds all subgraphs in the connection graph and calls ResolveDrivers() in parallel.

Definition at line 809 of file connection_graph.cpp.

{
 // Resolve drivers for subgraphs and propagate connectivity info

 // We don't want to spin up a new thread for fewer than 8 nets (overhead costs)
 size_t parallelThreadCount = std::min<size_t>( std::thread::hardware_concurrency(),
 ( m_subgraphs.size() + 3 ) / 4 );

 std::atomic<size_t> nextSubgraph( 0 );
 std::vector<std::future<size_t>> returns( parallelThreadCount );
 std::vector<CONNECTION_SUBGRAPH*> dirty_graphs;

 std::copy_if( m_subgraphs.begin(), m_subgraphs.end(), std::back_inserter( dirty_graphs ),
 [&] ( const CONNECTION_SUBGRAPH* candidate )
 {
 return candidate->m_dirty;
 } );

 auto update_lambda = [&nextSubgraph, &dirty_graphs]() -> size_t
 {
 for( size_t subgraphId = nextSubgraph++; subgraphId < dirty_graphs.size(); subgraphId = nextSubgraph++ )
 {
 auto subgraph = dirty_graphs[subgraphId];

 if( !subgraph->m_dirty )
 continue;

 // Special processing for some items
 for( auto item : subgraph->m_items )
 {
 switch( item->Type() )
 {
 case SCH_NO_CONNECT_T:
 subgraph->m_no_connect = item;
 break;

 case SCH_BUS_WIRE_ENTRY_T:
 subgraph->m_bus_entry = item;
 break;

 case SCH_PIN_T:
 {
 auto pin = static_cast<SCH_PIN*>( item );

 if( pin->GetType() == ELECTRICAL_PINTYPE::PT_NC )
 subgraph->m_no_connect = item;

 break;
 }

 default:
 break;
 }
 }

 subgraph->ResolveDrivers( true );
 subgraph->m_dirty = false;
 }

 return 1;
 };

 if( parallelThreadCount == 1 )
 update_lambda();
 else
 {
 for( size_t ii = 0; ii < parallelThreadCount; ++ii )
 returns[ii] = std::async( std::launch::async, update_lambda );

 // Finalize the threads
 for( size_t ii = 0; ii < parallelThreadCount; ++ii )
 returns[ii].wait();
 }

 // Now discard any non-driven subgraphs from further consideration

 std::copy_if( m_subgraphs.begin(), m_subgraphs.end(), std::back_inserter( m_driver_subgraphs ),
 [&] ( const CONNECTION_SUBGRAPH* candidate ) -> bool
 {
 return candidate->m_driver;
 } );
}

References m_driver_subgraphs, m_subgraphs, pin, PT_NC, SCH_BUS_WIRE_ENTRY_T, SCH_NO_CONNECT_T, and SCH_PIN_T.

Referenced by buildConnectionGraph().

RunERC()

int CONNECTION_GRAPH::RunERC

(

)

Runs electrical rule checks on the connectivity graph.

Precondition: graph is up-to-date

Returns

the number of errors found

NOTE:

We could check that labels attached to bus subgraphs follow the proper format (i.e. actually define a bus).

This check doesn't need to be here right now because labels won't actually be connected to bus wires if they aren't in the right format due to their TestDanglingEnds() implementation.

Definition at line 2233 of file connection_graph.cpp.

{
 int error_count = 0;

 wxCHECK_MSG( m_schematic, true, wxT( "Null m_schematic in CONNECTION_GRAPH::RunERC" ) );

 ERC_SETTINGS& settings = m_schematic->ErcSettings();

 // We don't want to run many ERC checks more than once on a given screen even though it may
 // represent multiple sheets with multiple subgraphs. We can tell these apart by drivers.
 std::set<SCH_ITEM*> seenDriverInstances;

 for( CONNECTION_SUBGRAPH* subgraph : m_subgraphs )
 {
 // There shouldn't be any null sub-graph pointers.
 wxCHECK2( subgraph, continue );

 // Graph is supposed to be up-to-date before calling RunERC()
 wxASSERT( !subgraph->m_dirty );

 if( subgraph->m_absorbed )
 continue;

 if( seenDriverInstances.count( subgraph->m_driver ) )
 continue;

 if( subgraph->m_driver )
 seenDriverInstances.insert( subgraph->m_driver );

 if( settings.IsTestEnabled( ERCE_DRIVER_CONFLICT ) )
 {
 if( !ercCheckMultipleDrivers( subgraph ) )
 error_count++;
 }

 subgraph->ResolveDrivers( false );

 if( settings.IsTestEnabled( ERCE_BUS_TO_NET_CONFLICT ) )
 {
 if( !ercCheckBusToNetConflicts( subgraph ) )
 error_count++;
 }

 if( settings.IsTestEnabled( ERCE_BUS_ENTRY_CONFLICT ) )
 {
 if( !ercCheckBusToBusEntryConflicts( subgraph ) )
 error_count++;
 }

 if( settings.IsTestEnabled( ERCE_BUS_TO_BUS_CONFLICT ) )
 {
 if( !ercCheckBusToBusConflicts( subgraph ) )
 error_count++;
 }

 if( settings.IsTestEnabled( ERCE_WIRE_DANGLING ) )
 {
 if( !ercCheckFloatingWires( subgraph ) )
 error_count++;
 }

 if( settings.IsTestEnabled( ERCE_NOCONNECT_CONNECTED )
 || settings.IsTestEnabled( ERCE_NOCONNECT_NOT_CONNECTED )
 || settings.IsTestEnabled( ERCE_PIN_NOT_CONNECTED ) )
 {
 if( !ercCheckNoConnects( subgraph ) )
 error_count++;
 }

 if( settings.IsTestEnabled( ERCE_LABEL_NOT_CONNECTED )
 || settings.IsTestEnabled( ERCE_GLOBLABEL ) )
 {
 if( !ercCheckLabels( subgraph ) )
 error_count++;
 }
 }

 // Hierarchical sheet checking is done at the schematic level
 if( settings.IsTestEnabled( ERCE_HIERACHICAL_LABEL )
 || settings.IsTestEnabled( ERCE_PIN_NOT_CONNECTED ) )
 {
 error_count += ercCheckHierSheets();
 }

 return error_count;
}

References ercCheckBusToBusConflicts(), ercCheckBusToBusEntryConflicts(), ercCheckBusToNetConflicts(), ercCheckFloatingWires(), ercCheckHierSheets(), ercCheckLabels(), ercCheckMultipleDrivers(), ercCheckNoConnects(), ERCE_BUS_ENTRY_CONFLICT, ERCE_BUS_TO_BUS_CONFLICT, ERCE_BUS_TO_NET_CONFLICT, ERCE_DRIVER_CONFLICT, ERCE_GLOBLABEL, ERCE_HIERACHICAL_LABEL, ERCE_LABEL_NOT_CONNECTED, ERCE_NOCONNECT_CONNECTED, ERCE_NOCONNECT_NOT_CONNECTED, ERCE_PIN_NOT_CONNECTED, ERCE_WIRE_DANGLING, SCHEMATIC::ErcSettings(), ERC_SETTINGS::IsTestEnabled(), m_schematic, and m_subgraphs.

Referenced by DIALOG_ERC::testErc().

SetSchematic()

void CONNECTION_GRAPH::SetSchematic ( SCHEMATIC *  aSchematic )

inline

Definition at line 265 of file connection_graph.h.

 {
 m_schematic = aSchematic;
 }

References m_schematic.

updateItemConnectivity()

void CONNECTION_GRAPH::updateItemConnectivity ( const SCH_SHEET_PATH &  aSheet, const std::vector< SCH_ITEM * > &  aItemList  )

private

Updates the graphical connectivity between items (i.e.

where they touch) The items passed in must be on the same sheet.

In the first phase, all items in aItemList have their connections initialized for the given sheet (since they may have connections on more than one sheet, and each needs to be calculated individually). The graphical connection points for the item are added to a map that stores (x, y) -> [list of items].

Any item that is stored in the list of items that have a connection point at a given (x, y) location will eventually be electrically connected. This means that we can't store SCH_SYMBOLs in this map – we must store a structure that links a specific pin on a symbol back to that symbol: a SCH_PIN_CONNECTION. This wrapper class is a convenience for linking a pin and symbol to a specific (x, y) point.

In the second phase, we iterate over each value in the map, which is a vector of items that have overlapping connection points. After some checks to ensure that the items should actually connect, the items are linked together using ConnectedItems().

As a side effect, items are loaded into m_items for BuildConnectionGraph()

Parameters

aSheet	is the path to the sheet of all items in the list
aItemList	is a list of items to consider

Definition at line 498 of file connection_graph.cpp.

{
 std::map< wxPoint, std::vector<SCH_ITEM*> > connection_map;

 for( SCH_ITEM* item : aItemList )
 {
 std::vector< wxPoint > points = item->GetConnectionPoints();
 item->ConnectedItems( aSheet ).clear();

 if( item->Type() == SCH_SHEET_T )
 {
 for( SCH_SHEET_PIN* pin : static_cast<SCH_SHEET*>( item )->GetPins() )
 {
 pin->InitializeConnection( aSheet, this );

 pin->ConnectedItems( aSheet ).clear();

 connection_map[ pin->GetTextPos() ].push_back( pin );
 m_items.emplace_back( pin );
 }
 }
 else if( item->Type() == SCH_SYMBOL_T )
 {
 SCH_SYMBOL* symbol = static_cast<SCH_SYMBOL*>( item );

 for( SCH_PIN* pin : symbol->GetPins( &aSheet ) )
 {
 pin->InitializeConnection( aSheet, this );

 wxPoint pos = pin->GetPosition();

 // because calling the first time is not thread-safe
 pin->GetDefaultNetName( aSheet );
 pin->ConnectedItems( aSheet ).clear();

 // Invisible power pins need to be post-processed later

 if( pin->IsPowerConnection() && !pin->IsVisible() )
 m_invisible_power_pins.emplace_back( std::make_pair( aSheet, pin ) );

 connection_map[ pos ].push_back( pin );
 m_items.emplace_back( pin );
 }
 }
 else
 {
 m_items.emplace_back( item );
 SCH_CONNECTION* conn = item->InitializeConnection( aSheet, this );

 // Set bus/net property here so that the propagation code uses it
 switch( item->Type() )
 {
 case SCH_LINE_T:
 conn->SetType( item->GetLayer() == LAYER_BUS ? CONNECTION_TYPE::BUS :
 CONNECTION_TYPE::NET );
 break;

 case SCH_BUS_BUS_ENTRY_T:
 conn->SetType( CONNECTION_TYPE::BUS );
 // clean previous (old) links:
 static_cast<SCH_BUS_BUS_ENTRY*>( item )->m_connected_bus_items[0] = nullptr;
 static_cast<SCH_BUS_BUS_ENTRY*>( item )->m_connected_bus_items[1] = nullptr;
 break;

 case SCH_PIN_T:
 conn->SetType( CONNECTION_TYPE::NET );
 break;

 case SCH_BUS_WIRE_ENTRY_T:
 conn->SetType( CONNECTION_TYPE::NET );
 // clean previous (old) link:
 static_cast<SCH_BUS_WIRE_ENTRY*>( item )->m_connected_bus_item = nullptr;
 break;

 default:
 break;
 }

 for( const wxPoint& point : points )
 connection_map[ point ].push_back( item );
 }

 item->SetConnectivityDirty( false );
 }

 for( const auto& it : connection_map )
 {
 const std::vector<SCH_ITEM*>& connection_vec = it.second;

 // Pre-scan to see if we have a bus at this location
 SCH_LINE* busLine = aSheet.LastScreen()->GetBus( it.first );

 // We don't want to spin up a new thread for fewer than 4 items (overhead costs)
 size_t parallelThreadCount = std::min<size_t>( std::thread::hardware_concurrency(),
 ( connection_vec.size() + 3 ) / 4 );

 std::atomic<size_t> nextItem( 0 );
 std::mutex update_mutex;
 std::vector<std::future<size_t>> returns( parallelThreadCount );

 auto update_lambda = [&]() -> size_t
 {
 for( size_t ii = nextItem++; ii < connection_vec.size(); ii = nextItem++ )
 {
 SCH_ITEM* connected_item = connection_vec[ii];
 // Bus entries are special: they can have connection points in the
 // middle of a wire segment, because the junction algo doesn't split
 // the segment in two where you place a bus entry. This means that
 // bus entries that don't land on the end of a line segment need to
 // have "virtual" connection points to the segments they graphically
 // touch.
 if( connected_item->Type() == SCH_BUS_WIRE_ENTRY_T )
 {
 // If this location only has the connection point of the bus
 // entry itself, this means that either the bus entry is not
 // connected to anything graphically, or that it is connected to
 // a segment at some point other than at one of the endpoints.
 if( connection_vec.size() == 1 )
 {
 if( busLine )
 {
 auto bus_entry = static_cast<SCH_BUS_WIRE_ENTRY*>( connected_item );
 bus_entry->m_connected_bus_item = busLine;
 }
 }
 }

 // Bus-to-bus entries are treated just like bus wires
 else if( connected_item->Type() == SCH_BUS_BUS_ENTRY_T )
 {
 if( connection_vec.size() < 2 )
 {
 if( busLine )
 {
 auto bus_entry = static_cast<SCH_BUS_BUS_ENTRY*>( connected_item );

 if( it.first == bus_entry->GetPosition() )
 bus_entry->m_connected_bus_items[0] = busLine;
 else
 bus_entry->m_connected_bus_items[1] = busLine;

 std::lock_guard<std::mutex> lock( update_mutex );
 bus_entry->AddConnectionTo( aSheet, busLine );
 busLine->AddConnectionTo( aSheet, bus_entry );
 }
 }
 }

 // Change junctions to be on bus junction layer if they are touching a bus
 else if( connected_item->Type() == SCH_JUNCTION_T )
 {
 connected_item->SetLayer( busLine ? LAYER_BUS_JUNCTION : LAYER_JUNCTION );
 }

 SCH_ITEM_SET& connected_set = connected_item->ConnectedItems( aSheet );
 connected_set.reserve( connection_vec.size() );

 for( SCH_ITEM* test_item : connection_vec )
 {
 bool bus_connection_ok = true;

 if( test_item == connected_item )
 continue;

 // Set up the link between the bus entry net and the bus
 if( connected_item->Type() == SCH_BUS_WIRE_ENTRY_T )
 {
 if( test_item->GetLayer() == LAYER_BUS )
 {
 auto bus_entry = static_cast<SCH_BUS_WIRE_ENTRY*>( connected_item );
 bus_entry->m_connected_bus_item = test_item;
 }
 }

 // Bus entries only connect to bus lines on the end that is touching a bus line.
 // If the user has overlapped another net line with the endpoint of the bus entry
 // where the entry connects to a bus, we don't want to short-circuit it.
 if( connected_item->Type() == SCH_BUS_WIRE_ENTRY_T )
 {
 bus_connection_ok = !busLine || test_item->GetLayer() == LAYER_BUS;
 }
 else if( test_item->Type() == SCH_BUS_WIRE_ENTRY_T )
 {
 bus_connection_ok = !busLine || connected_item->GetLayer() == LAYER_BUS;
 }

 if( connected_item->ConnectionPropagatesTo( test_item ) &&
 test_item->ConnectionPropagatesTo( connected_item ) &&
 bus_connection_ok )
 {
 connected_set.push_back( test_item );
 }
 }

 // If we got this far and did not find a connected bus item for a bus entry,
 // we should do a manual scan in case there is a bus item on this connection
 // point but we didn't pick it up earlier because there is *also* a net item here.
 if( connected_item->Type() == SCH_BUS_WIRE_ENTRY_T )
 {
 auto bus_entry = static_cast<SCH_BUS_WIRE_ENTRY*>( connected_item );

 if( !bus_entry->m_connected_bus_item )
 {
 SCH_SCREEN* screen = aSheet.LastScreen();
 SCH_LINE* bus = screen->GetBus( it.first );

 if( bus )
 bus_entry->m_connected_bus_item = bus;
 }
 }
 }

 return 1;
 };


 if( parallelThreadCount == 1 )
 update_lambda();
 else
 {
 for( size_t ii = 0; ii < parallelThreadCount; ++ii )
 returns[ii] = std::async( std::launch::async, update_lambda );

 // Finalize the threads
 for( size_t ii = 0; ii < parallelThreadCount; ++ii )
 returns[ii].wait();
 }
 }
}

References SCH_ITEM::AddConnectionTo(), BUS, SCH_ITEM::ConnectedItems(), SCH_ITEM::ConnectionPropagatesTo(), SCH_SCREEN::GetBus(), SCH_ITEM::GetLayer(), SCH_SYMBOL::GetPins(), SCH_SHEET_PATH::LastScreen(), LAYER_BUS, LAYER_BUS_JUNCTION, LAYER_JUNCTION, m_invisible_power_pins, m_items, NET, pin, SCH_BUS_BUS_ENTRY_T, SCH_BUS_WIRE_ENTRY_T, SCH_JUNCTION_T, SCH_LINE_T, SCH_PIN_T, SCH_SHEET_T, SCH_SYMBOL_T, SCH_ITEM::SetLayer(), SCH_CONNECTION::SetType(), and EDA_ITEM::Type().

Referenced by Recalculate().

Member Data Documentation

m_allowRealTime

bool CONNECTION_GRAPH::m_allowRealTime = true

static

Definition at line 535 of file connection_graph.h.

Referenced by SCH_CONNECTION::AppendInfoToMsgPanel(), SCH_EDITOR_CONTROL::AssignNetclass(), DIALOG_GLOBAL_EDIT_TEXT_AND_GRAPHICS::DIALOG_GLOBAL_EDIT_TEXT_AND_GRAPHICS(), SCH_EDITOR_CONTROL::DrawSheetOnClipboard(), SCH_EDITOR_CONTROL::HighlightNetCursor(), SCH_EDIT_FRAME::KiwayMailIn(), SCH_EDIT_FRAME::OnModify(), SCH_EDITOR_CONTROL::Plot(), SCH_EDITOR_CONTROL::Print(), Recalculate(), and BUS_UNFOLD_MENU::update().

m_bus_alias_cache

std::unordered_map< wxString, std::shared_ptr<BUS_ALIAS> > CONNECTION_GRAPH::m_bus_alias_cache

private

Definition at line 555 of file connection_graph.h.

Referenced by buildConnectionGraph(), GetBusAlias(), and Reset().

m_bus_name_to_code_map

std::map<wxString, int> CONNECTION_GRAPH::m_bus_name_to_code_map

private

Definition at line 559 of file connection_graph.h.

Referenced by processSubGraphs(), and Reset().

m_driver_subgraphs

std::vector<CONNECTION_SUBGRAPH*> CONNECTION_GRAPH::m_driver_subgraphs

private

Definition at line 548 of file connection_graph.h.

Referenced by buildConnectionGraph(), collectAllDriverValues(), generateInvisiblePinSubGraphs(), processSubGraphs(), Reset(), and resolveAllDrivers().

m_global_label_cache

std::map<wxString, std::vector<const CONNECTION_SUBGRAPH*> > CONNECTION_GRAPH::m_global_label_cache

private

Definition at line 561 of file connection_graph.h.

Referenced by collectAllDriverValues(), ercCheckNoConnects(), and Reset().

m_invisible_power_pins

std::vector<std::pair<SCH_SHEET_PATH, SCH_PIN*> > CONNECTION_GRAPH::m_invisible_power_pins

private

Definition at line 553 of file connection_graph.h.

Referenced by generateInvisiblePinSubGraphs(), Reset(), and updateItemConnectivity().

m_item_to_subgraph_map

std::map<SCH_ITEM*, CONNECTION_SUBGRAPH*> CONNECTION_GRAPH::m_item_to_subgraph_map

private

Definition at line 568 of file connection_graph.h.

Referenced by buildItemSubGraphs(), GetSubgraphForItem(), and Reset().

m_items

std::vector<SCH_ITEM*> CONNECTION_GRAPH::m_items

private

Definition at line 542 of file connection_graph.h.

Referenced by buildItemSubGraphs(), Recalculate(), Reset(), and updateItemConnectivity().

m_last_bus_code

int CONNECTION_GRAPH::m_last_bus_code

private

Definition at line 574 of file connection_graph.h.

Referenced by processSubGraphs(), and Reset().

m_last_net_code

int CONNECTION_GRAPH::m_last_net_code

private

Definition at line 572 of file connection_graph.h.

Referenced by assignNewNetCode(), and Reset().

m_last_subgraph_code

int CONNECTION_GRAPH::m_last_subgraph_code

private

Definition at line 576 of file connection_graph.h.

Referenced by buildItemSubGraphs(), generateInvisiblePinSubGraphs(), and Reset().

m_local_label_cache

std::map< std::pair<SCH_SHEET_PATH, wxString>, std::vector<const CONNECTION_SUBGRAPH*> > CONNECTION_GRAPH::m_local_label_cache

private

Definition at line 564 of file connection_graph.h.

Referenced by collectAllDriverValues(), ercCheckLabels(), ercCheckNoConnects(), and Reset().

m_net_code_to_subgraphs_map

NET_MAP CONNECTION_GRAPH::m_net_code_to_subgraphs_map

private

Definition at line 570 of file connection_graph.h.

Referenced by buildConnectionGraph(), generateInvisiblePinSubGraphs(), GetNetMap(), and Reset().

m_net_name_to_code_map

std::map<wxString, int> CONNECTION_GRAPH::m_net_name_to_code_map

private

Definition at line 557 of file connection_graph.h.

Referenced by assignNewNetCode(), and Reset().

m_net_name_to_subgraphs_map

std::unordered_map<wxString, std::vector<CONNECTION_SUBGRAPH*> > CONNECTION_GRAPH::m_net_name_to_subgraphs_map

private

Definition at line 566 of file connection_graph.h.

Referenced by buildConnectionGraph(), collectAllDriverValues(), ercCheckLabels(), FindFirstSubgraphByName(), FindSubgraphByName(), processSubGraphs(), recacheSubgraphName(), and Reset().

m_schematic

SCHEMATIC* CONNECTION_GRAPH::m_schematic

private

The schematic this graph represents.

Definition at line 578 of file connection_graph.h.

Referenced by buildConnectionGraph(), ercCheckHierSheets(), ercCheckLabels(), ercCheckNoConnects(), RunERC(), and SetSchematic().

m_sheet_to_subgraphs_map

std::unordered_map<SCH_SHEET_PATH, std::vector<CONNECTION_SUBGRAPH*> > CONNECTION_GRAPH::m_sheet_to_subgraphs_map

private

Definition at line 551 of file connection_graph.h.

Referenced by buildConnectionGraph(), processSubGraphs(), propagateToNeighbors(), and Reset().

m_sheetList

SCH_SHEET_LIST CONNECTION_GRAPH::m_sheetList

private

Definition at line 539 of file connection_graph.h.

Referenced by ercCheckHierSheets(), and Recalculate().

m_subgraphs

std::vector<CONNECTION_SUBGRAPH*> CONNECTION_GRAPH::m_subgraphs

private

Definition at line 545 of file connection_graph.h.

Referenced by buildConnectionGraph(), buildItemSubGraphs(), generateInvisiblePinSubGraphs(), GetBusesNeedingMigration(), Reset(), resolveAllDrivers(), and RunERC().

---

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

• connection_graph.h
• connection_graph.cpp