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 (std::function< void(SCH_ITEM *)> *aChangedItemHandler)
	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	ercCheckNetclassConflicts (const std::vector< CONNECTION_SUBGRAPH * > &subgraphs)
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::unordered_map< wxString, int >	m_net_name_to_code_map
std::unordered_map< wxString, int >	m_bus_name_to_code_map
std::unordered_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::unordered_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 272 of file connection_graph.h.

Constructor & Destructor Documentation

CONNECTION_GRAPH()

CONNECTION_GRAPH::CONNECTION_GRAPH ( SCHEMATIC *  aSchematic = nullptr )

inline

Definition at line 275 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 282 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 1749 of file connection_graph.cpp.

{
 std::vector< std::shared_ptr<SCH_CONNECTION>>& connections_to_check( aConnection->Members() );
 
 for( unsigned i = 0; i < connections_to_check.size(); i++ )
 {
 const std::shared_ptr<SCH_CONNECTION>& 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 1727 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 ( std::function< void(SCH_ITEM *)> *  aChangedItemHandler )

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 1410 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 std::shared_ptr<BUS_ALIAS>& 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 );
 
 GetKiCadThreadPool().parallelize_loop( 0, m_driver_subgraphs.size(),
 [&]( const int a, const int b)
 {
 for( int ii = a; ii < b; ++ii )
 m_driver_subgraphs[ii]->UpdateItemConnections();
 }).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, "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, "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, "Subgraph not processed by propagateToNeighbors!" );
 
 if( subgraph->m_bus_parents.size() < 2 )
 continue;
 
 SCH_CONNECTION* conn = subgraph->m_driver_connection;
 
 wxLogTrace( ConnTrace, "%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, "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, "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 );
 }
 }
 }
 }
 }
 
 
 auto updateItemConnectionsTask =
 [&]( CONNECTION_SUBGRAPH* subgraph ) -> size_t
 {
 // 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() )
 return 0;
 
 // 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() )
 return 0;
 }
 }
 
 return 1;
 };
 
 GetKiCadThreadPool().parallelize_loop( 0, m_driver_subgraphs.size(),
 [&]( const int a, const int b)
 {
 for( int ii = a; ii < b; ++ii )
 updateItemConnectionsTask( m_driver_subgraphs[ii] );
 }).wait();
 
 m_net_code_to_subgraphs_map.clear();
 m_net_name_to_subgraphs_map.clear();
 
 for( CONNECTION_SUBGRAPH* subgraph : m_driver_subgraphs )
 {
 NET_NAME_CODE_CACHE_KEY key = { 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 );
 }
 
 std::shared_ptr<NET_SETTINGS>& netSettings = m_schematic->Prj().GetProjectFile().m_NetSettings;
 std::map<wxString, wxString> oldAssignments = netSettings->m_NetClassLabelAssignments;
 
 netSettings->m_NetClassLabelAssignments.clear();
 
 auto dirtySubgraphs =
 [&]( const std::vector<CONNECTION_SUBGRAPH*>& subgraphs )
 {
 if( aChangedItemHandler )
 {
 for( const CONNECTION_SUBGRAPH* subgraph : subgraphs )
 {
 for( SCH_ITEM* item : subgraph->m_items )
 (*aChangedItemHandler)( item );
 }
 }
 };
 
 auto checkNetclassDrivers =
 [&]( const std::vector<CONNECTION_SUBGRAPH*>& subgraphs )
 {
 for( const CONNECTION_SUBGRAPH* subgraph : subgraphs )
 {
 for( SCH_ITEM* item : subgraph->m_items )
 {
 const wxString netclass = subgraph->GetNetclassForDriver( item );
 
 if( !netclass.IsEmpty() )
 {
 const wxString netname = subgraph->GetNetName();
 
 netSettings->m_NetClassLabelAssignments[ netname ] = netclass;
 
 if( oldAssignments[ netname ] != netclass )
 dirtySubgraphs( subgraphs );
 
 return;
 }
 }
 }
 };
 
 for( const auto& [ netname, subgraphs ] : m_net_name_to_subgraphs_map )
 checkNetclassDrivers( subgraphs );
}

