kibis.cpp

Go to the documentation of this file.

/*
 * This program source code file is part of KiCad, a free EDA CAD application.
 *
 * Copyright (C) 2022 Fabien Corona f.corona<at>laposte.net
 * Copyright (C) 2022-2023 KiCad Developers, see AUTHORS.txt for contributors.
 *
 * Redistribution and use in source and binary forms, with or without modification,
 * are permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright notice,
 * this list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright notice,
 * this list of conditions and the following disclaimer in the documentation
 * and/or other materials provided with the distribution.
 *
 * 3. Neither the name of the copyright holder nor the names of its contributors may be used
 * to endorse or promote products derived from this software without specific
 * prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
 * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
 * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */
 
 
#include "kibis.h"
#include "ibis_parser.h"
#include <sstream>
#include <sim/spice_simulator.h>
 
 
// _() is used here to mark translatable strings in IBIS_REPORTER::Report()
// However, currently non ASCII7 chars are nor correctly handled when printing messages
// So we disable translations
#if 0
#include <wx/intl.h> // for _() macro and wxGetTranslation()
#else
#undef _
#define _( x ) x
#endif
 
 
std::vector<std::pair<int, double>> SimplifyBitSequence( std::vector<std::pair<int, double>> bits )
{
 std::vector<std::pair<int, double>> result;
 int prevbit = -1;
 
 for( std::pair<int, double> bit : bits )
 {
 if( prevbit != bit.first )
 result.push_back( bit );
 
 prevbit = bit.first;
 }
 
 return result;
}
 
KIBIS_ANY::KIBIS_ANY( KIBIS* aTopLevel ) : IBIS_ANY( aTopLevel->m_reporter )
{
 m_topLevel = aTopLevel;
 m_valid = false;
}
 
 
IBIS_CORNER ReverseLogic( IBIS_CORNER aIn )
{
 IBIS_CORNER out = IBIS_CORNER::TYP;
 
 if( aIn == IBIS_CORNER::MIN )
 {
 out = IBIS_CORNER::MAX;
 }
 else if( aIn == IBIS_CORNER::MAX )
 {
 out = IBIS_CORNER::MIN;
 }
 
 return out;
}
 
KIBIS::KIBIS( std::string aFileName, REPORTER* aReporter ) :
 KIBIS_ANY( this ),
 m_reporter( aReporter ),
 m_file( this )
{
 IbisParser parser( m_reporter );
 bool status = true;
 
 parser.m_parrot = false;
 status &= parser.ParseFile( aFileName );
 
 
 status &= m_file.Init( parser );
 
 for( IbisModel& iModel : parser.m_ibisFile.m_models )
 {
 KIBIS_MODEL kModel( this, iModel, parser );
 status &= kModel.m_valid;
 m_models.push_back( kModel );
 }
 
 for( IbisComponent& iComponent : parser.m_ibisFile.m_components )
 {
 KIBIS_COMPONENT kComponent( this, iComponent, parser );
 
 status &= kComponent.m_valid;
 m_components.push_back( kComponent );
 
 for( KIBIS_PIN& pin : m_components.back().m_pins )
 {
 pin.m_parent = &( m_components.back() );
 }
 
 for( IbisDiffPinEntry dpEntry : iComponent.m_diffPin.m_entries )
 {
 KIBIS_PIN* pinA = m_components.back().GetPin( dpEntry.pinA );
 KIBIS_PIN* pinB = m_components.back().GetPin( dpEntry.pinB );
 
 if( pinA && pinB )
 {
 pinA->m_complementaryPin = pinB;
 pinB->m_complementaryPin = pinA;
 }
 }
 }
 
 m_valid = status;
}
 
 
KIBIS_FILE::KIBIS_FILE( KIBIS* aTopLevel ) : KIBIS_ANY( aTopLevel )
{
 m_fileRev = -1;
 m_ibisVersion = -1;
}
 
 
bool KIBIS_FILE::Init( IbisParser& aParser )
{
 bool status = true;
 m_fileName = aParser.m_ibisFile.m_header.m_fileName;
 m_fileRev = aParser.m_ibisFile.m_header.m_fileRevision;
 m_ibisVersion = aParser.m_ibisFile.m_header.m_ibisVersion;
 m_date = aParser.m_ibisFile.m_header.m_date;
 m_notes = aParser.m_ibisFile.m_header.m_notes;
 m_disclaimer = aParser.m_ibisFile.m_header.m_disclaimer;
 m_copyright = aParser.m_ibisFile.m_header.m_copyright;
 
 m_valid = status;
 
 return status;
}
 
 
KIBIS_PIN::KIBIS_PIN( KIBIS* aTopLevel, IbisComponentPin& aPin, IbisComponentPackage& aPackage,
 IbisParser& aParser, KIBIS_COMPONENT* aParent,
 std::vector<KIBIS_MODEL>& aModels ) :
 KIBIS_ANY( aTopLevel ),
 m_Rpin( aTopLevel->m_reporter ), m_Lpin( aTopLevel->m_reporter ),
 m_Cpin( aTopLevel->m_reporter )
{
 m_signalName = aPin.m_signalName;
 m_pinNumber = aPin.m_pinName;
 m_parent = aParent;
 
 m_Rpin = aPackage.m_Rpkg;
 m_Lpin = aPackage.m_Lpkg;
 m_Cpin = aPackage.m_Cpkg;
 
 // The values listed in the [Pin] description section override the default
 // values defined in [Package]
 
 // @TODO : Reading the IBIS standard, I can't figure out if we are supposed
 // to replace typ, min, and max, or just the typ ?
 
 if( !std::isnan( aPin.m_Rpin ) )
 {
 m_Rpin.value[IBIS_CORNER::TYP] = aPin.m_Rpin;
 m_Rpin.value[IBIS_CORNER::MIN] = aPin.m_Rpin;
 m_Rpin.value[IBIS_CORNER::MAX] = aPin.m_Rpin;
 }
 
 if( !std::isnan( aPin.m_Lpin ) )
 {
 m_Lpin.value[IBIS_CORNER::TYP] = aPin.m_Lpin;
 m_Lpin.value[IBIS_CORNER::MIN] = aPin.m_Lpin;
 m_Lpin.value[IBIS_CORNER::MAX] = aPin.m_Lpin;
 }
 
 if( !std::isnan( aPin.m_Cpin ) )
 {
 m_Cpin.value[IBIS_CORNER::TYP] = aPin.m_Cpin;
 m_Cpin.value[IBIS_CORNER::MIN] = aPin.m_Cpin;
 m_Cpin.value[IBIS_CORNER::MAX] = aPin.m_Cpin;
 }
 
 bool modelSelected = false;
 std::vector<std::string> listOfModels;
 
 for( IbisModelSelector modelSelector : aParser.m_ibisFile.m_modelSelectors )
 {
 if( !strcmp( modelSelector.m_name.c_str(), aPin.m_modelName.c_str() ) )
 {
 for( IbisModelSelectorEntry model : modelSelector.m_models )
 {
 listOfModels.push_back( model.m_modelName );
 }
 modelSelected = true;
 break;
 }
 }
 
 if( !modelSelected )
 {
 listOfModels.push_back( aPin.m_modelName );
 }
 
 for( std::string modelName : listOfModels )
 {
 for( KIBIS_MODEL& model : aModels )
 {
 if( !strcmp( model.m_name.c_str(), modelName.c_str() ) )
 {
 m_models.push_back( &model );
 }
 }
 }
 
 m_valid = true;
}
 
 
KIBIS_MODEL::KIBIS_MODEL( KIBIS* aTopLevel, IbisModel& aSource, IbisParser& aParser ) :
 KIBIS_ANY( aTopLevel ), m_C_comp( aTopLevel->m_reporter ),
 m_voltageRange( aTopLevel->m_reporter ), m_temperatureRange( aTopLevel->m_reporter ),
 m_pullupReference( aTopLevel->m_reporter ), m_pulldownReference( aTopLevel->m_reporter ),
 m_GNDClampReference( aTopLevel->m_reporter ),
 m_POWERClampReference( aTopLevel->m_reporter ), m_Rgnd( aTopLevel->m_reporter ),
 m_Rpower( aTopLevel->m_reporter ), m_Rac( aTopLevel->m_reporter ),
 m_Cac( aTopLevel->m_reporter ), m_GNDClamp( aTopLevel->m_reporter ),
 m_POWERClamp( aTopLevel->m_reporter ), m_pullup( aTopLevel->m_reporter ),
 m_pulldown( aTopLevel->m_reporter ), m_ramp( aTopLevel->m_reporter )
{
 bool status = true;
 
 m_name = aSource.m_name;
 m_type = aSource.m_type;
 
 m_description = std::string( "No description available." );
 
 for( IbisModelSelector modelSelector : aParser.m_ibisFile.m_modelSelectors )
 {
 for( IbisModelSelectorEntry entry : modelSelector.m_models )
 {
 if( !strcmp( entry.m_modelName.c_str(), m_name.c_str() ) )
 {
 m_description = entry.m_modelDescription;
 }
 }
 }
 
 m_vinh = aSource.m_vinh;
 m_vinl = aSource.m_vinl;
 m_vref = aSource.m_vref;
 m_rref = aSource.m_rref;
 m_cref = aSource.m_cref;
 m_vmeas = aSource.m_vmeas;
 
 m_enable = aSource.m_enable;
 m_polarity = aSource.m_polarity;
 
 m_ramp = aSource.m_ramp;
 m_risingWaveforms = aSource.m_risingWaveforms;
 m_fallingWaveforms = aSource.m_fallingWaveforms;
 m_GNDClamp = aSource.m_GNDClamp;
 m_GNDClampReference = aSource.m_GNDClampReference;
 m_POWERClamp = aSource.m_POWERClamp;
 m_POWERClampReference = aSource.m_POWERClampReference;
 
 m_C_comp = aSource.m_C_comp;
 m_voltageRange = aSource.m_voltageRange;
 m_temperatureRange = aSource.m_temperatureRange;
 m_pullupReference = aSource.m_pullupReference;
 m_pulldownReference = aSource.m_pulldownReference;
 
 m_Rgnd = aSource.m_Rgnd;
 m_Rpower = aSource.m_Rpower;
 m_Rac = aSource.m_Rac;
 m_Cac = aSource.m_Cac;
 m_pullup = aSource.m_pullup;
 m_pulldown = aSource.m_pulldown;
 
 m_valid = status;
}
 
 
KIBIS_COMPONENT::KIBIS_COMPONENT( KIBIS* aTopLevel, IbisComponent& aSource, IbisParser& aParser ) :
 KIBIS_ANY( aTopLevel )
{
 bool status = true;
 
 m_name = aSource.m_name;
 m_manufacturer = aSource.m_manufacturer;
 m_topLevel = aTopLevel;
 
 for( IbisComponentPin& iPin : aSource.m_pins )
 {
 if( iPin.m_dummy )
 {
 continue;
 }
 
 KIBIS_PIN kPin( aTopLevel, iPin, aSource.m_package, aParser, nullptr,
 m_topLevel->m_models );
 status &= kPin.m_valid;
 m_pins.push_back( kPin );
 }
 
 m_valid = status;
}
 
 
KIBIS_PIN* KIBIS_COMPONENT::GetPin( std::string aPinNumber )
{
 for( KIBIS_PIN& pin : m_pins )
 {
 if( pin.m_pinNumber == aPinNumber )
 {
 return &pin;
 }
 }
 
 return nullptr;
}
 
