drc_re_panel_matcher.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 KiCad Developers, see AUTHORS.txt for contributors.
 *
 * 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 2
 * 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 "drc_re_panel_matcher.h"
 
#include <algorithm>
#include <drc/drc_rule_condition.h>

 
DRC_PANEL_MATCHER::DRC_PANEL_MATCHER()
{
    initClaims();
}
 
 
void DRC_PANEL_MATCHER::initClaims()
{
    // Priority 100: ROUTING_DIFF_PAIR claims track_width + diff_pair_gap + diff_pair_uncoupled
    // This must be checked before ROUTING_WIDTH which also wants track_width
    m_claims.emplace_back( ROUTING_DIFF_PAIR,
                           std::set<DRC_CONSTRAINT_T>{ TRACK_WIDTH_CONSTRAINT, DIFF_PAIR_GAP_CONSTRAINT },
                           std::set<DRC_CONSTRAINT_T>{ MAX_UNCOUPLED_CONSTRAINT, SKEW_CONSTRAINT }, 100 );
 
    // Priority 90: VIA_STYLE claims via_diameter + hole_size
    m_claims.emplace_back(
            VIA_STYLE,
            std::set<DRC_CONSTRAINT_T>{ VIA_DIAMETER_CONSTRAINT, HOLE_SIZE_CONSTRAINT },
            std::set<DRC_CONSTRAINT_T>{},
            90 );
 
    // Priority 80: MINIMUM_TEXT_HEIGHT_THICKNESS claims text_height + text_thickness
    m_claims.emplace_back(
            MINIMUM_TEXT_HEIGHT_AND_THICKNESS,
            std::set<DRC_CONSTRAINT_T>{ TEXT_HEIGHT_CONSTRAINT, TEXT_THICKNESS_CONSTRAINT },
            std::set<DRC_CONSTRAINT_T>{},
            80 );
 
    // Priority 70: ROUTING_WIDTH claims track_width (single constraint, min/opt/max values)
    m_claims.emplace_back(
            ROUTING_WIDTH,
            std::set<DRC_CONSTRAINT_T>{ TRACK_WIDTH_CONSTRAINT },
            std::set<DRC_CONSTRAINT_T>{},
            70 );
 
    // Priority 60: ABSOLUTE_LENGTH claims length (single constraint, min/opt/max values)
    m_claims.emplace_back(
            ABSOLUTE_LENGTH,
            std::set<DRC_CONSTRAINT_T>{ LENGTH_CONSTRAINT },
            std::set<DRC_CONSTRAINT_T>{},
            60 );
 
    // Priority 50: PERMITTED_LAYERS claims assertion for layer-based rules
    m_claims.emplace_back(
            PERMITTED_LAYERS,
            std::set<DRC_CONSTRAINT_T>{ ASSERTION_CONSTRAINT },
            std::set<DRC_CONSTRAINT_T>{},
            50 );
 
    // Priority 40: ALLOWED_ORIENTATION claims assertion for orientation-based rules
    // Note that both PERMITTED_LAYERS and ALLOWED_ORIENTATION claim ASSERTION_CONSTRAINT.
    // The UI must differentiate based on assertion content.
    m_claims.emplace_back(
            ALLOWED_ORIENTATION,
            std::set<DRC_CONSTRAINT_T>{ ASSERTION_CONSTRAINT },
            std::set<DRC_CONSTRAINT_T>{},
            40 );
 
    // Priority 30: Generic single-constraint panels
 
    // Clearance constraints
    m_claims.emplace_back(
            MINIMUM_CLEARANCE,
            std::set<DRC_CONSTRAINT_T>{ CLEARANCE_CONSTRAINT },
            std::set<DRC_CONSTRAINT_T>{},
            30 );
 
    m_claims.emplace_back(
            COPPER_TO_EDGE_CLEARANCE,
            std::set<DRC_CONSTRAINT_T>{ EDGE_CLEARANCE_CONSTRAINT },
            std::set<DRC_CONSTRAINT_T>{},
            30 );
 
    m_claims.emplace_back(
            COPPER_TO_HOLE_CLEARANCE,
            std::set<DRC_CONSTRAINT_T>{ HOLE_CLEARANCE_CONSTRAINT },
            std::set<DRC_CONSTRAINT_T>{},
            30 );
 
   m_claims.emplace_back(
            HOLE_TO_HOLE_DISTANCE,
            std::set<DRC_CONSTRAINT_T>{ HOLE_TO_HOLE_CONSTRAINT },
            std::set<DRC_CONSTRAINT_T>{},
            30 );
 
   m_claims.emplace_back(
            COURTYARD_CLEARANCE,
            std::set<DRC_CONSTRAINT_T>{ COURTYARD_CLEARANCE_CONSTRAINT },
            std::set<DRC_CONSTRAINT_T>{},
            30 );
 
   m_claims.emplace_back(
            MINIMUM_SOLDERMASK_SLIVER,
            std::set<DRC_CONSTRAINT_T>{ SOLDER_MASK_SLIVER_CONSTRAINT },
            std::set<DRC_CONSTRAINT_T>{},
            30 );
 
    m_claims.emplace_back(
            PHYSICAL_CLEARANCE,
            std::set<DRC_CONSTRAINT_T>{ PHYSICAL_CLEARANCE_CONSTRAINT },
            std::set<DRC_CONSTRAINT_T>{},
            30 );
 
    m_claims.emplace_back(
            SILK_TO_SILK_CLEARANCE,
            std::set<DRC_CONSTRAINT_T>{ SILK_CLEARANCE_CONSTRAINT },
            std::set<DRC_CONSTRAINT_T>{},
            30 );
 
    m_claims.emplace_back(
            CREEPAGE_DISTANCE,
            std::set<DRC_CONSTRAINT_T>{ CREEPAGE_CONSTRAINT },
            std::set<DRC_CONSTRAINT_T>{},
            30 );
 
    // Size constraints
    m_claims.emplace_back(
            HOLE_SIZE,
            std::set<DRC_CONSTRAINT_T>{ HOLE_SIZE_CONSTRAINT },
            std::set<DRC_CONSTRAINT_T>{},
            20 );
 
    m_claims.emplace_back(
            MINIMUM_VIA_DIAMETER,
            std::set<DRC_CONSTRAINT_T>{ VIA_DIAMETER_CONSTRAINT },
            std::set<DRC_CONSTRAINT_T>{},
            20 );
 
    m_claims.emplace_back(
            MINIMUM_ANNULAR_WIDTH,
            std::set<DRC_CONSTRAINT_T>{ ANNULAR_WIDTH_CONSTRAINT },
            std::set<DRC_CONSTRAINT_T>{},
            20 );
 
    m_claims.emplace_back(
            MINIMUM_CONNECTION_WIDTH,
            std::set<DRC_CONSTRAINT_T>{ CONNECTION_WIDTH_CONSTRAINT },
            std::set<DRC_CONSTRAINT_T>{},
            20 );
 
    // Via count
    m_claims.emplace_back(
            MAXIMUM_VIA_COUNT,
            std::set<DRC_CONSTRAINT_T>{ VIA_COUNT_CONSTRAINT },
            std::set<DRC_CONSTRAINT_T>{},
            20 );
 
    // Solder mask/paste
    m_claims.emplace_back(
            SOLDERMASK_EXPANSION,
            std::set<DRC_CONSTRAINT_T>{ SOLDER_MASK_EXPANSION_CONSTRAINT },
            std::set<DRC_CONSTRAINT_T>{},
            20 );
 
    m_claims.emplace_back(
            SOLDERPASTE_EXPANSION,
            std::set<DRC_CONSTRAINT_T>{ SOLDER_PASTE_ABS_MARGIN_CONSTRAINT },
            std::set<DRC_CONSTRAINT_T>{},
            20 );
 
    // Thermal relief
    m_claims.emplace_back(
            MINIMUM_THERMAL_RELIEF_SPOKE_COUNT,
            std::set<DRC_CONSTRAINT_T>{ MIN_RESOLVED_SPOKES_CONSTRAINT },
            std::set<DRC_CONSTRAINT_T>{},
            20 );
 
    // Microvia stack limits
    m_claims.emplace_back( MICROVIA_STACK_DEPTH, std::set<DRC_CONSTRAINT_T>{ MICROVIA_STACK_DEPTH_CONSTRAINT },
                           std::set<DRC_CONSTRAINT_T>{}, 20 );
 
    m_claims.emplace_back( MICROVIA_ASPECT_RATIO, std::set<DRC_CONSTRAINT_T>{ MICROVIA_ASPECT_RATIO_CONSTRAINT },
                           std::set<DRC_CONSTRAINT_T>{}, 20 );
 
    // Diff pair length matching requires both length and skew.
    // Without this, LENGTH_CONSTRAINT alone would match here at priority 65
    // instead of falling through to ABSOLUTE_LENGTH at priority 60.
    m_claims.emplace_back(
            MATCHED_LENGTH_DIFF_PAIR,
            std::set<DRC_CONSTRAINT_T>{ LENGTH_CONSTRAINT, SKEW_CONSTRAINT },
            std::set<DRC_CONSTRAINT_T>{ },
            65 );
 
    // Skew-only (when not combined with length) still goes to matched length diff pair
    m_claims.emplace_back(
            MATCHED_LENGTH_DIFF_PAIR,
            std::set<DRC_CONSTRAINT_T>{ SKEW_CONSTRAINT },
            std::set<DRC_CONSTRAINT_T>{},
            55 );
 
    // Diff pair gap only (when not combined with track_width)
    m_claims.emplace_back(
            ROUTING_DIFF_PAIR,
            std::set<DRC_CONSTRAINT_T>{ DIFF_PAIR_GAP_CONSTRAINT },
            std::set<DRC_CONSTRAINT_T>{ MAX_UNCOUPLED_CONSTRAINT },
            15 );
 
    // Diff pair uncoupled only (when not combined with track_width or gap)                                           
    m_claims.emplace_back(
            ROUTING_DIFF_PAIR,
            std::set<DRC_CONSTRAINT_T>{ MAX_UNCOUPLED_CONSTRAINT },
            std::set<DRC_CONSTRAINT_T>{},
            10 );
 
    // Priority 5: Bool constraints
    m_claims.emplace_back(
            VIAS_UNDER_SMD,
            std::set<DRC_CONSTRAINT_T>{ DISALLOW_CONSTRAINT },
            std::set<DRC_CONSTRAINT_T>{},
            5 );
 
    // Sort claims by priority descending
    std::sort( m_claims.begin(), m_claims.end(),
               []( const DRC_PANEL_CLAIM& a, const DRC_PANEL_CLAIM& b )
               {
                   return a.priority > b.priority;
               } );
}
 
 
bool DRC_PANEL_MATCHER::matchesClaim( const DRC_PANEL_CLAIM&            aClaim,
                                       const std::set<DRC_CONSTRAINT_T>& aConstraints,
                                       std::set<DRC_CONSTRAINT_T>*       aClaimedOut )
{
    // Check that all required constraints are present
    for( DRC_CONSTRAINT_T required : aClaim.requiredConstraints )
    {
        if( aConstraints.find( required ) == aConstraints.end() )
            return false;
    }
 
    // Build the set of claimed constraints (required + any optional that are present)
    std::set<DRC_CONSTRAINT_T> claimed = aClaim.requiredConstraints;
 
    for( DRC_CONSTRAINT_T optional : aClaim.optionalConstraints )
    {
        if( aConstraints.find( optional ) != aConstraints.end() )
            claimed.insert( optional );
    }
 
    if( claimed.empty() )
        return false;
 
    if( aClaimedOut )
        *aClaimedOut = claimed;
 
    return true;
}
 
 
std::vector<DRC_PANEL_MATCH> DRC_PANEL_MATCHER::MatchRule( const DRC_RULE& aRule )
{
    std::vector<DRC_PANEL_MATCH> matches;
 
    // Extract all constraint types from the rule
    std::set<DRC_CONSTRAINT_T> remaining;
 
    for( const DRC_CONSTRAINT& constraint : aRule.m_Constraints )
    {
        if( constraint.m_Type != NULL_CONSTRAINT )
            remaining.insert( constraint.m_Type );
    }
 
    if( remaining.empty() )
        return matches;
 
    // Iterate through claims by priority (already sorted in initClaims)
    for( const DRC_PANEL_CLAIM& claim : m_claims )
    {
        if( remaining.empty() )
            break;
 
        std::set<DRC_CONSTRAINT_T> claimed;
 
        if( matchesClaim( claim, remaining, &claimed ) )
        {
            // VIAS_UNDER_SMD requires Pad_Type == 'SMD' in the condition
            if( claim.panelType == VIAS_UNDER_SMD )
            {
                if( !aRule.m_Condition || !aRule.m_Condition->GetExpression().Contains( wxS( "Pad_Type == 'SMD'" ) ) )
                    continue;
            }
 
            matches.emplace_back( claim.panelType, claimed );
 
            // Remove claimed constraints from remaining set
            for( DRC_CONSTRAINT_T type : claimed )
                remaining.erase( type );
        }
    }
 
    // Any remaining constraints go to CUSTOM_RULE panel
    if( !remaining.empty() )
        matches.emplace_back( CUSTOM_RULE, remaining );
 
    return matches;
}
 
 
bool DRC_PANEL_MATCHER::CanPanelLoad( DRC_RULE_EDITOR_CONSTRAINT_NAME   aPanel,
                                       const std::set<DRC_CONSTRAINT_T>& aConstraints )
{
    for( const DRC_PANEL_CLAIM& claim : m_claims )
    {
        if( claim.panelType == aPanel )
        {
            // Check if all constraints can be handled by this panel
            std::set<DRC_CONSTRAINT_T> allHandled = claim.requiredConstraints;
            allHandled.insert( claim.optionalConstraints.begin(), claim.optionalConstraints.end() );
 
            for( DRC_CONSTRAINT_T type : aConstraints )
            {
                if( allHandled.find( type ) == allHandled.end() )
                    return false;
            }
 
            return true;
        }
    }
 
    // CUSTOM_RULE can load anything
    return aPanel == CUSTOM_RULE;
}
 
 
DRC_RULE_EDITOR_CONSTRAINT_NAME DRC_PANEL_MATCHER::GetPanelForConstraint( DRC_CONSTRAINT_T aConstraintType )
{
    std::set<DRC_CONSTRAINT_T> singleConstraint{ aConstraintType };
 
    for( const DRC_PANEL_CLAIM& claim : m_claims )
    {
        // Only match claims with exactly one required constraint and no optional
        if( claim.requiredConstraints.size() == 1 &&
            claim.optionalConstraints.empty() &&
            claim.requiredConstraints.count( aConstraintType ) > 0 )
        {
            return claim.panelType;
        }
    }
 
    return CUSTOM_RULE;
}