board_stackup.h

Go to the documentation of this file.

/*
 * This program source code file is part of KiCad, a free EDA CAD application.
 *
 * Copyright (C) 2019 Jean-Pierre Charras, jp.charras at wanadoo.fr
 * Copyright The 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 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/>.
 */

 
#ifndef BOARD_STACKUP_H
#define BOARD_STACKUP_H
 
 
#include <vector>
#include <wx/string.h>
#include <layer_ids.h>
#include <lset.h>
#include <api/serializable.h>
#include "transline_calculations/transline_calculation_base.h"
 
class BOARD;
class BOARD_DESIGN_SETTINGS;
class OUTPUTFORMATTER;
 
namespace kiapi::board
{
    class BoardStackup;
}
 
// A enum to manage the different layers inside the stackup layers.
// Note the stackup layers include both dielectric and some layers handled by the board editor
// Therefore a stackup layer item is not exactly like a board layer
enum BOARD_STACKUP_ITEM_TYPE
{
    BS_ITEM_TYPE_UNDEFINED,     // For not yet initialized BOARD_STACKUP_ITEM item
    BS_ITEM_TYPE_COPPER,        // A initialized BOARD_STACKUP_ITEM item for copper layers
    BS_ITEM_TYPE_DIELECTRIC,    // A initialized BOARD_STACKUP_ITEM item for the
                                // dielectric between copper layers
    BS_ITEM_TYPE_SOLDERPASTE,   // A initialized BOARD_STACKUP_ITEM item for solder paste layers
    BS_ITEM_TYPE_SOLDERMASK,    // A initialized BOARD_STACKUP_ITEM item for solder mask layers
                                // note: this is a specialized dielectric material
    BS_ITEM_TYPE_SILKSCREEN,    // A initialized BOARD_STACKUP_ITEM item for silkscreen layers
};
 
// A enum to manage edge connector fab info
enum BS_EDGE_CONNECTOR_CONSTRAINTS
{
    BS_EDGE_CONNECTOR_NONE,     // No edge connector in board
    BS_EDGE_CONNECTOR_IN_USE,   // some edge connector in board
    BS_EDGE_CONNECTOR_BEVELLED  // Some connector in board, and the connector must be beveled
};
 

class DIELECTRIC_PRMS
{
public:
    DIELECTRIC_PRMS() :
            m_Thickness( 0 ),
            m_ThicknessLocked( false ),
            m_EpsilonR( 1.0 ),
            m_LossTangent( 0.0 ),
            m_SpecFreq( 0.0 ),
            m_DielectricModel( DIELECTRIC_MODEL::CONSTANT )
    {}
 
    bool operator==( const DIELECTRIC_PRMS& aOther ) const;
    bool operator!=( const DIELECTRIC_PRMS& aOther ) const { return !operator==( aOther ); }
 
private:
    friend class BOARD_STACKUP_ITEM;
 
    wxString m_Material;                
    int      m_Thickness;               
    bool     m_ThicknessLocked;         
    double           m_EpsilonR;        
    double           m_LossTangent;     
    double           m_SpecFreq;        
    DIELECTRIC_MODEL m_DielectricModel; 
    wxString         m_Color;           
};
 

class BOARD_STACKUP_ITEM
{
public:
    BOARD_STACKUP_ITEM( BOARD_STACKUP_ITEM_TYPE aType );
    BOARD_STACKUP_ITEM( const BOARD_STACKUP_ITEM& aOther );
 
    bool operator==( const BOARD_STACKUP_ITEM& aOther ) const;
    bool operator!=( const BOARD_STACKUP_ITEM& aOther ) const { return !operator==( aOther ); }

    void AddDielectricPrms( int aDielectricPrmsIdx );

    void RemoveDielectricPrms( int aDielectricPrmsIdx );

    bool HasEpsilonRValue() const;

    bool HasLossTangentValue() const;

    bool HasSpecFreqValue() const;

    bool HasMaterialValue( int aDielectricSubLayer = 0 ) const;

    bool IsMaterialEditable() const;

    bool IsColorEditable() const;

    bool IsThicknessEditable() const;

    static int GetCopperDefaultThickness();

    static int GetMaskDefaultThickness();

    int GetSublayersCount() const { return m_DielectricPrmsList.size(); }

    wxString FormatEpsilonR( int aDielectricSubLayer = 0 ) const;

    wxString FormatLossTangent( int aDielectricSubLayer = 0 ) const;

    wxString FormatDielectricLayerName() const;
 
    // Getters:
    bool IsEnabled() const { return m_enabled; }
 
    BOARD_STACKUP_ITEM_TYPE GetType() const { return m_Type; }
    PCB_LAYER_ID GetBrdLayerId() const { return m_LayerId; }
    wxString GetLayerName() const { return m_LayerName; }
    wxString GetTypeName() const { return m_TypeName; }
    int GetDielectricLayerId() const { return m_DielectricLayerId; }
 
