erc_settings.cpp

Go to the documentation of this file.

/*
 * This program source code file is part of KiCad, a free EDA CAD application.
 *
 * Copyright (C) 2024 CERN
 * Copyright The KiCad Developers, see AUTHORS.txt for contributors.
 * @author Jon Evans <[email protected]>
 *
 * This program is free software: you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the
 * Free Software Foundation, either version 3 of the License, or (at your
 * option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */
 
#include <algorithm>
#include <tuple>
#include <erc/erc_item.h>
#include <erc/erc_settings.h>
#include <schematic.h>
#include <sch_marker.h>
#include <sch_screen.h>
#include <settings/json_settings_internals.h>
#include <settings/parameters.h>
 
const int ercSettingsSchemaVersion = 1;
 
 
 
#define OK PIN_ERROR::OK
#define ERR PIN_ERROR::PP_ERROR
#define WAR PIN_ERROR::WARNING

PIN_ERROR ERC_SETTINGS::m_defaultPinMap[ELECTRICAL_PINTYPES_TOTAL][ELECTRICAL_PINTYPES_TOTAL] =
{
/*         I,   O,    Bi,   3S,   Pas,  NIC,  UnS,  PwrI, PwrO, OC,   OE,   NC */
/* I  */ { OK,  OK,   OK,   OK,   OK,   OK,   WAR,  OK,   OK,   OK,   OK,   ERR },
/* O  */ { OK,  ERR,  OK,   WAR,  OK,   OK,   WAR,  OK,   ERR,  ERR,  ERR,  ERR },
/* Bi */ { OK,  OK,   OK,   OK,   OK,   OK,   WAR,  OK,   WAR,  OK,   WAR,  ERR },
/* 3S */ { OK,  WAR,  OK,   OK,   OK,   OK,   WAR,  WAR,  ERR,  WAR,  WAR,  ERR },
/*Pas */ { OK,  OK,   OK,   OK,   OK,   OK,   WAR,  OK,   OK,   OK,   OK,   ERR },
/*NIC */ { OK,  OK,   OK,   OK,   OK,   OK,   OK,   OK,   OK,   OK,   OK,   ERR },
/*UnS */ { WAR, WAR,  WAR,  WAR,  WAR,  OK,   WAR,  WAR,  WAR,  WAR,  WAR,  ERR },
/*PwrI*/ { OK,  OK,   OK,   WAR,  OK,   OK,   WAR,  OK,   OK,   OK,   OK,   ERR },
/*PwrO*/ { OK,  ERR,  WAR,  ERR,  OK,   OK,   WAR,  OK,   ERR,  ERR,  ERR,  ERR },
/* OC */ { OK,  ERR,  OK,   WAR,  OK,   OK,   WAR,  OK,   ERR,  OK,   OK,   ERR },
/* OE */ { OK,  ERR,  WAR,  WAR,  OK,   OK,   WAR,  OK,   ERR,  OK,   OK,   ERR },
/* NC */ { ERR, ERR,  ERR,  ERR,  ERR,  ERR,  ERR,  ERR,  ERR,  ERR,  ERR,  ERR }
};
 