References buildItemSubGraphs(), BUS, SCH_CONNECTION::Clone(), collectAllDriverValues(), SCH_ITEM::Connection(), ConnProfileMask, ConnTrace, alg::delete_if(), generateInvisiblePinSubGraphs(), CONNECTION_SUBGRAPH::GetDriverPriority(), GetKiCadThreadPool(), PROJECT::GetProjectFile(), 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, m_driver_subgraphs, m_net_code_to_subgraphs_map, m_net_name_to_subgraphs_map, PROJECT_FILE::m_NetSettings, m_schematic, CONNECTION_SUBGRAPH::m_sheet, m_sheet_to_subgraphs_map, matchBusMember(), name, SCH_CONNECTION::Name(), EE_RTREE::OfType(), path, pin, CONNECTION_SUBGRAPH::POWER_PIN, SCHEMATIC::Prj(), processSubGraphs(), propagateToNeighbors(), resolveAllDrivers(), SCH_HIER_LABEL_T, SCH_PIN_T, SCH_SHEET_PIN_T, SCH_CONNECTION::SetType(), and PROF_TIMER::Show().

buildItemSubGraphs()

void CONNECTION_GRAPH::buildItemSubGraphs ( )

private

Generates individual item subgraphs on a per-sheet basis.

Definition at line 778 of file connection_graph.cpp.

