resistor_substitution_utils.h

Go to the documentation of this file.

/*
 * This program source code file
 * is part of KiCad, a free EDA CAD application.
 *
 * 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 <http://www.gnu.org/licenses/>.
 */
 
#pragma once
 
#include "eseries.h"
#include <array>
#include <optional>
#include <string>
#include <utility>
#include <vector>
 
const double epsilon = 1e-12; // machine epsilon for floating-point equality testing
 
// First value of resistor in Ohm
// It should be first value of the decade, i.e. power of 10
// This value is only pertinent to the resistor calculator.
// It is used to reduce the computational complexity of its calculations.
// There are valid resistor values using E-series numbers below this
// value and above the below LAST_VALUE.
#define RES_EQUIV_CALC_FIRST_VALUE 10
 
// Last value of resistor in Ohm
// This value is only pertinent to the resistor calculator. See above.
#define RES_EQUIV_CALC_LAST_VALUE 1e6
 
// Struct representing resistance value together with its composition, e.g. {20.0, "10R + 10R"}
struct RESISTANCE
{
    double              value;
    std::string         name;
    std::vector<double> parts;
 
    RESISTANCE( double aValue, const std::string& aName, std::vector<double> aParts = {} ) :
            value( aValue ),
            name( aName ),
            parts( std::move( aParts ) )
    {
        if( parts.empty() )
            parts.push_back( aValue );
    }
};
 
 
class RES_EQUIV_CALC
{
public:
    RES_EQUIV_CALC();
 
    enum
    {
        S2R,
        S3R,
        S4R,
        NUMBER_OF_LEVELS
    };

    void SetSeries( uint32_t aSeries );

    void NewCalc( double aTargetValue );

    void Exclude( double aValue );

    void Calculate();

    const std::array<std::optional<RESISTANCE>, NUMBER_OF_LEVELS>& GetResults() { return m_results; }
 
private:
    std::vector<RESISTANCE> buildSeriesData( const ESERIES::ESERIES_VALUES& aList );

    void prepare1RBuffer();

    void prepare2RBuffer();

    std::pair<RESISTANCE&, RESISTANCE&> findIn2RBuffer( double aTargetValue );

    RESISTANCE calculate2RSolution();
    RESISTANCE calculate3RSolution();
    RESISTANCE calculate4RSolution();
 
private:
    std::vector<std::vector<RESISTANCE>> m_e_series;
    std::vector<bool>                    m_exclude_mask;
    std::vector<RESISTANCE>              m_buffer_1R;
    std::vector<RESISTANCE>              m_buffer_2R;
 
    uint32_t m_series = ESERIES::E6;
    double   m_target = 0;
 
    std::array<std::optional<RESISTANCE>, NUMBER_OF_LEVELS> m_results;
};