int ERC_SETTINGS::m_PinMinDrive[ELECTRICAL_PINTYPES_TOTAL][ELECTRICAL_PINTYPES_TOTAL] =
{
/*         I,    O,    Bi,   3S,   Pas,  NIC,  UnS,  PwrI, PwrO, OC,   OE,   NC */
/* I  */ { NOD,  DRV,  DRV,  DRV,  DRV,  NOD,  DRV,  NOD,  DRV,  DRV,  DRV,  NPI },
/* O  */ { DRV,  DRV,  DRV,  DRV,  DRV,  NOD,  DRV,  DRV,  DRV,  DRV,  DRV,  NPI },
/* Bi */ { DRV,  DRV,  DRV,  DRV,  DRV,  NOD,  DRV,  NOD,  DRV,  DRV,  DRV,  NPI },
/* 3S */ { DRV,  DRV,  DRV,  DRV,  DRV,  NOD,  DRV,  NOD,  DRV,  DRV,  DRV,  NPI },
/*Pas */ { DRV,  DRV,  DRV,  DRV,  DRV,  NOD,  DRV,  NOD,  DRV,  DRV,  DRV,  NPI },
/*NIC */ { NOD,  NOD,  NOD,  NOD,  NOD,  NOD,  NOD,  NOD,  NOD,  NOD,  NOD,  NPI },
/*UnS */ { DRV,  DRV,  DRV,  DRV,  DRV,  NOD,  DRV,  NOD,  DRV,  DRV,  DRV,  NPI },
/*PwrI*/ { NOD,  DRV,  NOD,  NOD,  NOD,  NOD,  NOD,  NOD,  DRV,  NOD,  NOD,  NPI },
/*PwrO*/ { DRV,  DRV,  DRV,  DRV,  DRV,  NOD,  DRV,  DRV,  DRV,  DRV,  DRV,  NPI },
/* OC */ { DRV,  DRV,  DRV,  DRV,  DRV,  NOD,  DRV,  NOD,  DRV,  DRV,  DRV,  NPI },
/* OE */ { DRV,  DRV,  DRV,  DRV,  DRV,  NOD,  DRV,  NOD,  DRV,  DRV,  DRV,  NPI },
/* NC */ { NPI,  NPI,  NPI,  NPI,  NPI,  NPI,  NPI,  NPI,  NPI,  NPI,  NPI,  NPI }
};
 
 
ERC_SETTINGS::ERC_SETTINGS( JSON_SETTINGS* aParent, const std::string& aPath ) :
        NESTED_SETTINGS( "erc", ercSettingsSchemaVersion, aParent, aPath, false )
{
    ResetPinMap();
 
    for( int i = ERCE_FIRST; i <= ERCE_LAST; ++i )
        m_ERCSeverities[ i ] = RPT_SEVERITY_ERROR;
 
    // Error is the default setting so set non-error priorities here.
    m_ERCSeverities[ERCE_UNSPECIFIED]             = RPT_SEVERITY_UNDEFINED;
    m_ERCSeverities[ERCE_ENDPOINT_OFF_GRID]       = RPT_SEVERITY_WARNING;
    m_ERCSeverities[ERCE_PIN_TO_PIN_WARNING]      = RPT_SEVERITY_WARNING;
    m_ERCSeverities[ERCE_PIN_TO_PIN_ERROR]        = RPT_SEVERITY_ERROR;
    m_ERCSeverities[ERCE_SIMILAR_LABELS]          = RPT_SEVERITY_WARNING;
    m_ERCSeverities[ERCE_SIMILAR_POWER]           = RPT_SEVERITY_WARNING;
    m_ERCSeverities[ERCE_SIMILAR_LABEL_AND_POWER] = RPT_SEVERITY_WARNING;
    m_ERCSeverities[ERCE_SINGLE_GLOBAL_LABEL] = RPT_SEVERITY_IGNORE;
    m_ERCSeverities[ERCE_SAME_LOCAL_GLOBAL_LABEL] = RPT_SEVERITY_WARNING;
    m_ERCSeverities[ERCE_SAME_LOCAL_GLOBAL_POWER] = RPT_SEVERITY_WARNING;
    m_ERCSeverities[ERCE_GROUND_PIN_NOT_GROUND]   = RPT_SEVERITY_WARNING;
    m_ERCSeverities[ERCE_WIRED_IMPLICIT_POWER]    = RPT_SEVERITY_WARNING;
    m_ERCSeverities[ERCE_LABEL_SINGLE_PIN]        = RPT_SEVERITY_WARNING;
    m_ERCSeverities[ERCE_DRIVER_CONFLICT]         = RPT_SEVERITY_WARNING;
    m_ERCSeverities[ERCE_BUS_ENTRY_CONFLICT]      = RPT_SEVERITY_WARNING;
    m_ERCSeverities[ERCE_LIB_SYMBOL_ISSUES]       = RPT_SEVERITY_WARNING;
    m_ERCSeverities[ERCE_LIB_SYMBOL_MISMATCH]     = RPT_SEVERITY_WARNING;
    m_ERCSeverities[ERCE_FOOTPRINT_LINK_ISSUES]   = RPT_SEVERITY_WARNING;
    m_ERCSeverities[ERCE_FOOTPRINT_FILTERS]       = RPT_SEVERITY_IGNORE;
    m_ERCSeverities[ERCE_NOCONNECT_CONNECTED]     = RPT_SEVERITY_WARNING;
    m_ERCSeverities[ERCE_NOCONNECT_NOT_CONNECTED] = RPT_SEVERITY_WARNING;
    m_ERCSeverities[ERCE_MISSING_UNIT]            = RPT_SEVERITY_WARNING;
    m_ERCSeverities[ERCE_MISSING_INPUT_PIN]       = RPT_SEVERITY_WARNING;
    m_ERCSeverities[ERCE_MISSING_BIDI_PIN]        = RPT_SEVERITY_WARNING;
    m_ERCSeverities[ERCE_SIMULATION_MODEL]        = RPT_SEVERITY_IGNORE;
    m_ERCSeverities[ERCE_FOUR_WAY_JUNCTION]       = RPT_SEVERITY_IGNORE;
    m_ERCSeverities[ERCE_LABEL_MULTIPLE_WIRES]    = RPT_SEVERITY_WARNING;
    m_ERCSeverities[ERCE_UNCONNECTED_WIRE_ENDPOINT] = RPT_SEVERITY_WARNING;
    m_ERCSeverities[ERCE_STACKED_PIN_SYNTAX]      = RPT_SEVERITY_WARNING;
    m_ERCSeverities[ERCE_FIELD_NAME_WHITESPACE]   = RPT_SEVERITY_WARNING;
    m_ERCSeverities[ERCE_EMPTY_LABEL_NAME] = RPT_SEVERITY_ERROR;
    m_ERCSeverities[ERCE_PIN_MAP_UNMAPPED_PIN] = RPT_SEVERITY_WARNING;
    m_ERCSeverities[ERCE_PIN_MAP_STALE_PIN] = RPT_SEVERITY_WARNING;
    m_ERCSeverities[ERCE_VARIANT_SYMBOL_INVALID]  = RPT_SEVERITY_ERROR;
    m_ERCSeverities[ERCE_VARIANT_SYMBOL_INCOMPATIBLE] = RPT_SEVERITY_WARNING;
 
    m_params.emplace_back( new PARAM_LAMBDA<nlohmann::json>( "rule_severities",
            [&]() -> nlohmann::json
            {
                nlohmann::json ret = {};
 
                for( const RC_ITEM& item : ERC_ITEM::GetItemsWithSeverities() )
                {
                    wxString name = item.GetSettingsKey();
                    int      code = item.GetErrorCode();
 
                    if( name.IsEmpty() || m_ERCSeverities.count( code ) == 0 )
                        continue;
 
                    ret[std::string( name.ToUTF8() )] = SeverityToString( m_ERCSeverities[code] );
                }
 
                return ret;
            },
            [&]( const nlohmann::json& aJson )
            {
                if( !aJson.is_object() )
                    return;
 
                for( const RC_ITEM& item : ERC_ITEM::GetItemsWithSeverities() )
                {
                    int      code = item.GetErrorCode();
                    wxString name = item.GetSettingsKey();
 
                    std::string key( name.ToUTF8() );
 
                    if( aJson.contains( key ) )
                        m_ERCSeverities[code] = SeverityFromString( aJson[key] );
                }
            },
            {} ) );
 
    m_params.emplace_back( new PARAM_LAMBDA<nlohmann::json>( "erc_exclusions",
            [&]() -> nlohmann::json
            {
                nlohmann::json js = nlohmann::json::array();
 
                for( const ERC_EXCLUSION& exclusion : m_ErcExclusions )
                    js.push_back( exclusion );
 
                return js;
            },
            [&]( const nlohmann::json& aObj )
            {
                m_ErcExclusions.clear();
 
                if( !aObj.is_array() )
                    return;
 
                for( const nlohmann::json& entry : aObj )
                {
                    if( !entry.is_object() )
                        continue;
 
                    ERC_EXCLUSION exclusion = entry.get<ERC_EXCLUSION>();
 
                    if( !exclusion.GetSortKey().empty() )
                        m_ErcExclusions.insert( exclusion );
                }
            },
            {} ) );
 
    m_params.emplace_back( new PARAM_LAMBDA<nlohmann::json>( "pin_map",
            [&]() -> nlohmann::json
            {
                nlohmann::json ret = nlohmann::json::array();
 
                for( int i = 0; i < ELECTRICAL_PINTYPES_TOTAL; i++ )
                {
                    nlohmann::json inner = nlohmann::json::array();
 
                    for( int j = 0; j < ELECTRICAL_PINTYPES_TOTAL; j++ )
                        inner.push_back( static_cast<int>( GetPinMapValue( i, j ) ) );
 
                    ret.push_back( inner );
                }
 
                return ret;
            },
            [&]( const nlohmann::json& aJson )
            {
                if( !aJson.is_array() || aJson.size() != ELECTRICAL_PINTYPES_TOTAL )
                    return;
 
                for( size_t i = 0; i < ELECTRICAL_PINTYPES_TOTAL; i++ )
                {
                    if( i > aJson.size() - 1 )
                        break;
 
                    nlohmann::json inner = aJson[i];
 
                    if( !inner.is_array() || inner.size() != ELECTRICAL_PINTYPES_TOTAL )
                        return;
 
                    for( size_t j = 0; j < ELECTRICAL_PINTYPES_TOTAL; j++ )
                    {
                        if( inner[j].is_number_integer() )
                        {
                            int val = inner[j].get<int>();
 
                            if( val >= 0 && val <= static_cast<int>( PIN_ERROR::UNCONNECTED ) )
                                SetPinMapValue( i, j, static_cast<PIN_ERROR>( val ) );
                        }
                    }
                }
            },
            {} ) );
 
    registerMigration( 0, 1, std::bind( &ERC_SETTINGS::migrateSchema0to1, this ) );
 
    // Pin weights used for sorting. Take care, sorting is descending!
    m_PinTypeWeights.emplace( ELECTRICAL_PINTYPE::PT_NIC,           11 );
    m_PinTypeWeights.emplace( ELECTRICAL_PINTYPE::PT_UNSPECIFIED,   10 );
    m_PinTypeWeights.emplace( ELECTRICAL_PINTYPE::PT_PASSIVE,       9 );
    m_PinTypeWeights.emplace( ELECTRICAL_PINTYPE::PT_OPENCOLLECTOR, 8 );
    m_PinTypeWeights.emplace( ELECTRICAL_PINTYPE::PT_OPENEMITTER,   7 );
    m_PinTypeWeights.emplace( ELECTRICAL_PINTYPE::PT_INPUT,         6 );
    m_PinTypeWeights.emplace( ELECTRICAL_PINTYPE::PT_TRISTATE,      5 );
    m_PinTypeWeights.emplace( ELECTRICAL_PINTYPE::PT_BIDI,          4 );
    m_PinTypeWeights.emplace( ELECTRICAL_PINTYPE::PT_OUTPUT,        3 );
    m_PinTypeWeights.emplace( ELECTRICAL_PINTYPE::PT_POWER_IN,      2 );
    m_PinTypeWeights.emplace( ELECTRICAL_PINTYPE::PT_POWER_OUT,     1 );
    m_PinTypeWeights.emplace( ELECTRICAL_PINTYPE::PT_NC,            0 );
 
    m_ERCSortingMetric = ERC_PIN_SORTING_METRIC::SM_HEURISTICS;
}
 
 
bool ERC_SETTINGS::migrateSchema0to1()
{
    // Schema 0 to 1: convert ERC exclusions from legacy pipe-delimited strings to ProtoJSON
    std::optional<nlohmann::json> opt = Get<nlohmann::json>( "erc_exclusions" );
 
    if( !opt )
        return true;
 
    m_ErcExclusionsLegacy.clear();
 
    for( const nlohmann::json& entry : *opt )
    {
        if( entry.is_array() && entry.size() > 0 )
        {
            wxString markerData = entry[0].get<wxString>();
            wxString comment    = entry.size() > 1 ? entry[1].get<wxString>() : wxString();
 
            if( !markerData.IsEmpty() )
                m_ErcExclusionsLegacy.emplace( markerData, comment );
        }
        else if( entry.is_string() )
        {
            wxString markerData = entry.get<wxString>();
 
            if( !markerData.IsEmpty() )
                m_ErcExclusionsLegacy.emplace( markerData, wxString() );
        }
    }
 
    Set( "erc_exclusions", nlohmann::json::array() );
 
    return true;
}
 
 
ERC_SETTINGS::~ERC_SETTINGS()
{
    if( m_parent )
    {
        m_parent->ReleaseNestedSettings( this );
        m_parent = nullptr;
    }
}
 
 
SEVERITY ERC_SETTINGS::GetSeverity( int aErrorCode ) const
{
    // Special-case duplicate pin error. Multiple pins with the same number are allowed
    // if they share the same net, but having them on different nets is always an error.
    if( aErrorCode == ERCE_DUPLICATE_PIN_ERROR )
    {
        return RPT_SEVERITY_ERROR;
    }
    // Pin-to-pin codes carry independent ignore state but a fixed reported severity.
    // Warning-or-error is controlled by which errorCode it is, so each slot's stored
    // value is consulted only to determine ignore-vs-active.
    else if( aErrorCode == ERCE_PIN_TO_PIN_ERROR )
    {
        auto it = m_ERCSeverities.find( ERCE_PIN_TO_PIN_ERROR );
 
        if( it != m_ERCSeverities.end() && it->second == RPT_SEVERITY_IGNORE )
            return RPT_SEVERITY_IGNORE;
 
        return RPT_SEVERITY_ERROR;
    }
    else if( aErrorCode == ERCE_PIN_TO_PIN_WARNING )
    {
        auto it = m_ERCSeverities.find( ERCE_PIN_TO_PIN_WARNING );
 
        if( it != m_ERCSeverities.end() && it->second == RPT_SEVERITY_IGNORE )
            return RPT_SEVERITY_IGNORE;
 
        return RPT_SEVERITY_WARNING;
    }
    else if( aErrorCode == ERCE_GENERIC_WARNING )
    {
        return RPT_SEVERITY_WARNING;
    }
    else if( aErrorCode == ERCE_GENERIC_ERROR )
    {
        return RPT_SEVERITY_ERROR;
    }
 
    wxCHECK_MSG( m_ERCSeverities.count( aErrorCode ), RPT_SEVERITY_IGNORE,
            wxS( "Missing severity from map in ERC_SETTINGS!" ) );
 
    return m_ERCSeverities.at( aErrorCode );
}
 
 
void ERC_SETTINGS::SetSeverity( int aErrorCode, SEVERITY aSeverity )
{
    m_ERCSeverities[ aErrorCode ] = aSeverity;
}
 
 
void ERC_SETTINGS::ResetPinMap()
{
    memcpy( m_PinMap, m_defaultPinMap, sizeof( m_PinMap ) );
}
 
 
void SHEETLIST_ERC_ITEMS_PROVIDER::visitMarkers( std::function<void( SCH_MARKER* )> aVisitor ) const
{
    std::set<SCH_SCREEN*> seenScreens;
 
    for( const SCH_SHEET_PATH& sheet : m_schematic->BuildUnorderedSheetList() )
    {
        bool firstTime = seenScreens.count( sheet.LastScreen() ) == 0;
 
        if( firstTime )
            seenScreens.insert( sheet.LastScreen() );
 
        std::map<std::tuple<int, int, std::string, wxString>, SCH_MARKER*> orderedMarkers;
 
        for( SCH_ITEM* item : sheet.LastScreen()->Items().OfType( SCH_MARKER_T ) )
        {
            SCH_MARKER* marker = static_cast<SCH_MARKER*>( item );
 
            if( marker->GetMarkerType() != MARKER_BASE::MARKER_ERC )
                continue;
 
            const VECTOR2I& position = marker->GetPosition();
            orderedMarkers.emplace( std::make_tuple( position.x,
                                                     position.y,
                                                     ERC_EXCLUSION::FromMarker( *marker ).GetSortKey(),
                                                     marker->GetRCItem()->GetErrorMessage( false ) ),
                                    marker );
        }
 
        for( const auto& [key, marker] : orderedMarkers )
        {
            std::shared_ptr<const ERC_ITEM> ercItem =
                    std::static_pointer_cast<const ERC_ITEM>( marker->GetRCItem() );
 
            // Only show sheet-specific markers on the owning sheet
            if( ercItem->IsSheetSpecific() )
            {
                if( ercItem->GetSpecificSheetPath() != sheet )
                    continue;
            }
 
            // Don't show non-specific markers more than once
            if( !firstTime && !ercItem->IsSheetSpecific() )
                continue;
 
            aVisitor( marker );
        }
    }
}
 
 
SEVERITY SHEETLIST_ERC_ITEMS_PROVIDER::markerSeverity( SCH_MARKER* aMarker ) const
{
    if( aMarker->IsExcluded() )
        return RPT_SEVERITY_EXCLUSION;
 
    return m_schematic->ErcSettings().GetSeverity( aMarker->GetRCItem()->GetErrorCode() );
}
 
 
void SHEETLIST_ERC_ITEMS_PROVIDER::adjustCount( SEVERITY aSeverity, int aDelta )
{
    switch( aSeverity )
    {
    case RPT_SEVERITY_ERROR:     m_errorCount += aDelta;     break;
    case RPT_SEVERITY_WARNING:   m_warningCount += aDelta;   break;
    case RPT_SEVERITY_EXCLUSION: m_exclusionCount += aDelta; break;
    default:                                                 break;
    }
}
 
 
void SHEETLIST_ERC_ITEMS_PROVIDER::SetSeverities( int aSeverities )
{
    m_severities = aSeverities;
 
    m_filteredMarkers.clear();
    m_errorCount = 0;
    m_warningCount = 0;
    m_exclusionCount = 0;
 
    visitMarkers(
            [&]( SCH_MARKER* aMarker )
            {
                SEVERITY severity = markerSeverity( aMarker );
 
                adjustCount( severity, 1 );
 
                if( severity & m_severities )
                    m_filteredMarkers.push_back( aMarker );
            } );
 
    // Sort markers so that errors appear before warnings
    std::stable_sort( m_filteredMarkers.begin(), m_filteredMarkers.end(),
                      []( const SCH_MARKER* a, const SCH_MARKER* b )
                      {
                          return a->GetSeverity() > b->GetSeverity();
                      } );
}
 
 
int SHEETLIST_ERC_ITEMS_PROVIDER::GetSeverities() const
{
    return m_severities;
}
 
 
int SHEETLIST_ERC_ITEMS_PROVIDER::GetCount( int aSeverity ) const
{
    if( aSeverity < 0 )
        return m_filteredMarkers.size();
 
    int count = 0;
 
    if( aSeverity & RPT_SEVERITY_ERROR )
        count += m_errorCount;
 
    if( aSeverity & RPT_SEVERITY_WARNING )
        count += m_warningCount;
 
    if( aSeverity & RPT_SEVERITY_EXCLUSION )
        count += m_exclusionCount;
 
    return count;
}
 
 
std::shared_ptr<ERC_ITEM> SHEETLIST_ERC_ITEMS_PROVIDER::GetERCItem( int aIndex ) const
{
    SCH_MARKER* marker = m_filteredMarkers[ aIndex ];
 
    return marker ? std::static_pointer_cast<ERC_ITEM>( marker->GetRCItem() ) : nullptr;
}
 
 
std::shared_ptr<RC_ITEM> SHEETLIST_ERC_ITEMS_PROVIDER::GetItem( int aIndex ) const
{
    return GetERCItem( aIndex );
}
 
 
void SHEETLIST_ERC_ITEMS_PROVIDER::SetMarkerExcluded( SCH_MARKER* aMarker, bool aExcluded,
                                                     const wxString& aComment )
{
    // Toggling the exclusion moves the marker between the exclusion bucket and its error/warning
    // bucket, so the cached counts must follow the transition. Route the mutation through here so
    // the old severity is captured before the marker flips.
    if( aMarker->IsExcluded() == aExcluded )
    {
        aMarker->SetExcluded( aExcluded, aComment );
        return;
    }
 
    adjustCount( markerSeverity( aMarker ), -1 );
    aMarker->SetExcluded( aExcluded, aComment );
    adjustCount( markerSeverity( aMarker ), 1 );
}
 
 
void SHEETLIST_ERC_ITEMS_PROVIDER::DeleteItem( int aIndex, bool aDeep )
{
    SCH_MARKER* marker = m_filteredMarkers[ aIndex ];
    m_filteredMarkers.erase( m_filteredMarkers.begin() + aIndex );
 
    adjustCount( markerSeverity( marker ), -1 );
 
    if( aDeep )
    {
        SCH_SCREENS screens( m_schematic->Root() );
        screens.DeleteMarker( marker );
    }
}