{
 // Recache all bus aliases for later use
 wxCHECK_RET( m_schematic, "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 std::shared_ptr<BUS_ALIAS>& alias : all_sheets[i].LastScreen()->GetBusAliases() )
 m_bus_alias_cache[ alias->GetName() ] = alias;
 }
 
 // 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, SCHEMATIC::GetSheets(), m_bus_alias_cache, CONNECTION_SUBGRAPH::m_code, CONNECTION_SUBGRAPH::m_dirty, m_item_to_subgraph_map, m_items, m_last_subgraph_code, CONNECTION_SUBGRAPH::m_no_connect, m_schematic, 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 937 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:
 {
  UNITS_PROVIDER unitsProvider( schIUScale, EDA_UNITS::MILLIMETRES );
 
 wxLogTrace( ConnTrace, "Unexpected strong driver %s",
 driver->GetSelectMenuText( &unitsProvider ) );
 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, schIUScale, 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 2573 of file connection_graph.cpp.

{
 const SCH_SHEET_PATH& sheet = aSubgraph->m_sheet;
 SCH_SCREEN* screen = sheet.LastScreen();
 
 SCH_ITEM* label = nullptr;
 SCH_ITEM* port = nullptr;
 
 for( SCH_ITEM* 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, SCH_TEXT_T, and EDA_ITEM::Type().

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 2641 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 2516 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 2921 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 3125 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 2959 of file connection_graph.cpp.

{
 // Label connection rules:
 // Any label without a no-connect needs to have at least 2 pins, otherwise it is invalid
 // 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
 
 
 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;
 int pinCount = 0;
 
 std::map<KICAD_T, std::vector<SCH_TEXT*>> label_map;
 
 
 auto hasPins =
 []( const CONNECTION_SUBGRAPH* aLocSubgraph ) -> int
 {
 int retval = 0;
 
 for( const SCH_ITEM* item : aLocSubgraph->m_items )
 {
 switch( item->Type() )
 {
 case SCH_PIN_T:
 case SCH_SHEET_PIN_T:
 ++retval;
 break;
 
 default: break;
 }
 }
 
 return retval;
 };
 
 auto reportError = [&]( SCH_TEXT* aText, int errCode )
 {
 if( settings.IsTestEnabled( errCode ) )
 {
 std::shared_ptr<ERC_ITEM> ercItem = ERC_ITEM::Create( errCode );
 ercItem->SetItems( aText );
 
 SCH_MARKER* marker = new SCH_MARKER( ercItem, aText->GetPosition() );
 aSubgraph->m_sheet.LastScreen()->Append( marker );
 }
 };
 
 pinCount = hasPins( aSubgraph );
 
 for( SCH_ITEM* item : aSubgraph->m_items )
 {
 switch( item->Type() )
 {
 case SCH_LABEL_T:
 case SCH_GLOBAL_LABEL_T:
 case SCH_HIER_LABEL_T:
 {
 SCH_TEXT* text = static_cast<SCH_TEXT*>( item );
 
 label_map[item->Type()].push_back( text );
 
 // 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() )
 {
 reportError( text, ERCE_LABEL_NOT_CONNECTED );
 return false;
 }
 
 break;
 }
 
 // If this subgraph has a no-connect, do not continue processing as we do not
 // submit no-connect errors for nets explicitly designated as no-connect
 case SCH_NO_CONNECT_T:
 return true;
 
 default:
 break;
 }
 }
 
 if( label_map.empty() )
 return true;
 
 wxCHECK_MSG( m_schematic, true, "Null m_schematic in CONNECTION_GRAPH::ercCheckLabels" );
 
 // Labels that have multiple pins connected are not dangling (may be used for naming segments)
 // so leave them without errors here
 if( pinCount > 1 )
 return true;
 
 for( auto& [type, label_vec] : label_map )
 {
 
 switch( type )
 {
 case SCH_GLOBAL_LABEL_T:
 if( !settings.IsTestEnabled( ERCE_GLOBLABEL ) )
 continue;
 
 break;
 default:
 if( !settings.IsTestEnabled( ERCE_LABEL_NOT_CONNECTED ) )
 continue;
 
 break;
 }
 
 for( SCH_TEXT* text : label_vec )
 {
 int allPins = pinCount;
 
 // Labels are connected if there are at least 2 pins on their net
 const CONNECTION_SUBGRAPH* subgraph = aSubgraph;
 
 // If there is a hierarchical connection, walk up the hierarchy
 // to get the top-most subgraph
 while( subgraph->m_hier_parent )
 subgraph = subgraph->m_hier_parent;
 
 wxString name = subgraph->m_driver_connection->Name();
 
 // If there are local bus connections (a label with the same name as a bus element)
 // Then get the name from the SCH_CONNECTION element used to map the bus connection
 // as this is the "true" connection name
 if( !subgraph->m_bus_parents.empty() )
 name = subgraph->m_bus_parents.begin()->first->Name();
 
 auto it = m_net_name_to_subgraphs_map.find( name );
 
 if( it != m_net_name_to_subgraphs_map.end() )
 {
 for( const CONNECTION_SUBGRAPH* neighbor : it->second )
 {
 if( neighbor == aSubgraph )
 continue;
 
 allPins += hasPins( neighbor );
 }
 }
 
 if( allPins < 2 )
 {
 reportError( text,
 type == SCH_GLOBAL_LABEL_T ? ERCE_GLOBLABEL : ERCE_LABEL_NOT_CONNECTED );
 ok = false;
 }
 }
 }
 
 return ok;
}

References SCH_SCREEN::Append(), ERC_ITEM::Create(), ERCE_GLOBLABEL, ERCE_LABEL_NOT_CONNECTED, SCHEMATIC::ErcSettings(), SCH_TEXT::GetPosition(), SCH_CONNECTION::IsBus(), ERC_SETTINGS::IsTestEnabled(), SCH_SHEET_PATH::LastScreen(), CONNECTION_SUBGRAPH::m_bus_parents, CONNECTION_SUBGRAPH::m_driver_connection, CONNECTION_SUBGRAPH::m_hier_parent, CONNECTION_SUBGRAPH::m_items, m_net_name_to_subgraphs_map, m_schematic, CONNECTION_SUBGRAPH::m_sheet, name, SCH_CONNECTION::Name(), SCH_GLOBAL_LABEL_T, SCH_HIER_LABEL_T, SCH_LABEL_T, SCH_NO_CONNECT_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 2405 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().

ercCheckNetclassConflicts()

bool CONNECTION_GRAPH::ercCheckNetclassConflicts ( const std::vector< CONNECTION_SUBGRAPH * > &  subgraphs )

private

Definition at line 2478 of file connection_graph.cpp.

{
 wxString firstNetclass;
 SCH_ITEM* firstNetclassDriver = nullptr;
 
 for( const CONNECTION_SUBGRAPH* subgraph : subgraphs )
 {
 for( SCH_ITEM* item : subgraph->m_items )
 {
 const wxString netclass = subgraph->GetNetclassForDriver( item );
 
 if( netclass.IsEmpty() )
 continue;
 
 if( netclass != firstNetclass )
 {
 if( !firstNetclassDriver )
 {
 firstNetclass = netclass;
 firstNetclassDriver = item;
 continue;
 }
 
 std::shared_ptr<ERC_ITEM> ercItem = ERC_ITEM::Create( ERCE_NETCLASS_CONFLICT );
 ercItem->SetItems( firstNetclassDriver, item );
 
 SCH_MARKER* marker = new SCH_MARKER( ercItem, item->GetPosition() );
 subgraph->m_sheet.LastScreen()->Append( marker );
 
 return false;
 }
 }
 }
 
 return true;
}

References ERC_ITEM::Create(), ERCE_NETCLASS_CONFLICT, and EDA_ITEM::GetPosition().

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 2739 of file connection_graph.cpp.

{
 ERC_SETTINGS& settings = m_schematic->ErcSettings();
 const SCH_SHEET_PATH& sheet = aSubgraph->m_sheet;
 SCH_SCREEN* screen = sheet.LastScreen();
 bool ok = true;
 
 if( aSubgraph->m_no_connect != nullptr )
 {
 SCH_PIN* pin = nullptr;
 std::set<SCH_ITEM*> unique_items;
 
 // 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:
 {
 pin = static_cast<SCH_PIN*>( item );
 
 // Insert the pin's parent so that we don't flag stacked pins
 if( auto [existing, success] = unique_items.insert(
 static_cast<SCH_ITEM*>( pin->GetParent() ) ); !success )
 {
 SCH_PIN* ex_pin = static_cast<SCH_PIN*>( *existing );
 
 // Stacked pins don't count as connected
 // but if they are not stacked, but still in the same symbol
 // flag this for an error
 if( !pin->IsStacked( ex_pin ) )
 unique_items.insert( ex_pin );
 }
 
 break;
 }
 
 case SCH_LINE_T:
 case SCH_JUNCTION_T:
 case SCH_NO_CONNECT_T:
 break;
 
 default:
 unique_items.insert( item );
 }
 }
 
 if( unique_items.size() > 1 && pin && 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( unique_items.empty() && 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:
 {
 // Stacked pins do not count as other connections but non-stacked pins do
 if( !has_other_connections && !pins.empty() )
 {
 SCH_PIN* pin = static_cast<SCH_PIN*>( item );
 
 for( SCH_PIN* other_pin : pins )
 {
 if( other_pin->GetParent() != pin->GetParent()
 || other_pin->GetPosition() != pin->GetPosition() )
 {
 has_other_connections = true;
 break;
 }
 }
 }
 
 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(), 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 2273 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 2252 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 1000 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();
 
  NET_NAME_CODE_CACHE_KEY key = { 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 2197 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 2205 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, "SG %ld (%s) has multiple bus labels", subgraph->m_code,
 connection->Name() );
 
 ret.push_back( subgraph );
 }
 }
 
 return ret;
}

References SCH_ITEM::Connection(), ConnTrace, SCH_TEXT::GetShownText(), 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 2088 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 330 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 2286 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 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 2127 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 1061 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;
 wxString suffixStr = std::to_wstring( suffix );
 
 // 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 << prefix << wxT( "_" ) << suffixStr << wxT( "{" ) << oldName;
 
 aConn->ConfigureFromLabel( newName );
 }
 else
 {
 newName << aConn->Name() << wxT( "_" ) << suffixStr;
 aConn->SetSuffix( wxString( wxT( "_" ) ) << suffixStr );
 }
 
 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, "%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,
 "%ld (%s) skipped for promotion due to potential conflict",
 subgraph->m_code, name );
 }
 else
 {
 UNITS_PROVIDER unitsProvider( schIUScale, EDA_UNITS::MILLIMETRES );
 
 wxLogTrace( ConnTrace,
 "%ld (%s) weakly driven by unique sheet pin %s, promoting",
 subgraph->m_code, name,
 subgraph->m_driver->GetSelectMenuText( &unitsProvider ) );
 
 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,
 "%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( CONNECTION_SUBGRAPH* 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, "%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, "%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, "Re-resolving drivers for %lu (%s)", subgraph->m_code,
 subgraph->m_driver_connection->Name() );
 }
 
}