std::vector<std::pair<IbisWaveform*, IbisWaveform*>> KIBIS_MODEL::waveformPairs()
{
 std::vector<std::pair<IbisWaveform*, IbisWaveform*>> pairs;
 IbisWaveform* wf1;
 IbisWaveform* wf2;
 
 for( size_t i = 0; i < m_risingWaveforms.size(); i++ )
 {
 for( size_t j = 0; j < m_fallingWaveforms.size(); j++ )
 {
 wf1 = m_risingWaveforms.at( i );
 wf2 = m_fallingWaveforms.at( j );
 
 if( wf1->m_R_fixture == wf2->m_R_fixture && wf1->m_L_fixture == wf2->m_L_fixture
 && wf1->m_C_fixture == wf2->m_C_fixture && wf1->m_V_fixture == wf2->m_V_fixture
 && wf1->m_V_fixture_min == wf2->m_V_fixture_min
 && wf1->m_V_fixture_max == wf2->m_V_fixture_max )
 {
 std::pair<IbisWaveform*, IbisWaveform*> p;
 p.first = wf1;
 p.second = wf2;
 pairs.push_back( p );
 }
 }
 }
 
 return pairs;
}
 
 
std::string KIBIS_MODEL::SpiceDie( KIBIS_PARAMETER& aParam, int aIndex )
{
 std::string result;
 
 std::string GC_GND = "GC_GND";
 std::string PC_PWR = "PC_PWR";
 std::string PU_PWR = "PU_PWR";
 std::string PD_GND = "PD_GND";
 std::string DIE = "DIE";
 std::string DIEBUFF = "DIEBUFF";
 
 IBIS_CORNER supply = aParam.m_supply;
 IBIS_CORNER ccomp = aParam.m_Ccomp;
 
 GC_GND += std::to_string( aIndex );
 PC_PWR += std::to_string( aIndex );
 PU_PWR += std::to_string( aIndex );
 PD_GND += std::to_string( aIndex );
 DIE += std::to_string( aIndex );
 DIEBUFF += std::to_string( aIndex );
 
 
 std::string GC = "GC";
 std::string PC = "PC";
 std::string PU = "PU";
 std::string PD = "PD";
 
 GC += std::to_string( aIndex );
 PC += std::to_string( aIndex );
 PU += std::to_string( aIndex );
 PD += std::to_string( aIndex );
 
 result = "\n";
 result += "VPWR POWER GND ";
 result += doubleToString( m_voltageRange.value[supply] );
 result += "\n";
 result += "CCPOMP " + DIE + " GND ";
 result += doubleToString( m_C_comp.value[ccomp] );
 result += "\n";
 
 if( HasGNDClamp() )
 {
 result += m_GNDClamp.Spice( aIndex * 4 + 1, DIE, GC_GND, GC, supply );
 result += "VmeasGC GND " + GC_GND + " 0\n";
 }
 
 if( HasPOWERClamp() )
 {
 result += m_POWERClamp.Spice( aIndex * 4 + 2, "POWER", DIE, PC, supply );
 result += "VmeasPC POWER " + PC_PWR + " 0\n";
 }
 
 if( HasPulldown() )
 {
 result += m_pulldown.Spice( aIndex * 4 + 3, DIEBUFF, PD_GND, PD, supply );
 result += "VmeasPD GND " + PD_GND + " 0\n";
 result += "BKD GND " + DIE + " i=( i(VmeasPD) * v(KD) )\n";
 }
 
 if( HasPullup() )
 {
 result += m_pullup.Spice( aIndex * 4 + 4, PU_PWR, DIEBUFF, PU, supply );
 result += "VmeasPU POWER " + PU_PWR + " 0\n";
 result += "BKU POWER " + DIE + " i=( -i(VmeasPU) * v(KU) )\n";
 }
 
 if ( HasPullup() || HasPulldown() )
 result += "BDIEBUFF " + DIEBUFF + " GND v=v(" + DIE + ")\n";
 
 return result;
}
 
 
IbisWaveform KIBIS_MODEL::TrimWaveform( IbisWaveform& aIn )
{
 IbisWaveform out( aIn.m_reporter );
 
 int nbPoints = aIn.m_table.m_entries.size();
 
 if( nbPoints < 2 )
 {
 Report( _( "waveform has less than two points" ), RPT_SEVERITY_ERROR );
 return out;
 }
 
 double DCtyp = aIn.m_table.m_entries[0].V.value[IBIS_CORNER::TYP];
 double DCmin = aIn.m_table.m_entries[0].V.value[IBIS_CORNER::MIN];
 double DCmax = aIn.m_table.m_entries[0].V.value[IBIS_CORNER::MAX];
 
 if( nbPoints == 2 )
 {
 return out;
 }
 
 out.m_table.m_entries.clear();
 
 for( int i = 0; i < nbPoints; i++ )
 {
 VTtableEntry entry( out.m_reporter );
 
 entry.t = aIn.m_table.m_entries.at( i ).t;
 entry.V.value[IBIS_CORNER::TYP] = aIn.m_table.m_entries.at( i ).V.value[IBIS_CORNER::TYP];
 entry.V.value[IBIS_CORNER::MIN] = aIn.m_table.m_entries.at( i ).V.value[IBIS_CORNER::MIN];
 entry.V.value[IBIS_CORNER::MAX] = aIn.m_table.m_entries.at( i ).V.value[IBIS_CORNER::MAX];
 out.m_table.m_entries.push_back( entry );
 out.m_table.m_entries.at( i ).V.value[IBIS_CORNER::TYP] -= DCtyp;
 out.m_table.m_entries.at( i ).V.value[IBIS_CORNER::MIN] -= DCmin;
 out.m_table.m_entries.at( i ).V.value[IBIS_CORNER::MAX] -= DCmax;
 }
 
 return out;
}
 
 
bool KIBIS_MODEL::HasPulldown()
{
 return m_pulldown.m_entries.size() > 0;
}
 
 
bool KIBIS_MODEL::HasPullup()
{
 return m_pullup.m_entries.size() > 0;
}
 
 
bool KIBIS_MODEL::HasGNDClamp()
{
 return m_GNDClamp.m_entries.size() > 0;
}
 
 
bool KIBIS_MODEL::HasPOWERClamp()
{
 return m_POWERClamp.m_entries.size() > 0;
}
 
 
std::string KIBIS_MODEL::generateSquareWave( std::string aNode1, std::string aNode2,
 std::vector<std::pair<int, double>> aBits,
 std::pair<IbisWaveform*, IbisWaveform*> aPair,
 KIBIS_PARAMETER& aParam )
{
 IBIS_CORNER supply = aParam.m_supply;
 std::string simul;
 std::vector<int>stimuliIndex;
 
 IbisWaveform risingWF = TrimWaveform( *( aPair.first ) );
 IbisWaveform fallingWF = TrimWaveform( *( aPair.second ) );
 
 double deltaR = risingWF.m_table.m_entries.back().V.value[supply]
 - risingWF.m_table.m_entries.at( 0 ).V.value[supply];
 double deltaF = fallingWF.m_table.m_entries.back().V.value[supply]
 - fallingWF.m_table.m_entries.at( 0 ).V.value[supply];
 
 // Ideally, delta should be equal to zero.
 // It can be different from zero if the falling waveform does not start were the rising one ended.
 double delta = deltaR + deltaF;
 
 int i = 0;
 
 int prevBit = 2;
 
 for( std::pair<int, double> bit : aBits )
 {
 IbisWaveform* WF;
 double timing = bit.second;
 
 
 if ( bit.first != prevBit )
 {
 if( bit.first == 1 )
 WF = &risingWF;
 else
 WF = &fallingWF;
 
 stimuliIndex.push_back( i );
 
 simul += "Vstimuli";
 simul += std::to_string( i );
 simul += " stimuli";
 simul += std::to_string( i );
 simul += " ";
 simul += aNode2;
 simul += " pwl ( \n+";
 
 if( i != 0 )
 {
 simul += "0 0 ";
 VTtableEntry entry0 = WF->m_table.m_entries.at( 0 );
 VTtableEntry entry1 = WF->m_table.m_entries.at( 1 );
 double deltaT = entry1.t - entry0.t;
 
 simul += doubleToString( entry0.t + timing - deltaT );
 simul += " ";
 simul += "0";
 simul += "\n+";
 }
 
 for( VTtableEntry& entry : WF->m_table.m_entries )
 {
 simul += doubleToString( entry.t + timing );
 simul += " ";
 simul += doubleToString( entry.V.value[supply] - delta );
 simul += "\n+";
 }
 simul += ")\n";
 }
 
 i++;
 prevBit = bit.first;
 }
 
 simul += "bin ";
 simul += aNode1;
 simul += " ";
 simul += aNode2;
 simul += " v=(";
 
 for( int ii: stimuliIndex )
 {
 simul += " v( stimuli";
 simul += std::to_string( ii );
 simul += " ) +\n+";
 }
 
 // Depending on the first bit, we add a different DC value
 // The DC value we add is the first value of the first bit.
 if( ( aBits.size() > 0 ) && ( aBits[0].first == 0 ) )
 {
 simul += doubleToString( aPair.second->m_table.m_entries.at( 0 ).V.value[supply] );
 }
 else
 {
 simul += doubleToString( aPair.first->m_table.m_entries.at( 0 ).V.value[supply] );
 }
 
 simul += ")\n";
 return simul;
}
 
 
std::string KIBIS_PIN::addDie( KIBIS_MODEL& aModel, KIBIS_PARAMETER& aParam, int aIndex )
{
 IBIS_CORNER supply = aParam.m_supply;
 std::string simul;
 
 std::string GC_GND = "GC_GND";
 std::string PC_PWR = "PC_PWR";
 std::string PU_PWR = "PU_PWR";
 std::string PD_GND = "PD_GND";
 std::string DIE = "DIE";
 
 GC_GND += std::to_string( aIndex );
 PC_PWR += std::to_string( aIndex );
 PU_PWR += std::to_string( aIndex );
 PD_GND += std::to_string( aIndex );
 DIE += std::to_string( aIndex );
 
 
 std::string GC = "GC";
 std::string PC = "PC";
 std::string PU = "PU";
 std::string PD = "PD";
 
 GC += std::to_string( aIndex );
 PC += std::to_string( aIndex );
 PU += std::to_string( aIndex );
 PD += std::to_string( aIndex );
 
 if( aModel.HasGNDClamp() )
 {
 simul += aModel.m_GNDClamp.Spice( aIndex * 4 + 1, DIE, GC_GND, GC, supply );
 }
 
 if( aModel.HasPOWERClamp() )
 {
 simul += aModel.m_POWERClamp.Spice( aIndex * 4 + 2, PC_PWR, DIE, PC, supply );
 }
 
 if( aModel.HasPulldown() )
 {
 simul += aModel.m_pulldown.Spice( aIndex * 4 + 3, DIE, PD_GND, PD, supply );
 }
 
 if( aModel.HasPullup() )
 {
 simul += aModel.m_pullup.Spice( aIndex * 4 + 4, PU_PWR, DIE, PU, supply );
 }
 
 return simul;
}
 
 
void KIBIS_PIN::getKuKdFromFile( std::string* aSimul )
{
 std::string outputFileName = m_topLevel->m_cacheDir + "temp_output.spice";
 
 if( std::remove( outputFileName.c_str() ) )
 {
 Report( _( "Cannot remove temporary output file" ), RPT_SEVERITY_WARNING );
 }
 
 std::shared_ptr<SPICE_SIMULATOR> ng = SIMULATOR::CreateInstance( "ng-kibis" );
 
 if( !ng )
 {
 throw std::runtime_error( "Could not create simulator instance" );
 return;
 }
 ng->Init();
 ng->LoadNetlist( *aSimul );
 
 std::ifstream KuKdfile;
 KuKdfile.open( outputFileName );
 
 std::vector<double> ku, kd, t;
 if( KuKdfile )
 {
 std::string line;
 
 for( int i = 0; i < 11; i++ ) // number of line in the ngspice output header
 {
 std::getline( KuKdfile, line );
 }
 
 int i = 0;
 double t_v, ku_v, kd_v;
 
 while( KuKdfile )
 {
 std::getline( KuKdfile, line );
 
 if( line.empty() )
 {
 continue;
 }
 
 switch( i )
 {
 case 0:
 line = line.substr( line.find_first_of( "\t" ) + 1 );
 t_v = std::stod( line );
 break;
 case 1: ku_v = std::stod( line ); break;
 case 2:
 kd_v = std::stod( line );
 ku.push_back( ku_v );
 kd.push_back( kd_v );
 t.push_back( t_v );
 break;
 default: Report( _( "Error while reading temporary file" ), RPT_SEVERITY_ERROR );
 }
 i = ( i + 1 ) % 3;
 }
 
 std::getline( KuKdfile, line );
 }
 else
 {
 Report( _( "Error while creating temporary output file" ), RPT_SEVERITY_ERROR );
 }
 
 if( std::remove( outputFileName.c_str() ) )
 {
 Report( _( "Cannot remove temporary output file" ), RPT_SEVERITY_WARNING );
 }
 
 m_Ku = ku;
 m_Kd = kd;
 m_t = t;
}
 
 
std::string KIBIS_PIN::KuKdDriver( KIBIS_MODEL& aModel,
 std::pair<IbisWaveform*, IbisWaveform*> aPair,
 KIBIS_PARAMETER& aParam, int aIndex )
{
 IBIS_CORNER supply = aParam.m_supply;
 IBIS_CORNER ccomp = aParam.m_Ccomp;
 KIBIS_WAVEFORM* wave = aParam.m_waveform;
 
 std::string simul = "";
 
 simul += "*THIS IS NOT A VALID SPICE MODEL.\n";
 simul += "*This part is intended to be executed by Kibis internally.\n";
 simul += "*You should not be able to read this.\n\n";
 
 simul += ".SUBCKT DRIVER";
 simul += std::to_string( aIndex );
 simul += " POWER GND PIN \n"; // 1: POWER, 2:GND, 3:PIN
 
 simul += "Vdummy 2 PIN 0\n";
 
 if( ( aPair.first->m_R_dut != 0 ) || ( aPair.first->m_L_dut != 0 )
 || ( aPair.first->m_C_dut != 0 ) )
 {
 Report( _( "Kibis does not support DUT values yet. "
 "https://ibis.org/summits/nov16a/chen.pdf" ),
 RPT_SEVERITY_WARNING );
 }
 
 simul += "\n";
 simul += "CCPOMP 2 GND ";
 simul += doubleToString( aModel.m_C_comp.value[ccomp] ); //@TODO: Check the corner ?
 simul += "\n";
 
 IbisWaveform* risingWF = aPair.first;
 IbisWaveform* fallingWF = aPair.second;
 
 switch( wave->GetType() )
 {
 case KIBIS_WAVEFORM_TYPE::RECTANGULAR:
 case KIBIS_WAVEFORM_TYPE::PRBS:
 {
 wave->Check( risingWF, fallingWF );
 std::vector<std::pair<int, double>> bits = wave->GenerateBitSequence();
 bits = SimplifyBitSequence( bits );
 simul += aModel.generateSquareWave( "DIE0", "GND", bits, aPair, aParam );
 break;
 }
 case KIBIS_WAVEFORM_TYPE::STUCK_HIGH:
 {
 IbisWaveform* waveform = wave->inverted ? risingWF : fallingWF;
 simul += "Vsig DIE0 GND ";
 simul += doubleToString( waveform->m_table.m_entries.at( 0 ).V.value[supply] );
 simul += "\n";
 break;
 }
 case KIBIS_WAVEFORM_TYPE::STUCK_LOW:
 {
 IbisWaveform* waveform = wave->inverted ? fallingWF : risingWF;
 simul += "Vsig DIE0 GND ";
 simul += doubleToString( waveform->m_table.m_entries.at( 0 ).V.value[supply] );
 simul += "\n";
 break;
 }
 case KIBIS_WAVEFORM_TYPE::NONE:
 case KIBIS_WAVEFORM_TYPE::HIGH_Z:
 default: break;
 }
 simul += addDie( aModel, aParam, 0 );
 
 simul += "\n.ENDS DRIVER\n\n";
 return simul;
}
 
 
void KIBIS_PIN::getKuKdOneWaveform( KIBIS_MODEL& aModel,
 std::pair<IbisWaveform*, IbisWaveform*> aPair,
 KIBIS_PARAMETER& aParam )
{
 IBIS_CORNER supply = aParam.m_supply;
 KIBIS_WAVEFORM* wave = aParam.m_waveform;
 
 std::string simul = "";
 
 if( !wave )
 return;
 
 if( wave->GetType() == KIBIS_WAVEFORM_TYPE::NONE )
 {
 //@TODO , there could be some current flowing through pullup / pulldown transistors, even when off
 std::vector<double> ku, kd, t;
 ku.push_back( 0 );
 kd.push_back( 0 );
 t.push_back( 0 );
 m_Ku = ku;
 m_Kd = kd;
 m_t = t;
 }
 else
 {
 simul += KuKdDriver( aModel, aPair, aParam, 0 );
 simul += "\n x1 3 0 1 DRIVER0 \n";
 
 simul += "VCC 3 0 ";
 simul += doubleToString( aModel.m_voltageRange.value[supply] );
 simul += "\n";
 //simul += "Vpin x1.DIE 0 1 \n"
 simul += "Lfixture 1 4 ";
 simul += doubleToString( aPair.first->m_L_fixture );
 simul += "\n";
 simul += "Rfixture 4 5 ";
 simul += doubleToString( aPair.first->m_R_fixture );
 simul += "\n";
 simul += "Cfixture 4 0 ";
 simul += doubleToString( aPair.first->m_C_fixture );
 simul += "\n";
 simul += "Vfixture 5 0 ";
 simul += doubleToString( aPair.first->m_V_fixture );
 simul += "\n";
 simul += "VmeasIout x1.DIE0 x1.2 0\n";
 simul += "VmeasPD 0 x1.PD_GND0 0\n";
 simul += "VmeasPU x1.PU_PWR0 3 0\n";
 simul += "VmeasPC x1.PC_PWR0 3 0\n";
 simul += "VmeasGC 0 x1.GC_PWR0 0\n";
 
 if( aModel.HasPullup() && aModel.HasPulldown() )
 {
 Report( _( "Model has only one waveform pair, reduced accuracy" ),
 RPT_SEVERITY_WARNING );
 simul += "Bku KU 0 v=( (i(VmeasIout)-i(VmeasPC)-i(VmeasGC)-i(VmeasPD) "
 ")/(i(VmeasPU)-i(VmeasPD)))\n";
 simul += "Bkd KD 0 v=(1-v(KU))\n";
 }
 
 else if( !aModel.HasPullup() && aModel.HasPulldown() )
 {
 simul += "Bku KD 0 v=( ( i(VmeasIout)+i(VmeasPC)+i(VmeasGC) )/(i(VmeasPD)))\n";
 simul += "Bkd KU 0 v=0\n";
 }
 
 else if( aModel.HasPullup() && !aModel.HasPulldown() )
 {
 simul += "Bku KU 0 v=( ( i(VmeasIout)+i(VmeasPC)+i(VmeasGC) )/(i(VmeasPU)))\n";
 simul += "Bkd KD 0 v=0\n";
 }
 else
 {
 Report( _( "Driver needs at least a pullup or a pulldown" ), RPT_SEVERITY_ERROR );
 }
 
 switch( wave->GetType() )
 {
 case KIBIS_WAVEFORM_TYPE::PRBS:
 case KIBIS_WAVEFORM_TYPE::RECTANGULAR:
 {
 double duration = wave->GetDuration();
 simul += ".tran 0.1n ";
 simul += doubleToString( duration );
 simul += "\n";
 break;
 }
 case KIBIS_WAVEFORM_TYPE::HIGH_Z:
 case KIBIS_WAVEFORM_TYPE::STUCK_LOW:
 case KIBIS_WAVEFORM_TYPE::STUCK_HIGH:
 default: simul += ".tran 0.5 1 \n"; //
 }
 //simul += ".dc Vpin -5 5 0.1\n";
 simul += ".control run \n";
 simul += "set filetype=ascii\n";
 simul += "run \n";
 //simul += "plot v(x1.DIE0) i(VmeasIout) i(VmeasPD) i(VmeasPU) i(VmeasPC) i(VmeasGC)\n";
 //simul += "plot v(KU) v(KD)\n";
 
 std::string outputFileName = m_topLevel->m_cacheDir + "temp_output.spice";
 simul += "write '" + outputFileName + "' v(KU) v(KD)\n";
 simul += "quit\n";
 simul += ".endc \n";
 simul += ".end \n";
 
 getKuKdFromFile( &simul );
 }
}
 
 
void KIBIS_PIN::getKuKdNoWaveform( KIBIS_MODEL& aModel, KIBIS_PARAMETER& aParam )
{
 std::vector<double> ku, kd, t;
 KIBIS_WAVEFORM* wave = aParam.m_waveform;
 IBIS_CORNER& supply = aParam.m_supply;
 
 if( !wave )
 {
 return;
 }
 
 switch( wave->GetType() )
 {
 case KIBIS_WAVEFORM_TYPE::RECTANGULAR:
 case KIBIS_WAVEFORM_TYPE::PRBS:
 {
 wave->Check( aModel.m_ramp.m_rising, aModel.m_ramp.m_falling );
 std::vector<std::pair<int, double>> bits = wave->GenerateBitSequence();
 bits = SimplifyBitSequence( bits );
 
 for( std::pair<int, double> bit : bits )
 {
 ku.push_back( bit.first ? 0 : 1 );
 kd.push_back( bit.first ? 1 : 0 );
 t.push_back( bit.second );
 ku.push_back( bit.first ? 1 : 0 );
 kd.push_back( bit.first ? 0 : 1 );
 t.push_back( bit.second
 + ( bit.first ? +aModel.m_ramp.m_rising.value[supply].m_dt
 : aModel.m_ramp.m_falling.value[supply].m_dt )
 / 0.6 );
 // 0.6 because ibis only gives 20%-80% time
 }
 break;
 }
 case KIBIS_WAVEFORM_TYPE::STUCK_HIGH:
 {
 ku.push_back( wave->inverted ? 0 : 1 );
 kd.push_back( wave->inverted ? 1 : 0 );
 t.push_back( 0 );
 break;
 }
 case KIBIS_WAVEFORM_TYPE::STUCK_LOW:
 {
 ku.push_back( wave->inverted ? 1 : 0 );
 kd.push_back( wave->inverted ? 0 : 1 );
 t.push_back( 0 );
 break;
 }
 case KIBIS_WAVEFORM_TYPE::HIGH_Z:
 case KIBIS_WAVEFORM_TYPE::NONE:
 default:
 ku.push_back( 0 );
 kd.push_back( 0 );
 t.push_back( 0 );
 }
 m_Ku = ku;
 m_Kd = kd;
 m_t = t;
}
 
 
void KIBIS_PIN::getKuKdTwoWaveforms( KIBIS_MODEL& aModel,
 std::pair<IbisWaveform*, IbisWaveform*> aPair1,
 std::pair<IbisWaveform*, IbisWaveform*> aPair2,
 KIBIS_PARAMETER& aParam )
{
 std::string simul = "";
 IBIS_CORNER supply = aParam.m_supply;
 KIBIS_WAVEFORM* wave = aParam.m_waveform;
 
 if( !wave )
 return;
 
 if( wave->GetType() == KIBIS_WAVEFORM_TYPE::NONE )
 {
 //@TODO , there could be some current flowing through pullup / pulldown transistors, even when off
 std::vector<double> ku, kd, t;
 ku.push_back( 0 );
 kd.push_back( 0 );
 t.push_back( 0 );
 m_Ku = ku;
 m_Kd = kd;
 m_t = t;
 }
 else
 {
 simul += KuKdDriver( aModel, aPair1, aParam, 0 );
 simul += KuKdDriver( aModel, aPair2, aParam, 1 );
 simul += "\n x1 3 0 1 DRIVER0 \n";
 
 simul += "VCC 3 0 ";
 simul += doubleToString( aModel.m_voltageRange.value[supply] );
 simul += "\n";
 //simul += "Vpin x1.DIE 0 1 \n"
 simul += "Lfixture0 1 4 ";
 simul += doubleToString( aPair1.first->m_L_fixture );
 simul += "\n";
 simul += "Rfixture0 4 5 ";
 simul += doubleToString( aPair1.first->m_R_fixture );
 simul += "\n";
 simul += "Cfixture0 4 0 ";
 simul += doubleToString( aPair1.first->m_C_fixture );
 simul += "\n";
 simul += "Vfixture0 5 0 ";
 simul += doubleToString( aPair1.first->m_V_fixture );
 simul += "\n";
 simul += "VmeasIout0 x1.2 x1.DIE0 0\n";
 simul += "VmeasPD0 0 x1.PD_GND0 0\n";
 simul += "VmeasPU0 x1.PU_PWR0 3 0\n";
 simul += "VmeasPC0 x1.PC_PWR0 3 0\n";
 simul += "VmeasGC0 0 x1.GC_PWR0 0\n";
 
 
 simul += "\n x2 3 0 7 DRIVER1 \n";
 //simul += "Vpin x1.DIE 0 1 \n"
 simul += "Lfixture1 7 8 ";
 simul += doubleToString( aPair2.first->m_L_fixture );
 simul += "\n";
 simul += "Rfixture1 8 9 ";
 simul += doubleToString( aPair2.first->m_R_fixture );
 simul += "\n";
 simul += "Cfixture1 8 0 ";
 simul += doubleToString( aPair2.first->m_C_fixture );
 simul += "\n";
 simul += "Vfixture1 9 0 ";
 simul += doubleToString( aPair2.first->m_V_fixture );
 simul += "\n";
 simul += "VmeasIout1 x2.2 x2.DIE0 0\n";
 simul += "VmeasPD1 0 x2.PD_GND0 0\n";
 simul += "VmeasPU1 x2.PU_PWR0 3 0\n";
 simul += "VmeasPC1 x2.PC_PWR0 3 0\n";
 simul += "VmeasGC1 0 x2.GC_PWR0 0\n";
 
 if( aModel.HasPullup() && aModel.HasPulldown() )
 {
 simul +=
 "Bku KU 0 v=( ( i(VmeasPD1) * ( i(VmeasIout0) + i(VmeasPC0) + i(VmeasGC0) ) - "
 "i(VmeasPD0) * ( i(VmeasIout1) + i(VmeasPC1) + i(VmeasGC1) ) )/ ( i(VmeasPU1) "
 "* "
 "i(VmeasPD0) - i(VmeasPU0) * i(VmeasPD1) ) )\n";
 simul +=
 "Bkd KD 0 v=( ( i(VmeasPU1) * ( i(VmeasIout0) + i(VmeasPC0) + i(VmeasGC0) ) - "
 "i(VmeasPU0) * ( i(VmeasIout1) + i(VmeasPC1) + i(VmeasGC1) ) )/ ( i(VmeasPD1) "
 "* "
 "i(VmeasPU0) - i(VmeasPD0) * i(VmeasPU1) ) )\n";
 //simul += "Bkd KD 0 v=(1-v(KU))\n";
 }
 
 else if( !aModel.HasPullup() && aModel.HasPulldown() )
 {
 Report( _( "There are two waveform pairs, but only one transistor. More equations than "
 "unknowns." ),
 RPT_SEVERITY_WARNING );
 simul += "Bku KD 0 v=( ( i(VmeasIout0)+i(VmeasPC0)+i(VmeasGC0) )/(i(VmeasPD0)))\n";
 simul += "Bkd KU 0 v=0\n";
 }
 
 else if( aModel.HasPullup() && !aModel.HasPulldown() )
 {
 Report( _( "There are two waveform pairs, but only one transistor. More equations than "
 "unknowns." ),
 RPT_SEVERITY_WARNING );
 simul += "Bku KU 0 v=( ( i(VmeasIout)+i(VmeasPC)+i(VmeasGC) )/(i(VmeasPU)))\n";
 simul += "Bkd KD 0 v=0\n";
 }
 else
 {
 Report( _( "Driver needs at least a pullup or a pulldown" ), RPT_SEVERITY_ERROR );
 }
 
 switch( wave->GetType() )
 {
 case KIBIS_WAVEFORM_TYPE::RECTANGULAR:
 case KIBIS_WAVEFORM_TYPE::PRBS:
 {
 double duration = wave->GetDuration();
 simul += ".tran 0.1n ";
 simul += doubleToString( duration );
 simul += "\n";
 break;
 }
 case KIBIS_WAVEFORM_TYPE::HIGH_Z:
 case KIBIS_WAVEFORM_TYPE::STUCK_LOW:
 case KIBIS_WAVEFORM_TYPE::STUCK_HIGH:
 default: simul += ".tran 0.5 1 \n"; //
 }
 //simul += ".dc Vpin -5 5 0.1\n";
 simul += ".control run \n";
 simul += "set filetype=ascii\n";
 simul += "run \n";
 simul += "plot v(KU) v(KD)\n";
 //simul += "plot v(x1.DIE0) \n";
 std::string outputFileName = m_topLevel->m_cacheDir + "temp_output.spice";
 simul += "write '" + outputFileName + "' v(KU) v(KD)\n";
 simul += "quit\n";
 simul += ".endc \n";
 simul += ".end \n";
 
 getKuKdFromFile( &simul );
 }
}
 
 
bool KIBIS_PIN::writeSpiceDriver( std::string* aDest, std::string aName, KIBIS_MODEL& aModel,
 KIBIS_PARAMETER& aParam )
{
 bool status = true;
 
 switch( aModel.m_type )
 {
 case IBIS_MODEL_TYPE::OUTPUT:
 case IBIS_MODEL_TYPE::IO:
 case IBIS_MODEL_TYPE::THREE_STATE:
 case IBIS_MODEL_TYPE::OPEN_DRAIN:
 case IBIS_MODEL_TYPE::IO_OPEN_DRAIN:
 case IBIS_MODEL_TYPE::OPEN_SINK:
 case IBIS_MODEL_TYPE::IO_OPEN_SINK:
 case IBIS_MODEL_TYPE::OPEN_SOURCE:
 case IBIS_MODEL_TYPE::IO_OPEN_SOURCE:
 case IBIS_MODEL_TYPE::OUTPUT_ECL:
 case IBIS_MODEL_TYPE::IO_ECL:
 case IBIS_MODEL_TYPE::THREE_STATE_ECL:
 {
 std::string result;
 std::string tmp;
 
 result = "\n*Driver model generated by Kicad using Ibis data. ";
 result += "\n*Component: ";
 
 if( m_parent )
 {
 //result += m_parent->m_name;
 }
 result += "\n*Manufacturer: ";
 
 if( m_parent )
 {
 //result += m_parent->m_manufacturer;
 }
 result += "\n*Pin number: ";
 result += m_pinNumber;
 result += "\n*Signal name: ";
 result += m_signalName;
 result += "\n*Model: ";
 result += aModel.m_name;
 result += "\n.SUBCKT ";
 result += aName;
 result += " GND PIN \n";
 result += "\n";
 
 result += "RPIN 1 PIN ";
 result += doubleToString( m_Rpin.value[aParam.m_Rpin] );
 result += "\n";
 result += "LPIN DIE0 1 ";
 result += doubleToString( m_Lpin.value[aParam.m_Lpin] );
 result += "\n";
 result += "CPIN PIN GND ";
 result += doubleToString( m_Cpin.value[aParam.m_Cpin] );
 result += "\n";
 
 std::vector<std::pair<IbisWaveform*, IbisWaveform*>> wfPairs = aModel.waveformPairs();
 KIBIS_ACCURACY accuracy = aParam.m_accuracy;
 
 if( wfPairs.size() < 1 || accuracy <= KIBIS_ACCURACY::LEVEL_0 )
 {
 if( accuracy > KIBIS_ACCURACY::LEVEL_0 )
 {
 Report( _( "Model has no waveform pair, using [Ramp] instead, poor accuracy" ),
 RPT_SEVERITY_INFO );
 }
 getKuKdNoWaveform( aModel, aParam );
 }
 else if( wfPairs.size() == 1 || accuracy <= KIBIS_ACCURACY::LEVEL_1 )
 {
 getKuKdOneWaveform( aModel, wfPairs.at( 0 ), aParam );
 }
 else
 {
 if( wfPairs.size() > 2 || accuracy <= KIBIS_ACCURACY::LEVEL_2 )
 {
 Report( _( "Model has more than 2 waveform pairs, using the first two." ),
 RPT_SEVERITY_WARNING );
 }
 getKuKdTwoWaveforms( aModel, wfPairs.at( 0 ), wfPairs.at( 1 ), aParam );
 }
 
 result += "Vku KU GND pwl ( ";
 
 for( size_t i = 0; i < m_t.size(); i++ )
 {
 result += doubleToString( m_t.at( i ) );
 result += " ";
 result += doubleToString( m_Ku.at( i ) );
 result += " ";
 }
 
 result += ") \n";
 
 
 result += "Vkd KD GND pwl ( ";
 
 for( size_t i = 0; i < m_t.size(); i++ )
 {
 result += doubleToString( m_t.at( i ) );
 result += " ";
 result += doubleToString( m_Kd.at( i ) );
 result += " ";
 }
 
 result += ") \n";
 
 result += aModel.SpiceDie( aParam, 0 );
 
 result += "\n.ENDS DRIVER\n\n";
 
 *aDest += result;
 break;
 }
 default: Report( _( "Invalid model type for a driver." ), RPT_SEVERITY_ERROR ); status = false;
 }
 
 return status;
}
 
 
bool KIBIS_PIN::writeSpiceDevice( std::string* aDest, std::string aName, KIBIS_MODEL& aModel,
 KIBIS_PARAMETER& aParam )
{
 bool status = true;
 
 switch( aModel.m_type )
 {
 case IBIS_MODEL_TYPE::INPUT_STD:
 case IBIS_MODEL_TYPE::IO:
 case IBIS_MODEL_TYPE::IO_OPEN_DRAIN:
 case IBIS_MODEL_TYPE::IO_OPEN_SINK:
 case IBIS_MODEL_TYPE::IO_OPEN_SOURCE:
 case IBIS_MODEL_TYPE::IO_ECL:
 {
 std::string result;
 std::string tmp;
 
 result += "\n";
 result = "*Device model generated by Kicad using Ibis data.";
 result += "\n.SUBCKT ";
 result += aName;
 result += " GND PIN\n";
 result += "\n";
 result += "\n";
 result += "RPIN 1 PIN ";
 result += doubleToString( m_Rpin.value[aParam.m_Rpin] );
 result += "\n";
 result += "LPIN DIE0 1 ";
 result += doubleToString( m_Lpin.value[aParam.m_Lpin] );
 result += "\n";
 result += "CPIN PIN GND ";
 result += doubleToString( m_Cpin.value[aParam.m_Cpin] );
 result += "\n";
 
 
 result += "Vku KU GND pwl ( 0 0 )\n";
 result += "Vkd KD GND pwl ( 0 0 )\n";
 
 result += aModel.SpiceDie( aParam, 0 );
 
 result += "\n.ENDS DRIVER\n\n";
 
 *aDest = result;
 break;
 }
 default: Report( _( "Invalid model type for a device" ), RPT_SEVERITY_ERROR ); status = false;
 }
 
 return status;
}
 
 
bool KIBIS_PIN::writeSpiceDiffDriver( std::string* aDest, std::string aName, KIBIS_MODEL& aModel,
 KIBIS_PARAMETER& aParam )
{
 bool status = true;
 KIBIS_WAVEFORM* wave = aParam.m_waveform;
 
 if( !wave )
 return false;
 
 std::string result;
 result = "\n*Differential driver model generated by Kicad using Ibis data. ";
 result += "\n*Component: ";
 
 if( m_parent )
 {
 //result += m_parent->m_name;
 }
 result += "\n*Manufacturer: ";
 
 if( m_parent )
 {
 //result += m_parent->m_manufacturer;
 }
 
 result += "\n.SUBCKT ";
 result += aName;
 result += " GND PIN_P PIN_N\n";
 result += "\n";
 
 status &= writeSpiceDriver( &result, aName + "_P", aModel, aParam );
 wave->inverted = !wave->inverted;
 status &= writeSpiceDriver( &result, aName + "_N", aModel, aParam );
 wave->inverted = !wave->inverted;
 
 
 result += "\n";
 result += "x1 GND PIN_P " + aName + "_P \n";
 result += "x2 GND PIN_N " + aName + "_N \n";
 result += "\n";
 
 result += "\n.ENDS " + aName + "\n\n";
 
 if( status )
 {
 *aDest += result;
 }
 
 return status;
}
 
 
bool KIBIS_PIN::writeSpiceDiffDevice( std::string* aDest, std::string aName, KIBIS_MODEL& aModel,
 KIBIS_PARAMETER& aParam )
{
 bool status = true;
 
 std::string result;
 result = "\n*Differential device model generated by Kicad using Ibis data. ";
 result += "\n*Component: ";
 
 if( m_parent )
 {
 //result += m_parent->m_name;
 }
 result += "\n*Manufacturer: ";
 
 if( m_parent )
 {
 //result += m_parent->m_manufacturer;
 }
 
 result += "\n.SUBCKT ";
 result += aName;
 result += " GND PIN_P PIN_N\n";
 result += "\n";
 
 status &= writeSpiceDevice( &result, aName + "_P", aModel, aParam );
 status &= writeSpiceDevice( &result, aName + "_N", aModel, aParam );
 
 result += "\n";
 result += "x1 GND PIN_P " + aName + "_P \n";
 result += "x2 GND PIN_N " + aName + "_N \n";
 result += "\n";
 
 result += "\n.ENDS " + aName + "\n\n";
 
 if( status )
 {
 *aDest += result;
 }
 
 return status;
}
 
 
KIBIS_MODEL* KIBIS::GetModel( std::string aName )
{
 for( KIBIS_MODEL& model : m_models )
 {
 if( model.m_name == aName )
 return &model;
 }
 return nullptr;
}
 
 
KIBIS_COMPONENT* KIBIS::GetComponent( std::string aName )
{
 for( KIBIS_COMPONENT& cmp : m_components )
 {
 if( cmp.m_name == aName )
 return &cmp;
 }
 return nullptr;
}
 
 
void KIBIS_PARAMETER::SetCornerFromString( IBIS_CORNER& aCorner, std::string aString )
{
 if( aString == "MIN" )
 aCorner = IBIS_CORNER::MIN;
 else if( aString == "MAX" )
 aCorner = IBIS_CORNER::MAX;
 else
 aCorner = IBIS_CORNER::TYP;
}
 
 
std::vector<std::pair<int, double>> KIBIS_WAVEFORM_STUCK_HIGH::GenerateBitSequence()
{
 std::vector<std::pair<int, double>> bits;
 std::pair<int, double> bit;
 bit.first = inverted ? 1 : 0;
 bit.second = 0;
 return bits;
}
 
 
std::vector<std::pair<int, double>> KIBIS_WAVEFORM_STUCK_LOW::GenerateBitSequence()
{
 std::vector<std::pair<int, double>> bits;
 std::pair<int, double> bit;
 bit.first = inverted ? 0 : 1;
 bit.second = 0;
 return bits;
}
 
