kicad/eeschema/sim/legacy_workbook.cpp

355 lines
11 KiB
C++
Raw Normal View History

/*
* This program source code file is part of KiCad, a free EDA CAD application.
*
* Copyright (C) 2016-2023 CERN
* Copyright (C) 2016-2023 KiCad Developers, see AUTHORS.txt for contributors.
* @author Tomasz Wlostowski <tomasz.wlostowski@cern.ch>
* @author Maciej Suminski <maciej.suminski@cern.ch>
*
* 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, you may find one here:
* https://www.gnu.org/licenses/gpl-3.0.html
* or you may search the http://www.gnu.org website for the version 3 license,
* or you may write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
*/
#include <memory>
#include <wx/debug.h>
#include <project/project_file.h>
#include <confirm.h>
#include <string_utils.h>
#include <sim/simulator_frame_ui.h>
#include <sim/simulator_frame.h>
#include <sim/sim_plot_tab.h>
void SIMULATOR_FRAME_UI::parseTraceParams( SIM_PLOT_TAB* aPlotTab, TRACE* aTrace,
const wxString& aSignalName, const wxString& aParams )
{
auto addCursor =
[&]( int aCursorId, double x )
{
CURSOR* cursor = new CURSOR( aTrace, aPlotTab );
cursor->SetName( aSignalName );
cursor->SetPen( wxPen( aTrace->GetTraceColour() ) );
cursor->SetCoordX( x );
aTrace->SetCursor( aCursorId, cursor );
aPlotTab->GetPlotWin()->AddLayer( cursor );
};
wxArrayString items = wxSplit( aParams, '|' );
for( const wxString& item : items )
{
if( item.StartsWith( wxS( "rgb" ) ) )
{
wxColour color;
color.Set( item );
aTrace->SetTraceColour( color );
aPlotTab->UpdateTraceStyle( aTrace );
}
else if( item.StartsWith( wxS( "cursor1" ) ) )
{
wxArrayString parts = wxSplit( item, ':' );
double val;
if( parts.size() == 3 )
{
parts[0].AfterFirst( '=' ).ToDouble( &val );
m_cursorFormats[0][0].FromString( parts[1] );
m_cursorFormats[0][1].FromString( parts[2] );
addCursor( 1, val );
}
}
else if( item.StartsWith( wxS( "cursor2" ) ) )
{
wxArrayString parts = wxSplit( item, ':' );
double val;
if( parts.size() == 3 )
{
parts[0].AfterFirst( '=' ).ToDouble( &val );
m_cursorFormats[1][0].FromString( parts[1] );
m_cursorFormats[1][1].FromString( parts[2] );
addCursor( 2, val );
}
}
else if( item.StartsWith( wxS( "cursorD" ) ) )
{
wxArrayString parts = wxSplit( item, ':' );
if( parts.size() == 3 )
{
m_cursorFormats[2][0].FromString( parts[1] );
m_cursorFormats[2][1].FromString( parts[2] );
}
}
else if( item == wxS( "dottedSecondary" ) )
{
aPlotTab->SetDottedSecondary( true );
}
else if( item == wxS( "hideGrid" ) )
{
aPlotTab->ShowGrid( false );
}
}
}
bool SIMULATOR_FRAME_UI::loadLegacyWorkbook( const wxString& aPath )
{
wxTextFile file( aPath );
#define EXPECTING( msg ) \
DisplayErrorMessage( this, wxString::Format( _( "Error loading workbook: line %d: %s." ), \
file.GetCurrentLine()+1, \
msg ) )
if( !file.Open() )
return false;
long version = 1;
wxString firstLine = file.GetFirstLine();
wxString pageCountLine;
if( firstLine.StartsWith( wxT( "version " ) ) )
{
if( !firstLine.substr( 8 ).ToLong( &version ) )
{
EXPECTING( _( "expecting version" ) );
file.Close();
return false;
}
pageCountLine = file.GetNextLine();
}
else
{
pageCountLine = firstLine;
}
long tabCount;
if( !pageCountLine.ToLong( &tabCount ) )
{
EXPECTING( _( "expecting simulation tab count" ) );
file.Close();
return false;
}
std::map<SIM_PLOT_TAB*, std::vector<std::tuple<long, wxString, wxString>>> traceInfo;
for( long i = 0; i < tabCount; ++i )
{
long simType, tracesCount;
if( !file.GetNextLine().ToLong( &simType ) )
{
EXPECTING( _( "expecting simulation tab type" ) );
file.Close();
return false;
}
wxString command = UnescapeString( file.GetNextLine() );
wxString simCommand;
int simOptions = NETLIST_EXPORTER_SPICE::OPTION_DEFAULT_FLAGS;
wxStringTokenizer tokenizer( command, wxT( "\r\n" ), wxTOKEN_STRTOK );
if( version >= 2 )
{
simOptions &= ~NETLIST_EXPORTER_SPICE::OPTION_ADJUST_INCLUDE_PATHS;
simOptions &= ~NETLIST_EXPORTER_SPICE::OPTION_SAVE_ALL_VOLTAGES;
simOptions &= ~NETLIST_EXPORTER_SPICE::OPTION_SAVE_ALL_CURRENTS;
}
if( version >= 3 )
{
simOptions &= ~NETLIST_EXPORTER_SPICE::OPTION_SAVE_ALL_DISSIPATIONS;
}
while( tokenizer.HasMoreTokens() )
{
wxString line = tokenizer.GetNextToken();
if( line.StartsWith( wxT( ".kicad adjustpaths" ) ) )
simOptions |= NETLIST_EXPORTER_SPICE::OPTION_ADJUST_INCLUDE_PATHS;
else if( line.StartsWith( wxT( ".save all" ) ) )
simOptions |= NETLIST_EXPORTER_SPICE::OPTION_SAVE_ALL_VOLTAGES;
else if( line.StartsWith( wxT( ".probe alli" ) ) )
simOptions |= NETLIST_EXPORTER_SPICE::OPTION_SAVE_ALL_CURRENTS;
else if( line.StartsWith( wxT( ".probe allp" ) ) )
simOptions |= NETLIST_EXPORTER_SPICE::OPTION_SAVE_ALL_DISSIPATIONS;
else
simCommand += line + wxT( "\n" );
}
SIM_TAB* simTab = NewSimTab( simCommand );
SIM_PLOT_TAB* plotTab = dynamic_cast<SIM_PLOT_TAB*>( simTab );
simTab->SetSimOptions( simOptions );
if( !file.GetNextLine().ToLong( &tracesCount ) )
{
EXPECTING( _( "expecting trace count" ) );
file.Close();
return false;
}
if( plotTab )
traceInfo[plotTab] = {};
for( long j = 0; j < tracesCount; ++j )
{
long traceType;
wxString name, param;
if( !file.GetNextLine().ToLong( &traceType ) )
{
EXPECTING( _( "expecting trace type" ) );
file.Close();
return false;
}
name = file.GetNextLine();
if( name.IsEmpty() )
{
EXPECTING( _( "expecting trace name" ) );
file.Close();
return false;
}
param = file.GetNextLine();
if( param.IsEmpty() )
{
EXPECTING( _( "expecting trace color" ) );
file.Close();
return false;
}
if( plotTab )
traceInfo[plotTab].emplace_back( std::make_tuple( traceType, name, param ) );
}
if( version > 4 )
{
long measurementCount;
if( !file.GetNextLine().ToLong( &measurementCount ) )
{
EXPECTING( _( "expecting measurement count" ) );
file.Close();
return false;
}
for( int ii = 0; ii < (int) measurementCount; ++ ii )
{
wxString measurement = file.GetNextLine();
if( measurement.IsEmpty() )
{
EXPECTING( _( "expecting measurement definition" ) );
file.Close();
return false;
}
wxString format = file.GetNextLine();
if( format.IsEmpty() )
{
EXPECTING( _( "expecting measurement format definition" ) );
file.Close();
return false;
}
if( plotTab )
plotTab->Measurements().emplace_back( measurement, format );
}
}
}
long userDefinedSignalCount;
if( file.GetNextLine().ToLong( &userDefinedSignalCount ) )
{
for( int ii = 0; ii < (int) userDefinedSignalCount; ++ii )
m_userDefinedSignals[ ii ] = file.GetNextLine();
}
for( const auto& [ plotTab, traceInfoVector ] : traceInfo )
{
for( const auto& [ traceType, signalName, param ] : traceInfoVector )
{
if( traceType == SPT_UNKNOWN && signalName == wxS( "$LEGEND" ) )
{
wxArrayString coords = wxSplit( param, ' ' );
if( coords.size() >= 2 )
{
long x = 0;
long y = 0;
coords[0].ToLong( &x );
coords[1].ToLong( &y );
plotTab->SetLegendPosition( wxPoint( (int) x, (int) y ) );
}
plotTab->ShowLegend( true );
}
else
{
wxString vectorName = vectorNameFromSignalName( plotTab, signalName, nullptr );
2023-10-03 11:55:19 +00:00
TRACE* trace = plotTab->GetOrAddTrace( vectorName, (int) traceType );
if( version >= 4 && trace )
parseTraceParams( plotTab, trace, signalName, param );
}
}
plotTab->UpdatePlotColors();
}
if( SIM_TAB* simTab = GetCurrentSimTab() )
{
m_simulatorFrame->LoadSimulator( simTab->GetSimCommand(), simTab->GetSimOptions() );
if( version >= 5 )
{
simTab = dynamic_cast<SIM_TAB*>( m_plotNotebook->GetPage( 0 ) );
if( simTab )
simTab->SetLastSchTextSimCommand( file.GetNextLine() );
}
}
file.Close();
return true;
}