References assignNetCodesToBus(), assignNewNetCode(), BUS, BUS_GROUP, ConnTrace, alg::delete_matching(), getDefaultConnection(), SCH_CONNECTION::IsBus(), SCH_CONNECTION::IsNet(), CONNECTION_SUBGRAPH::m_absorbed, m_bus_name_to_code_map, CONNECTION_SUBGRAPH::m_bus_parents, CONNECTION_SUBGRAPH::m_code, CONNECTION_SUBGRAPH::m_driver, CONNECTION_SUBGRAPH::m_driver_connection, m_driver_subgraphs, CONNECTION_SUBGRAPH::m_drivers, m_last_bus_code, CONNECTION_SUBGRAPH::m_multiple_drivers, 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, schIUScale, 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 1770 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, "%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;
 }
 
 const KIID& last_parent_uuid = aParent->m_sheet.Last()->m_Uuid;
 
 for( SCH_SHEET_PIN* pin : candidate->m_hier_pins )
 {
 // If the last sheet UUIDs won't match, no need to check the full path
 if( pin->GetParent()->m_Uuid != last_parent_uuid )
 continue;
 
 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, "%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, "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, "%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, "%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, "%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, "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, "%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, "WARNING: failed to match stale member %s in %s.",
 stale_member->Name(), subgraph->m_driver_connection->Name() );
 continue;
 }
 
 wxLogTrace( ConnTrace, "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, propagateToNeighbors(), SCH_SHEET_PATH::push_back(), recacheSubgraphName(), SCH_SHEET_PATH::size(), and SCH_CONNECTION::Type().

Referenced by buildConnectionGraph(), and propagateToNeighbors().

recacheSubgraphName()

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

private

Definition at line 2179 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, "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 479 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;
 // Store current unit value, to regenerate it after calculations
 // (useful in complex hierarchies)
 std::vector<std::pair<SCH_SYMBOL*, int>> symbolsChanged;
 
 for( SCH_ITEM* item : sheet.LastScreen()->Items() )
 {
 if( item->IsConnectable() && ( aUnconditional || item->IsConnectivityDirty() ) )
 items.push_back( item );
 
 // Ensure the hierarchy info stored in SCREENS is built and up to date
 // (multi-unit symbols)
 if( item->Type() == SCH_SYMBOL_T )
 {
 SCH_SYMBOL* symbol = static_cast<SCH_SYMBOL*>( item );
 int new_unit = symbol->GetUnitSelection( &sheet );
 
 // Store the initial unit value, to regenerate it after calculations,
 // if modified
 if( symbol->GetUnit() != new_unit )
 symbolsChanged.push_back( { symbol, symbol->GetUnit() } );
 
 symbol->UpdateUnit( new_unit );
 }
 }
 
 m_items.reserve( m_items.size() + items.size() );
 
 updateItemConnectivity( sheet, items );
 
 // UpdateDanglingState() also adds connected items for SCH_TEXT
 sheet.LastScreen()->TestDanglingEnds( &sheet, aChangedItemHandler );
 
 // Restore the m_unit member, to avoid changes in current active sheet path
 // after calculations
 for( auto& item : symbolsChanged )
 {
 item.first->UpdateUnit( item.second );
 }
 }
 
 if( wxLog::IsAllowedTraceMask( ConnProfileMask ) )
 update_items.Show();
 
 PROF_TIMER build_graph( "buildConnectionGraph" );
 
 buildConnectionGraph( aChangedItemHandler );
 
 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 SCH_SYMBOL::GetUnit(), SCH_SYMBOL::GetUnitSelection(), m_items, m_sheetList, Reset(), SCH_SYMBOL_T, and updateItemConnectivity().

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