std::vector<std::pair<int, double>> KIBIS_WAVEFORM_HIGH_Z::GenerateBitSequence()
{
 std::vector<std::pair<int, double>> bits;
 return bits;
}
 
std::vector<std::pair<int, double>> KIBIS_WAVEFORM_RECTANGULAR::GenerateBitSequence()
{
 std::vector<std::pair<int, double>> bits;
 
 for( int i = 0; i < m_cycles; i++ )
 {
 std::pair<int, double> bit;
 bit.first = inverted ? 0 : 1;
 bit.second = ( m_ton + m_toff ) * i + m_delay;
 bits.push_back( bit );
 
 bit.first = inverted ? 1 : 0;
 bit.second = ( m_ton + m_toff ) * i + m_delay + m_ton;
 bits.push_back( bit );
 }
 return bits;
}
 
 
std::vector<std::pair<int, double>> KIBIS_WAVEFORM_PRBS::GenerateBitSequence()
{
 std::vector<std::pair<int, double>> bitSequence;
 uint8_t polynomial = 0b1100000;
 //1100000 = x^7+x^6+1
 //10100 = x^5+x^3+1
 //110 = x^3+x^2+1
 uint8_t seed = 0x12; // Any non zero state
 uint8_t lfsr = seed;
 
 if ( m_bitrate == 0 )
 return bitSequence;
 
 double period = 1/m_bitrate;
 double t = 0;
 m_bits = abs( m_bits ); // Just to be sure.
 
 int bits = 0;
 do
 {
 uint8_t lsb = lfsr & 0x01;
 bitSequence.emplace_back( ( static_cast<uint8_t>( inverted ) ^ lsb ? 1 : 0 ), t );
 lfsr = lfsr >> 1;
 
 if ( lsb )
 lfsr ^= polynomial;
 
 t += period;
 
 } while ( ++bits < m_bits );
 
 return bitSequence;
}
 
