KiCad PCB EDA Suite
Loading...
Searching...
No Matches
simulator_frame_ui.cpp
Go to the documentation of this file.
1/*
2 * This program source code file is part of KiCad, a free EDA CAD application.
3 *
4 * Copyright (C) 2016-2023 CERN
5 * Copyright (C) 2016-2024 KiCad Developers, see AUTHORS.txt for contributors.
6 * @author Tomasz Wlostowski <[email protected]>
7 * @author Maciej Suminski <[email protected]>
8 *
9 * This program is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU General Public License
11 * as published by the Free Software Foundation; either version 3
12 * of the License, or (at your option) any later version.
13 *
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
18 *
19 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, you may find one here:
21 * https://www.gnu.org/licenses/gpl-3.0.html
22 * or you may search the http://www.gnu.org website for the version 3 license,
23 * or you may write to the Free Software Foundation, Inc.,
24 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
25 */
26
27#include <memory>
28
29#include <fmt/format.h>
30#include <wx/wfstream.h>
31#include <wx/stdstream.h>
32#include <wx/debug.h>
33#include <wx/clipbrd.h>
34#include <wx/log.h>
35
37#include <sch_edit_frame.h>
38#include <confirm.h>
42#include <widgets/wx_grid.h>
43#include <grid_tricks.h>
44#include <eda_pattern_match.h>
45#include <string_utils.h>
46#include <pgm_base.h>
48#include <sim/simulator_frame.h>
49#include <sim/sim_plot_tab.h>
50#include <sim/spice_simulator.h>
53#include <eeschema_settings.h>
54#include "kiplatform/app.h"
55
56
58{
59 int res = (int) aFirst | (int) aSecond;
60
61 return (SIM_TRACE_TYPE) res;
62}
63
64
66{
72};
73
74
76{
81};
82
83
85{
89};
90
91
92enum
93{
103
107
108
110{
111public:
113 GRID_TRICKS( aGrid ),
114 m_parent( aParent ),
115 m_menuRow( 0 ),
116 m_menuCol( 0 )
117 {}
118
119protected:
120 void showPopupMenu( wxMenu& menu, wxGridEvent& aEvent ) override;
121 void doPopupSelection( wxCommandEvent& event ) override;
122
123protected:
127};
128
129
130void SIGNALS_GRID_TRICKS::showPopupMenu( wxMenu& menu, wxGridEvent& aEvent )
131{
132 m_menuRow = aEvent.GetRow();
133 m_menuCol = aEvent.GetCol();
134
136 {
137 if( !( m_grid->IsInSelection( m_menuRow, m_menuCol ) ) )
138 m_grid->ClearSelection();
139
140 m_grid->SetGridCursor( m_menuRow, m_menuCol );
141
142 if( SIM_TAB* panel = m_parent->GetCurrentSimTab() )
143 {
144 if( panel->GetSimType() == ST_TRAN || panel->GetSimType() == ST_AC
145 || panel->GetSimType() == ST_DC || panel->GetSimType() == ST_SP )
146 {
147 menu.Append( MYID_MEASURE_MIN, _( "Measure Min" ) );
148 menu.Append( MYID_MEASURE_MAX, _( "Measure Max" ) );
149 menu.Append( MYID_MEASURE_AVG, _( "Measure Average" ) );
150 menu.Append( MYID_MEASURE_RMS, _( "Measure RMS" ) );
151 menu.Append( MYID_MEASURE_PP, _( "Measure Peak-to-peak" ) );
152
153 if( panel->GetSimType() == ST_AC || panel->GetSimType() == ST_SP )
154 {
155 menu.Append( MYID_MEASURE_MIN_AT, _( "Measure Frequency of Min" ) );
156 menu.Append( MYID_MEASURE_MAX_AT, _( "Measure Frequency of Max" ) );
157 }
158 else
159 {
160 menu.Append( MYID_MEASURE_MIN_AT, _( "Measure Time of Min" ) );
161 menu.Append( MYID_MEASURE_MAX_AT, _( "Measure Time of Max" ) );
162 }
163
164 menu.Append( MYID_MEASURE_INTEGRAL, _( "Measure Integral" ) );
165
166 if( panel->GetSimType() == ST_TRAN )
167 {
168 menu.AppendSeparator();
169 menu.Append( MYID_FOURIER, _( "Perform Fourier Analysis..." ) );
170 }
171
172 menu.AppendSeparator();
173 menu.Append( GRIDTRICKS_ID_COPY, _( "Copy Signal Name" ) + "\tCtrl+C" );
174
175 m_grid->PopupMenu( &menu );
176 }
177 }
178 }
179}
180
181
182void SIGNALS_GRID_TRICKS::doPopupSelection( wxCommandEvent& event )
183{
184 std::vector<wxString> signals;
185
186 wxGridCellCoordsArray cells1 = m_grid->GetSelectionBlockTopLeft();
187 wxGridCellCoordsArray cells2 = m_grid->GetSelectionBlockBottomRight();
188
189 for( size_t i = 0; i < cells1.Count(); i++ )
190 {
191 if( cells1[i].GetCol() == COL_SIGNAL_NAME )
192 {
193 for( int j = cells1[i].GetRow(); j < cells2[i].GetRow() + 1; j++ )
194 {
195 signals.push_back( m_grid->GetCellValue( j, cells1[i].GetCol() ) );
196 }
197 }
198 }
199
200 wxGridCellCoordsArray cells3 = m_grid->GetSelectedCells();
201
202 for( size_t i = 0; i < cells3.Count(); i++ )
203 {
204 if( cells3[i].GetCol() == COL_SIGNAL_NAME )
205 signals.push_back( m_grid->GetCellValue( cells3[i].GetRow(), cells3[i].GetCol() ) );
206 }
207
208 if( signals.size() < 1 )
209 signals.push_back( m_grid->GetCellValue( m_menuRow, m_menuCol ) );
210
211 auto addMeasurement =
212 [this]( const wxString& cmd, wxString signal )
213 {
214 if( signal.EndsWith( _( " (phase)" ) ) )
215 return;
216
217 if( signal.EndsWith( _( " (gain)" ) ) || signal.EndsWith( _( " (amplitude)" ) ) )
218 {
219 signal = signal.Left( signal.length() - 7 );
220
221 if( signal.Upper().StartsWith( wxS( "V(" ) ) )
222 signal = wxS( "vdb" ) + signal.Mid( 1 );
223 }
224
225 m_parent->AddMeasurement( cmd + wxS( " " ) + signal );
226 };
227
228 if( event.GetId() == MYID_MEASURE_MIN )
229 {
230 for( const wxString& signal : signals )
231 addMeasurement( wxS( "MIN" ), signal );
232 }
233 else if( event.GetId() == MYID_MEASURE_MAX )
234 {
235 for( const wxString& signal : signals )
236 addMeasurement( wxS( "MAX" ), signal );
237 }
238 else if( event.GetId() == MYID_MEASURE_AVG )
239 {
240 for( const wxString& signal : signals )
241 addMeasurement( wxS( "AVG" ), signal );
242 }
243 else if( event.GetId() == MYID_MEASURE_RMS )
244 {
245 for( const wxString& signal : signals )
246 addMeasurement( wxS( "RMS" ), signal );
247 }
248 else if( event.GetId() == MYID_MEASURE_PP )
249 {
250 for( const wxString& signal : signals )
251 addMeasurement( wxS( "PP" ), signal );
252 }
253 else if( event.GetId() == MYID_MEASURE_MIN_AT )
254 {
255 for( const wxString& signal : signals )
256 addMeasurement( wxS( "MIN_AT" ), signal );
257 }
258 else if( event.GetId() == MYID_MEASURE_MAX_AT )
259 {
260 for( const wxString& signal : signals )
261 addMeasurement( wxS( "MAX_AT" ), signal );
262 }
263 else if( event.GetId() == MYID_MEASURE_INTEGRAL )
264 {
265 for( const wxString& signal : signals )
266 addMeasurement( wxS( "INTEG" ), signal );
267 }
268 else if( event.GetId() == MYID_FOURIER )
269 {
270 wxString title;
271 wxString fundamental = wxT( "1K" );
272
273 if( signals.size() == 1 )
274 title.Printf( _( "Fourier Analysis of %s" ), signals[0] );
275 else
276 title = _( "Fourier Analyses of Multiple Signals" );
277
278 WX_TEXT_ENTRY_DIALOG dlg( m_parent, _( "Fundamental frequency:" ), title, fundamental );
279
280 if( dlg.ShowModal() != wxID_OK )
281 return;
282
283 if( !dlg.GetValue().IsEmpty() )
284 fundamental = dlg.GetValue();
285
286 for( const wxString& signal : signals )
287 m_parent->DoFourier( signal, fundamental );
288 }
289 else if( event.GetId() == GRIDTRICKS_ID_COPY )
290 {
291 wxLogNull doNotLog; // disable logging of failed clipboard actions
292 wxString txt;
293
294 for( const wxString& signal : signals )
295 {
296 if( !txt.IsEmpty() )
297 txt += '\r';
298
299 txt += signal;
300 }
301
302 if( wxTheClipboard->Open() )
303 {
304 wxTheClipboard->SetData( new wxTextDataObject( txt ) );
305 wxTheClipboard->Flush(); // Allow data to be available after closing KiCad
306 wxTheClipboard->Close();
307 }
308 }
309}
310
311
313{
314public:
316 GRID_TRICKS( aGrid ),
317 m_parent( aParent ),
318 m_menuRow( 0 ),
319 m_menuCol( 0 )
320 {}
321
322protected:
323 void showPopupMenu( wxMenu& menu, wxGridEvent& aEvent ) override;
324 void doPopupSelection( wxCommandEvent& event ) override;
325
326protected:
330};
331
332
333void CURSORS_GRID_TRICKS::showPopupMenu( wxMenu& menu, wxGridEvent& aEvent )
334{
335 m_menuRow = aEvent.GetRow();
336 m_menuCol = aEvent.GetCol();
337
339 {
340 wxString msg = m_grid->GetColLabelValue( m_menuCol );
341
342 menu.Append( MYID_FORMAT_VALUE, wxString::Format( _( "Format %s..." ), msg ) );
343 menu.AppendSeparator();
344 }
345
346 GRID_TRICKS::showPopupMenu( menu, aEvent );
347}
348
349
350void CURSORS_GRID_TRICKS::doPopupSelection( wxCommandEvent& event )
351{
352 auto getSignalName =
353 [this]( int row ) -> wxString
354 {
355 wxString signal = m_grid->GetCellValue( row, COL_CURSOR_SIGNAL );
356
357 if( signal.EndsWith( "[2 - 1]" ) )
358 signal = signal.Left( signal.length() - 7 );
359
360 return signal;
361 };
362
363 if( event.GetId() == MYID_FORMAT_VALUE )
364 {
365 int axis = m_menuCol - COL_CURSOR_X;
367 DIALOG_SIM_FORMAT_VALUE formatDialog( m_parent, &format );
368
369 if( formatDialog.ShowModal() == wxID_OK )
370 {
371 for( int row = 0; row < m_grid->GetNumberRows(); ++row )
372 {
373 if( getSignalName( row ) == getSignalName( m_menuRow ) )
374 m_parent->SetCursorFormat( row, axis, format );
375 }
376 }
377 }
378 else
379 {
381 }
382}
383
384
386{
387public:
389 GRID_TRICKS( aGrid ),
390 m_parent( aParent ),
391 m_menuRow( 0 ),
392 m_menuCol( 0 )
393 {}
394
395protected:
396 void showPopupMenu( wxMenu& menu, wxGridEvent& aEvent ) override;
397 void doPopupSelection( wxCommandEvent& event ) override;
398
399protected:
403};
404
405
406void MEASUREMENTS_GRID_TRICKS::showPopupMenu( wxMenu& menu, wxGridEvent& aEvent )
407{
408 m_menuRow = aEvent.GetRow();
409 m_menuCol = aEvent.GetCol();
410
411 if( !( m_grid->IsInSelection( m_menuRow, m_menuCol ) ) )
412 m_grid->ClearSelection();
413
414 m_grid->SetGridCursor( m_menuRow, m_menuCol );
415
417 menu.Append( MYID_FORMAT_VALUE, _( "Format Value..." ) );
418
419 if( m_menuRow < ( m_grid->GetNumberRows() - 1 ) )
420 menu.Append( MYID_DELETE_MEASUREMENT, _( "Delete Measurement" ) );
421
422 menu.AppendSeparator();
423
424 GRID_TRICKS::showPopupMenu( menu, aEvent );
425}
426
427
429{
430 if( event.GetId() == MYID_FORMAT_VALUE )
431 {
433 DIALOG_SIM_FORMAT_VALUE formatDialog( m_parent, &format );
434
435 if( formatDialog.ShowModal() == wxID_OK )
436 {
440 }
441 }
442 else if( event.GetId() == MYID_DELETE_MEASUREMENT )
443 {
444 std::vector<int> measurements;
445
446 wxGridCellCoordsArray cells1 = m_grid->GetSelectionBlockTopLeft();
447 wxGridCellCoordsArray cells2 = m_grid->GetSelectionBlockBottomRight();
448
449 for( size_t i = 0; i < cells1.Count(); i++ )
450 {
451 if( cells1[i].GetCol() == COL_MEASUREMENT )
452 {
453 for( int j = cells1[i].GetRow(); j < cells2[i].GetRow() + 1; j++ )
454 measurements.push_back( j );
455 }
456 }
457
458 wxGridCellCoordsArray cells3 = m_grid->GetSelectedCells();
459
460 for( size_t i = 0; i < cells3.Count(); i++ )
461 {
462 if( cells3[i].GetCol() == COL_MEASUREMENT )
463 measurements.push_back( cells3[i].GetRow() );
464 }
465
466 if( measurements.size() < 1 )
467 measurements.push_back( m_menuRow );
468
469 // When deleting a row, we'll change the indexes.
470 // To avoid problems, we can start with the highest indexes.
471 sort( measurements.begin(), measurements.end(), std::greater<>() );
472
473 for( int row : measurements )
475
476 m_grid->ClearSelection();
477
479 }
480 else
481 {
483 }
484}
485
486
488{
489public:
491 m_frame( aFrame )
492 {
494 }
495
497 {
499 }
500
501private:
503};
504
505
506#define ID_SIM_REFRESH 10207
507#define REFRESH_INTERVAL 50 // 20 frames/second.
508
509
511 SCH_EDIT_FRAME* aSchematicFrame ) :
512 SIMULATOR_FRAME_UI_BASE( aSimulatorFrame ),
513 m_SuppressGridEvents( 0 ),
514 m_simulatorFrame( aSimulatorFrame ),
515 m_schematicFrame( aSchematicFrame ),
516 m_darkMode( true ),
517 m_plotNumber( 0 ),
518 m_refreshTimer( this, ID_SIM_REFRESH )
519{
520 // Get the previous size and position of windows:
522
523 m_filter->SetHint( _( "Filter" ) );
524
525 m_signalsGrid->wxGrid::SetLabelFont( KIUI::GetStatusFont( this ) );
526 m_cursorsGrid->wxGrid::SetLabelFont( KIUI::GetStatusFont( this ) );
527 m_measurementsGrid->wxGrid::SetLabelFont( KIUI::GetStatusFont( this ) );
528
529 m_signalsGrid->PushEventHandler( new SIGNALS_GRID_TRICKS( this, m_signalsGrid ) );
530 m_cursorsGrid->PushEventHandler( new CURSORS_GRID_TRICKS( this, m_cursorsGrid ) );
531 m_measurementsGrid->PushEventHandler( new MEASUREMENTS_GRID_TRICKS( this, m_measurementsGrid ) );
532
533 wxGridCellAttr* attr = new wxGridCellAttr;
534 attr->SetReadOnly();
535 m_signalsGrid->SetColAttr( COL_SIGNAL_NAME, attr );
536
537 attr = new wxGridCellAttr;
538 attr->SetReadOnly();
539 m_cursorsGrid->SetColAttr( COL_CURSOR_NAME, attr );
540
541 attr = new wxGridCellAttr;
542 attr->SetReadOnly();
543 m_cursorsGrid->SetColAttr( COL_CURSOR_SIGNAL, attr );
544
545 attr = new wxGridCellAttr;
546 attr->SetReadOnly();
547 m_cursorsGrid->SetColAttr( COL_CURSOR_Y, attr );
548
549 for( int cursorId = 0; cursorId < 3; ++cursorId )
550 {
551 m_cursorFormats[ cursorId ][ 0 ] = { 3, wxS( "~s" ) };
552 m_cursorFormats[ cursorId ][ 1 ] = { 3, wxS( "~V" ) };
553 }
554
555 attr = new wxGridCellAttr;
556 attr->SetReadOnly();
557 m_measurementsGrid->SetColAttr( COL_MEASUREMENT_VALUE, attr );
558
559 // Prepare the color list to plot traces
561
562 Bind( EVT_SIM_CURSOR_UPDATE, &SIMULATOR_FRAME_UI::onPlotCursorUpdate, this );
563
564 Bind( wxEVT_TIMER,
565 [&]( wxTimerEvent& aEvent )
566 {
567 OnSimRefresh( false );
568
569 if( m_simulatorFrame->GetSimulator()->IsRunning() )
570 m_refreshTimer.Start( REFRESH_INTERVAL, wxTIMER_ONE_SHOT );
571 },
572 m_refreshTimer.GetId() );
573
574#ifndef wxHAS_NATIVE_TABART
575 // Default non-native tab art has ugly gradients we don't want
576 m_plotNotebook->SetArtProvider( new wxAuiSimpleTabArt() );
577#endif
578}
579
580
582{
583 // Delete the GRID_TRICKS.
584 m_signalsGrid->PopEventHandler( true );
585 m_cursorsGrid->PopEventHandler( true );
586 m_measurementsGrid->PopEventHandler( true );
587}
588
589
591{
592 for( int ii = 0; ii < (int) m_plotNotebook->GetPageCount(); ++ii )
593 {
594 SIM_TAB* simTab = dynamic_cast<SIM_TAB*>( m_plotNotebook->GetPage( ii ) );
595
596 wxCHECK( simTab, /* void */ );
597
598 simTab->OnLanguageChanged();
599
600 wxString pageTitle( simulator()->TypeToName( simTab->GetSimType(), true ) );
601 pageTitle.Prepend( wxString::Format( _( "Analysis %u - " ), ii+1 /* 1-based */ ) );
602
603 m_plotNotebook->SetPageText( ii, pageTitle );
604 }
605
606 m_filter->SetHint( _( "Filter" ) );
607
608 m_signalsGrid->SetColLabelValue( COL_SIGNAL_NAME, _( "Signal" ) );
609 m_signalsGrid->SetColLabelValue( COL_SIGNAL_SHOW, _( "Plot" ) );
610 m_signalsGrid->SetColLabelValue( COL_SIGNAL_COLOR, _( "Color" ) );
611 m_signalsGrid->SetColLabelValue( COL_CURSOR_1, _( "Cursor 1" ) );
612 m_signalsGrid->SetColLabelValue( COL_CURSOR_2, _( "Cursor 2" ) );
613
614 m_cursorsGrid->SetColLabelValue( COL_CURSOR_NAME, _( "Cursor" ) );
615 m_cursorsGrid->SetColLabelValue( COL_CURSOR_SIGNAL, _( "Signal" ) );
616 m_cursorsGrid->SetColLabelValue( COL_CURSOR_X, _( "Time" ) );
617 m_cursorsGrid->SetColLabelValue( COL_CURSOR_Y, _( "Value" ) );
619
620 for( TUNER_SLIDER* tuner : m_tuners )
621 tuner->ShowChangedLanguage();
622}
623
624
626{
627 const EESCHEMA_SETTINGS::SIMULATOR& settings = aCfg->m_Simulator;
628
629 // Read subwindows sizes (should be > 0 )
635 m_darkMode = !settings.view.white_background;
636
637 m_preferences = settings.preferences;
638}
639
640
642{
644
645 settings.view.plot_panel_width = m_splitterLeftRight->GetSashPosition();
646 settings.view.plot_panel_height = m_splitterPlotAndConsole->GetSashPosition();
647 settings.view.signal_panel_height = m_splitterSignals->GetSashPosition();
648 settings.view.cursors_panel_height = m_splitterCursors->GetSashPosition();
649 settings.view.measurements_panel_height = m_splitterMeasurements->GetSashPosition();
650 settings.view.white_background = !m_darkMode;
651}
652
653
655{
656 m_preferences = aPrefs;
657
658 const std::size_t pageCount = m_plotNotebook->GetPageCount();
659 for( std::size_t i = 0; i < pageCount; ++i )
660 {
661 wxWindow* page = m_plotNotebook->GetPage( i );
662 auto simTab = dynamic_cast<SIM_TAB*>( page );
663 wxASSERT( simTab != nullptr );
664 simTab->ApplyPreferences( aPrefs );
665 }
666}
667
668
670{
671 if( !simulator()->Settings()->GetWorkbookFilename().IsEmpty() )
672 {
673 wxFileName filename = simulator()->Settings()->GetWorkbookFilename();
674 filename.SetPath( m_schematicFrame->Prj().GetProjectPath() );
675
676 if( !LoadWorkbook( filename.GetFullPath() ) )
677 simulator()->Settings()->SetWorkbookFilename( "" );
678 }
679 else if( m_simulatorFrame->LoadSimulator( wxEmptyString, 0 ) )
680 {
681 wxString schTextSimCommand = circuitModel()->GetSchTextSimCommand();
682
683 if( !schTextSimCommand.IsEmpty() )
684 {
685 SIM_TAB* simTab = NewSimTab( schTextSimCommand );
687 }
688
690 rebuildSignalsGrid( m_filter->GetValue() );
691 }
692}
693
694
696{
699
702
705
708
711}
712
713
714void sortSignals( std::vector<wxString>& signals )
715{
716 std::sort( signals.begin(), signals.end(),
717 []( const wxString& lhs, const wxString& rhs )
718 {
719 // Sort voltages first
720 if( lhs.Upper().StartsWith( 'V' ) && !rhs.Upper().StartsWith( 'V' ) )
721 return true;
722 else if( !lhs.Upper().StartsWith( 'V' ) && rhs.Upper().StartsWith( 'V' ) )
723 return false;
724
725 return StrNumCmp( lhs, rhs, true /* ignore case */ ) < 0;
726 } );
727}
728
729
731{
732 SUPPRESS_GRID_CELL_EVENTS raii( this );
733
735
736 SIM_PLOT_TAB* plotPanel = dynamic_cast<SIM_PLOT_TAB*>( GetCurrentSimTab() );
737
738 if( !plotPanel )
739 return;
740
741 SIM_TYPE simType = plotPanel->GetSimType();
742 std::vector<wxString> signals;
743
744 if( plotPanel->GetSimType() == ST_FFT )
745 {
746 wxStringTokenizer tokenizer( plotPanel->GetSimCommand(), wxT( " \t\r\n" ), wxTOKEN_STRTOK );
747
748 while( tokenizer.HasMoreTokens() && tokenizer.GetNextToken().Lower() != wxT( "fft" ) )
749 {};
750
751 while( tokenizer.HasMoreTokens() )
752 signals.emplace_back( tokenizer.GetNextToken() );
753 }
754 else
755 {
756 // NB: m_signals are already broken out into gain/phase, but m_userDefinedSignals are
757 // as the user typed them
758
759 for( const wxString& signal : m_signals )
760 signals.push_back( signal );
761
762 for( const auto& [ id, signal ] : m_userDefinedSignals )
763 {
764 if( simType == ST_AC )
765 {
766 signals.push_back( signal + _( " (gain)" ) );
767 signals.push_back( signal + _( " (phase)" ) );
768 }
769 else if( simType == ST_SP )
770 {
771 signals.push_back( signal + _( " (amplitude)" ) );
772 signals.push_back( signal + _( " (phase)" ) );
773 }
774 else
775 {
776 signals.push_back( signal );
777 }
778 }
779
780 sortSignals( signals );
781 }
782
783 if( aFilter.IsEmpty() )
784 aFilter = wxS( "*" );
785
786 EDA_COMBINED_MATCHER matcher( aFilter.Upper(), CTX_SIGNAL );
787 int row = 0;
788
789 for( const wxString& signal : signals )
790 {
791 if( matcher.Find( signal.Upper() ) )
792 {
793 int traceType = SPT_UNKNOWN;
794 wxString vectorName = vectorNameFromSignalName( plotPanel, signal, &traceType );
795 TRACE* trace = plotPanel->GetTrace( vectorName, traceType );
796
797 m_signalsGrid->AppendRows( 1 );
798 m_signalsGrid->SetCellValue( row, COL_SIGNAL_NAME, signal );
799
800 wxGridCellAttr* attr = new wxGridCellAttr;
801 attr->SetRenderer( new wxGridCellBoolRenderer() );
802 attr->SetReadOnly(); // not really; we delegate interactivity to GRID_TRICKS
803 attr->SetAlignment( wxALIGN_CENTER, wxALIGN_CENTER );
804 m_signalsGrid->SetAttr( row, COL_SIGNAL_SHOW, attr );
805
806 if( !trace )
807 {
808 attr = new wxGridCellAttr;
809 attr->SetReadOnly();
810 m_signalsGrid->SetAttr( row, COL_SIGNAL_COLOR, attr );
811 m_signalsGrid->SetCellValue( row, COL_SIGNAL_COLOR, wxEmptyString );
812
813 attr = new wxGridCellAttr;
814 attr->SetReadOnly();
815 m_signalsGrid->SetAttr( row, COL_CURSOR_1, attr );
816
817 attr = new wxGridCellAttr;
818 attr->SetReadOnly();
819 m_signalsGrid->SetAttr( row, COL_CURSOR_2, attr );
820 }
821 else
822 {
823 m_signalsGrid->SetCellValue( row, COL_SIGNAL_SHOW, wxS( "1" ) );
824
825 attr = new wxGridCellAttr;
826 attr->SetRenderer( new GRID_CELL_COLOR_RENDERER( this ) );
827 attr->SetEditor( new GRID_CELL_COLOR_SELECTOR( this, m_signalsGrid ) );
828 attr->SetAlignment( wxALIGN_CENTER, wxALIGN_CENTER );
829 m_signalsGrid->SetAttr( row, COL_SIGNAL_COLOR, attr );
830 KIGFX::COLOR4D color( trace->GetPen().GetColour() );
831 m_signalsGrid->SetCellValue( row, COL_SIGNAL_COLOR, color.ToCSSString() );
832
833 attr = new wxGridCellAttr;
834 attr->SetRenderer( new wxGridCellBoolRenderer() );
835 attr->SetReadOnly(); // not really; we delegate interactivity to GRID_TRICKS
836 attr->SetAlignment( wxALIGN_CENTER, wxALIGN_CENTER );
837 m_signalsGrid->SetAttr( row, COL_CURSOR_1, attr );
838
839 attr = new wxGridCellAttr;
840 attr->SetRenderer( new wxGridCellBoolRenderer() );
841 attr->SetReadOnly(); // not really; we delegate interactivity to GRID_TRICKS
842 attr->SetAlignment( wxALIGN_CENTER, wxALIGN_CENTER );
843 m_signalsGrid->SetAttr( row, COL_CURSOR_2, attr );
844 }
845
846 row++;
847 }
848 }
849}
850
851
853{
854 m_signals.clear();
855
856 int options = m_simulatorFrame->GetCurrentOptions();
858 wxString unconnected = wxString( wxS( "unconnected-(" ) );
859
860 if( simType == ST_UNKNOWN )
861 simType = ST_TRAN;
862
863 unconnected.Replace( '(', '_' ); // Convert to SPICE markup
864
865 auto addSignal =
866 [&]( const wxString& aSignalName )
867 {
868 if( simType == ST_AC )
869 {
870 m_signals.push_back( aSignalName + _( " (gain)" ) );
871 m_signals.push_back( aSignalName + _( " (phase)" ) );
872 }
873 else if( simType == ST_SP )
874 {
875 m_signals.push_back( aSignalName + _( " (amplitude)" ) );
876 m_signals.push_back( aSignalName + _( " (phase)" ) );
877 }
878 else
879 {
880 m_signals.push_back( aSignalName );
881 }
882 };
883
885 && ( simType == ST_TRAN || simType == ST_DC || simType == ST_AC || simType == ST_FFT) )
886 {
887 for( const wxString& net : circuitModel()->GetNets() )
888 {
889 // netnames are escaped (can contain "{slash}" for '/') Unscape them:
890 wxString netname = UnescapeString( net );
892
893 if( netname == "GND" || netname == "0" || netname.StartsWith( unconnected ) )
894 continue;
895
896 m_quotedNetnames[ netname ] = wxString::Format( wxS( "\"%s\"" ), netname );
897 addSignal( wxString::Format( wxS( "V(%s)" ), netname ) );
898 }
899 }
900
902 && ( simType == ST_TRAN || simType == ST_DC || simType == ST_AC ) )
903 {
904 for( const SPICE_ITEM& item : circuitModel()->GetItems() )
905 {
906 // Add all possible currents for the device.
907 for( const std::string& name : item.model->SpiceGenerator().CurrentNames( item ) )
908 addSignal( name );
909 }
910 }
911
913 && ( simType == ST_TRAN || simType == ST_DC ) )
914 {
915 for( const SPICE_ITEM& item : circuitModel()->GetItems() )
916 {
917 if( item.model->GetPinCount() >= 2 )
918 {
919 wxString name = item.model->SpiceGenerator().ItemName( item );
920 addSignal( wxString::Format( wxS( "P(%s)" ), name ) );
921 }
922 }
923 }
924
925 if( simType == ST_NOISE )
926 {
927 addSignal( wxS( "inoise_spectrum" ) );
928 addSignal( wxS( "onoise_spectrum" ) );
929 }
930
931 if( simType == ST_SP )
932 {
933 std::vector<std::string> portnums;
934
935 for( const SPICE_ITEM& item : circuitModel()->GetItems() )
936 {
937 wxString name = item.model->SpiceGenerator().ItemName( item );
938
939 // We are only looking for voltage sources in .SP mode
940 if( !name.StartsWith( "V" ) )
941 continue;
942
943 std::string portnum = "";
944
945 if( const SIM_MODEL::PARAM* portnum_param = item.model->FindParam( "portnum" ) )
946 portnum = SIM_VALUE::ToSpice( portnum_param->value );
947
948 if( portnum != "" )
949 portnums.push_back( portnum );
950 }
951
952 for( const std::string& portnum1 : portnums )
953 {
954 for( const std::string& portnum2 : portnums )
955 {
956 addSignal( wxString::Format( wxS( "S_%s_%s" ), portnum1, portnum2 ) );
957 }
958 }
959 }
960
961 // Add .SAVE and .PROBE directives
962 for( const wxString& directive : circuitModel()->GetDirectives() )
963 {
964 wxStringTokenizer directivesTokenizer( directive, wxT( "\r\n" ), wxTOKEN_STRTOK );
965
966 while( directivesTokenizer.HasMoreTokens() )
967 {
968 wxString line = directivesTokenizer.GetNextToken().Upper();
969 wxString directiveParams;
970
971 if( line.StartsWith( wxS( ".SAVE" ), &directiveParams )
972 || line.StartsWith( wxS( ".PROBE" ), &directiveParams ) )
973 {
974 wxStringTokenizer paramsTokenizer( directiveParams, wxT( " \t" ), wxTOKEN_STRTOK );
975
976 while( paramsTokenizer.HasMoreTokens() )
977 addSignal( paramsTokenizer.GetNextToken() );
978 }
979 }
980 }
981}
982
983
984SIM_TAB* SIMULATOR_FRAME_UI::NewSimTab( const wxString& aSimCommand )
985{
986 SIM_TAB* simTab = nullptr;
987 SIM_TYPE simType = SPICE_CIRCUIT_MODEL::CommandToSimType( aSimCommand );
988
989 if( SIM_TAB::IsPlottable( simType ) )
990 {
991 SIM_PLOT_TAB* panel = new SIM_PLOT_TAB( aSimCommand, m_plotNotebook );
992 simTab = panel;
994 }
995 else
996 {
997 simTab = new SIM_NOPLOT_TAB( aSimCommand, m_plotNotebook );
998 }
999
1000 wxString pageTitle( simulator()->TypeToName( simType, true ) );
1001 pageTitle.Prepend( wxString::Format( _( "Analysis %u - " ), (unsigned int) ++m_plotNumber ) );
1002
1003 m_plotNotebook->AddPage( simTab, pageTitle, true );
1004
1005 return simTab;
1006}
1007
1008
1009void SIMULATOR_FRAME_UI::OnFilterText( wxCommandEvent& aEvent )
1010{
1011 rebuildSignalsGrid( m_filter->GetValue() );
1012}
1013
1014
1015void SIMULATOR_FRAME_UI::OnFilterMouseMoved( wxMouseEvent& aEvent )
1016{
1017 wxPoint pos = aEvent.GetPosition();
1018 wxRect ctrlRect = m_filter->GetScreenRect();
1019 int buttonWidth = ctrlRect.GetHeight(); // Presume buttons are square
1020
1021 if( m_filter->IsSearchButtonVisible() && pos.x < buttonWidth )
1022 SetCursor( wxCURSOR_ARROW );
1023 else if( m_filter->IsCancelButtonVisible() && pos.x > ctrlRect.GetWidth() - buttonWidth )
1024 SetCursor( wxCURSOR_ARROW );
1025 else
1026 SetCursor( wxCURSOR_IBEAM );
1027}
1028
1029
1030wxString vectorNameFromSignalId( int aUserDefinedSignalId )
1031{
1032 return wxString::Format( wxS( "user%d" ), aUserDefinedSignalId );
1033}
1034
1035
1041 const wxString& aSignalName,
1042 int* aTraceType )
1043{
1044 std::map<wxString, int> suffixes;
1045 suffixes[ _( " (amplitude)" ) ] = SPT_SP_AMP;
1046 suffixes[ _( " (gain)" ) ] = SPT_AC_GAIN;
1047 suffixes[ _( " (phase)" ) ] = SPT_AC_PHASE;
1048
1049 if( aTraceType )
1050 {
1051 if( aPlotTab && aPlotTab->GetSimType() == ST_NOISE )
1052 {
1053 if( getNoiseSource().Upper().StartsWith( 'I' ) )
1054 *aTraceType = SPT_CURRENT;
1055 else
1056 *aTraceType = SPT_VOLTAGE;
1057 }
1058 else
1059 {
1060 wxUniChar firstChar = aSignalName.Upper()[0];
1061
1062 if( firstChar == 'V' )
1063 *aTraceType = SPT_VOLTAGE;
1064 else if( firstChar == 'I' )
1065 *aTraceType = SPT_CURRENT;
1066 else if( firstChar == 'P' )
1067 *aTraceType = SPT_POWER;
1068 }
1069 }
1070
1071 wxString suffix;
1072 wxString name = aSignalName;
1073
1074 for( const auto& [ candidate, type ] : suffixes )
1075 {
1076 if( name.EndsWith( candidate ) )
1077 {
1078 name = name.Left( name.Length() - candidate.Length() );
1079
1080 if( aTraceType )
1081 *aTraceType |= type;
1082
1083 break;
1084 }
1085 }
1086
1087 for( const auto& [ id, signal ] : m_userDefinedSignals )
1088 {
1089 if( name == signal )
1090 return vectorNameFromSignalId( id );
1091 }
1092
1093 return name;
1094};
1095
1096
1098{
1099 if( m_SuppressGridEvents > 0 )
1100 return;
1101
1102 SIM_PLOT_TAB* plotTab = dynamic_cast<SIM_PLOT_TAB*>( GetCurrentSimTab() );
1103
1104 if( !plotTab )
1105 return;
1106
1107 int row = aEvent.GetRow();
1108 int col = aEvent.GetCol();
1109 wxString text = m_signalsGrid->GetCellValue( row, col );
1110 wxString signalName = m_signalsGrid->GetCellValue( row, COL_SIGNAL_NAME );
1111 int traceType = SPT_UNKNOWN;
1112 wxString vectorName = vectorNameFromSignalName( plotTab, signalName, &traceType );
1113
1114 if( col == COL_SIGNAL_SHOW )
1115 {
1116 if( text == wxS( "1" ) )
1117 updateTrace( vectorName, traceType, plotTab );
1118 else
1119 plotTab->DeleteTrace( vectorName, traceType );
1120
1121 plotTab->GetPlotWin()->UpdateAll();
1122
1123 // Update enabled/visible states of other controls
1126 OnModify();
1127 }
1128 else if( col == COL_SIGNAL_COLOR )
1129 {
1130 KIGFX::COLOR4D color( m_signalsGrid->GetCellValue( row, COL_SIGNAL_COLOR ) );
1131 TRACE* trace = plotTab->GetTrace( vectorName, traceType );
1132
1133 if( trace )
1134 {
1135 trace->SetTraceColour( color.ToColour() );
1136 plotTab->UpdateTraceStyle( trace );
1137 plotTab->UpdatePlotColors();
1138 OnModify();
1139 }
1140 }
1141 else if( col == COL_CURSOR_1 || col == COL_CURSOR_2 )
1142 {
1143 for( int ii = 0; ii < m_signalsGrid->GetNumberRows(); ++ii )
1144 {
1145 signalName = m_signalsGrid->GetCellValue( ii, COL_SIGNAL_NAME );
1146 vectorName = vectorNameFromSignalName( plotTab, signalName, &traceType );
1147
1148 int id = col == COL_CURSOR_1 ? 1 : 2;
1149 bool enable = ii == row && text == wxS( "1" );
1150
1151 plotTab->EnableCursor( vectorName, traceType, id, enable, signalName );
1152 OnModify();
1153 }
1154
1155 // Update cursor checkboxes (which are really radio buttons)
1157 }
1158}
1159
1160
1162{
1163 if( m_SuppressGridEvents > 0 )
1164 return;
1165
1166 SIM_PLOT_TAB* plotTab = dynamic_cast<SIM_PLOT_TAB*>( GetCurrentSimTab() );
1167
1168 if( !plotTab )
1169 return;
1170
1171 int row = aEvent.GetRow();
1172 int col = aEvent.GetCol();
1173 wxString text = m_cursorsGrid->GetCellValue( row, col );
1174 wxString cursorName = m_cursorsGrid->GetCellValue( row, COL_CURSOR_NAME );
1175
1176 if( col == COL_CURSOR_X )
1177 {
1178 CURSOR* cursor1 = nullptr;
1179 CURSOR* cursor2 = nullptr;
1180
1181 for( const auto& [name, trace] : plotTab->GetTraces() )
1182 {
1183 if( CURSOR* cursor = trace->GetCursor( 1 ) )
1184 cursor1 = cursor;
1185
1186 if( CURSOR* cursor = trace->GetCursor( 2 ) )
1187 cursor2 = cursor;
1188 }
1189
1190 double value = SPICE_VALUE( text ).ToDouble();
1191
1192 if( cursorName == wxS( "1" ) && cursor1 )
1193 cursor1->SetCoordX( value );
1194 else if( cursorName == wxS( "2" ) && cursor2 )
1195 cursor2->SetCoordX( value );
1196 else if( cursorName == _( "Diff" ) && cursor1 && cursor2 )
1197 cursor2->SetCoordX( cursor1->GetCoords().x + value );
1198
1200 OnModify();
1201 }
1202 else
1203 {
1204 wxFAIL_MSG( wxT( "All other columns are supposed to be read-only!" ) );
1205 }
1206}
1207
1208
1210{
1211 SPICE_VALUE_FORMAT result;
1212 result.FromString( m_measurementsGrid->GetCellValue( aRow, COL_MEASUREMENT_FORMAT ) );
1213 return result;
1214}
1215
1216
1218{
1219 m_measurementsGrid->SetCellValue( aRow, COL_MEASUREMENT_FORMAT, aFormat.ToString() );
1220}
1221
1222
1224{
1225 if( aRow < ( m_measurementsGrid->GetNumberRows() - 1 ) )
1226 m_measurementsGrid->DeleteRows( aRow, 1 );
1227}
1228
1229
1231{
1232 SIM_PLOT_TAB* plotTab = dynamic_cast<SIM_PLOT_TAB*>( GetCurrentSimTab() );
1233
1234 if( !plotTab )
1235 return;
1236
1237 int row = aEvent.GetRow();
1238 int col = aEvent.GetCol();
1239 wxString text = m_measurementsGrid->GetCellValue( row, col );
1240
1241 if( col == COL_MEASUREMENT )
1242 {
1243 UpdateMeasurement( row );
1245 OnModify();
1246 }
1247 else
1248 {
1249 wxFAIL_MSG( wxT( "All other columns are supposed to be read-only!" ) );
1250 }
1251
1252 // Always leave a single empty row for type-in
1253
1254 int rowCount = (int) m_measurementsGrid->GetNumberRows();
1255 int emptyRows = 0;
1256
1257 for( row = rowCount - 1; row >= 0; row-- )
1258 {
1259 if( m_measurementsGrid->GetCellValue( row, COL_MEASUREMENT ).IsEmpty() )
1260 emptyRows++;
1261 else
1262 break;
1263 }
1264
1265 if( emptyRows > 1 )
1266 {
1267 int killRows = emptyRows - 1;
1268 m_measurementsGrid->DeleteRows( rowCount - killRows, killRows );
1269 }
1270 else if( emptyRows == 0 )
1271 {
1272 m_measurementsGrid->AppendRows( 1 );
1273 }
1274}
1275
1276
1277void SIMULATOR_FRAME_UI::OnUpdateUI( wxUpdateUIEvent& event )
1278{
1279 if( SIM_PLOT_TAB* plotTab = dynamic_cast<SIM_PLOT_TAB*>( GetCurrentSimTab() ) )
1280 {
1281 if( plotTab->GetLegendPosition() != plotTab->m_LastLegendPosition )
1282 {
1283 plotTab->m_LastLegendPosition = plotTab->GetLegendPosition();
1284 OnModify();
1285 }
1286 }
1287}
1288
1289
1305{
1306 static wxRegEx measureParamsRegEx( wxT( "^"
1307 " *"
1308 "([a-zA-Z_]+)"
1309 " +"
1310 "([a-zA-Z]*)\\(([^\\)]+)\\)" ) );
1311
1312 SIM_PLOT_TAB* plotTab = dynamic_cast<SIM_PLOT_TAB*>( GetCurrentSimTab() );
1313
1314 if( !plotTab )
1315 return;
1316
1317 wxString text = m_measurementsGrid->GetCellValue( aRow, COL_MEASUREMENT );
1318
1319 if( text.IsEmpty() )
1320 {
1321 m_measurementsGrid->SetCellValue( aRow, COL_MEASUREMENT_VALUE, wxEmptyString );
1322 return;
1323 }
1324
1325 wxString simType = simulator()->TypeToName( plotTab->GetSimType(), true );
1326 wxString resultName = wxString::Format( wxS( "meas_result_%u" ), aRow );
1327 wxString result = wxS( "?" );
1328
1329 if( measureParamsRegEx.Matches( text ) )
1330 {
1331 wxString func = measureParamsRegEx.GetMatch( text, 1 ).Upper();
1332 wxString signalType = measureParamsRegEx.GetMatch( text, 2 ).Upper();
1333 wxString deviceName = measureParamsRegEx.GetMatch( text, 3 );
1334 wxString units;
1336
1337 if( signalType.EndsWith( wxS( "DB" ) ) )
1338 {
1339 units = wxS( "dB" );
1340 }
1341 else if( signalType.StartsWith( 'I' ) )
1342 {
1343 units = wxS( "A" );
1344 }
1345 else if( signalType.StartsWith( 'P' ) )
1346 {
1347 units = wxS( "W" );
1348 // Our syntax is different from ngspice for power signals
1349 text = func + " " + deviceName + ":power";
1350 }
1351 else
1352 {
1353 units = wxS( "V" );
1354 }
1355
1356 if( func.EndsWith( wxS( "_AT" ) ) )
1357 {
1358 if( plotTab->GetSimType() == ST_AC || plotTab->GetSimType() == ST_SP )
1359 units = wxS( "Hz" );
1360 else
1361 units = wxS( "s" );
1362 }
1363 else if( func.StartsWith( wxS( "INTEG" ) ) )
1364 {
1365 switch( plotTab->GetSimType() )
1366 {
1367 case ST_TRAN:
1368 if ( signalType.StartsWith( 'P' ) )
1369 units = wxS( "J" );
1370 else
1371 units += wxS( ".s" );
1372
1373 break;
1374
1375 case ST_AC:
1376 case ST_SP:
1377 case ST_DISTO:
1378 case ST_NOISE:
1379 case ST_FFT:
1380 case ST_SENS: // If there is a vector, it is frequency
1381 units += wxS( "·Hz" );
1382 break;
1383
1384 case ST_DC: // Could be a lot of things : V, A, deg C, ohm, ...
1385 case ST_OP: // There is no vector for integration
1386 case ST_PZ: // There is no vector for integration
1387 case ST_TF: // There is no vector for integration
1388 default:
1389 units += wxS( "·?" );
1390 break;
1391 }
1392 }
1393
1394 fmt.UpdateUnits( units );
1395 SetMeasureFormat( aRow, fmt );
1396
1398 }
1399
1401 {
1402 wxString cmd = wxString::Format( wxS( "meas %s %s %s" ), simType, resultName, text );
1403 simulator()->Command( "echo " + cmd.ToStdString() );
1404 simulator()->Command( cmd.ToStdString() );
1405
1406 std::vector<double> resultVec = simulator()->GetGainVector( resultName.ToStdString() );
1407
1408 if( resultVec.size() > 0 )
1409 result = SPICE_VALUE( resultVec[0] ).ToString( GetMeasureFormat( aRow ) );
1410 }
1411
1412 m_measurementsGrid->SetCellValue( aRow, COL_MEASUREMENT_VALUE, result );
1413}
1414
1415
1416void SIMULATOR_FRAME_UI::AddTuner( const SCH_SHEET_PATH& aSheetPath, SCH_SYMBOL* aSymbol )
1417{
1418 SIM_PLOT_TAB* plotTab = dynamic_cast<SIM_PLOT_TAB*>( GetCurrentSimTab() );
1419
1420 if( !plotTab )
1421 return;
1422
1423 wxString ref = aSymbol->GetRef( &aSheetPath );
1424
1425 // Do not add multiple instances for the same component.
1426 for( TUNER_SLIDER* tuner : m_tuners )
1427 {
1428 if( tuner->GetSymbolRef() == ref )
1429 return;
1430 }
1431
1432 const SPICE_ITEM* item = GetExporter()->FindItem( ref );
1433
1434 // Do nothing if the symbol is not tunable.
1435 if( !item || !item->model->GetTunerParam() )
1436 return;
1437
1438 try
1439 {
1440 TUNER_SLIDER* tuner = new TUNER_SLIDER( this, m_panelTuners, aSheetPath, aSymbol );
1441 m_sizerTuners->Add( tuner );
1442 m_tuners.push_back( tuner );
1443 m_panelTuners->Layout();
1444 OnModify();
1445 }
1446 catch( const KI_PARAM_ERROR& e )
1447 {
1448 DisplayErrorMessage( nullptr, e.What() );
1449 }
1450}
1451
1452
1453void SIMULATOR_FRAME_UI::UpdateTunerValue( const SCH_SHEET_PATH& aSheetPath, const KIID& aSymbol,
1454 const wxString& aRef, const wxString& aValue )
1455{
1456 SCH_ITEM* item = aSheetPath.GetItem( aSymbol );
1457 SCH_SYMBOL* symbol = dynamic_cast<SCH_SYMBOL*>( item );
1458
1459 if( !symbol )
1460 {
1461 DisplayErrorMessage( this, _( "Could not apply tuned value(s):" ) + wxS( " " )
1462 + wxString::Format( _( "%s not found" ), aRef ) );
1463 return;
1464 }
1465
1466 NULL_REPORTER devnull;
1467 SIM_LIB_MGR mgr( &m_schematicFrame->Prj() );
1468 SIM_MODEL& model = mgr.CreateModel( &aSheetPath, *symbol, devnull ).model;
1469
1470 const SIM_MODEL::PARAM* tunerParam = model.GetTunerParam();
1471
1472 if( !tunerParam )
1473 {
1474 DisplayErrorMessage( this, _( "Could not apply tuned value(s):" ) + wxS( " " )
1475 + wxString::Format( _( "%s is not tunable" ), aRef ) );
1476 return;
1477 }
1478
1479 model.SetParamValue( tunerParam->info.name, std::string( aValue.ToUTF8() ) );
1480 model.WriteFields( symbol->GetFields() );
1481
1482 m_schematicFrame->UpdateItem( symbol, false, true );
1484}
1485
1486
1488{
1489 m_tuners.remove( aTuner );
1490 aTuner->Destroy();
1491 m_panelTuners->Layout();
1492 OnModify();
1493}
1494
1495
1496void SIMULATOR_FRAME_UI::AddMeasurement( const wxString& aCmd )
1497{
1498 // -1 because the last one is for user input
1499 for( int i = 0; i < m_measurementsGrid->GetNumberRows(); i++ )
1500 {
1501 if ( m_measurementsGrid->GetCellValue( i, COL_MEASUREMENT ) == aCmd )
1502 return; // Don't create duplicates
1503 }
1504
1505 SIM_PLOT_TAB* plotTab = dynamic_cast<SIM_PLOT_TAB*>( GetCurrentSimTab() );
1506
1507 if( !plotTab )
1508 return;
1509
1510 wxString simType = simulator()->TypeToName( plotTab->GetSimType(), true );
1511 int row;
1512
1513 for( row = 0; row < m_measurementsGrid->GetNumberRows(); ++row )
1514 {
1515 if( m_measurementsGrid->GetCellValue( row, COL_MEASUREMENT ).IsEmpty() )
1516 break;
1517 }
1518
1519 if( !m_measurementsGrid->GetCellValue( row, COL_MEASUREMENT ).IsEmpty() )
1520 {
1521 m_measurementsGrid->AppendRows( 1 );
1522 row = m_measurementsGrid->GetNumberRows() - 1;
1523 }
1524
1525 m_measurementsGrid->SetCellValue( row, COL_MEASUREMENT, aCmd );
1526
1527 UpdateMeasurement( row );
1529 OnModify();
1530
1531 // Always leave at least one empty row for type-in:
1532 row = m_measurementsGrid->GetNumberRows() - 1;
1533
1534 if( !m_measurementsGrid->GetCellValue( row, COL_MEASUREMENT ).IsEmpty() )
1535 m_measurementsGrid->AppendRows( 1 );
1536}
1537
1538
1539void SIMULATOR_FRAME_UI::DoFourier( const wxString& aSignal, const wxString& aFundamental )
1540{
1541 wxString cmd = wxString::Format( wxS( "fourier %s %s" ),
1542 SPICE_VALUE( aFundamental ).ToSpiceString(),
1543 aSignal );
1544
1545 simulator()->Command( cmd.ToStdString() );
1546}
1547
1548
1550{
1551 return circuitModel().get();
1552}
1553
1554
1555void SIMULATOR_FRAME_UI::AddTrace( const wxString& aName, SIM_TRACE_TYPE aType )
1556{
1557 if( !GetCurrentSimTab() )
1558 {
1559 m_simConsole->AppendText( _( "Error: no current simulation.\n" ) );
1560 m_simConsole->SetInsertionPointEnd();
1561 return;
1562 }
1563
1564 SIM_TYPE simType = SPICE_CIRCUIT_MODEL::CommandToSimType( GetCurrentSimTab()->GetSimCommand() );
1565
1566 if( simType == ST_UNKNOWN )
1567 {
1568 m_simConsole->AppendText( _( "Error: simulation type not defined.\n" ) );
1569 m_simConsole->SetInsertionPointEnd();
1570 return;
1571 }
1572 else if( !SIM_TAB::IsPlottable( simType ) )
1573 {
1574 m_simConsole->AppendText( _( "Error: simulation type doesn't support plotting.\n" ) );
1575 m_simConsole->SetInsertionPointEnd();
1576 return;
1577 }
1578
1579 SIM_PLOT_TAB* plotTab = dynamic_cast<SIM_PLOT_TAB*>( GetCurrentSimTab() );
1580 wxCHECK( plotTab, /* void */ );
1581
1582 if( simType == ST_AC )
1583 {
1584 updateTrace( aName, aType | SPT_AC_GAIN, plotTab );
1585 updateTrace( aName, aType | SPT_AC_PHASE, plotTab );
1586 }
1587 else if( simType == ST_SP )
1588 {
1589 updateTrace( aName, aType | SPT_AC_GAIN, plotTab );
1590 updateTrace( aName, aType | SPT_AC_PHASE, plotTab );
1591 }
1592 else
1593 {
1594 updateTrace( aName, aType, plotTab );
1595 }
1596
1597 plotTab->GetPlotWin()->UpdateAll();
1598
1600 OnModify();
1601}
1602
1603
1604void SIMULATOR_FRAME_UI::SetUserDefinedSignals( const std::map<int, wxString>& aNewSignals )
1605{
1606 for( size_t ii = 0; ii < m_plotNotebook->GetPageCount(); ++ii )
1607 {
1608 SIM_PLOT_TAB* plotTab = dynamic_cast<SIM_PLOT_TAB*>( m_plotNotebook->GetPage( ii ) );
1609
1610 if( !plotTab )
1611 continue;
1612
1613 for( const auto& [ id, existingSignal ] : m_userDefinedSignals )
1614 {
1615 int traceType = SPT_UNKNOWN;
1616 wxString vectorName = vectorNameFromSignalName( plotTab, existingSignal, &traceType );
1617
1618 if( aNewSignals.count( id ) == 0 )
1619 {
1620 if( plotTab->GetSimType() == ST_AC )
1621 {
1622 for( int subType : { SPT_AC_GAIN, SPT_AC_PHASE } )
1623 plotTab->DeleteTrace( vectorName, traceType | subType );
1624 }
1625 else if( plotTab->GetSimType() == ST_SP )
1626 {
1627 for( int subType : { SPT_SP_AMP, SPT_AC_PHASE } )
1628 plotTab->DeleteTrace( vectorName, traceType | subType );
1629 }
1630 else
1631 {
1632 plotTab->DeleteTrace( vectorName, traceType );
1633 }
1634 }
1635 else
1636 {
1637 if( plotTab->GetSimType() == ST_AC )
1638 {
1639 for( int subType : { SPT_AC_GAIN, SPT_AC_PHASE } )
1640 {
1641 if( TRACE* trace = plotTab->GetTrace( vectorName, traceType | subType ) )
1642 trace->SetName( aNewSignals.at( id ) );
1643 }
1644 }
1645 else if( plotTab->GetSimType() == ST_SP )
1646 {
1647 for( int subType : { SPT_SP_AMP, SPT_AC_PHASE } )
1648 {
1649 if( TRACE* trace = plotTab->GetTrace( vectorName, traceType | subType ) )
1650 trace->SetName( aNewSignals.at( id ) );
1651 }
1652 }
1653 else
1654 {
1655 if( TRACE* trace = plotTab->GetTrace( vectorName, traceType ) )
1656 trace->SetName( aNewSignals.at( id ) );
1657 }
1658 }
1659 }
1660 }
1661
1662 m_userDefinedSignals = aNewSignals;
1663
1666
1668 rebuildSignalsGrid( m_filter->GetValue() );
1671 OnModify();
1672}
1673
1674
1675void SIMULATOR_FRAME_UI::updateTrace( const wxString& aVectorName, int aTraceType,
1676 SIM_PLOT_TAB* aPlotTab, std::vector<double>* aDataX,
1677 bool aClearData )
1678{
1680
1681 aTraceType &= aTraceType & SPT_Y_AXIS_MASK;
1682 aTraceType |= getXAxisType( simType );
1683
1684 wxString simVectorName = aVectorName;
1685
1686 if( aTraceType & SPT_POWER )
1687 simVectorName = simVectorName.AfterFirst( '(' ).BeforeLast( ')' ) + wxS( ":power" );
1688
1689 if( !SIM_TAB::IsPlottable( simType ) )
1690 {
1691 // There is no plot to be shown
1692 simulator()->Command( wxString::Format( wxT( "print %s" ), aVectorName ).ToStdString() );
1693
1694 return;
1695 }
1696
1697 std::vector<double> data_x;
1698 std::vector<double> data_y;
1699
1700 if( !aDataX || aClearData )
1701 aDataX = &data_x;
1702
1703 // First, handle the x axis
1704 if( aDataX->empty() && !aClearData )
1705 {
1706 wxString xAxisName( simulator()->GetXAxis( simType ) );
1707
1708 if( xAxisName.IsEmpty() )
1709 return;
1710
1711 *aDataX = simulator()->GetGainVector( (const char*) xAxisName.c_str() );
1712 }
1713
1714 unsigned int size = aDataX->size();
1715
1716 switch( simType )
1717 {
1718 case ST_AC:
1719 if( aTraceType & SPT_AC_GAIN )
1720 data_y = simulator()->GetGainVector( (const char*) simVectorName.c_str(), size );
1721 else if( aTraceType & SPT_AC_PHASE )
1722 data_y = simulator()->GetPhaseVector( (const char*) simVectorName.c_str(), size );
1723 else
1724 wxFAIL_MSG( wxT( "Plot type missing AC_PHASE or AC_MAG bit" ) );
1725
1726 break;
1727 case ST_SP:
1728 if( aTraceType & SPT_SP_AMP )
1729 data_y = simulator()->GetGainVector( (const char*) simVectorName.c_str(), size );
1730 else if( aTraceType & SPT_AC_PHASE )
1731 data_y = simulator()->GetPhaseVector( (const char*) simVectorName.c_str(), size );
1732 else
1733 wxFAIL_MSG( wxT( "Plot type missing AC_PHASE or SPT_SP_AMP bit" ) );
1734
1735 break;
1736
1737 case ST_DC:
1738 data_y = simulator()->GetGainVector( (const char*) simVectorName.c_str(), -1 );
1739 break;
1740
1741 case ST_NOISE:
1742 case ST_TRAN:
1743 case ST_FFT:
1744 data_y = simulator()->GetGainVector( (const char*) simVectorName.c_str(), size );
1745 break;
1746
1747 default:
1748 wxFAIL_MSG( wxT( "Unhandled plot type" ) );
1749 }
1750
1751 SPICE_DC_PARAMS source1, source2;
1752 int sweepCount = 1;
1753 size_t sweepSize = std::numeric_limits<size_t>::max();
1754
1755 if( simType == ST_DC
1756 && circuitModel()->ParseDCCommand( aPlotTab->GetSimCommand(), &source1, &source2 )
1757 && !source2.m_source.IsEmpty() )
1758 {
1759 SPICE_VALUE v = ( source2.m_vend - source2.m_vstart ) / source2.m_vincrement;
1760
1761 sweepCount = KiROUND( v.ToDouble() ) + 1;
1762 sweepSize = aDataX->size() / sweepCount;
1763 }
1764
1765 if( TRACE* trace = aPlotTab->GetOrAddTrace( aVectorName, aTraceType ) )
1766 {
1767 if( data_y.size() >= size )
1768 aPlotTab->SetTraceData( trace, *aDataX, data_y, sweepCount, sweepSize );
1769 }
1770}
1771
1772
1774{
1775 SIM_PLOT_TAB* plotTab = dynamic_cast<SIM_PLOT_TAB*>( GetCurrentSimTab() );
1776
1777 for( int row = 0; row < m_signalsGrid->GetNumberRows(); ++row )
1778 {
1779 wxString signalName = m_signalsGrid->GetCellValue( row, COL_SIGNAL_NAME );
1780 int traceType = SPT_UNKNOWN;
1781 wxString vectorName = vectorNameFromSignalName( plotTab, signalName, &traceType );
1782
1783 if( TRACE* trace = plotTab ? plotTab->GetTrace( vectorName, traceType ) : nullptr )
1784 {
1785 m_signalsGrid->SetCellValue( row, COL_SIGNAL_SHOW, wxS( "1" ) );
1786
1787 wxGridCellAttr* attr = new wxGridCellAttr;
1788 attr->SetRenderer( new GRID_CELL_COLOR_RENDERER( this ) );
1789 attr->SetEditor( new GRID_CELL_COLOR_SELECTOR( this, m_signalsGrid ) );
1790 attr->SetAlignment( wxALIGN_CENTER, wxALIGN_CENTER );
1791 m_signalsGrid->SetAttr( row, COL_SIGNAL_COLOR, attr );
1792
1793 KIGFX::COLOR4D color( trace->GetPen().GetColour() );
1794 m_signalsGrid->SetCellValue( row, COL_SIGNAL_COLOR, color.ToCSSString() );
1795
1796 attr = new wxGridCellAttr;
1797 attr->SetRenderer( new wxGridCellBoolRenderer() );
1798 attr->SetReadOnly(); // not really; we delegate interactivity to GRID_TRICKS
1799 attr->SetAlignment( wxALIGN_CENTER, wxALIGN_CENTER );
1800 m_signalsGrid->SetAttr( row, COL_CURSOR_1, attr );
1801
1802 attr = new wxGridCellAttr;
1803 attr->SetRenderer( new wxGridCellBoolRenderer() );
1804 attr->SetReadOnly(); // not really; we delegate interactivity to GRID_TRICKS
1805 attr->SetAlignment( wxALIGN_CENTER, wxALIGN_CENTER );
1806 m_signalsGrid->SetAttr( row, COL_CURSOR_2, attr );
1807
1808 if( trace->HasCursor( 1 ) )
1809 m_signalsGrid->SetCellValue( row, COL_CURSOR_1, wxS( "1" ) );
1810 else
1811 m_signalsGrid->SetCellValue( row, COL_CURSOR_1, wxEmptyString );
1812
1813 if( trace->HasCursor( 2 ) )
1814 m_signalsGrid->SetCellValue( row, COL_CURSOR_2, wxS( "1" ) );
1815 else
1816 m_signalsGrid->SetCellValue( row, COL_CURSOR_2, wxEmptyString );
1817 }
1818 else
1819 {
1820 m_signalsGrid->SetCellValue( row, COL_SIGNAL_SHOW, wxEmptyString );
1821
1822 wxGridCellAttr* attr = new wxGridCellAttr;
1823 attr->SetReadOnly();
1824 m_signalsGrid->SetAttr( row, COL_SIGNAL_COLOR, attr );
1825 m_signalsGrid->SetCellValue( row, COL_SIGNAL_COLOR, wxEmptyString );
1826
1827 attr = new wxGridCellAttr;
1828 attr->SetReadOnly();
1829 m_signalsGrid->SetAttr( row, COL_CURSOR_1, attr );
1830 m_signalsGrid->SetCellValue( row, COL_CURSOR_1, wxEmptyString );
1831
1832 attr = new wxGridCellAttr;
1833 attr->SetReadOnly();
1834 m_signalsGrid->SetAttr( row, COL_CURSOR_2, attr );
1835 m_signalsGrid->SetCellValue( row, COL_CURSOR_2, wxEmptyString );
1836 }
1837 }
1838}
1839
1840
1842{
1843 auto quoteNetNames =
1844 [&]( wxString aExpression ) -> wxString
1845 {
1846 for( const auto& [netname, quotedNetname] : m_quotedNetnames )
1847 aExpression.Replace( netname, quotedNetname );
1848
1849 return aExpression;
1850 };
1851
1852 for( const auto& [ id, signal ] : m_userDefinedSignals )
1853 {
1854 constexpr const char* cmd = "let user{} = {}";
1855
1856 simulator()->Command( "echo " + fmt::format( cmd, id, signal.ToStdString() ) );
1857 simulator()->Command( fmt::format( cmd, id, quoteNetNames( signal ).ToStdString() ) );
1858 }
1859}
1860
1861
1863{
1864 wxString errors;
1865 WX_STRING_REPORTER reporter( &errors );
1866
1867 for( const TUNER_SLIDER* tuner : m_tuners )
1868 {
1869 SCH_SHEET_PATH sheetPath;
1870 wxString ref = tuner->GetSymbolRef();
1871 KIID symbolId = tuner->GetSymbol( &sheetPath );
1872 SCH_ITEM* schItem = sheetPath.GetItem( symbolId );
1873 SCH_SYMBOL* symbol = dynamic_cast<SCH_SYMBOL*>( schItem );
1874
1875 if( !symbol )
1876 {
1877 reporter.Report( wxString::Format( _( "%s not found" ), ref ) );
1878 continue;
1879 }
1880
1881 const SPICE_ITEM* item = GetExporter()->FindItem( tuner->GetSymbolRef() );
1882
1883 if( !item || !item->model->GetTunerParam() )
1884 {
1885 reporter.Report( wxString::Format( _( "%s is not tunable" ), ref ) );
1886 continue;
1887 }
1888
1889 double floatVal = tuner->GetValue().ToDouble();
1890
1891 simulator()->Command( item->model->SpiceGenerator().TunerCommand( *item, floatVal ) );
1892 }
1893
1894 if( reporter.HasMessage() )
1895 DisplayErrorMessage( this, _( "Could not apply tuned value(s):" ) + wxS( "\n" ) + errors );
1896}
1897
1898
1899bool SIMULATOR_FRAME_UI::LoadWorkbook( const wxString& aPath )
1900{
1901 wxTextFile file( aPath );
1902
1903 if( !file.Open() )
1904 return false;
1905
1906 wxString firstLine = file.GetFirstLine();
1907 long dummy;
1908 bool legacy = firstLine.StartsWith( wxT( "version " ) ) || firstLine.ToLong( &dummy );
1909
1910 file.Close();
1911
1912 m_plotNotebook->DeleteAllPages();
1913 m_userDefinedSignals.clear();
1914
1915 if( legacy )
1916 {
1917 if( !loadLegacyWorkbook( aPath ) )
1918 return false;
1919 }
1920 else
1921 {
1922 if( !loadJsonWorkbook( aPath ) )
1923 return false;
1924 }
1925
1927
1928 rebuildSignalsGrid( m_filter->GetValue() );
1932
1933 wxFileName filename( aPath );
1934 filename.MakeRelativeTo( m_schematicFrame->Prj().GetProjectPath() );
1935
1936 // Remember the loaded workbook filename.
1937 simulator()->Settings()->SetWorkbookFilename( filename.GetFullPath() );
1938
1939 return true;
1940}
1941
1942
1943bool SIMULATOR_FRAME_UI::loadJsonWorkbook( const wxString& aPath )
1944{
1945 wxFFileInputStream fp( aPath, wxT( "rt" ) );
1946 wxStdInputStream fstream( fp );
1947
1948 if( !fp.IsOk() )
1949 return false;
1950
1951 try
1952 {
1953 nlohmann::json js = nlohmann::json::parse( fstream, nullptr, true, true );
1954
1955 std::map<SIM_PLOT_TAB*, nlohmann::json> traceInfo;
1956
1957 for( const nlohmann::json& tab_js : js[ "tabs" ] )
1958 {
1959 wxString simCommand;
1962
1963 for( const nlohmann::json& cmd : tab_js[ "commands" ] )
1964 {
1965 if( cmd == ".kicad adjustpaths" )
1967 else if( cmd == ".save all" )
1969 else if( cmd == ".probe alli" )
1971 else if( cmd == ".probe allp" )
1973 else if( cmd == ".kicad esavenone" )
1974 simOptions &= ~NETLIST_EXPORTER_SPICE::OPTION_SAVE_ALL_EVENTS;
1975 else
1976 simCommand += wxString( cmd.get<wxString>() ).Trim();
1977 }
1978
1979 SIM_TAB* simTab = NewSimTab( simCommand );
1980 SIM_PLOT_TAB* plotTab = dynamic_cast<SIM_PLOT_TAB*>( simTab );
1981
1982 simTab->SetSimOptions( simOptions );
1983
1984 if( plotTab )
1985 {
1986 if( tab_js.contains( "traces" ) )
1987 traceInfo[plotTab] = tab_js[ "traces" ];
1988
1989 if( tab_js.contains( "measurements" ) )
1990 {
1991 for( const nlohmann::json& m_js : tab_js[ "measurements" ] )
1992 plotTab->Measurements().emplace_back( m_js[ "expr" ], m_js[ "format" ] );
1993 }
1994
1995 plotTab->SetDottedSecondary( tab_js[ "dottedSecondary" ] );
1996 plotTab->ShowGrid( tab_js[ "showGrid" ] );
1997
1998 if( tab_js.contains( "fixedY1scale" ) )
1999 {
2000 const nlohmann::json& scale_js = tab_js[ "fixedY1scale" ];
2001 plotTab->SetY1Scale( true, scale_js[ "min" ], scale_js[ "max" ] );
2002 plotTab->GetPlotWin()->LockY( true );
2003 }
2004
2005 if( tab_js.contains( "fixedY2scale" ) )
2006 {
2007 const nlohmann::json& scale_js = tab_js[ "fixedY2scale" ];
2008 plotTab->SetY2Scale( true, scale_js[ "min" ], scale_js[ "max" ] );
2009 plotTab->GetPlotWin()->LockY( true );
2010 }
2011
2012 if( tab_js.contains( "fixedY3scale" ) )
2013 {
2014 plotTab->EnsureThirdYAxisExists();
2015 const nlohmann::json& scale_js = tab_js[ "fixedY3scale" ];
2016 plotTab->SetY3Scale( true, scale_js[ "min" ], scale_js[ "max" ] );
2017 plotTab->GetPlotWin()->LockY( true );
2018 }
2019
2020 if( tab_js.contains( "legend" ) )
2021 {
2022 const nlohmann::json& legend_js = tab_js[ "legend" ];
2023 plotTab->SetLegendPosition( wxPoint( legend_js[ "x" ], legend_js[ "y" ] ) );
2024 plotTab->ShowLegend( true );
2025 }
2026
2027 if( tab_js.contains( "margins" ) )
2028 {
2029 const nlohmann::json& margins_js = tab_js[ "margins" ];
2030 plotTab->GetPlotWin()->SetMargins( margins_js[ "top" ],
2031 margins_js[ "right" ],
2032 margins_js[ "bottom" ],
2033 margins_js[ "left" ] );
2034 }
2035 }
2036 }
2037
2038 int ii = 0;
2039
2040 if( js.contains( "user_defined_signals" ) )
2041 {
2042 for( const nlohmann::json& signal_js : js[ "user_defined_signals" ] )
2043 m_userDefinedSignals[ii++] = wxString( signal_js.get<wxString>() );
2044 }
2045
2046 auto addCursor =
2047 [this]( SIM_PLOT_TAB* aPlotTab, TRACE* aTrace, const wxString& aSignalName,
2048 int aCursorId, const nlohmann::json& aCursor_js )
2049 {
2050 if( aCursorId == 1 || aCursorId == 2 )
2051 {
2052 CURSOR* cursor = new CURSOR( aTrace, aPlotTab );
2053
2054 cursor->SetName( aSignalName );
2055 cursor->SetPen( wxPen( aTrace->GetTraceColour() ) );
2056 cursor->SetCoordX( aCursor_js[ "position" ] );
2057
2058 aTrace->SetCursor( aCursorId, cursor );
2059 aPlotTab->GetPlotWin()->AddLayer( cursor );
2060 }
2061
2062 m_cursorFormats[aCursorId-1][0].FromString( aCursor_js[ "x_format" ] );
2063 m_cursorFormats[aCursorId-1][1].FromString( aCursor_js[ "y_format" ] );
2064 };
2065
2066 for( const auto& [ plotTab, traces_js ] : traceInfo )
2067 {
2068 for( const nlohmann::json& trace_js : traces_js )
2069 {
2070 wxString signalName = trace_js[ "signal" ];
2071 wxString vectorName = vectorNameFromSignalName( plotTab, signalName, nullptr );
2072 TRACE* trace = plotTab->GetOrAddTrace( vectorName, trace_js[ "trace_type" ] );
2073
2074 if( trace )
2075 {
2076 if( trace_js.contains( "cursor1" ) )
2077 addCursor( plotTab, trace, signalName, 1, trace_js[ "cursor1" ] );
2078
2079 if( trace_js.contains( "cursor2" ) )
2080 addCursor( plotTab, trace, signalName, 2, trace_js[ "cursor2" ] );
2081
2082 if( trace_js.contains( "cursorD" ) )
2083 addCursor( plotTab, trace, signalName, 3, trace_js[ "cursorD" ] );
2084
2085 if( trace_js.contains( "color" ) )
2086 {
2087 wxColour color;
2088 color.Set( wxString( trace_js["color"].get<wxString>() ) );
2089 trace->SetTraceColour( color );
2090 plotTab->UpdateTraceStyle( trace );
2091 }
2092 }
2093 }
2094
2095 plotTab->UpdatePlotColors();
2096 }
2097
2098 if( SIM_TAB* simTab = GetCurrentSimTab() )
2099 {
2100 m_simulatorFrame->LoadSimulator( simTab->GetSimCommand(), simTab->GetSimOptions() );
2101
2102 simTab = dynamic_cast<SIM_TAB*>( m_plotNotebook->GetPage( 0 ) );
2103
2104 wxCHECK( simTab, false );
2105
2106 simTab->SetLastSchTextSimCommand( js[ "last_sch_text_sim_command" ] );
2107 }
2108 }
2109 catch( nlohmann::json::parse_error& error )
2110 {
2111 wxLogTrace( traceSettings, wxT( "Json parse error reading %s: %s" ), aPath, error.what() );
2112
2113 return false;
2114 }
2115 catch( nlohmann::json::type_error& error )
2116 {
2117 wxLogTrace( traceSettings, wxT( "Json type error reading %s: %s" ), aPath, error.what() );
2118
2119 return false;
2120 }
2121 catch( nlohmann::json::invalid_iterator& error )
2122 {
2123 wxLogTrace( traceSettings, wxT( "Json invalid_iterator error reading %s: %s" ), aPath, error.what() );
2124
2125 return false;
2126 }
2127 catch( nlohmann::json::out_of_range& error )
2128 {
2129 wxLogTrace( traceSettings, wxT( "Json out_of_range error reading %s: %s" ), aPath, error.what() );
2130
2131 return false;
2132 }
2133 catch( ... )
2134 {
2135 wxLogTrace( traceSettings, wxT( "Error reading %s" ), aPath );
2136 return false;
2137 }
2138
2139 return true;
2140}
2141
2142
2143bool SIMULATOR_FRAME_UI::SaveWorkbook( const wxString& aPath )
2144{
2146
2147 wxFileName filename = aPath;
2148 filename.SetExt( FILEEXT::WorkbookFileExtension );
2149
2150 wxFile file;
2151
2152 file.Create( filename.GetFullPath(), true /* overwrite */ );
2153
2154 if( !file.IsOpened() )
2155 return false;
2156
2157 nlohmann::json tabs_js = nlohmann::json::array();
2158
2159 for( size_t i = 0; i < m_plotNotebook->GetPageCount(); i++ )
2160 {
2161 SIM_TAB* simTab = dynamic_cast<SIM_TAB*>( m_plotNotebook->GetPage( i ) );
2162
2163 if( !simTab )
2164 continue;
2165
2166 SIM_TYPE simType = simTab->GetSimType();
2167
2168 nlohmann::json commands_js = nlohmann::json::array();
2169
2170 commands_js.push_back( simTab->GetSimCommand() );
2171
2172 int options = simTab->GetSimOptions();
2173
2175 commands_js.push_back( ".kicad adjustpaths" );
2176
2178 commands_js.push_back( ".save all" );
2179
2181 commands_js.push_back( ".probe alli" );
2182
2184 commands_js.push_back( ".probe allp" );
2185
2187 commands_js.push_back( ".kicad esavenone" );
2188
2189 nlohmann::json tab_js = nlohmann::json(
2190 { { "analysis", SPICE_SIMULATOR::TypeToName( simType, true ) },
2191 { "commands", commands_js } } );
2192
2193 if( SIM_PLOT_TAB* plotTab = dynamic_cast<SIM_PLOT_TAB*>( simTab ) )
2194 {
2195 nlohmann::json traces_js = nlohmann::json::array();
2196
2197 auto findSignalName =
2198 [&]( const wxString& aVectorName ) -> wxString
2199 {
2200 wxString vectorName;
2201 wxString suffix;
2202
2203 if( aVectorName.EndsWith( _( " (phase)" ) ) )
2204 suffix = _( " (phase)" );
2205 else if( aVectorName.EndsWith( _( " (gain)" ) ) )
2206 suffix = _( " (gain)" );
2207
2208 vectorName = aVectorName.Left( aVectorName.Length() - suffix.Length() );
2209
2210 for( const auto& [ id, signal ] : m_userDefinedSignals )
2211 {
2212 if( vectorName == vectorNameFromSignalId( id ) )
2213 return signal + suffix;
2214 }
2215
2216 return aVectorName;
2217 };
2218
2219 for( const auto& [name, trace] : plotTab->GetTraces() )
2220 {
2221 nlohmann::json trace_js = nlohmann::json(
2222 { { "trace_type", (int) trace->GetType() },
2223 { "signal", findSignalName( trace->GetDisplayName() ) },
2224 { "color", COLOR4D( trace->GetTraceColour() ).ToCSSString() } } );
2225
2226 if( CURSOR* cursor = trace->GetCursor( 1 ) )
2227 {
2228 trace_js["cursor1"] = nlohmann::json(
2229 { { "position", cursor->GetCoords().x },
2230 { "x_format", m_cursorFormats[0][0].ToString() },
2231 { "y_format", m_cursorFormats[0][1].ToString() } } );
2232 }
2233
2234 if( CURSOR* cursor = trace->GetCursor( 2 ) )
2235 {
2236 trace_js["cursor2"] = nlohmann::json(
2237 { { "position", cursor->GetCoords().x },
2238 { "x_format", m_cursorFormats[1][0].ToString() },
2239 { "y_format", m_cursorFormats[1][1].ToString() } } );
2240 }
2241
2242 if( trace->GetCursor( 1 ) || trace->GetCursor( 2 ) )
2243 {
2244 trace_js["cursorD"] = nlohmann::json(
2245 { { "x_format", m_cursorFormats[2][0].ToString() },
2246 { "y_format", m_cursorFormats[2][1].ToString() } } );
2247 }
2248
2249 traces_js.push_back( trace_js );
2250 }
2251
2252 nlohmann::json measurements_js = nlohmann::json::array();
2253
2254 for( const auto& [ measurement, format ] : plotTab->Measurements() )
2255 {
2256 measurements_js.push_back( nlohmann::json( { { "expr", measurement },
2257 { "format", format } } ) );
2258 }
2259
2260 tab_js[ "traces" ] = traces_js;
2261 tab_js[ "measurements" ] = measurements_js;
2262 tab_js[ "dottedSecondary" ] = plotTab->GetDottedSecondary();
2263 tab_js[ "showGrid" ] = plotTab->IsGridShown();
2264
2265 double min, max;
2266
2267 if( plotTab->GetY1Scale( &min, &max ) )
2268 tab_js[ "fixedY1scale" ] = nlohmann::json( { { "min", min }, { "max", max } } );
2269
2270 if( plotTab->GetY2Scale( &min, &max ) )
2271 tab_js[ "fixedY2scale" ] = nlohmann::json( { { "min", min }, { "max", max } } );
2272
2273 if( plotTab->GetY3Scale( &min, &max ) )
2274 tab_js[ "fixedY3scale" ] = nlohmann::json( { { "min", min }, { "max", max } } );
2275
2276 if( plotTab->IsLegendShown() )
2277 {
2278 tab_js[ "legend" ] = nlohmann::json( { { "x", plotTab->GetLegendPosition().x },
2279 { "y", plotTab->GetLegendPosition().y } } );
2280 }
2281
2282 mpWindow* plotWin = plotTab->GetPlotWin();
2283
2284 tab_js[ "margins" ] = nlohmann::json( { { "left", plotWin->GetMarginLeft() },
2285 { "right", plotWin->GetMarginRight() },
2286 { "top", plotWin->GetMarginTop() },
2287 { "bottom", plotWin->GetMarginBottom() } } );
2288 }
2289
2290 tabs_js.push_back( tab_js );
2291 }
2292
2293 nlohmann::json userDefinedSignals_js = nlohmann::json::array();
2294
2295 for( const auto& [ id, signal ] : m_userDefinedSignals )
2296 userDefinedSignals_js.push_back( signal );
2297
2298 nlohmann::json js = nlohmann::json( { { "version", 6 },
2299 { "tabs", tabs_js },
2300 { "user_defined_signals", userDefinedSignals_js } } );
2301
2302 // Store the value of any simulation command found on the schematic sheet in a SCH_TEXT
2303 // object. If this changes we want to warn the user and ask them if they want to update
2304 // the corresponding panel's sim command.
2305 if( m_plotNotebook->GetPageCount() > 0 )
2306 {
2307 SIM_TAB* simTab = dynamic_cast<SIM_TAB*>( m_plotNotebook->GetPage( 0 ) );
2308 js[ "last_sch_text_sim_command" ] = simTab->GetLastSchTextSimCommand();
2309 }
2310
2311 std::stringstream buffer;
2312 buffer << std::setw( 2 ) << js << std::endl;
2313
2314 bool res = file.Write( buffer.str() );
2315 file.Close();
2316
2317 // Store the filename of the last saved workbook.
2318 if( res )
2319 {
2320 filename.MakeRelativeTo( m_schematicFrame->Prj().GetProjectPath() );
2321 simulator()->Settings()->SetWorkbookFilename( filename.GetFullPath() );
2322 }
2323
2324 return res;
2325}
2326
2327
2329{
2330 switch( aType )
2331 {
2333 case ST_AC: return SPT_LIN_FREQUENCY;
2334 case ST_SP: return SPT_LIN_FREQUENCY;
2335 case ST_FFT: return SPT_LIN_FREQUENCY;
2336 case ST_DC: return SPT_SWEEP;
2337 case ST_TRAN: return SPT_TIME;
2338 case ST_NOISE: return SPT_LIN_FREQUENCY;
2339 default: wxFAIL_MSG( wxS( "Unhandled simulation type" ) ); return SPT_UNKNOWN;
2340 }
2341}
2342
2343
2345{
2346 wxString output;
2347 wxString ref;
2348 wxString source;
2349 wxString scale;
2350 SPICE_VALUE pts;
2351 SPICE_VALUE fStart;
2352 SPICE_VALUE fStop;
2353 bool saveAll;
2354
2355 if( GetCurrentSimTab() )
2356 {
2357 circuitModel()->ParseNoiseCommand( GetCurrentSimTab()->GetSimCommand(), &output, &ref,
2358 &source, &scale, &pts, &fStart, &fStop, &saveAll );
2359 }
2360
2361 return source;
2362}
2363
2364
2366{
2368
2369 // Rebuild the color list to plot traces
2371
2372 // Now send changes to all SIM_PLOT_TAB
2373 for( size_t page = 0; page < m_plotNotebook->GetPageCount(); page++ )
2374 {
2375 wxWindow* curPage = m_plotNotebook->GetPage( page );
2376
2377 // ensure it is truly a plot plotTab and not the (zero plots) placeholder
2378 // which is only SIM_TAB
2379 SIM_PLOT_TAB* plotTab = dynamic_cast<SIM_PLOT_TAB*>( curPage );
2380
2381 if( plotTab )
2382 plotTab->UpdatePlotColors();
2383 }
2384}
2385
2386
2387void SIMULATOR_FRAME_UI::onPlotClose( wxAuiNotebookEvent& event )
2388{
2389 OnModify();
2390}
2391
2392
2393void SIMULATOR_FRAME_UI::onPlotClosed( wxAuiNotebookEvent& event )
2394{
2395 CallAfter( [this]()
2396 {
2398 rebuildSignalsGrid( m_filter->GetValue() );
2400
2401 SIM_TAB* panel = GetCurrentSimTab();
2402
2403 if( !panel || panel->GetSimType() != ST_OP )
2404 {
2405 SCHEMATIC& schematic = m_schematicFrame->Schematic();
2406 schematic.ClearOperatingPoints();
2409 }
2410 } );
2411}
2412
2413
2415{
2416 if( SIM_PLOT_TAB* plotTab = dynamic_cast<SIM_PLOT_TAB*>( GetCurrentSimTab() ) )
2417 {
2418 std::vector<std::pair<wxString, wxString>>& measurements = plotTab->Measurements();
2419
2420 measurements.clear();
2421
2422 for( int row = 0; row < m_measurementsGrid->GetNumberRows(); ++row )
2423 {
2424 if( !m_measurementsGrid->GetCellValue( row, COL_MEASUREMENT ).IsEmpty() )
2425 {
2426 measurements.emplace_back( m_measurementsGrid->GetCellValue( row, COL_MEASUREMENT ),
2427 m_measurementsGrid->GetCellValue( row, COL_MEASUREMENT_FORMAT ) );
2428 }
2429 }
2430 }
2431}
2432
2433
2434void SIMULATOR_FRAME_UI::onPlotChanging( wxAuiNotebookEvent& event )
2435{
2437
2438 event.Skip();
2439}
2440
2441
2443{
2445 rebuildSignalsGrid( m_filter->GetValue() );
2447
2449
2450 for( int row = 0; row < m_measurementsGrid->GetNumberRows(); ++row )
2451 UpdateMeasurement( row );
2452}
2453
2454
2455void SIMULATOR_FRAME_UI::onPlotChanged( wxAuiNotebookEvent& event )
2456{
2457 if( SIM_TAB* simTab = GetCurrentSimTab() )
2458 simulator()->Command( "setplot " + simTab->GetSpicePlotName().ToStdString() );
2459
2461
2462 event.Skip();
2463}
2464
2465
2467{
2469
2470 if( SIM_PLOT_TAB* plotTab = dynamic_cast<SIM_PLOT_TAB*>( GetCurrentSimTab() ) )
2471 {
2472 for( const auto& [ measurement, format ] : plotTab->Measurements() )
2473 {
2474 int row = m_measurementsGrid->GetNumberRows();
2475 m_measurementsGrid->AppendRows();
2476 m_measurementsGrid->SetCellValue( row, COL_MEASUREMENT, measurement );
2477 m_measurementsGrid->SetCellValue( row, COL_MEASUREMENT_FORMAT, format );
2478 }
2479
2480 if( plotTab->GetSimType() == ST_TRAN || plotTab->GetSimType() == ST_AC
2481 || plotTab->GetSimType() == ST_DC || plotTab->GetSimType() == ST_SP )
2482 {
2483 m_measurementsGrid->AppendRows(); // Empty row at end
2484 }
2485 }
2486}
2487
2488
2489void SIMULATOR_FRAME_UI::onPlotDragged( wxAuiNotebookEvent& event )
2490{
2491}
2492
2493
2494std::shared_ptr<SPICE_SIMULATOR> SIMULATOR_FRAME_UI::simulator() const
2495{
2497}
2498
2499
2500std::shared_ptr<SPICE_CIRCUIT_MODEL> SIMULATOR_FRAME_UI::circuitModel() const
2501{
2503}
2504
2505
2507{
2508 SUPPRESS_GRID_CELL_EVENTS raii( this );
2509
2511
2512 SIM_PLOT_TAB* plotTab = dynamic_cast<SIM_PLOT_TAB*>( GetCurrentSimTab() );
2513
2514 if( !plotTab )
2515 return;
2516
2517 // Update cursor values
2518 CURSOR* cursor1 = nullptr;
2519 wxString cursor1Name;
2520 wxString cursor1Units;
2521 CURSOR* cursor2 = nullptr;
2522 wxString cursor2Name;
2523 wxString cursor2Units;
2524
2525 auto getUnitsY =
2526 [&]( TRACE* aTrace ) -> wxString
2527 {
2528 if( plotTab->GetSimType() == ST_AC )
2529 {
2530 if( aTrace->GetType() & SPT_AC_PHASE )
2531 return plotTab->GetUnitsY2();
2532 else
2533 return plotTab->GetUnitsY1();
2534 }
2535 else
2536 {
2537 if( aTrace->GetType() & SPT_POWER )
2538 return plotTab->GetUnitsY3();
2539 else if( aTrace->GetType() & SPT_CURRENT )
2540 return plotTab->GetUnitsY2();
2541 else
2542 return plotTab->GetUnitsY1();
2543 }
2544 };
2545
2546 auto getNameY =
2547 [&]( TRACE* aTrace ) -> wxString
2548 {
2549 if( plotTab->GetSimType() == ST_AC )
2550 {
2551 if( aTrace->GetType() & SPT_AC_PHASE )
2552 return plotTab->GetLabelY2();
2553 else
2554 return plotTab->GetLabelY1();
2555 }
2556 else
2557 {
2558 if( aTrace->GetType() & SPT_POWER )
2559 return plotTab->GetLabelY3();
2560 else if( aTrace->GetType() & SPT_CURRENT )
2561 return plotTab->GetLabelY2();
2562 else
2563 return plotTab->GetLabelY1();
2564 }
2565 };
2566
2567 auto formatValue =
2568 [this]( double aValue, int aCursorId, int aCol ) -> wxString
2569 {
2570 if( ( !m_simulatorFrame->SimFinished() && aCol == 1 ) || std::isnan( aValue ) )
2571 return wxS( "--" );
2572 else
2573 return SPICE_VALUE( aValue ).ToString( m_cursorFormats[ aCursorId ][ aCol ] );
2574 };
2575
2576 for( const auto& [name, trace] : plotTab->GetTraces() )
2577 {
2578 if( CURSOR* cursor = trace->GetCursor( 1 ) )
2579 {
2580 cursor1 = cursor;
2581 cursor1Name = getNameY( trace );
2582 cursor1Units = getUnitsY( trace );
2583
2584 wxRealPoint coords = cursor->GetCoords();
2585 int row = m_cursorsGrid->GetNumberRows();
2586
2587 m_cursorFormats[0][0].UpdateUnits( plotTab->GetUnitsX() );
2588 m_cursorFormats[0][1].UpdateUnits( cursor1Units );
2589
2590 m_cursorsGrid->AppendRows( 1 );
2591 m_cursorsGrid->SetCellValue( row, COL_CURSOR_NAME, wxS( "1" ) );
2592 m_cursorsGrid->SetCellValue( row, COL_CURSOR_SIGNAL, cursor->GetName() );
2593 m_cursorsGrid->SetCellValue( row, COL_CURSOR_X, formatValue( coords.x, 0, 0 ) );
2594 m_cursorsGrid->SetCellValue( row, COL_CURSOR_Y, formatValue( coords.y, 0, 1 ) );
2595 break;
2596 }
2597 }
2598
2599 for( const auto& [name, trace] : plotTab->GetTraces() )
2600 {
2601 if( CURSOR* cursor = trace->GetCursor( 2 ) )
2602 {
2603 cursor2 = cursor;
2604 cursor2Name = getNameY( trace );
2605 cursor2Units = getUnitsY( trace );
2606
2607 wxRealPoint coords = cursor->GetCoords();
2608 int row = m_cursorsGrid->GetNumberRows();
2609
2610 m_cursorFormats[1][0].UpdateUnits( plotTab->GetUnitsX() );
2611 m_cursorFormats[1][1].UpdateUnits( cursor2Units );
2612
2613 m_cursorsGrid->AppendRows( 1 );
2614 m_cursorsGrid->SetCellValue( row, COL_CURSOR_NAME, wxS( "2" ) );
2615 m_cursorsGrid->SetCellValue( row, COL_CURSOR_SIGNAL, cursor->GetName() );
2616 m_cursorsGrid->SetCellValue( row, COL_CURSOR_X, formatValue( coords.x, 1, 0 ) );
2617 m_cursorsGrid->SetCellValue( row, COL_CURSOR_Y, formatValue( coords.y, 1, 1 ) );
2618 break;
2619 }
2620 }
2621
2622 if( cursor1 && cursor2 && cursor1Units == cursor2Units )
2623 {
2624 wxRealPoint coords = cursor2->GetCoords() - cursor1->GetCoords();
2625 wxString signal;
2626
2627 m_cursorFormats[2][0].UpdateUnits( plotTab->GetUnitsX() );
2628 m_cursorFormats[2][1].UpdateUnits( cursor1Units );
2629
2630 if( cursor1->GetName() == cursor2->GetName() )
2631 signal = wxString::Format( wxS( "%s[2 - 1]" ), cursor2->GetName() );
2632 else
2633 signal = wxString::Format( wxS( "%s - %s" ), cursor2->GetName(), cursor1->GetName() );
2634
2635 m_cursorsGrid->AppendRows( 1 );
2636 m_cursorsGrid->SetCellValue( 2, COL_CURSOR_NAME, _( "Diff" ) );
2637 m_cursorsGrid->SetCellValue( 2, COL_CURSOR_SIGNAL, signal );
2638 m_cursorsGrid->SetCellValue( 2, COL_CURSOR_X, formatValue( coords.x, 2, 0 ) );
2639 m_cursorsGrid->SetCellValue( 2, COL_CURSOR_Y, formatValue( coords.y, 2, 1 ) );
2640 }
2641
2642 // Set up the labels
2643 m_cursorsGrid->SetColLabelValue( COL_CURSOR_X, plotTab->GetLabelX() );
2644
2645 wxString valColName = _( "Value" );
2646
2647 if( !cursor1Name.IsEmpty() )
2648 {
2649 if( cursor2Name.IsEmpty() || cursor1Name == cursor2Name )
2650 valColName = cursor1Name;
2651 }
2652 else if( !cursor2Name.IsEmpty() )
2653 {
2654 valColName = cursor2Name;
2655 }
2656
2657 m_cursorsGrid->SetColLabelValue( COL_CURSOR_Y, valColName );
2658}
2659
2660
2661void SIMULATOR_FRAME_UI::onPlotCursorUpdate( wxCommandEvent& aEvent )
2662{
2664 OnModify();
2665}
2666
2667
2669{
2670 if( SIM_PLOT_TAB* plotTab = dynamic_cast<SIM_PLOT_TAB*>( GetCurrentSimTab() ) )
2671 plotTab->ResetScales( true );
2672
2673 m_simConsole->Clear();
2674
2675 // Do not export netlist, it is already stored in the simulator
2676 applyTuners();
2677
2678 m_refreshTimer.Start( REFRESH_INTERVAL, wxTIMER_ONE_SHOT );
2679}
2680
2681
2682void SIMULATOR_FRAME_UI::OnSimReport( const wxString& aMsg )
2683{
2684 m_simConsole->AppendText( aMsg + "\n" );
2685 m_simConsole->SetInsertionPointEnd();
2686}
2687
2688
2689std::vector<wxString> SIMULATOR_FRAME_UI::SimPlotVectors() const
2690{
2691 std::vector<wxString> signals;
2692
2693 for( const std::string& vec : simulator()->AllVectors() )
2694 signals.emplace_back( vec );
2695
2696 return signals;
2697}
2698
2699
2700std::vector<wxString> SIMULATOR_FRAME_UI::Signals() const
2701{
2702 std::vector<wxString> signals;
2703
2704 for( const wxString& signal : m_signals )
2705 signals.emplace_back( signal );
2706
2707 for( const auto& [ id, signal ] : m_userDefinedSignals )
2708 signals.emplace_back( signal );
2709
2710 sortSignals( signals );
2711
2712 return signals;
2713}
2714
2715
2717{
2718 if( aFinal )
2719 m_refreshTimer.Stop();
2720
2721 SIM_TAB* simTab = GetCurrentSimTab();
2722
2723 if( !simTab )
2724 return;
2725
2726 SIM_TYPE simType = simTab->GetSimType();
2727 wxString msg;
2728
2729 if( aFinal )
2730 {
2733 }
2734
2735 // If there are any signals plotted, update them
2736 if( SIM_TAB::IsPlottable( simType ) )
2737 {
2738 simTab->SetSpicePlotName( simulator()->CurrentPlotName() );
2739
2740 if( simType == ST_NOISE && aFinal )
2741 {
2742 m_simConsole->AppendText( _( "\n\nSimulation results:\n\n" ) );
2743 m_simConsole->SetInsertionPointEnd();
2744
2745 // The simulator will create noise1 & noise2 on the first run, noise3 and noise4
2746 // on the second, etc. The first plot for each run contains the spectral density
2747 // noise vectors and second contains the integrated noise.
2748 long number;
2749 simulator()->CurrentPlotName().Mid( 5 ).ToLong( &number );
2750
2751 for( const std::string& vec : simulator()->AllVectors() )
2752 {
2753 std::vector<double> val_list = simulator()->GetRealVector( vec, 1 );
2754 wxString value = SPICE_VALUE( val_list[ 0 ] ).ToSpiceString();
2755
2756 msg.Printf( wxS( "%s: %sV\n" ), vec, value );
2757
2758 m_simConsole->AppendText( msg );
2759 m_simConsole->SetInsertionPointEnd();
2760 }
2761
2762 simulator()->Command( fmt::format( "setplot noise{}", number - 1 ) );
2763 simTab->SetSpicePlotName( simulator()->CurrentPlotName() );
2764 }
2765
2766 SIM_PLOT_TAB* plotTab = dynamic_cast<SIM_PLOT_TAB*>( simTab );
2767 wxCHECK_RET( plotTab, wxT( "not a SIM_PLOT_TAB" ) );
2768
2769 struct TRACE_INFO
2770 {
2771 wxString Vector;
2772 int TraceType;
2773 bool ClearData;
2774 };
2775
2776 std::map<TRACE*, TRACE_INFO> traceMap;
2777
2778 for( const auto& [ name, trace ] : plotTab->GetTraces() )
2779 traceMap[ trace ] = { wxEmptyString, SPT_UNKNOWN, false };
2780
2781 // NB: m_signals are already broken out into gain/phase, but m_userDefinedSignals are
2782 // as the user typed them
2783
2784 for( const wxString& signal : m_signals )
2785 {
2786 int traceType = SPT_UNKNOWN;
2787 wxString vectorName = vectorNameFromSignalName( plotTab, signal, &traceType );
2788
2789 if( TRACE* trace = plotTab->GetTrace( vectorName, traceType ) )
2790 traceMap[ trace ] = { vectorName, traceType, false };
2791 }
2792
2793 for( const auto& [ id, signal ] : m_userDefinedSignals )
2794 {
2795 int traceType = SPT_UNKNOWN;
2796 wxString vectorName = vectorNameFromSignalName( plotTab, signal, &traceType );
2797
2798 if( simType == ST_AC )
2799 {
2800 int baseType = traceType &= ~( SPT_AC_GAIN | SPT_AC_PHASE );
2801
2802 for( int subType : { baseType | SPT_AC_GAIN, baseType | SPT_AC_PHASE } )
2803 {
2804 if( TRACE* trace = plotTab->GetTrace( vectorName, subType ) )
2805 traceMap[ trace ] = { vectorName, subType, !aFinal };
2806 }
2807 }
2808 else if( simType == ST_SP )
2809 {
2810 int baseType = traceType &= ~( SPT_SP_AMP | SPT_AC_PHASE );
2811
2812 for( int subType : { baseType | SPT_SP_AMP, baseType | SPT_AC_PHASE } )
2813 {
2814 if( TRACE* trace = plotTab->GetTrace( vectorName, subType ) )
2815 traceMap[trace] = { vectorName, subType, !aFinal };
2816 }
2817 }
2818 else
2819 {
2820 if( TRACE* trace = plotTab->GetTrace( vectorName, traceType ) )
2821 traceMap[ trace ] = { vectorName, traceType, !aFinal };
2822 }
2823 }
2824
2825 // Two passes so that DC-sweep sub-traces get deleted and re-created:
2826
2827 for( const auto& [ trace, traceInfo ] : traceMap )
2828 {
2829 if( traceInfo.Vector.IsEmpty() )
2830 plotTab->DeleteTrace( trace );
2831 }
2832
2833 for( const auto& [ trace, info ] : traceMap )
2834 {
2835 std::vector<double> data_x;
2836
2837 if( !info.Vector.IsEmpty() )
2838 updateTrace( info.Vector, info.TraceType, plotTab, &data_x, info.ClearData );
2839 }
2840
2841 plotTab->GetPlotWin()->UpdateAll();
2842
2843 if( aFinal )
2844 {
2845 for( int row = 0; row < m_measurementsGrid->GetNumberRows(); ++row )
2846 UpdateMeasurement( row );
2847
2848 plotTab->ResetScales( true );
2849 }
2850
2851 plotTab->GetPlotWin()->Fit();
2852
2854 }
2855 else if( simType == ST_OP && aFinal )
2856 {
2857 m_simConsole->AppendText( _( "\n\nSimulation results:\n\n" ) );
2858 m_simConsole->SetInsertionPointEnd();
2859
2860 for( const std::string& vec : simulator()->AllVectors() )
2861 {
2862 std::vector<double> val_list = simulator()->GetRealVector( vec, 1 );
2863
2864 if( val_list.empty() )
2865 continue;
2866
2867 wxString value = SPICE_VALUE( val_list[ 0 ] ).ToSpiceString();
2868 wxString signal;
2869 SIM_TRACE_TYPE type = circuitModel()->VectorToSignal( vec, signal );
2870
2871 const size_t tab = 25; //characters
2872 size_t padding = ( signal.length() < tab ) ? ( tab - signal.length() ) : 1;
2873
2874 switch( type )
2875 {
2876 case SPT_VOLTAGE: value.Append( wxS( "V" ) ); break;
2877 case SPT_CURRENT: value.Append( wxS( "A" ) ); break;
2878 case SPT_POWER: value.Append( wxS( "W" ) ); break;
2879 default: value.Append( wxS( "?" ) ); break;
2880 }
2881
2882 msg.Printf( wxT( "%s%s\n" ),
2883 ( signal + wxT( ":" ) ).Pad( padding, wxUniChar( ' ' ) ),
2884 value );
2885
2886 m_simConsole->AppendText( msg );
2887 m_simConsole->SetInsertionPointEnd();
2888
2889 if( type == SPT_VOLTAGE || type == SPT_CURRENT || type == SPT_POWER )
2890 signal = signal.SubString( 2, signal.Length() - 2 );
2891
2892 if( type == SPT_POWER )
2893 signal += wxS( ":power" );
2894
2895 m_schematicFrame->Schematic().SetOperatingPoint( signal, val_list.at( 0 ) );
2896 }
2897 }
2898 else if( simType == ST_PZ && aFinal )
2899 {
2900 m_simConsole->AppendText( _( "\n\nSimulation results:\n\n" ) );
2901 m_simConsole->SetInsertionPointEnd();
2902 simulator()->Command( "print all" );
2903 }
2904}
2905
2906
2908{
2910}
int color
Definition: DXF_plotter.cpp:58
const char * name
Definition: DXF_plotter.cpp:57
void showPopupMenu(wxMenu &menu, wxGridEvent &aEvent) override
void doPopupSelection(wxCommandEvent &event) override
SIMULATOR_FRAME_UI * m_parent
CURSORS_GRID_TRICKS(SIMULATOR_FRAME_UI *aParent, WX_GRID *aGrid)
The SIMULATOR_FRAME holds the main user-interface for running simulations.
Definition: sim_plot_tab.h:64
const wxRealPoint & GetCoords() const
Definition: sim_plot_tab.h:100
void SetCoordX(double aValue)
bool Find(const wxString &aTerm, int &aMatchersTriggered, int &aPosition)
virtual void Refresh(bool aEraseBackground=true, const wxRect *aRect=nullptr) override
Add mouse and command handling (such as cut, copy, and paste) to a WX_GRID instance.
Definition: grid_tricks.h:61
virtual void doPopupSelection(wxCommandEvent &event)
virtual void showPopupMenu(wxMenu &menu, wxGridEvent &aEvent)
WX_GRID * m_grid
I don't own the grid, but he owns me.
Definition: grid_tricks.h:125
A color representation with 4 components: red, green, blue, alpha.
Definition: color4d.h:104
wxString ToCSSString() const
Definition: color4d.cpp:147
Definition: kiid.h:49
PROJECT & Prj() const
Return a reference to the PROJECT associated with this KIWAY.
Hold a translatable error message and may be used when throwing exceptions containing a translated er...
Definition: ki_exception.h:46
const wxString What() const
Definition: ki_exception.h:58
void doPopupSelection(wxCommandEvent &event) override
void showPopupMenu(wxMenu &menu, wxGridEvent &aEvent) override
SIMULATOR_FRAME_UI * m_parent
MEASUREMENTS_GRID_TRICKS(SIMULATOR_FRAME_UI *aParent, WX_GRID *aGrid)
static void ConvertToSpiceMarkup(wxString *aNetName)
Remove formatting wrappers and replace illegal spice net name characters with underscores.
const SPICE_ITEM * FindItem(const wxString &aRefName) const
Find and return the item corresponding to aRefName.
A singleton reporter that reports to nowhere.
Definition: reporter.h:223
virtual const wxString GetProjectPath() const
Return the full path of the project.
Definition: project.cpp:135
Holds all the data relating to one schematic.
Definition: schematic.h:76
void SetOperatingPoint(const wxString &aSignal, double aValue)
Set operating points from a .op simulation.
Definition: schematic.h:243
void ClearOperatingPoints()
Clear operating points from a .op simulation.
Definition: schematic.h:235
SCH_DRAW_PANEL * GetCanvas() const override
Return a pointer to GAL-based canvas of given EDA draw frame.
EESCHEMA_SETTINGS * eeconfig() const
Schematic editor (Eeschema) main window.
void RefreshOperatingPointDisplay()
Refresh the display of any operaintg points.
void OnModify() override
Must be called after a schematic change in order to set the "modify" flag and update other data struc...
SCHEMATIC & Schematic() const
void UpdateItem(EDA_ITEM *aItem, bool isAddOrDelete=false, bool aUpdateRtree=false) override
Mark an item for refresh.
Base class for any item which can be embedded within the SCHEMATIC container class,...
Definition: sch_item.h:166
Handle access to a stack of flattened SCH_SHEET objects by way of a path for creating a flattened sch...
SCH_ITEM * GetItem(const KIID &aID) const
Fetch a SCH_ITEM by ID.
Schematic symbol object.
Definition: sch_symbol.h:105
void GetFields(std::vector< SCH_FIELD * > &aVector, bool aVisibleOnly)
Populate a std::vector with SCH_FIELDs.
Definition: sch_symbol.cpp:967
const wxString GetRef(const SCH_SHEET_PATH *aSheet, bool aIncludeUnit=false) const override
Definition: sch_symbol.cpp:720
void doPopupSelection(wxCommandEvent &event) override
void showPopupMenu(wxMenu &menu, wxGridEvent &aEvent) override
SIMULATOR_FRAME_UI * m_parent
SIGNALS_GRID_TRICKS(SIMULATOR_FRAME_UI *aParent, WX_GRID *aGrid)
Class SIMULATOR_FRAME_UI_BASE.
wxSplitterWindow * m_splitterLeftRight
wxSplitterWindow * m_splitterMeasurements
wxSplitterWindow * m_splitterCursors
wxSplitterWindow * m_splitterPlotAndConsole
wxSplitterWindow * m_splitterSignals
The SIMULATOR_FRAME_UI holds the main user-interface for running simulations.
SIM_TAB * NewSimTab(const wxString &aSimCommand)
Create a new simulation tab for a given simulation type.
void SetUserDefinedSignals(const std::map< int, wxString > &aSignals)
void updatePlotCursors()
Update the cursor values (in the grid) and graphics (in the plot window).
void OnSimRefresh(bool aFinal)
void onPlotClose(wxAuiNotebookEvent &event) override
void onPlotChanged(wxAuiNotebookEvent &event) override
void rebuildSignalsGrid(wxString aFilter)
Rebuild the filtered list of signals in the signals grid.
void DoFourier(const wxString &aSignal, const wxString &aFundamental)
void rebuildMeasurementsGrid()
Rebuild the measurements grid for the current plot.
std::list< TUNER_SLIDER * > m_tuners
SPICE expressions need quoted versions of the netnames since KiCad allows '-' and '/' in netnames.
void rebuildSignalsList()
Rebuild the list of signals available from the netlist.
bool loadLegacyWorkbook(const wxString &aPath)
void UpdateMeasurement(int aRow)
Update a measurement in the measurements grid.
wxString getNoiseSource() const
std::vector< wxString > SimPlotVectors() const
void applyUserDefinedSignals()
Apply user-defined signals to the SPICE session.
std::map< wxString, wxString > m_quotedNetnames
SIM_PREFERENCES m_preferences
void DeleteMeasurement(int aRow)
Delete a row from the measurements grid.
SCH_EDIT_FRAME * m_schematicFrame
wxString vectorNameFromSignalName(SIM_PLOT_TAB *aPlotTab, const wxString &aSignalName, int *aTraceType)
Get the simulator output vector name for a given signal name and type.
void updateSignalsGrid()
Update the values in the signals grid.
void onCursorsGridCellChanged(wxGridEvent &aEvent) override
void onPlotDragged(wxAuiNotebookEvent &event) override
std::vector< wxString > Signals() const
bool SaveWorkbook(const wxString &aPath)
Save plot, signal, cursor, measurement, etc.
std::vector< wxString > m_signals
SIM_TAB * GetCurrentSimTab() const
Return the currently opened plot panel (or NULL if there is none).
bool LoadWorkbook(const wxString &aPath)
Load plot, signal, cursor, measurement, etc.
SPICE_VALUE_FORMAT GetMeasureFormat(int aRow) const
Get/Set the format of a value in the measurements grid.
std::map< int, wxString > m_userDefinedSignals
void UpdateTunerValue(const SCH_SHEET_PATH &aSheetPath, const KIID &aSymbol, const wxString &aRef, const wxString &aValue)
Safely update a field of the associated symbol without dereferencing the symbol.
void AddTrace(const wxString &aName, SIM_TRACE_TYPE aType)
Add a new trace to the current plot.
void onPlotClosed(wxAuiNotebookEvent &event) override
void RemoveTuner(TUNER_SLIDER *aTuner)
Remove an existing tuner.
void SaveSettings(EESCHEMA_SETTINGS *aCfg)
std::shared_ptr< SPICE_CIRCUIT_MODEL > circuitModel() const
void OnFilterText(wxCommandEvent &aEvent) override
void onMeasurementsGridCellChanged(wxGridEvent &aEvent) override
void applyTuners()
Apply component values specified using tuner sliders to the current netlist.
bool loadJsonWorkbook(const wxString &aPath)
void OnFilterMouseMoved(wxMouseEvent &aEvent) override
void AddMeasurement(const wxString &aCmd)
Add a measurement to the measurements grid.
void onPlotChanging(wxAuiNotebookEvent &event) override
std::shared_ptr< SPICE_SIMULATOR > simulator() const
void onPlotCursorUpdate(wxCommandEvent &aEvent)
void onSignalsGridCellChanged(wxGridEvent &aEvent) override
void SetCursorFormat(int aCursorId, int aValueCol, const SPICE_VALUE_FORMAT &aFormat)
void InitWorkbook()
Load the currently active workbook stored in the project settings.
SIM_TRACE_TYPE getXAxisType(SIM_TYPE aType) const
Return X axis for a given simulation type.
void SetMeasureFormat(int aRow, const SPICE_VALUE_FORMAT &aFormat)
void OnSimReport(const wxString &aMsg)
void ApplyPreferences(const SIM_PREFERENCES &aPrefs)
Called when settings are changed via the common Preferences dialog.
const SPICE_CIRCUIT_MODEL * GetExporter() const
Return the netlist exporter object used for simulations.
SIMULATOR_FRAME * m_simulatorFrame
void AddTuner(const SCH_SHEET_PATH &aSheetPath, SCH_SYMBOL *aSymbol)
Add a tuner for a symbol.
SPICE_VALUE_FORMAT GetCursorFormat(int aCursorId, int aValueCol) const
Get/Set the number of significant digits and the range for formatting a cursor value.
void OnUpdateUI(wxUpdateUIEvent &event) override
void updateTrace(const wxString &aVectorName, int aTraceType, SIM_PLOT_TAB *aPlotTab, std::vector< double > *aDataX=nullptr, bool aClearData=false)
Update a trace in a particular SIM_PLOT_TAB.
SIMULATOR_FRAME_UI(SIMULATOR_FRAME *aSimulatorFrame, SCH_EDIT_FRAME *aSchematicFrame)
SPICE_VALUE_FORMAT m_cursorFormats[3][2]
void LoadSettings(EESCHEMA_SETTINGS *aCfg)
The SIMULATOR_FRAME holds the main user-interface for running simulations.
bool LoadSimulator(const wxString &aSimCommand, unsigned aSimOptions)
Check and load the current netlist into the simulator.
std::shared_ptr< SPICE_CIRCUIT_MODEL > GetCircuitModel() const
SIM_TYPE GetCurrentSimType() const
void OnModify() override
Must be called after a model change in order to set the "modify" flag and do other frame-specific pro...
bool SimFinished() const
int GetCurrentOptions() const
std::shared_ptr< SPICE_SIMULATOR > GetSimulator() const
SIM_MODEL & CreateModel(SIM_MODEL::TYPE aType, const std::vector< SCH_PIN * > &aPins, REPORTER &aReporter)
virtual const PARAM * GetTunerParam() const
Definition: sim_model.h:484
const SPICE_GENERATOR & SpiceGenerator() const
Definition: sim_model.h:435
void WriteFields(std::vector< SCH_FIELD > &aFields) const
Definition: sim_model.cpp:441
void SetParamValue(int aParamIndex, const std::string &aValue, SIM_VALUE::NOTATION aNotation=SIM_VALUE::NOTATION::SI)
Definition: sim_model.cpp:849
static void FillDefaultColorList(bool aWhiteBg)
Fills m_colorList by a default set of colors.
bool DeleteTrace(const wxString &aVectorName, int aTraceType)
void EnableCursor(const wxString &aVectorName, int aType, int aCursorId, bool aEnable, const wxString &aSignalName)
Reset scale ranges to fit the current traces.
wxString GetLabelY1() const
Definition: sim_plot_tab.h:208
mpWindow * GetPlotWin() const
Definition: sim_plot_tab.h:350
void ShowGrid(bool aEnable)
Definition: sim_plot_tab.h:268
wxString GetUnitsY2() const
void SetY2Scale(bool aLock, double aMin, double aMax)
TRACE * GetTrace(const wxString &aVecName, int aType) const
Definition: sim_plot_tab.h:261
wxString GetLabelX() const
Definition: sim_plot_tab.h:203
const std::map< wxString, TRACE * > & GetTraces() const
Definition: sim_plot_tab.h:256
wxString GetLabelY3() const
Definition: sim_plot_tab.h:218
void SetY1Scale(bool aLock, double aMin, double aMax)
void SetY3Scale(bool aLock, double aMin, double aMax)
std::vector< std::pair< wxString, wxString > > & Measurements()
Definition: sim_plot_tab.h:360
void UpdateTraceStyle(TRACE *trace)
Update plot colors.
void SetLegendPosition(const wxPoint &aPosition)
Definition: sim_plot_tab.h:309
void ResetScales(bool aIncludeX)
Update trace line style.
void UpdatePlotColors()
void ShowLegend(bool aEnable)
Definition: sim_plot_tab.h:293
wxString GetLabelY2() const
Definition: sim_plot_tab.h:213
void SetTraceData(TRACE *aTrace, std::vector< double > &aX, std::vector< double > &aY, int aSweepCount, size_t aSweepSize)
wxString GetUnitsX() const
void EnsureThirdYAxisExists()
TRACE * GetOrAddTrace(const wxString &aVectorName, int aType)
void SetDottedSecondary(bool aEnable)
Draw secondary signal traces (current or phase) with dotted lines.
Definition: sim_plot_tab.h:319
void ApplyPreferences(const SIM_PREFERENCES &aPrefs) override
Definition: sim_plot_tab.h:198
wxString GetUnitsY1() const
wxString GetUnitsY3() const
int GetSimOptions() const
Definition: sim_tab.h:55
virtual void OnLanguageChanged()=0
SIM_TYPE GetSimType() const
Definition: sim_tab.cpp:75
const wxString & GetSimCommand() const
Definition: sim_tab.h:52
static bool IsPlottable(SIM_TYPE aSimType)
Definition: sim_tab.cpp:53
void SetSimOptions(int aOptions)
Definition: sim_tab.h:56
wxString GetLastSchTextSimCommand() const
Definition: sim_tab.h:58
void SetSpicePlotName(const wxString &aPlotName)
Definition: sim_tab.h:62
static std::string ToSpice(const std::string &aString)
Definition: sim_value.h:84
Special netlist exporter flavor that allows one to override simulation commands.
static SIM_TYPE CommandToSimType(const wxString &aCmd)
Return simulation type basing on a simulation command directive.
virtual std::string TunerCommand(const SPICE_ITEM &aItem, double aValue) const
static wxString TypeToName(SIM_TYPE aType, bool aShortName)
Return a string with simulation name based on enum.
Helper class to recognize Spice formatted values.
Definition: spice_value.h:56
wxString ToString() const
Return string value as when converting double to string (e.g.
wxString ToSpiceString() const
Return string value in Spice format (e.g.
double ToDouble() const
SUPPRESS_GRID_CELL_EVENTS(SIMULATOR_FRAME_UI *aFrame)
SIMULATOR_FRAME_UI * m_frame
void SetTraceColour(const wxColour &aColour)
Definition: sim_plot_tab.h:181
Custom widget to handle quick component values modification and simulation on the fly.
Definition: tuner_slider.h:44
void ClearRows()
wxWidgets recently added an ASSERT which fires if the position is greater than or equal to the number...
Definition: wx_grid.h:165
A wrapper for reporting to a wxString object.
Definition: reporter.h:164
bool HasMessage() const override
Returns true if the reporter client is non-empty.
Definition: reporter.cpp:80
REPORTER & Report(const wxString &aText, SEVERITY aSeverity=RPT_SEVERITY_UNDEFINED) override
Report a string with a given severity.
Definition: reporter.cpp:70
A KICAD version of wxTextEntryDialog which supports the various improvements/work-arounds from DIALOG...
wxString GetValue() const
const wxString & GetName() const
Get layer name.
Definition: mathplot.h:239
const wxPen & GetPen() const
Get pen set for this layer.
Definition: mathplot.h:254
Canvas for plotting mpLayer implementations.
Definition: mathplot.h:908
int GetMarginLeft() const
Definition: mathplot.h:1219
void SetMargins(int top, int right, int bottom, int left)
Set window margins, creating a blank area where some kinds of layers cannot draw.
Definition: mathplot.cpp:2385
int GetMarginTop() const
Definition: mathplot.h:1213
void UpdateAll()
Refresh display.
Definition: mathplot.cpp:2286
int GetMarginRight() const
Definition: mathplot.h:1215
int GetMarginBottom() const
Definition: mathplot.h:1217
void LockY(bool aLock)
Definition: mathplot.h:1263
bool AddLayer(mpLayer *layer, bool refreshDisplay=true)
Add a plot layer to the canvas.
Definition: mathplot.cpp:1970
void Fit() override
Set view to fit global bounding box of all plot layers and refresh display.
Definition: mathplot.cpp:1614
void DisplayErrorMessage(wxWindow *aParent, const wxString &aText, const wxString &aExtraInfo)
Display an error message with aMessage.
Definition: confirm.cpp:195
This file is part of the common library.
#define _(s)
Abstract pattern-matching tool and implementations.
@ CTX_SIGNAL
@ GRIDTRICKS_ID_COPY
Definition: grid_tricks.h:43
@ GRIDTRICKS_FIRST_CLIENT_ID
Definition: grid_tricks.h:48
static const std::string WorkbookFileExtension
#define traceSettings
Definition: json_settings.h:52
KICOMMON_API wxFont GetStatusFont(wxWindow *aWindow)
Definition: ui_common.cpp:130
see class PGM_BASE
SIM_TRACE_TYPE
Definition: sim_types.h:50
@ SPT_TIME
Definition: sim_types.h:61
@ SPT_AC_PHASE
Definition: sim_types.h:54
@ SPT_SWEEP
Definition: sim_types.h:64
@ SPT_UNKNOWN
Definition: sim_types.h:67
@ SPT_AC_GAIN
Definition: sim_types.h:55
@ SPT_Y_AXIS_MASK
Definition: sim_types.h:58
@ SPT_SP_AMP
Definition: sim_types.h:57
@ SPT_VOLTAGE
Definition: sim_types.h:52
@ SPT_POWER
Definition: sim_types.h:56
@ SPT_CURRENT
Definition: sim_types.h:53
@ SPT_LIN_FREQUENCY
Definition: sim_types.h:62
SIM_TYPE
< Possible simulation types
Definition: sim_types.h:32
@ ST_SP
Definition: sim_types.h:43
@ ST_TRAN
Definition: sim_types.h:42
@ ST_UNKNOWN
Definition: sim_types.h:33
@ ST_NOISE
Definition: sim_types.h:37
@ ST_AC
Definition: sim_types.h:34
@ ST_DISTO
Definition: sim_types.h:36
@ ST_TF
Definition: sim_types.h:41
@ ST_SENS
Definition: sim_types.h:40
@ ST_DC
Definition: sim_types.h:35
@ ST_OP
Definition: sim_types.h:38
@ ST_FFT
Definition: sim_types.h:44
@ ST_PZ
Definition: sim_types.h:39
void sortSignals(std::vector< wxString > &signals)
wxString vectorNameFromSignalId(int aUserDefinedSignalId)
MEASUREMENTS_GIRD_COLUMNS
@ COL_MEASUREMENT_FORMAT
@ COL_MEASUREMENT_VALUE
@ COL_MEASUREMENT
CURSORS_GRID_COLUMNS
@ COL_CURSOR_NAME
@ COL_CURSOR_SIGNAL
@ COL_CURSOR_X
@ COL_CURSOR_Y
SIGNALS_GRID_COLUMNS
@ COL_SIGNAL_SHOW
@ COL_SIGNAL_NAME
@ COL_CURSOR_1
@ COL_SIGNAL_COLOR
@ COL_CURSOR_2
#define ID_SIM_REFRESH
SIM_TRACE_TYPE operator|(SIM_TRACE_TYPE aFirst, SIM_TRACE_TYPE aSecond)
#define REFRESH_INTERVAL
@ MYID_MEASURE_INTEGRAL
@ MYID_MEASURE_MAX_AT
@ MYID_MEASURE_AVG
@ MYID_MEASURE_MAX
@ MYID_FOURIER
@ MYID_FORMAT_VALUE
@ MYID_MEASURE_RMS
@ MYID_DELETE_MEASUREMENT
@ MYID_MEASURE_MIN
@ MYID_MEASURE_MIN_AT
@ MYID_MEASURE_PP
const int scale
std::vector< FAB_LAYER_COLOR > dummy
wxString UnescapeString(const wxString &aSource)
const INFO & info
Definition: sim_model.h:401
Contains preferences pertaining to the simulator.
SPICE_VALUE m_vincrement
const SIM_MODEL * model
A SPICE_VALUE_FORMAT holds precision and range info for formatting values.Helper class to handle Spic...
Definition: spice_value.h:43
wxString ToString() const
Definition: spice_value.cpp:58
void UpdateUnits(const wxString &aUnits)
Definition: spice_value.cpp:64
void FromString(const wxString &aString)
Definition: spice_value.cpp:41
VECTOR3I res
constexpr ret_type KiROUND(fp_type v)
Round a floating point number to an integer using "round halfway cases away from zero".
Definition: util.h:121
Definition of file extensions used in Kicad.