Reset()

void CONNECTION_GRAPH::Reset

(

)

Definition at line 455 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 868 of file connection_graph.cpp.

{
 // Resolve drivers for subgraphs and propagate connectivity info
 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;
 } );
 
 std::vector<std::future<size_t>> returns( dirty_graphs.size() );
 
 auto update_lambda = []( CONNECTION_SUBGRAPH* subgraph ) -> size_t
 {
 if( !subgraph->m_dirty )
 return 0;
 
 // Special processing for some items
 for( SCH_ITEM* 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;
 };
 
 GetKiCadThreadPool().parallelize_loop( 0, dirty_graphs.size(),
 [&]( const int a, const int b)
 {
 for( int ii = a; ii < b; ++ii )
 update_lambda( dirty_graphs[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 GetKiCadThreadPool(), m_driver_subgraphs, m_subgraphs, pin, PT_NC, SCH_BUS_WIRE_ENTRY_T, SCH_NO_CONNECT_T, SCH_PIN_T, and EDA_ITEM::Type().

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 2298 of file connection_graph.cpp.

{
 int error_count = 0;
 
 wxCHECK_MSG( m_schematic, true, "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();
 }
 
 if( settings.IsTestEnabled( ERCE_NETCLASS_CONFLICT ) )
 {
 for( const auto& [ netname, subgraphs ] : m_net_name_to_subgraphs_map )
 {
 if( !ercCheckNetclassConflicts( subgraphs ) )
 error_count++;
 }
 }
 
 return error_count;
}

References ercCheckBusToBusConflicts(), ercCheckBusToBusEntryConflicts(), ercCheckBusToNetConflicts(), ercCheckFloatingWires(), ercCheckHierSheets(), ercCheckLabels(), ercCheckMultipleDrivers(), ercCheckNetclassConflicts(), 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_NETCLASS_CONFLICT, ERCE_NOCONNECT_CONNECTED, ERCE_NOCONNECT_NOT_CONNECTED, ERCE_PIN_NOT_CONNECTED, ERCE_WIRE_DANGLING, SCHEMATIC::ErcSettings(), ERC_SETTINGS::IsTestEnabled(), m_net_name_to_subgraphs_map, m_schematic, and m_subgraphs.

Referenced by DIALOG_ERC::testErc().

SetSchematic()

void CONNECTION_GRAPH::SetSchematic ( SCHEMATIC *  aSchematic )

inline

Definition at line 289 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 562 of file connection_graph.cpp.

{
 std::map<VECTOR2I, std::vector<SCH_ITEM*>> connection_map;
 
 for( SCH_ITEM* item : aItemList )
 {
 std::vector<VECTOR2I> 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 );
 
 VECTOR2I 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 VECTOR2I& 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 );
 
 std::mutex update_mutex;
 
 auto update_lambda = [&]( SCH_ITEM* connected_item ) -> size_t
 {
 // 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;
 };
 
 GetKiCadThreadPool().parallelize_loop( 0, connection_vec.size(),
 [&]( const int a, const int b)
 {
 for( int ii = a; ii < b; ++ii )
 update_lambda( connection_vec[ii] );
 }).wait();
 }
}

References SCH_ITEM::AddConnectionTo(), BUS, SCH_SCREEN::GetBus(), GetKiCadThreadPool(), SCH_ITEM::GetLayer(), SCH_SYMBOL::GetPins(), SCH_SHEET_PATH::LastScreen(), LAYER_BUS, LAYER_BUS_JUNCTION, LAYER_JUNCTION, SCH_BUS_WIRE_ENTRY::m_connected_bus_item, SCH_BUS_BUS_ENTRY::m_connected_bus_items, 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::SetConnectivityDirty(), and SCH_CONNECTION::SetType().

Referenced by Recalculate().

Member Data Documentation

m_allowRealTime

bool CONNECTION_GRAPH::m_allowRealTime = true

static

Definition at line 561 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(), 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 581 of file connection_graph.h.

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

m_bus_name_to_code_map

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

private

Definition at line 585 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 574 of file connection_graph.h.

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

m_global_label_cache

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

private

Definition at line 587 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 579 of file connection_graph.h.

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

m_item_to_subgraph_map

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

private

Definition at line 594 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 568 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 600 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 598 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 602 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 590 of file connection_graph.h.

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

m_net_code_to_subgraphs_map

NET_MAP CONNECTION_GRAPH::m_net_code_to_subgraphs_map

private

Definition at line 596 of file connection_graph.h.

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

m_net_name_to_code_map

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

private

Definition at line 583 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 592 of file connection_graph.h.

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

m_schematic

SCHEMATIC* CONNECTION_GRAPH::m_schematic

private

The schematic this graph represents.

Definition at line 604 of file connection_graph.h.

Referenced by buildConnectionGraph(), buildItemSubGraphs(), 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 577 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 565 of file connection_graph.h.

Referenced by ercCheckHierSheets(), and Recalculate().

m_subgraphs

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

private

Definition at line 571 of file connection_graph.h.

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

---

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

• connection_graph.h
• connection_graph.cpp