bool KIBIS_WAVEFORM_RECTANGULAR::Check( IbisWaveform* aRisingWf, IbisWaveform* aFallingWf )
{
 bool status = true;
 
 if( m_cycles < 1 )
 {
 status = false;
 Report( _( "Number of cycles should be greater than 0." ), RPT_SEVERITY_ERROR );
 }
 
 if( m_ton <= 0 )
 {
 status = false;
 Report( _( "ON time should be greater than 0." ), RPT_SEVERITY_ERROR );
 }
 
 if( m_toff <= 0 )
 {
 status = false;
 Report( _( "OFF time should be greater than 0." ), RPT_SEVERITY_ERROR );
 }
 
 if( aRisingWf )
 {
 if( m_ton < aRisingWf->m_table.m_entries.back().t )
 {
 status = false;
 Report( _( "Rising edge is longer than on time." ), RPT_SEVERITY_WARNING );
 }
 }
 
 if( aFallingWf )
 {
 if( m_toff < aFallingWf->m_table.m_entries.back().t )
 {
 status = false;
 Report( _( "Falling edge is longer than off time." ), RPT_SEVERITY_WARNING );
 }
 }
 
 status &= aRisingWf && aFallingWf;
 
 return status;
}
 
 
bool KIBIS_WAVEFORM_RECTANGULAR::Check( dvdtTypMinMax aRisingRp, dvdtTypMinMax aFallingRp )
{
 bool status = true;
 
 if( m_cycles < 1 )
 {
 status = false;
 Report( _( "Number of cycles should be greater than 0." ), RPT_SEVERITY_ERROR );
 }
 
 if( m_ton <= 0 )
 {
 status = false;
 Report( _( "ON time should be greater than 0." ), RPT_SEVERITY_ERROR );
 }
 
 if( m_toff <= 0 )
 {
 status = false;
 Report( _( "OFF time should be greater than 0." ), RPT_SEVERITY_ERROR );
 }
 
 if( ( m_ton < aRisingRp.value[IBIS_CORNER::TYP].m_dt / 0.6 )
 || ( m_ton < aRisingRp.value[IBIS_CORNER::MIN].m_dt / 0.6 )
 || ( m_ton < aRisingRp.value[IBIS_CORNER::MAX].m_dt / 0.6 ) )
 {
 status = false;
 Report( _( "Rising edge is longer than ON time." ), RPT_SEVERITY_ERROR );
 }
 
 if( ( m_toff < aFallingRp.value[IBIS_CORNER::TYP].m_dt / 0.6 )
 || ( m_toff < aFallingRp.value[IBIS_CORNER::MIN].m_dt / 0.6 )
 || ( m_toff < aFallingRp.value[IBIS_CORNER::MAX].m_dt / 0.6 ) )
 {
 status = false;
 Report( _( "Falling edge is longer than OFF time." ), RPT_SEVERITY_ERROR );
 }
 
 return status;
}
 
 
bool KIBIS_WAVEFORM_PRBS::Check( dvdtTypMinMax aRisingRp, dvdtTypMinMax aFallingRp )
{
 bool status = true;
 
 if( m_bitrate <= 0 )
 {
 status = false;
 Report( _( "Bitrate should be greater than 0." ), RPT_SEVERITY_ERROR );
 }
 
 if( m_bits <= 0 )
 {
 status = false;
 Report( _( "Number of bits should be greater than 0." ), RPT_SEVERITY_ERROR );
 }
 
 if( m_bitrate
 && ( ( 1 / m_bitrate ) < ( aRisingRp.value[IBIS_CORNER::TYP].m_dt / 0.6
 + aFallingRp.value[IBIS_CORNER::TYP].m_dt / 0.6 ) )
 && ( ( 1 / m_bitrate ) < ( aRisingRp.value[IBIS_CORNER::TYP].m_dt / 0.6
 + aFallingRp.value[IBIS_CORNER::TYP].m_dt / 0.6 ) )
 && ( ( 1 / m_bitrate ) < ( aRisingRp.value[IBIS_CORNER::TYP].m_dt / 0.6
 + aFallingRp.value[IBIS_CORNER::TYP].m_dt / 0.6 ) ) )
 {
 status = false;
 Report( _( "Bitrate is too high for rising / falling edges" ), RPT_SEVERITY_ERROR );
 }
 
 return status;
}
 
bool KIBIS_WAVEFORM_PRBS::Check( IbisWaveform* aRisingWf, IbisWaveform* aFallingWf )
{
 bool status = true;
 
 if( m_bitrate <= 0 )
 {
 status = false;
 Report( _( "Bitrate should be greater than 0." ), RPT_SEVERITY_ERROR );
 }
 
 if( m_bits <= 0 )
 {
 status = false;
 Report( _( "Number of bits should be greater than 0." ), RPT_SEVERITY_ERROR );
 }
 
 if( m_bitrate && aRisingWf && aFallingWf
 && ( ( 1 / m_bitrate ) < ( aRisingWf->m_table.m_entries.back().t
 + aFallingWf->m_table.m_entries.back().t ) ) )
 {
 status = false;
 Report( _( "Bitrate could be too high for rising / falling edges" ), RPT_SEVERITY_WARNING );
 }
 
 return status;
}