    wxString GetColor( int aDielectricSubLayer = 0 ) const;
    int GetThickness( int aDielectricSubLayer = 0 ) const;
    bool IsThicknessLocked( int aDielectricSubLayer = 0 ) const;
    double GetEpsilonR( int aDielectricSubLayer = 0 ) const;
    double GetLossTangent( int aDielectricSubLayer = 0 ) const;
    double GetSpecFreq( int aDielectricSubLayer = 0 ) const;
    DIELECTRIC_MODEL GetDielectricModel( int aDielectricSubLayer = 0 ) const;
    wxString GetMaterial( int aDielectricSubLayer = 0 ) const;
 
    // Setters:
    void SetEnabled( bool aEnable) { m_enabled = aEnable; }
    void SetBrdLayerId( PCB_LAYER_ID aBrdLayerId ) { m_LayerId = aBrdLayerId; }
    void SetLayerName( const wxString& aName ) { m_LayerName = aName; }
    void SetTypeName( const wxString& aName ) { m_TypeName = aName; }
    void SetDielectricLayerId( int aLayerId ) { m_DielectricLayerId = aLayerId; }
 
    void SetColor( const wxString& aColorName, int aDielectricSubLayer = 0 );
    void SetThickness( int aThickness, int aDielectricSubLayer = 0 );
    void SetThicknessLocked( bool aLocked, int aDielectricSubLayer = 0 );
    void SetEpsilonR( double aEpsilon, int aDielectricSubLayer = 0 );
    void SetLossTangent( double aTg, int aDielectricSubLayer = 0 );
    void SetSpecFreq( double aSpecFreq, int aDielectricSubLayer = 0 );
    void SetDielectricModel( DIELECTRIC_MODEL aModel, int aDielectricSubLayer = 0 );
    void SetMaterial( const wxString& aName, int aDielectricSubLayer = 0 );
 
private:
    BOARD_STACKUP_ITEM_TYPE m_Type;
    wxString m_LayerName;   
    wxString m_TypeName;    
    PCB_LAYER_ID m_LayerId; 
    int m_DielectricLayerId;
    std::vector<DIELECTRIC_PRMS> m_DielectricPrmsList;
 
    bool m_enabled;         
};
 

class BOARD_STACKUP : public SERIALIZABLE
{
public:
    BOARD_STACKUP();
    BOARD_STACKUP( const BOARD_STACKUP& aOther );
    BOARD_STACKUP& operator=( const BOARD_STACKUP& aOther );
 
    bool operator==( const BOARD_STACKUP& aOther ) const;
    bool operator!=( const BOARD_STACKUP& aOther ) const { return !operator==( aOther ); }
 
    ~BOARD_STACKUP() { RemoveAll(); }
 
    void Serialize( google::protobuf::Any &aContainer ) const override;
 
    bool Deserialize( const google::protobuf::Any &aContainer ) override;
 
    void Serialize( kiapi::board::BoardStackup& aOutput ) const;
    bool Deserialize( const kiapi::board::BoardStackup& aInput );
 
    const std::vector<BOARD_STACKUP_ITEM*>& GetList() const { return m_list; }

    BOARD_STACKUP_ITEM* GetStackupLayer( int aIndex );

    static LSET StackupAllowedBrdLayers()
    {
        return LSET( { F_SilkS, F_Mask, F_Paste, B_SilkS, B_Mask, B_Paste } )
               | LSET::ExternalCuMask() | LSET::InternalCuMask();
    }
 

    void RemoveAll();

    int GetCount() const { return (int) m_list.size(); }

    int BuildBoardThicknessFromStackup() const;

    void Add( BOARD_STACKUP_ITEM* aItem ) { m_list.push_back( aItem ); }

    bool SynchronizeWithBoard( BOARD_DESIGN_SETTINGS* aSettings );

    void BuildDefaultStackupList( const BOARD_DESIGN_SETTINGS* aSettings,
            int aActiveCopperLayersCount = 0 );

    void FormatBoardStackup( OUTPUTFORMATTER* aFormatter, const BOARD* aBoard ) const;

    int GetLayerDistance( PCB_LAYER_ID aFirstLayer, PCB_LAYER_ID aSecondLayer ) const;

    wxString m_FinishType;

    bool m_HasDielectricConstrains;

    bool m_HasThicknessConstrains;

    BS_EDGE_CONNECTOR_CONSTRAINTS m_EdgeConnectorConstraints;
 
    bool m_EdgePlating;             
 
private:
    // The list of items describing the stackup for fabrication.
    // this is not just copper layers, but also mask dielectric layers
    std::vector<BOARD_STACKUP_ITEM*> m_list;
};
 
 
#endif      // BOARD_STACKUP_H