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 if( SIM_TAB* simTab = dynamic_cast<SIM_TAB*>( m_plotNotebook->GetPage( ii ) ) )
595 {
596 simTab->OnLanguageChanged();
597
598 wxString pageTitle( simulator()->TypeToName( simTab->GetSimType(), true ) );
599 pageTitle.Prepend( wxString::Format( _( "Analysis %u - " ), ii+1 /* 1-based */ ) );
600
601 m_plotNotebook->SetPageText( ii, pageTitle );
602 }
603 }
604
605 m_filter->SetHint( _( "Filter" ) );
606
607 m_signalsGrid->SetColLabelValue( COL_SIGNAL_NAME, _( "Signal" ) );
608 m_signalsGrid->SetColLabelValue( COL_SIGNAL_SHOW, _( "Plot" ) );
609 m_signalsGrid->SetColLabelValue( COL_SIGNAL_COLOR, _( "Color" ) );
610 m_signalsGrid->SetColLabelValue( COL_CURSOR_1, _( "Cursor 1" ) );
611 m_signalsGrid->SetColLabelValue( COL_CURSOR_2, _( "Cursor 2" ) );
612
613 m_cursorsGrid->SetColLabelValue( COL_CURSOR_NAME, _( "Cursor" ) );
614 m_cursorsGrid->SetColLabelValue( COL_CURSOR_SIGNAL, _( "Signal" ) );
615 m_cursorsGrid->SetColLabelValue( COL_CURSOR_X, _( "Time" ) );
616 m_cursorsGrid->SetColLabelValue( COL_CURSOR_Y, _( "Value" ) );
618
619 for( TUNER_SLIDER* tuner : m_tuners )
620 tuner->ShowChangedLanguage();
621}
622
623
625{
626 const EESCHEMA_SETTINGS::SIMULATOR& settings = aCfg->m_Simulator;
627
628 // Read subwindows sizes (should be > 0 )
634 m_darkMode = !settings.view.white_background;
635
636 m_preferences = settings.preferences;
637}
638
639
641{
643
644 settings.view.plot_panel_width = m_splitterLeftRight->GetSashPosition();
645 settings.view.plot_panel_height = m_splitterPlotAndConsole->GetSashPosition();
646 settings.view.signal_panel_height = m_splitterSignals->GetSashPosition();
647 settings.view.cursors_panel_height = m_splitterCursors->GetSashPosition();
648 settings.view.measurements_panel_height = m_splitterMeasurements->GetSashPosition();
649 settings.view.white_background = !m_darkMode;
650}
651
652
654{
655 m_preferences = aPrefs;
656
657 const std::size_t pageCount = m_plotNotebook->GetPageCount();
658 for( std::size_t i = 0; i < pageCount; ++i )
659 {
660 wxWindow* page = m_plotNotebook->GetPage( i );
661 auto simTab = dynamic_cast<SIM_TAB*>( page );
662 wxASSERT( simTab != nullptr );
663 simTab->ApplyPreferences( aPrefs );
664 }
665}
666
667
669{
670 if( !simulator()->Settings()->GetWorkbookFilename().IsEmpty() )
671 {
672 wxFileName filename = simulator()->Settings()->GetWorkbookFilename();
673 filename.SetPath( m_schematicFrame->Prj().GetProjectPath() );
674
675 if( !LoadWorkbook( filename.GetFullPath() ) )
676 simulator()->Settings()->SetWorkbookFilename( "" );
677 }
678 else if( m_simulatorFrame->LoadSimulator( wxEmptyString, 0 ) )
679 {
680 wxString schTextSimCommand = circuitModel()->GetSchTextSimCommand();
681
682 if( !schTextSimCommand.IsEmpty() )
683 {
684 SIM_TAB* simTab = NewSimTab( schTextSimCommand );
686 }
687
689 rebuildSignalsGrid( m_filter->GetValue() );
690 }
691}
692
693
695{
698
701
704
707
710}
711
712
713void sortSignals( std::vector<wxString>& signals )
714{
715 std::sort( signals.begin(), signals.end(),
716 []( const wxString& lhs, const wxString& rhs )
717 {
718 // Sort voltages first
719 if( lhs.Upper().StartsWith( 'V' ) && !rhs.Upper().StartsWith( 'V' ) )
720 return true;
721 else if( !lhs.Upper().StartsWith( 'V' ) && rhs.Upper().StartsWith( 'V' ) )
722 return false;
723
724 return StrNumCmp( lhs, rhs, true /* ignore case */ ) < 0;
725 } );
726}
727
728
730{
731 SUPPRESS_GRID_CELL_EVENTS raii( this );
732
734
735 SIM_PLOT_TAB* plotPanel = dynamic_cast<SIM_PLOT_TAB*>( GetCurrentSimTab() );
736
737 if( !plotPanel )
738 return;
739
740 SIM_TYPE simType = plotPanel->GetSimType();
741 std::vector<wxString> signals;
742
743 if( plotPanel->GetSimType() == ST_FFT )
744 {
745 wxStringTokenizer tokenizer( plotPanel->GetSimCommand(), wxT( " \t\r\n" ), wxTOKEN_STRTOK );
746
747 while( tokenizer.HasMoreTokens() && tokenizer.GetNextToken().Lower() != wxT( "fft" ) )
748 {};
749
750 while( tokenizer.HasMoreTokens() )
751 signals.emplace_back( tokenizer.GetNextToken() );
752 }
753 else
754 {
755 // NB: m_signals are already broken out into gain/phase, but m_userDefinedSignals are
756 // as the user typed them
757
758 for( const wxString& signal : m_signals )
759 signals.push_back( signal );
760
761 for( const auto& [ id, signal ] : m_userDefinedSignals )
762 {
763 if( simType == ST_AC )
764 {
765 signals.push_back( signal + _( " (gain)" ) );
766 signals.push_back( signal + _( " (phase)" ) );
767 }
768 else if( simType == ST_SP )
769 {
770 signals.push_back( signal + _( " (amplitude)" ) );
771 signals.push_back( signal + _( " (phase)" ) );
772 }
773 else
774 {
775 signals.push_back( signal );
776 }
777 }
778
779 sortSignals( signals );
780 }
781
782 if( aFilter.IsEmpty() )
783 aFilter = wxS( "*" );
784
785 EDA_COMBINED_MATCHER matcher( aFilter.Upper(), CTX_SIGNAL );
786 int row = 0;
787
788 for( const wxString& signal : signals )
789 {
790 if( matcher.Find( signal.Upper() ) )
791 {
792 int traceType = SPT_UNKNOWN;
793 wxString vectorName = vectorNameFromSignalName( plotPanel, signal, &traceType );
794 TRACE* trace = plotPanel->GetTrace( vectorName, traceType );
795
796 m_signalsGrid->AppendRows( 1 );
797 m_signalsGrid->SetCellValue( row, COL_SIGNAL_NAME, signal );
798
799 wxGridCellAttr* attr = new wxGridCellAttr;
800 attr->SetRenderer( new wxGridCellBoolRenderer() );
801 attr->SetReadOnly(); // not really; we delegate interactivity to GRID_TRICKS
802 attr->SetAlignment( wxALIGN_CENTER, wxALIGN_CENTER );
803 m_signalsGrid->SetAttr( row, COL_SIGNAL_SHOW, attr );
804
805 if( !trace )
806 {
807 attr = new wxGridCellAttr;
808 attr->SetReadOnly();
809 m_signalsGrid->SetAttr( row, COL_SIGNAL_COLOR, attr );
810 m_signalsGrid->SetCellValue( row, COL_SIGNAL_COLOR, wxEmptyString );
811
812 attr = new wxGridCellAttr;
813 attr->SetReadOnly();
814 m_signalsGrid->SetAttr( row, COL_CURSOR_1, attr );
815
816 attr = new wxGridCellAttr;
817 attr->SetReadOnly();
818 m_signalsGrid->SetAttr( row, COL_CURSOR_2, attr );
819 }
820 else
821 {
822 m_signalsGrid->SetCellValue( row, COL_SIGNAL_SHOW, wxS( "1" ) );
823
824 attr = new wxGridCellAttr;
825 attr->SetRenderer( new GRID_CELL_COLOR_RENDERER( this ) );
826 attr->SetEditor( new GRID_CELL_COLOR_SELECTOR( this, m_signalsGrid ) );
827 attr->SetAlignment( wxALIGN_CENTER, wxALIGN_CENTER );
828 m_signalsGrid->SetAttr( row, COL_SIGNAL_COLOR, attr );
829 KIGFX::COLOR4D color( trace->GetPen().GetColour() );
830 m_signalsGrid->SetCellValue( row, COL_SIGNAL_COLOR, color.ToCSSString() );
831
832 attr = new wxGridCellAttr;
833 attr->SetRenderer( new wxGridCellBoolRenderer() );
834 attr->SetReadOnly(); // not really; we delegate interactivity to GRID_TRICKS
835 attr->SetAlignment( wxALIGN_CENTER, wxALIGN_CENTER );
836 m_signalsGrid->SetAttr( row, COL_CURSOR_1, attr );
837
838 attr = new wxGridCellAttr;
839 attr->SetRenderer( new wxGridCellBoolRenderer() );
840 attr->SetReadOnly(); // not really; we delegate interactivity to GRID_TRICKS
841 attr->SetAlignment( wxALIGN_CENTER, wxALIGN_CENTER );
842 m_signalsGrid->SetAttr( row, COL_CURSOR_2, attr );
843 }
844
845 row++;
846 }
847 }
848}
849
850
852{
853 m_signals.clear();
854
855 int options = m_simulatorFrame->GetCurrentOptions();
857 wxString unconnected = wxString( wxS( "unconnected-(" ) );
858
859 if( simType == ST_UNKNOWN )
860 simType = ST_TRAN;
861
862 unconnected.Replace( '(', '_' ); // Convert to SPICE markup
863
864 auto addSignal =
865 [&]( const wxString& aSignalName )
866 {
867 if( simType == ST_AC )
868 {
869 m_signals.push_back( aSignalName + _( " (gain)" ) );
870 m_signals.push_back( aSignalName + _( " (phase)" ) );
871 }
872 else if( simType == ST_SP )
873 {
874 m_signals.push_back( aSignalName + _( " (amplitude)" ) );
875 m_signals.push_back( aSignalName + _( " (phase)" ) );
876 }
877 else
878 {
879 m_signals.push_back( aSignalName );
880 }
881 };
882
884 && ( simType == ST_TRAN || simType == ST_DC || simType == ST_AC || simType == ST_FFT) )
885 {
886 for( const wxString& net : circuitModel()->GetNets() )
887 {
888 // netnames are escaped (can contain "{slash}" for '/') Unscape them:
889 wxString netname = UnescapeString( net );
891
892 if( netname == "GND" || netname == "0" || netname.StartsWith( unconnected ) )
893 continue;
894
895 m_quotedNetnames[ netname ] = wxString::Format( wxS( "\"%s\"" ), netname );
896 addSignal( wxString::Format( wxS( "V(%s)" ), netname ) );
897 }
898 }
899
901 && ( simType == ST_TRAN || simType == ST_DC || simType == ST_AC ) )
902 {
903 for( const SPICE_ITEM& item : circuitModel()->GetItems() )
904 {
905 // Add all possible currents for the device.
906 for( const std::string& name : item.model->SpiceGenerator().CurrentNames( item ) )
907 addSignal( name );
908 }
909 }
910
912 && ( simType == ST_TRAN || simType == ST_DC ) )
913 {
914 for( const SPICE_ITEM& item : circuitModel()->GetItems() )
915 {
916 if( item.model->GetPinCount() >= 2 )
917 {
918 wxString name = item.model->SpiceGenerator().ItemName( item );
919 addSignal( wxString::Format( wxS( "P(%s)" ), name ) );
920 }
921 }
922 }
923
924 if( simType == ST_NOISE )
925 {
926 addSignal( wxS( "inoise_spectrum" ) );
927 addSignal( wxS( "onoise_spectrum" ) );
928 }
929
930 if( simType == ST_SP )
931 {
932 std::vector<std::string> portnums;
933
934 for( const SPICE_ITEM& item : circuitModel()->GetItems() )
935 {
936 wxString name = item.model->SpiceGenerator().ItemName( item );
937
938 // We are only looking for voltage sources in .SP mode
939 if( !name.StartsWith( "V" ) )
940 continue;
941
942 std::string portnum = "";
943
944 if( const SIM_MODEL::PARAM* portnum_param = item.model->FindParam( "portnum" ) )
945 portnum = SIM_VALUE::ToSpice( portnum_param->value );
946
947 if( portnum != "" )
948 portnums.push_back( portnum );
949 }
950
951 for( const std::string& portnum1 : portnums )
952 {
953 for( const std::string& portnum2 : portnums )
954 {
955 addSignal( wxString::Format( wxS( "S_%s_%s" ), portnum1, portnum2 ) );
956 }
957 }
958 }
959
960 // Add .SAVE and .PROBE directives
961 for( const wxString& directive : circuitModel()->GetDirectives() )
962 {
963 wxStringTokenizer directivesTokenizer( directive, wxT( "\r\n" ), wxTOKEN_STRTOK );
964
965 while( directivesTokenizer.HasMoreTokens() )
966 {
967 wxString line = directivesTokenizer.GetNextToken().Upper();
968 wxString directiveParams;
969
970 if( line.StartsWith( wxS( ".SAVE" ), &directiveParams )
971 || line.StartsWith( wxS( ".PROBE" ), &directiveParams ) )
972 {
973 wxStringTokenizer paramsTokenizer( directiveParams, wxT( " \t" ), wxTOKEN_STRTOK );
974
975 while( paramsTokenizer.HasMoreTokens() )
976 addSignal( paramsTokenizer.GetNextToken() );
977 }
978 }
979 }
980}
981
982
983SIM_TAB* SIMULATOR_FRAME_UI::NewSimTab( const wxString& aSimCommand )
984{
985 SIM_TAB* simTab = nullptr;
986 SIM_TYPE simType = SPICE_CIRCUIT_MODEL::CommandToSimType( aSimCommand );
987
988 if( SIM_TAB::IsPlottable( simType ) )
989 {
990 SIM_PLOT_TAB* panel = new SIM_PLOT_TAB( aSimCommand, m_plotNotebook );
991 simTab = panel;
993 }
994 else
995 {
996 simTab = new SIM_NOPLOT_TAB( aSimCommand, m_plotNotebook );
997 }
998
999 wxString pageTitle( simulator()->TypeToName( simType, true ) );
1000 pageTitle.Prepend( wxString::Format( _( "Analysis %u - " ), (unsigned int) ++m_plotNumber ) );
1001
1002 m_plotNotebook->AddPage( simTab, pageTitle, true );
1003
1004 return simTab;
1005}
1006
1007
1008void SIMULATOR_FRAME_UI::OnFilterText( wxCommandEvent& aEvent )
1009{
1010 rebuildSignalsGrid( m_filter->GetValue() );
1011}
1012
1013
1014void SIMULATOR_FRAME_UI::OnFilterMouseMoved( wxMouseEvent& aEvent )
1015{
1016 wxPoint pos = aEvent.GetPosition();
1017 wxRect ctrlRect = m_filter->GetScreenRect();
1018 int buttonWidth = ctrlRect.GetHeight(); // Presume buttons are square
1019
1020 if( m_filter->IsSearchButtonVisible() && pos.x < buttonWidth )
1021 SetCursor( wxCURSOR_ARROW );
1022 else if( m_filter->IsCancelButtonVisible() && pos.x > ctrlRect.GetWidth() - buttonWidth )
1023 SetCursor( wxCURSOR_ARROW );
1024 else
1025 SetCursor( wxCURSOR_IBEAM );
1026}
1027
1028
1029wxString vectorNameFromSignalId( int aUserDefinedSignalId )
1030{
1031 return wxString::Format( wxS( "user%d" ), aUserDefinedSignalId );
1032}
1033
1034
1040 const wxString& aSignalName,
1041 int* aTraceType )
1042{
1043 std::map<wxString, int> suffixes;
1044 suffixes[ _( " (amplitude)" ) ] = SPT_SP_AMP;
1045 suffixes[ _( " (gain)" ) ] = SPT_AC_GAIN;
1046 suffixes[ _( " (phase)" ) ] = SPT_AC_PHASE;
1047
1048 if( aTraceType )
1049 {
1050 if( aPlotTab && aPlotTab->GetSimType() == ST_NOISE )
1051 {
1052 if( getNoiseSource().Upper().StartsWith( 'I' ) )
1053 *aTraceType = SPT_CURRENT;
1054 else
1055 *aTraceType = SPT_VOLTAGE;
1056 }
1057 else
1058 {
1059 wxUniChar firstChar = aSignalName.Upper()[0];
1060
1061 if( firstChar == 'V' )
1062 *aTraceType = SPT_VOLTAGE;
1063 else if( firstChar == 'I' )
1064 *aTraceType = SPT_CURRENT;
1065 else if( firstChar == 'P' )
1066 *aTraceType = SPT_POWER;
1067 }
1068 }
1069
1070 wxString suffix;
1071 wxString name = aSignalName;
1072
1073 for( const auto& [ candidate, type ] : suffixes )
1074 {
1075 if( name.EndsWith( candidate ) )
1076 {
1077 name = name.Left( name.Length() - candidate.Length() );
1078
1079 if( aTraceType )
1080 *aTraceType |= type;
1081
1082 break;
1083 }
1084 }
1085
1086 for( const auto& [ id, signal ] : m_userDefinedSignals )
1087 {
1088 if( name == signal )
1089 return vectorNameFromSignalId( id );
1090 }
1091
1092 return name;
1093};
1094
1095
1097{
1098 if( m_SuppressGridEvents > 0 )
1099 return;
1100
1101 SIM_PLOT_TAB* plotTab = dynamic_cast<SIM_PLOT_TAB*>( GetCurrentSimTab() );
1102
1103 if( !plotTab )
1104 return;
1105
1106 int row = aEvent.GetRow();
1107 int col = aEvent.GetCol();
1108 wxString text = m_signalsGrid->GetCellValue( row, col );
1109 wxString signalName = m_signalsGrid->GetCellValue( row, COL_SIGNAL_NAME );
1110 int traceType = SPT_UNKNOWN;
1111 wxString vectorName = vectorNameFromSignalName( plotTab, signalName, &traceType );
1112
1113 if( col == COL_SIGNAL_SHOW )
1114 {
1115 if( text == wxS( "1" ) )
1116 updateTrace( vectorName, traceType, plotTab );
1117 else
1118 plotTab->DeleteTrace( vectorName, traceType );
1119
1120 plotTab->GetPlotWin()->UpdateAll();
1121
1122 // Update enabled/visible states of other controls
1125 OnModify();
1126 }
1127 else if( col == COL_SIGNAL_COLOR )
1128 {
1129 KIGFX::COLOR4D color( m_signalsGrid->GetCellValue( row, COL_SIGNAL_COLOR ) );
1130 TRACE* trace = plotTab->GetTrace( vectorName, traceType );
1131
1132 if( trace )
1133 {
1134 trace->SetTraceColour( color.ToColour() );
1135 plotTab->UpdateTraceStyle( trace );
1136 plotTab->UpdatePlotColors();
1137 OnModify();
1138 }
1139 }
1140 else if( col == COL_CURSOR_1 || col == COL_CURSOR_2 )
1141 {
1142 for( int ii = 0; ii < m_signalsGrid->GetNumberRows(); ++ii )
1143 {
1144 signalName = m_signalsGrid->GetCellValue( ii, COL_SIGNAL_NAME );
1145 vectorName = vectorNameFromSignalName( plotTab, signalName, &traceType );
1146
1147 int id = col == COL_CURSOR_1 ? 1 : 2;
1148 bool enable = ii == row && text == wxS( "1" );
1149
1150 plotTab->EnableCursor( vectorName, traceType, id, enable, signalName );
1151 OnModify();
1152 }
1153
1154 // Update cursor checkboxes (which are really radio buttons)
1156 }
1157}
1158
1159
1161{
1162 if( m_SuppressGridEvents > 0 )
1163 return;
1164
1165 SIM_PLOT_TAB* plotTab = dynamic_cast<SIM_PLOT_TAB*>( GetCurrentSimTab() );
1166
1167 if( !plotTab )
1168 return;
1169
1170 int row = aEvent.GetRow();
1171 int col = aEvent.GetCol();
1172 wxString text = m_cursorsGrid->GetCellValue( row, col );
1173 wxString cursorName = m_cursorsGrid->GetCellValue( row, COL_CURSOR_NAME );
1174
1175 if( col == COL_CURSOR_X )
1176 {
1177 CURSOR* cursor1 = nullptr;
1178 CURSOR* cursor2 = nullptr;
1179
1180 for( const auto& [name, trace] : plotTab->GetTraces() )
1181 {
1182 if( CURSOR* cursor = trace->GetCursor( 1 ) )
1183 cursor1 = cursor;
1184
1185 if( CURSOR* cursor = trace->GetCursor( 2 ) )
1186 cursor2 = cursor;
1187 }
1188
1189 double value = SPICE_VALUE( text ).ToDouble();
1190
1191 if( cursorName == wxS( "1" ) && cursor1 )
1192 cursor1->SetCoordX( value );
1193 else if( cursorName == wxS( "2" ) && cursor2 )
1194 cursor2->SetCoordX( value );
1195 else if( cursorName == _( "Diff" ) && cursor1 && cursor2 )
1196 cursor2->SetCoordX( cursor1->GetCoords().x + value );
1197
1199 OnModify();
1200 }
1201 else
1202 {
1203 wxFAIL_MSG( wxT( "All other columns are supposed to be read-only!" ) );
1204 }
1205}
1206
1207
1209{
1210 SPICE_VALUE_FORMAT result;
1211 result.FromString( m_measurementsGrid->GetCellValue( aRow, COL_MEASUREMENT_FORMAT ) );
1212 return result;
1213}
1214
1215
1217{
1218 m_measurementsGrid->SetCellValue( aRow, COL_MEASUREMENT_FORMAT, aFormat.ToString() );
1219}
1220
1221
1223{
1224 if( aRow < ( m_measurementsGrid->GetNumberRows() - 1 ) )
1225 m_measurementsGrid->DeleteRows( aRow, 1 );
1226}
1227
1228
1230{
1231 SIM_PLOT_TAB* plotTab = dynamic_cast<SIM_PLOT_TAB*>( GetCurrentSimTab() );
1232
1233 if( !plotTab )
1234 return;
1235
1236 int row = aEvent.GetRow();
1237 int col = aEvent.GetCol();
1238 wxString text = m_measurementsGrid->GetCellValue( row, col );
1239
1240 if( col == COL_MEASUREMENT )
1241 {
1242 UpdateMeasurement( row );
1244 OnModify();
1245 }
1246 else
1247 {
1248 wxFAIL_MSG( wxT( "All other columns are supposed to be read-only!" ) );
1249 }
1250
1251 // Always leave a single empty row for type-in
1252
1253 int rowCount = (int) m_measurementsGrid->GetNumberRows();
1254 int emptyRows = 0;
1255
1256 for( row = rowCount - 1; row >= 0; row-- )
1257 {
1258 if( m_measurementsGrid->GetCellValue( row, COL_MEASUREMENT ).IsEmpty() )
1259 emptyRows++;
1260 else
1261 break;
1262 }
1263
1264 if( emptyRows > 1 )
1265 {
1266 int killRows = emptyRows - 1;
1267 m_measurementsGrid->DeleteRows( rowCount - killRows, killRows );
1268 }
1269 else if( emptyRows == 0 )
1270 {
1271 m_measurementsGrid->AppendRows( 1 );
1272 }
1273}
1274
1275
1276void SIMULATOR_FRAME_UI::OnUpdateUI( wxUpdateUIEvent& event )
1277{
1278 if( SIM_PLOT_TAB* plotTab = dynamic_cast<SIM_PLOT_TAB*>( GetCurrentSimTab() ) )
1279 {
1280 if( plotTab->GetLegendPosition() != plotTab->m_LastLegendPosition )
1281 {
1282 plotTab->m_LastLegendPosition = plotTab->GetLegendPosition();
1283 OnModify();
1284 }
1285 }
1286}
1287
1288
1304{
1305 static wxRegEx measureParamsRegEx( wxT( "^"
1306 " *"
1307 "([a-zA-Z_]+)"
1308 " +"
1309 "([a-zA-Z]*)\\(([^\\)]+)\\)" ) );
1310
1311 SIM_PLOT_TAB* plotTab = dynamic_cast<SIM_PLOT_TAB*>( GetCurrentSimTab() );
1312
1313 if( !plotTab )
1314 return;
1315
1316 wxString text = m_measurementsGrid->GetCellValue( aRow, COL_MEASUREMENT );
1317
1318 if( text.IsEmpty() )
1319 {
1320 m_measurementsGrid->SetCellValue( aRow, COL_MEASUREMENT_VALUE, wxEmptyString );
1321 return;
1322 }
1323
1324 wxString simType = simulator()->TypeToName( plotTab->GetSimType(), true );
1325 wxString resultName = wxString::Format( wxS( "meas_result_%u" ), aRow );
1326 wxString result = wxS( "?" );
1327
1328 if( measureParamsRegEx.Matches( text ) )
1329 {
1330 wxString func = measureParamsRegEx.GetMatch( text, 1 ).Upper();
1331 wxString signalType = measureParamsRegEx.GetMatch( text, 2 ).Upper();
1332 wxString deviceName = measureParamsRegEx.GetMatch( text, 3 );
1333 wxString units;
1335
1336 if( signalType.EndsWith( wxS( "DB" ) ) )
1337 {
1338 units = wxS( "dB" );
1339 }
1340 else if( signalType.StartsWith( 'I' ) )
1341 {
1342 units = wxS( "A" );
1343 }
1344 else if( signalType.StartsWith( 'P' ) )
1345 {
1346 units = wxS( "W" );
1347 // Our syntax is different from ngspice for power signals
1348 text = func + " " + deviceName + ":power";
1349 }
1350 else
1351 {
1352 units = wxS( "V" );
1353 }
1354
1355 if( func.EndsWith( wxS( "_AT" ) ) )
1356 {
1357 if( plotTab->GetSimType() == ST_AC || plotTab->GetSimType() == ST_SP )
1358 units = wxS( "Hz" );
1359 else
1360 units = wxS( "s" );
1361 }
1362 else if( func.StartsWith( wxS( "INTEG" ) ) )
1363 {
1364 switch( plotTab->GetSimType() )
1365 {
1366 case ST_TRAN:
1367 if ( signalType.StartsWith( 'P' ) )
1368 units = wxS( "J" );
1369 else
1370 units += wxS( ".s" );
1371
1372 break;
1373
1374 case ST_AC:
1375 case ST_SP:
1376 case ST_DISTO:
1377 case ST_NOISE:
1378 case ST_FFT:
1379 case ST_SENS: // If there is a vector, it is frequency
1380 units += wxS( "·Hz" );
1381 break;
1382
1383 case ST_DC: // Could be a lot of things : V, A, deg C, ohm, ...
1384 case ST_OP: // There is no vector for integration
1385 case ST_PZ: // There is no vector for integration
1386 case ST_TF: // There is no vector for integration
1387 default:
1388 units += wxS( "·?" );
1389 break;
1390 }
1391 }
1392
1393 fmt.UpdateUnits( units );
1394 SetMeasureFormat( aRow, fmt );
1395
1397 }
1398
1400 {
1401 wxString cmd = wxString::Format( wxS( "meas %s %s %s" ), simType, resultName, text );
1402 simulator()->Command( "echo " + cmd.ToStdString() );
1403 simulator()->Command( cmd.ToStdString() );
1404
1405 std::vector<double> resultVec = simulator()->GetGainVector( resultName.ToStdString() );
1406
1407 if( resultVec.size() > 0 )
1408 result = SPICE_VALUE( resultVec[0] ).ToString( GetMeasureFormat( aRow ) );
1409 }
1410
1411 m_measurementsGrid->SetCellValue( aRow, COL_MEASUREMENT_VALUE, result );
1412}
1413
1414
1415void SIMULATOR_FRAME_UI::AddTuner( const SCH_SHEET_PATH& aSheetPath, SCH_SYMBOL* aSymbol )
1416{
1417 SIM_PLOT_TAB* plotTab = dynamic_cast<SIM_PLOT_TAB*>( GetCurrentSimTab() );
1418
1419 if( !plotTab )
1420 return;
1421
1422 wxString ref = aSymbol->GetRef( &aSheetPath );
1423
1424 // Do not add multiple instances for the same component.
1425 for( TUNER_SLIDER* tuner : m_tuners )
1426 {
1427 if( tuner->GetSymbolRef() == ref )
1428 return;
1429 }
1430
1431 const SPICE_ITEM* item = GetExporter()->FindItem( ref );
1432
1433 // Do nothing if the symbol is not tunable.
1434 if( !item || !item->model->GetTunerParam() )
1435 return;
1436
1437 try
1438 {
1439 TUNER_SLIDER* tuner = new TUNER_SLIDER( this, m_panelTuners, aSheetPath, aSymbol );
1440 m_sizerTuners->Add( tuner );
1441 m_tuners.push_back( tuner );
1442 m_panelTuners->Layout();
1443 OnModify();
1444 }
1445 catch( const KI_PARAM_ERROR& e )
1446 {
1447 DisplayErrorMessage( nullptr, e.What() );
1448 }
1449}
1450
1451
1452void SIMULATOR_FRAME_UI::UpdateTunerValue( const SCH_SHEET_PATH& aSheetPath, const KIID& aSymbol,
1453 const wxString& aRef, const wxString& aValue )
1454{
1455 SCH_ITEM* item = aSheetPath.GetItem( aSymbol );
1456 SCH_SYMBOL* symbol = dynamic_cast<SCH_SYMBOL*>( item );
1457
1458 if( !symbol )
1459 {
1460 DisplayErrorMessage( this, _( "Could not apply tuned value(s):" ) + wxS( " " )
1461 + wxString::Format( _( "%s not found" ), aRef ) );
1462 return;
1463 }
1464
1465 NULL_REPORTER devnull;
1466 SIM_LIB_MGR mgr( &m_schematicFrame->Prj() );
1467 SIM_MODEL& model = mgr.CreateModel( &aSheetPath, *symbol, devnull ).model;
1468
1469 const SIM_MODEL::PARAM* tunerParam = model.GetTunerParam();
1470
1471 if( !tunerParam )
1472 {
1473 DisplayErrorMessage( this, _( "Could not apply tuned value(s):" ) + wxS( " " )
1474 + wxString::Format( _( "%s is not tunable" ), aRef ) );
1475 return;
1476 }
1477
1478 model.SetParamValue( tunerParam->info.name, std::string( aValue.ToUTF8() ) );
1479 model.WriteFields( symbol->GetFields() );
1480
1481 m_schematicFrame->UpdateItem( symbol, false, true );
1483}
1484
1485
1487{
1488 m_tuners.remove( aTuner );
1489 aTuner->Destroy();
1490 m_panelTuners->Layout();
1491 OnModify();
1492}
1493
1494
1495void SIMULATOR_FRAME_UI::AddMeasurement( const wxString& aCmd )
1496{
1497 // -1 because the last one is for user input
1498 for( int i = 0; i < m_measurementsGrid->GetNumberRows(); i++ )
1499 {
1500 if ( m_measurementsGrid->GetCellValue( i, COL_MEASUREMENT ) == aCmd )
1501 return; // Don't create duplicates
1502 }
1503
1504 SIM_PLOT_TAB* plotTab = dynamic_cast<SIM_PLOT_TAB*>( GetCurrentSimTab() );
1505
1506 if( !plotTab )
1507 return;
1508
1509 wxString simType = simulator()->TypeToName( plotTab->GetSimType(), true );
1510 int row;
1511
1512 for( row = 0; row < m_measurementsGrid->GetNumberRows(); ++row )
1513 {
1514 if( m_measurementsGrid->GetCellValue( row, COL_MEASUREMENT ).IsEmpty() )
1515 break;
1516 }
1517
1518 if( !m_measurementsGrid->GetCellValue( row, COL_MEASUREMENT ).IsEmpty() )
1519 {
1520 m_measurementsGrid->AppendRows( 1 );
1521 row = m_measurementsGrid->GetNumberRows() - 1;
1522 }
1523
1524 m_measurementsGrid->SetCellValue( row, COL_MEASUREMENT, aCmd );
1525
1526 UpdateMeasurement( row );
1528 OnModify();
1529
1530 // Always leave at least one empty row for type-in:
1531 row = m_measurementsGrid->GetNumberRows() - 1;
1532
1533 if( !m_measurementsGrid->GetCellValue( row, COL_MEASUREMENT ).IsEmpty() )
1534 m_measurementsGrid->AppendRows( 1 );
1535}
1536
1537
1538void SIMULATOR_FRAME_UI::DoFourier( const wxString& aSignal, const wxString& aFundamental )
1539{
1540 wxString cmd = wxString::Format( wxS( "fourier %s %s" ),
1541 SPICE_VALUE( aFundamental ).ToSpiceString(),
1542 aSignal );
1543
1544 simulator()->Command( cmd.ToStdString() );
1545}
1546
1547
1549{
1550 return circuitModel().get();
1551}
1552
1553
1554void SIMULATOR_FRAME_UI::AddTrace( const wxString& aName, SIM_TRACE_TYPE aType )
1555{
1556 if( !GetCurrentSimTab() )
1557 {
1558 m_simConsole->AppendText( _( "Error: no current simulation.\n" ) );
1559 m_simConsole->SetInsertionPointEnd();
1560 return;
1561 }
1562
1563 SIM_TYPE simType = SPICE_CIRCUIT_MODEL::CommandToSimType( GetCurrentSimTab()->GetSimCommand() );
1564
1565 if( simType == ST_UNKNOWN )
1566 {
1567 m_simConsole->AppendText( _( "Error: simulation type not defined.\n" ) );
1568 m_simConsole->SetInsertionPointEnd();
1569 return;
1570 }
1571 else if( !SIM_TAB::IsPlottable( simType ) )
1572 {
1573 m_simConsole->AppendText( _( "Error: simulation type doesn't support plotting.\n" ) );
1574 m_simConsole->SetInsertionPointEnd();
1575 return;
1576 }
1577
1578 if( SIM_PLOT_TAB* plotTab = dynamic_cast<SIM_PLOT_TAB*>( GetCurrentSimTab() ) )
1579 {
1580 if( simType == ST_AC )
1581 {
1582 updateTrace( aName, aType | SPT_AC_GAIN, plotTab );
1583 updateTrace( aName, aType | SPT_AC_PHASE, plotTab );
1584 }
1585 else if( simType == ST_SP )
1586 {
1587 updateTrace( aName, aType | SPT_AC_GAIN, plotTab );
1588 updateTrace( aName, aType | SPT_AC_PHASE, plotTab );
1589 }
1590 else
1591 {
1592 updateTrace( aName, aType, plotTab );
1593 }
1594
1595 plotTab->GetPlotWin()->UpdateAll();
1596 }
1597
1599 OnModify();
1600}
1601
1602
1603void SIMULATOR_FRAME_UI::SetUserDefinedSignals( const std::map<int, wxString>& aNewSignals )
1604{
1605 for( size_t ii = 0; ii < m_plotNotebook->GetPageCount(); ++ii )
1606 {
1607 SIM_PLOT_TAB* plotTab = dynamic_cast<SIM_PLOT_TAB*>( m_plotNotebook->GetPage( ii ) );
1608
1609 if( !plotTab )
1610 continue;
1611
1612 for( const auto& [ id, existingSignal ] : m_userDefinedSignals )
1613 {
1614 int traceType = SPT_UNKNOWN;
1615 wxString vectorName = vectorNameFromSignalName( plotTab, existingSignal, &traceType );
1616
1617 if( aNewSignals.count( id ) == 0 )
1618 {
1619 if( plotTab->GetSimType() == ST_AC )
1620 {
1621 for( int subType : { SPT_AC_GAIN, SPT_AC_PHASE } )
1622 plotTab->DeleteTrace( vectorName, traceType | subType );
1623 }
1624 else if( plotTab->GetSimType() == ST_SP )
1625 {
1626 for( int subType : { SPT_SP_AMP, SPT_AC_PHASE } )
1627 plotTab->DeleteTrace( vectorName, traceType | subType );
1628 }
1629 else
1630 {
1631 plotTab->DeleteTrace( vectorName, traceType );
1632 }
1633 }
1634 else
1635 {
1636 if( plotTab->GetSimType() == ST_AC )
1637 {
1638 for( int subType : { SPT_AC_GAIN, SPT_AC_PHASE } )
1639 {
1640 if( TRACE* trace = plotTab->GetTrace( vectorName, traceType | subType ) )
1641 trace->SetName( aNewSignals.at( id ) );
1642 }
1643 }
1644 else if( plotTab->GetSimType() == ST_SP )
1645 {
1646 for( int subType : { SPT_SP_AMP, SPT_AC_PHASE } )
1647 {
1648 if( TRACE* trace = plotTab->GetTrace( vectorName, traceType | subType ) )
1649 trace->SetName( aNewSignals.at( id ) );
1650 }
1651 }
1652 else
1653 {
1654 if( TRACE* trace = plotTab->GetTrace( vectorName, traceType ) )
1655 trace->SetName( aNewSignals.at( id ) );
1656 }
1657 }
1658 }
1659 }
1660
1661 m_userDefinedSignals = aNewSignals;
1662
1665
1667 rebuildSignalsGrid( m_filter->GetValue() );
1670 OnModify();
1671}
1672
1673
1674void SIMULATOR_FRAME_UI::updateTrace( const wxString& aVectorName, int aTraceType,
1675 SIM_PLOT_TAB* aPlotTab, std::vector<double>* aDataX,
1676 bool aClearData )
1677{
1679
1680 aTraceType &= aTraceType & SPT_Y_AXIS_MASK;
1681 aTraceType |= getXAxisType( simType );
1682
1683 wxString simVectorName = aVectorName;
1684
1685 if( aTraceType & SPT_POWER )
1686 simVectorName = simVectorName.AfterFirst( '(' ).BeforeLast( ')' ) + wxS( ":power" );
1687
1688 if( !SIM_TAB::IsPlottable( simType ) )
1689 {
1690 // There is no plot to be shown
1691 simulator()->Command( wxString::Format( wxT( "print %s" ), aVectorName ).ToStdString() );
1692
1693 return;
1694 }
1695
1696 std::vector<double> data_x;
1697 std::vector<double> data_y;
1698
1699 if( !aDataX || aClearData )
1700 aDataX = &data_x;
1701
1702 // First, handle the x axis
1703 if( aDataX->empty() && !aClearData )
1704 {
1705 wxString xAxisName( simulator()->GetXAxis( simType ) );
1706
1707 if( xAxisName.IsEmpty() )
1708 return;
1709
1710 *aDataX = simulator()->GetGainVector( (const char*) xAxisName.c_str() );
1711 }
1712
1713 unsigned int size = aDataX->size();
1714
1715 switch( simType )
1716 {
1717 case ST_AC:
1718 if( aTraceType & SPT_AC_GAIN )
1719 data_y = simulator()->GetGainVector( (const char*) simVectorName.c_str(), size );
1720 else if( aTraceType & SPT_AC_PHASE )
1721 data_y = simulator()->GetPhaseVector( (const char*) simVectorName.c_str(), size );
1722 else
1723 wxFAIL_MSG( wxT( "Plot type missing AC_PHASE or AC_MAG bit" ) );
1724
1725 break;
1726 case ST_SP:
1727 if( aTraceType & SPT_SP_AMP )
1728 data_y = simulator()->GetGainVector( (const char*) simVectorName.c_str(), size );
1729 else if( aTraceType & SPT_AC_PHASE )
1730 data_y = simulator()->GetPhaseVector( (const char*) simVectorName.c_str(), size );
1731 else
1732 wxFAIL_MSG( wxT( "Plot type missing AC_PHASE or SPT_SP_AMP bit" ) );
1733
1734 break;
1735
1736 case ST_DC:
1737 data_y = simulator()->GetGainVector( (const char*) simVectorName.c_str(), -1 );
1738 break;
1739
1740 case ST_NOISE:
1741 case ST_TRAN:
1742 case ST_FFT:
1743 data_y = simulator()->GetGainVector( (const char*) simVectorName.c_str(), size );
1744 break;
1745
1746 default:
1747 wxFAIL_MSG( wxT( "Unhandled plot type" ) );
1748 }
1749
1750 SPICE_DC_PARAMS source1, source2;
1751 int sweepCount = 1;
1752 size_t sweepSize = std::numeric_limits<size_t>::max();
1753
1754 if( simType == ST_DC
1755 && circuitModel()->ParseDCCommand( aPlotTab->GetSimCommand(), &source1, &source2 )
1756 && !source2.m_source.IsEmpty() )
1757 {
1758 SPICE_VALUE v = ( source2.m_vend - source2.m_vstart ) / source2.m_vincrement;
1759
1760 sweepCount = KiROUND( v.ToDouble() ) + 1;
1761 sweepSize = aDataX->size() / sweepCount;
1762 }
1763
1764 if( TRACE* trace = aPlotTab->GetOrAddTrace( aVectorName, aTraceType ) )
1765 {
1766 if( data_y.size() >= size )
1767 aPlotTab->SetTraceData( trace, *aDataX, data_y, sweepCount, sweepSize );
1768 }
1769}
1770
1771
1773{
1774 SIM_PLOT_TAB* plotTab = dynamic_cast<SIM_PLOT_TAB*>( GetCurrentSimTab() );
1775
1776 for( int row = 0; row < m_signalsGrid->GetNumberRows(); ++row )
1777 {
1778 wxString signalName = m_signalsGrid->GetCellValue( row, COL_SIGNAL_NAME );
1779 int traceType = SPT_UNKNOWN;
1780 wxString vectorName = vectorNameFromSignalName( plotTab, signalName, &traceType );
1781
1782 if( TRACE* trace = plotTab ? plotTab->GetTrace( vectorName, traceType ) : nullptr )
1783 {
1784 m_signalsGrid->SetCellValue( row, COL_SIGNAL_SHOW, wxS( "1" ) );
1785
1786 wxGridCellAttr* attr = new wxGridCellAttr;
1787 attr->SetRenderer( new GRID_CELL_COLOR_RENDERER( this ) );
1788 attr->SetEditor( new GRID_CELL_COLOR_SELECTOR( this, m_signalsGrid ) );
1789 attr->SetAlignment( wxALIGN_CENTER, wxALIGN_CENTER );
1790 m_signalsGrid->SetAttr( row, COL_SIGNAL_COLOR, attr );
1791
1792 KIGFX::COLOR4D color( trace->GetPen().GetColour() );
1793 m_signalsGrid->SetCellValue( row, COL_SIGNAL_COLOR, color.ToCSSString() );
1794
1795 attr = new wxGridCellAttr;
1796 attr->SetRenderer( new wxGridCellBoolRenderer() );
1797 attr->SetReadOnly(); // not really; we delegate interactivity to GRID_TRICKS
1798 attr->SetAlignment( wxALIGN_CENTER, wxALIGN_CENTER );
1799 m_signalsGrid->SetAttr( row, COL_CURSOR_1, attr );
1800
1801 attr = new wxGridCellAttr;
1802 attr->SetRenderer( new wxGridCellBoolRenderer() );
1803 attr->SetReadOnly(); // not really; we delegate interactivity to GRID_TRICKS
1804 attr->SetAlignment( wxALIGN_CENTER, wxALIGN_CENTER );
1805 m_signalsGrid->SetAttr( row, COL_CURSOR_2, attr );
1806
1807 if( trace->HasCursor( 1 ) )
1808 m_signalsGrid->SetCellValue( row, COL_CURSOR_1, wxS( "1" ) );
1809 else
1810 m_signalsGrid->SetCellValue( row, COL_CURSOR_1, wxEmptyString );
1811
1812 if( trace->HasCursor( 2 ) )
1813 m_signalsGrid->SetCellValue( row, COL_CURSOR_2, wxS( "1" ) );
1814 else
1815 m_signalsGrid->SetCellValue( row, COL_CURSOR_2, wxEmptyString );
1816 }
1817 else
1818 {
1819 m_signalsGrid->SetCellValue( row, COL_SIGNAL_SHOW, wxEmptyString );
1820
1821 wxGridCellAttr* attr = new wxGridCellAttr;
1822 attr->SetReadOnly();
1823 m_signalsGrid->SetAttr( row, COL_SIGNAL_COLOR, attr );
1824 m_signalsGrid->SetCellValue( row, COL_SIGNAL_COLOR, wxEmptyString );
1825
1826 attr = new wxGridCellAttr;
1827 attr->SetReadOnly();
1828 m_signalsGrid->SetAttr( row, COL_CURSOR_1, attr );
1829 m_signalsGrid->SetCellValue( row, COL_CURSOR_1, wxEmptyString );
1830
1831 attr = new wxGridCellAttr;
1832 attr->SetReadOnly();
1833 m_signalsGrid->SetAttr( row, COL_CURSOR_2, attr );
1834 m_signalsGrid->SetCellValue( row, COL_CURSOR_2, wxEmptyString );
1835 }
1836 }
1837}
1838
1839
1841{
1842 auto quoteNetNames =
1843 [&]( wxString aExpression ) -> wxString
1844 {
1845 for( const auto& [netname, quotedNetname] : m_quotedNetnames )
1846 aExpression.Replace( netname, quotedNetname );
1847
1848 return aExpression;
1849 };
1850
1851 for( const auto& [ id, signal ] : m_userDefinedSignals )
1852 {
1853 constexpr const char* cmd = "let user{} = {}";
1854
1855 simulator()->Command( "echo " + fmt::format( cmd, id, signal.ToStdString() ) );
1856 simulator()->Command( fmt::format( cmd, id, quoteNetNames( signal ).ToStdString() ) );
1857 }
1858}
1859
1860
1862{
1863 wxString errors;
1864 WX_STRING_REPORTER reporter( &errors );
1865
1866 for( const TUNER_SLIDER* tuner : m_tuners )
1867 {
1868 SCH_SHEET_PATH sheetPath;
1869 wxString ref = tuner->GetSymbolRef();
1870 KIID symbolId = tuner->GetSymbol( &sheetPath );
1871 SCH_ITEM* schItem = sheetPath.GetItem( symbolId );
1872 SCH_SYMBOL* symbol = dynamic_cast<SCH_SYMBOL*>( schItem );
1873
1874 if( !symbol )
1875 {
1876 reporter.Report( wxString::Format( _( "%s not found" ), ref ) );
1877 continue;
1878 }
1879
1880 const SPICE_ITEM* item = GetExporter()->FindItem( tuner->GetSymbolRef() );
1881
1882 if( !item || !item->model->GetTunerParam() )
1883 {
1884 reporter.Report( wxString::Format( _( "%s is not tunable" ), ref ) );
1885 continue;
1886 }
1887
1888 double floatVal = tuner->GetValue().ToDouble();
1889
1890 simulator()->Command( item->model->SpiceGenerator().TunerCommand( *item, floatVal ) );
1891 }
1892
1893 if( reporter.HasMessage() )
1894 DisplayErrorMessage( this, _( "Could not apply tuned value(s):" ) + wxS( "\n" ) + errors );
1895}
1896
1897
1898bool SIMULATOR_FRAME_UI::LoadWorkbook( const wxString& aPath )
1899{
1900 wxTextFile file( aPath );
1901
1902 if( !file.Open() )
1903 return false;
1904
1905 wxString firstLine = file.GetFirstLine();
1906 long dummy;
1907 bool legacy = firstLine.StartsWith( wxT( "version " ) ) || firstLine.ToLong( &dummy );
1908
1909 file.Close();
1910
1911 m_plotNotebook->DeleteAllPages();
1912 m_userDefinedSignals.clear();
1913
1914 if( legacy )
1915 {
1916 if( !loadLegacyWorkbook( aPath ) )
1917 return false;
1918 }
1919 else
1920 {
1921 if( !loadJsonWorkbook( aPath ) )
1922 return false;
1923 }
1924
1926
1927 rebuildSignalsGrid( m_filter->GetValue() );
1931
1932 wxFileName filename( aPath );
1933 filename.MakeRelativeTo( m_schematicFrame->Prj().GetProjectPath() );
1934
1935 // Remember the loaded workbook filename.
1936 simulator()->Settings()->SetWorkbookFilename( filename.GetFullPath() );
1937
1938 return true;
1939}
1940
1941
1942bool SIMULATOR_FRAME_UI::loadJsonWorkbook( const wxString& aPath )
1943{
1944 wxFFileInputStream fp( aPath, wxT( "rt" ) );
1945 wxStdInputStream fstream( fp );
1946
1947 if( !fp.IsOk() )
1948 return false;
1949
1950 try
1951 {
1952 nlohmann::json js = nlohmann::json::parse( fstream, nullptr, true, true );
1953
1954 std::map<SIM_PLOT_TAB*, nlohmann::json> traceInfo;
1955
1956 for( const nlohmann::json& tab_js : js[ "tabs" ] )
1957 {
1958 wxString simCommand;
1961
1962 for( const nlohmann::json& cmd : tab_js[ "commands" ] )
1963 {
1964 if( cmd == ".kicad adjustpaths" )
1966 else if( cmd == ".save all" )
1968 else if( cmd == ".probe alli" )
1970 else if( cmd == ".probe allp" )
1972 else if( cmd == ".kicad esavenone" )
1973 simOptions &= ~NETLIST_EXPORTER_SPICE::OPTION_SAVE_ALL_EVENTS;
1974 else
1975 simCommand += wxString( cmd.get<wxString>() ).Trim();
1976 }
1977
1978 SIM_TAB* simTab = NewSimTab( simCommand );
1979 SIM_PLOT_TAB* plotTab = dynamic_cast<SIM_PLOT_TAB*>( simTab );
1980
1981 simTab->SetSimOptions( simOptions );
1982
1983 if( plotTab )
1984 {
1985 if( tab_js.contains( "traces" ) )
1986 traceInfo[plotTab] = tab_js[ "traces" ];
1987
1988 if( tab_js.contains( "measurements" ) )
1989 {
1990 for( const nlohmann::json& m_js : tab_js[ "measurements" ] )
1991 plotTab->Measurements().emplace_back( m_js[ "expr" ], m_js[ "format" ] );
1992 }
1993
1994 plotTab->SetDottedSecondary( tab_js[ "dottedSecondary" ] );
1995 plotTab->ShowGrid( tab_js[ "showGrid" ] );
1996
1997 if( tab_js.contains( "fixedY1scale" ) )
1998 {
1999 const nlohmann::json& scale_js = tab_js[ "fixedY1scale" ];
2000 plotTab->SetY1Scale( true, scale_js[ "min" ], scale_js[ "max" ] );
2001 plotTab->GetPlotWin()->LockY( true );
2002 }
2003
2004 if( tab_js.contains( "fixedY2scale" ) )
2005 {
2006 const nlohmann::json& scale_js = tab_js[ "fixedY2scale" ];
2007 plotTab->SetY2Scale( true, scale_js[ "min" ], scale_js[ "max" ] );
2008 plotTab->GetPlotWin()->LockY( true );
2009 }
2010
2011 if( tab_js.contains( "fixedY3scale" ) )
2012 {
2013 plotTab->EnsureThirdYAxisExists();
2014 const nlohmann::json& scale_js = tab_js[ "fixedY3scale" ];
2015 plotTab->SetY3Scale( true, scale_js[ "min" ], scale_js[ "max" ] );
2016 plotTab->GetPlotWin()->LockY( true );
2017 }
2018
2019 if( tab_js.contains( "legend" ) )
2020 {
2021 const nlohmann::json& legend_js = tab_js[ "legend" ];
2022 plotTab->SetLegendPosition( wxPoint( legend_js[ "x" ], legend_js[ "y" ] ) );
2023 plotTab->ShowLegend( true );
2024 }
2025
2026 if( tab_js.contains( "margins" ) )
2027 {
2028 const nlohmann::json& margins_js = tab_js[ "margins" ];
2029 plotTab->GetPlotWin()->SetMargins( margins_js[ "top" ],
2030 margins_js[ "right" ],
2031 margins_js[ "bottom" ],
2032 margins_js[ "left" ] );
2033 }
2034 }
2035 }
2036
2037 int ii = 0;
2038
2039 if( js.contains( "user_defined_signals" ) )
2040 {
2041 for( const nlohmann::json& signal_js : js[ "user_defined_signals" ] )
2042 m_userDefinedSignals[ii++] = wxString( signal_js.get<wxString>() );
2043 }
2044
2045 auto addCursor =
2046 [this]( SIM_PLOT_TAB* aPlotTab, TRACE* aTrace, const wxString& aSignalName,
2047 int aCursorId, const nlohmann::json& aCursor_js )
2048 {
2049 if( aCursorId == 1 || aCursorId == 2 )
2050 {
2051 CURSOR* cursor = new CURSOR( aTrace, aPlotTab );
2052
2053 cursor->SetName( aSignalName );
2054 cursor->SetPen( wxPen( aTrace->GetTraceColour() ) );
2055 cursor->SetCoordX( aCursor_js[ "position" ] );
2056
2057 aTrace->SetCursor( aCursorId, cursor );
2058 aPlotTab->GetPlotWin()->AddLayer( cursor );
2059 }
2060
2061 m_cursorFormats[aCursorId-1][0].FromString( aCursor_js[ "x_format" ] );
2062 m_cursorFormats[aCursorId-1][1].FromString( aCursor_js[ "y_format" ] );
2063 };
2064
2065 for( const auto& [ plotTab, traces_js ] : traceInfo )
2066 {
2067 for( const nlohmann::json& trace_js : traces_js )
2068 {
2069 wxString signalName = trace_js[ "signal" ];
2070 wxString vectorName = vectorNameFromSignalName( plotTab, signalName, nullptr );
2071 TRACE* trace = plotTab->GetOrAddTrace( vectorName, trace_js[ "trace_type" ] );
2072
2073 if( trace )
2074 {
2075 if( trace_js.contains( "cursor1" ) )
2076 addCursor( plotTab, trace, signalName, 1, trace_js[ "cursor1" ] );
2077
2078 if( trace_js.contains( "cursor2" ) )
2079 addCursor( plotTab, trace, signalName, 2, trace_js[ "cursor2" ] );
2080
2081 if( trace_js.contains( "cursorD" ) )
2082 addCursor( plotTab, trace, signalName, 3, trace_js[ "cursorD" ] );
2083
2084 if( trace_js.contains( "color" ) )
2085 {
2086 wxColour color;
2087 color.Set( wxString( trace_js["color"].get<wxString>() ) );
2088 trace->SetTraceColour( color );
2089 plotTab->UpdateTraceStyle( trace );
2090 }
2091 }
2092 }
2093
2094 plotTab->UpdatePlotColors();
2095 }
2096
2097 if( SIM_TAB* simTab = GetCurrentSimTab() )
2098 {
2099 m_simulatorFrame->LoadSimulator( simTab->GetSimCommand(), simTab->GetSimOptions() );
2100
2101 if( SIM_TAB* firstTab = dynamic_cast<SIM_TAB*>( m_plotNotebook->GetPage( 0 ) ) )
2102 firstTab->SetLastSchTextSimCommand( js[ "last_sch_text_sim_command" ] );
2103 }
2104 }
2105 catch( nlohmann::json::parse_error& error )
2106 {
2107 wxLogTrace( traceSettings, wxT( "Json parse error reading %s: %s" ), aPath, error.what() );
2108
2109 return false;
2110 }
2111 catch( nlohmann::json::type_error& error )
2112 {
2113 wxLogTrace( traceSettings, wxT( "Json type error reading %s: %s" ), aPath, error.what() );
2114
2115 return false;
2116 }
2117 catch( nlohmann::json::invalid_iterator& error )
2118 {
2119 wxLogTrace( traceSettings, wxT( "Json invalid_iterator error reading %s: %s" ), aPath, error.what() );
2120
2121 return false;
2122 }
2123 catch( nlohmann::json::out_of_range& error )
2124 {
2125 wxLogTrace( traceSettings, wxT( "Json out_of_range error reading %s: %s" ), aPath, error.what() );
2126
2127 return false;
2128 }
2129 catch( ... )
2130 {
2131 wxLogTrace( traceSettings, wxT( "Error reading %s" ), aPath );
2132 return false;
2133 }
2134
2135 return true;
2136}
2137
2138
2139bool SIMULATOR_FRAME_UI::SaveWorkbook( const wxString& aPath )
2140{
2142
2143 wxFileName filename = aPath;
2144 filename.SetExt( FILEEXT::WorkbookFileExtension );
2145
2146 wxFile file;
2147
2148 file.Create( filename.GetFullPath(), true /* overwrite */ );
2149
2150 if( !file.IsOpened() )
2151 return false;
2152
2153 nlohmann::json tabs_js = nlohmann::json::array();
2154
2155 for( size_t i = 0; i < m_plotNotebook->GetPageCount(); i++ )
2156 {
2157 SIM_TAB* simTab = dynamic_cast<SIM_TAB*>( m_plotNotebook->GetPage( i ) );
2158
2159 if( !simTab )
2160 continue;
2161
2162 SIM_TYPE simType = simTab->GetSimType();
2163
2164 nlohmann::json commands_js = nlohmann::json::array();
2165
2166 commands_js.push_back( simTab->GetSimCommand() );
2167
2168 int options = simTab->GetSimOptions();
2169
2171 commands_js.push_back( ".kicad adjustpaths" );
2172
2174 commands_js.push_back( ".save all" );
2175
2177 commands_js.push_back( ".probe alli" );
2178
2180 commands_js.push_back( ".probe allp" );
2181
2183 commands_js.push_back( ".kicad esavenone" );
2184
2185 nlohmann::json tab_js = nlohmann::json(
2186 { { "analysis", SPICE_SIMULATOR::TypeToName( simType, true ) },
2187 { "commands", commands_js } } );
2188
2189 if( SIM_PLOT_TAB* plotTab = dynamic_cast<SIM_PLOT_TAB*>( simTab ) )
2190 {
2191 nlohmann::json traces_js = nlohmann::json::array();
2192
2193 auto findSignalName =
2194 [&]( const wxString& aVectorName ) -> wxString
2195 {
2196 wxString vectorName;
2197 wxString suffix;
2198
2199 if( aVectorName.EndsWith( _( " (phase)" ) ) )
2200 suffix = _( " (phase)" );
2201 else if( aVectorName.EndsWith( _( " (gain)" ) ) )
2202 suffix = _( " (gain)" );
2203
2204 vectorName = aVectorName.Left( aVectorName.Length() - suffix.Length() );
2205
2206 for( const auto& [ id, signal ] : m_userDefinedSignals )
2207 {
2208 if( vectorName == vectorNameFromSignalId( id ) )
2209 return signal + suffix;
2210 }
2211
2212 return aVectorName;
2213 };
2214
2215 for( const auto& [name, trace] : plotTab->GetTraces() )
2216 {
2217 nlohmann::json trace_js = nlohmann::json(
2218 { { "trace_type", (int) trace->GetType() },
2219 { "signal", findSignalName( trace->GetDisplayName() ) },
2220 { "color", COLOR4D( trace->GetTraceColour() ).ToCSSString() } } );
2221
2222 if( CURSOR* cursor = trace->GetCursor( 1 ) )
2223 {
2224 trace_js["cursor1"] = nlohmann::json(
2225 { { "position", cursor->GetCoords().x },
2226 { "x_format", m_cursorFormats[0][0].ToString() },
2227 { "y_format", m_cursorFormats[0][1].ToString() } } );
2228 }
2229
2230 if( CURSOR* cursor = trace->GetCursor( 2 ) )
2231 {
2232 trace_js["cursor2"] = nlohmann::json(
2233 { { "position", cursor->GetCoords().x },
2234 { "x_format", m_cursorFormats[1][0].ToString() },
2235 { "y_format", m_cursorFormats[1][1].ToString() } } );
2236 }
2237
2238 if( trace->GetCursor( 1 ) || trace->GetCursor( 2 ) )
2239 {
2240 trace_js["cursorD"] = nlohmann::json(
2241 { { "x_format", m_cursorFormats[2][0].ToString() },
2242 { "y_format", m_cursorFormats[2][1].ToString() } } );
2243 }
2244
2245 traces_js.push_back( trace_js );
2246 }
2247
2248 nlohmann::json measurements_js = nlohmann::json::array();
2249
2250 for( const auto& [ measurement, format ] : plotTab->Measurements() )
2251 {
2252 measurements_js.push_back( nlohmann::json( { { "expr", measurement },
2253 { "format", format } } ) );
2254 }
2255
2256 tab_js[ "traces" ] = traces_js;
2257 tab_js[ "measurements" ] = measurements_js;
2258 tab_js[ "dottedSecondary" ] = plotTab->GetDottedSecondary();
2259 tab_js[ "showGrid" ] = plotTab->IsGridShown();
2260
2261 double min, max;
2262
2263 if( plotTab->GetY1Scale( &min, &max ) )
2264 tab_js[ "fixedY1scale" ] = nlohmann::json( { { "min", min }, { "max", max } } );
2265
2266 if( plotTab->GetY2Scale( &min, &max ) )
2267 tab_js[ "fixedY2scale" ] = nlohmann::json( { { "min", min }, { "max", max } } );
2268
2269 if( plotTab->GetY3Scale( &min, &max ) )
2270 tab_js[ "fixedY3scale" ] = nlohmann::json( { { "min", min }, { "max", max } } );
2271
2272 if( plotTab->IsLegendShown() )
2273 {
2274 tab_js[ "legend" ] = nlohmann::json( { { "x", plotTab->GetLegendPosition().x },
2275 { "y", plotTab->GetLegendPosition().y } } );
2276 }
2277
2278 mpWindow* plotWin = plotTab->GetPlotWin();
2279
2280 tab_js[ "margins" ] = nlohmann::json( { { "left", plotWin->GetMarginLeft() },
2281 { "right", plotWin->GetMarginRight() },
2282 { "top", plotWin->GetMarginTop() },
2283 { "bottom", plotWin->GetMarginBottom() } } );
2284 }
2285
2286 tabs_js.push_back( tab_js );
2287 }
2288
2289 nlohmann::json userDefinedSignals_js = nlohmann::json::array();
2290
2291 for( const auto& [ id, signal ] : m_userDefinedSignals )
2292 userDefinedSignals_js.push_back( signal );
2293
2294 nlohmann::json js = nlohmann::json( { { "version", 6 },
2295 { "tabs", tabs_js },
2296 { "user_defined_signals", userDefinedSignals_js } } );
2297
2298 // Store the value of any simulation command found on the schematic sheet in a SCH_TEXT
2299 // object. If this changes we want to warn the user and ask them if they want to update
2300 // the corresponding panel's sim command.
2301 if( m_plotNotebook->GetPageCount() > 0 )
2302 {
2303 SIM_TAB* simTab = dynamic_cast<SIM_TAB*>( m_plotNotebook->GetPage( 0 ) );
2304 js[ "last_sch_text_sim_command" ] = simTab->GetLastSchTextSimCommand();
2305 }
2306
2307 std::stringstream buffer;
2308 buffer << std::setw( 2 ) << js << std::endl;
2309
2310 bool res = file.Write( buffer.str() );
2311 file.Close();
2312
2313 // Store the filename of the last saved workbook.
2314 if( res )
2315 {
2316 filename.MakeRelativeTo( m_schematicFrame->Prj().GetProjectPath() );
2317 simulator()->Settings()->SetWorkbookFilename( filename.GetFullPath() );
2318 }
2319
2320 return res;
2321}
2322
2323
2325{
2326 switch( aType )
2327 {
2329 case ST_AC: return SPT_LIN_FREQUENCY;
2330 case ST_SP: return SPT_LIN_FREQUENCY;
2331 case ST_FFT: return SPT_LIN_FREQUENCY;
2332 case ST_DC: return SPT_SWEEP;
2333 case ST_TRAN: return SPT_TIME;
2334 case ST_NOISE: return SPT_LIN_FREQUENCY;
2335 default: wxFAIL_MSG( wxS( "Unhandled simulation type" ) ); return SPT_UNKNOWN;
2336 }
2337}
2338
2339
2341{
2342 wxString output;
2343 wxString ref;
2344 wxString source;
2345 wxString scale;
2346 SPICE_VALUE pts;
2347 SPICE_VALUE fStart;
2348 SPICE_VALUE fStop;
2349 bool saveAll;
2350
2351 if( GetCurrentSimTab() )
2352 {
2353 circuitModel()->ParseNoiseCommand( GetCurrentSimTab()->GetSimCommand(), &output, &ref,
2354 &source, &scale, &pts, &fStart, &fStop, &saveAll );
2355 }
2356
2357 return source;
2358}
2359
2360
2362{
2364
2365 // Rebuild the color list to plot traces
2367
2368 // Now send changes to all SIM_PLOT_TAB
2369 for( size_t page = 0; page < m_plotNotebook->GetPageCount(); page++ )
2370 {
2371 wxWindow* curPage = m_plotNotebook->GetPage( page );
2372
2373 // ensure it is truly a plot plotTab and not the (zero plots) placeholder
2374 // which is only SIM_TAB
2375 SIM_PLOT_TAB* plotTab = dynamic_cast<SIM_PLOT_TAB*>( curPage );
2376
2377 if( plotTab )
2378 plotTab->UpdatePlotColors();
2379 }
2380}
2381
2382
2383void SIMULATOR_FRAME_UI::onPlotClose( wxAuiNotebookEvent& event )
2384{
2385 OnModify();
2386}
2387
2388
2389void SIMULATOR_FRAME_UI::onPlotClosed( wxAuiNotebookEvent& event )
2390{
2391 CallAfter( [this]()
2392 {
2394 rebuildSignalsGrid( m_filter->GetValue() );
2396
2397 SIM_TAB* panel = GetCurrentSimTab();
2398
2399 if( !panel || panel->GetSimType() != ST_OP )
2400 {
2401 SCHEMATIC& schematic = m_schematicFrame->Schematic();
2402 schematic.ClearOperatingPoints();
2405 }
2406 } );
2407}
2408
2409
2411{
2412 if( SIM_PLOT_TAB* plotTab = dynamic_cast<SIM_PLOT_TAB*>( GetCurrentSimTab() ) )
2413 {
2414 std::vector<std::pair<wxString, wxString>>& measurements = plotTab->Measurements();
2415
2416 measurements.clear();
2417
2418 for( int row = 0; row < m_measurementsGrid->GetNumberRows(); ++row )
2419 {
2420 if( !m_measurementsGrid->GetCellValue( row, COL_MEASUREMENT ).IsEmpty() )
2421 {
2422 measurements.emplace_back( m_measurementsGrid->GetCellValue( row, COL_MEASUREMENT ),
2423 m_measurementsGrid->GetCellValue( row, COL_MEASUREMENT_FORMAT ) );
2424 }
2425 }
2426 }
2427}
2428
2429
2430void SIMULATOR_FRAME_UI::onPlotChanging( wxAuiNotebookEvent& event )
2431{
2433
2434 event.Skip();
2435}
2436
2437
2439{
2441 rebuildSignalsGrid( m_filter->GetValue() );
2443
2445
2446 for( int row = 0; row < m_measurementsGrid->GetNumberRows(); ++row )
2447 UpdateMeasurement( row );
2448}
2449
2450
2451void SIMULATOR_FRAME_UI::onPlotChanged( wxAuiNotebookEvent& event )
2452{
2453 if( SIM_TAB* simTab = GetCurrentSimTab() )
2454 simulator()->Command( "setplot " + simTab->GetSpicePlotName().ToStdString() );
2455
2457
2458 event.Skip();
2459}
2460
2461
2463{
2465
2466 if( SIM_PLOT_TAB* plotTab = dynamic_cast<SIM_PLOT_TAB*>( GetCurrentSimTab() ) )
2467 {
2468 for( const auto& [ measurement, format ] : plotTab->Measurements() )
2469 {
2470 int row = m_measurementsGrid->GetNumberRows();
2471 m_measurementsGrid->AppendRows();
2472 m_measurementsGrid->SetCellValue( row, COL_MEASUREMENT, measurement );
2473 m_measurementsGrid->SetCellValue( row, COL_MEASUREMENT_FORMAT, format );
2474 }
2475
2476 if( plotTab->GetSimType() == ST_TRAN || plotTab->GetSimType() == ST_AC
2477 || plotTab->GetSimType() == ST_DC || plotTab->GetSimType() == ST_SP )
2478 {
2479 m_measurementsGrid->AppendRows(); // Empty row at end
2480 }
2481 }
2482}
2483
2484
2485void SIMULATOR_FRAME_UI::onPlotDragged( wxAuiNotebookEvent& event )
2486{
2487}
2488
2489
2490std::shared_ptr<SPICE_SIMULATOR> SIMULATOR_FRAME_UI::simulator() const
2491{
2493}
2494
2495
2496std::shared_ptr<SPICE_CIRCUIT_MODEL> SIMULATOR_FRAME_UI::circuitModel() const
2497{
2499}
2500
2501
2503{
2504 SUPPRESS_GRID_CELL_EVENTS raii( this );
2505
2507
2508 SIM_PLOT_TAB* plotTab = dynamic_cast<SIM_PLOT_TAB*>( GetCurrentSimTab() );
2509
2510 if( !plotTab )
2511 return;
2512
2513 // Update cursor values
2514 CURSOR* cursor1 = nullptr;
2515 wxString cursor1Name;
2516 wxString cursor1Units;
2517 CURSOR* cursor2 = nullptr;
2518 wxString cursor2Name;
2519 wxString cursor2Units;
2520
2521 auto getUnitsY =
2522 [&]( TRACE* aTrace ) -> wxString
2523 {
2524 if( plotTab->GetSimType() == ST_AC )
2525 {
2526 if( aTrace->GetType() & SPT_AC_PHASE )
2527 return plotTab->GetUnitsY2();
2528 else
2529 return plotTab->GetUnitsY1();
2530 }
2531 else
2532 {
2533 if( aTrace->GetType() & SPT_POWER )
2534 return plotTab->GetUnitsY3();
2535 else if( aTrace->GetType() & SPT_CURRENT )
2536 return plotTab->GetUnitsY2();
2537 else
2538 return plotTab->GetUnitsY1();
2539 }
2540 };
2541
2542 auto getNameY =
2543 [&]( TRACE* aTrace ) -> wxString
2544 {
2545 if( plotTab->GetSimType() == ST_AC )
2546 {
2547 if( aTrace->GetType() & SPT_AC_PHASE )
2548 return plotTab->GetLabelY2();
2549 else
2550 return plotTab->GetLabelY1();
2551 }
2552 else
2553 {
2554 if( aTrace->GetType() & SPT_POWER )
2555 return plotTab->GetLabelY3();
2556 else if( aTrace->GetType() & SPT_CURRENT )
2557 return plotTab->GetLabelY2();
2558 else
2559 return plotTab->GetLabelY1();
2560 }
2561 };
2562
2563 auto formatValue =
2564 [this]( double aValue, int aCursorId, int aCol ) -> wxString
2565 {
2566 if( ( !m_simulatorFrame->SimFinished() && aCol == 1 ) || std::isnan( aValue ) )
2567 return wxS( "--" );
2568 else
2569 return SPICE_VALUE( aValue ).ToString( m_cursorFormats[ aCursorId ][ aCol ] );
2570 };
2571
2572 for( const auto& [name, trace] : plotTab->GetTraces() )
2573 {
2574 if( CURSOR* cursor = trace->GetCursor( 1 ) )
2575 {
2576 cursor1 = cursor;
2577 cursor1Name = getNameY( trace );
2578 cursor1Units = getUnitsY( trace );
2579
2580 wxRealPoint coords = cursor->GetCoords();
2581 int row = m_cursorsGrid->GetNumberRows();
2582
2583 m_cursorFormats[0][0].UpdateUnits( plotTab->GetUnitsX() );
2584 m_cursorFormats[0][1].UpdateUnits( cursor1Units );
2585
2586 m_cursorsGrid->AppendRows( 1 );
2587 m_cursorsGrid->SetCellValue( row, COL_CURSOR_NAME, wxS( "1" ) );
2588 m_cursorsGrid->SetCellValue( row, COL_CURSOR_SIGNAL, cursor->GetName() );
2589 m_cursorsGrid->SetCellValue( row, COL_CURSOR_X, formatValue( coords.x, 0, 0 ) );
2590 m_cursorsGrid->SetCellValue( row, COL_CURSOR_Y, formatValue( coords.y, 0, 1 ) );
2591 break;
2592 }
2593 }
2594
2595 for( const auto& [name, trace] : plotTab->GetTraces() )
2596 {
2597 if( CURSOR* cursor = trace->GetCursor( 2 ) )
2598 {
2599 cursor2 = cursor;
2600 cursor2Name = getNameY( trace );
2601 cursor2Units = getUnitsY( trace );
2602
2603 wxRealPoint coords = cursor->GetCoords();
2604 int row = m_cursorsGrid->GetNumberRows();
2605
2606 m_cursorFormats[1][0].UpdateUnits( plotTab->GetUnitsX() );
2607 m_cursorFormats[1][1].UpdateUnits( cursor2Units );
2608
2609 m_cursorsGrid->AppendRows( 1 );
2610 m_cursorsGrid->SetCellValue( row, COL_CURSOR_NAME, wxS( "2" ) );
2611 m_cursorsGrid->SetCellValue( row, COL_CURSOR_SIGNAL, cursor->GetName() );
2612 m_cursorsGrid->SetCellValue( row, COL_CURSOR_X, formatValue( coords.x, 1, 0 ) );
2613 m_cursorsGrid->SetCellValue( row, COL_CURSOR_Y, formatValue( coords.y, 1, 1 ) );
2614 break;
2615 }
2616 }
2617
2618 if( cursor1 && cursor2 && cursor1Units == cursor2Units )
2619 {
2620 wxRealPoint coords = cursor2->GetCoords() - cursor1->GetCoords();
2621 wxString signal;
2622
2623 m_cursorFormats[2][0].UpdateUnits( plotTab->GetUnitsX() );
2624 m_cursorFormats[2][1].UpdateUnits( cursor1Units );
2625
2626 if( cursor1->GetName() == cursor2->GetName() )
2627 signal = wxString::Format( wxS( "%s[2 - 1]" ), cursor2->GetName() );
2628 else
2629 signal = wxString::Format( wxS( "%s - %s" ), cursor2->GetName(), cursor1->GetName() );
2630
2631 m_cursorsGrid->AppendRows( 1 );
2632 m_cursorsGrid->SetCellValue( 2, COL_CURSOR_NAME, _( "Diff" ) );
2633 m_cursorsGrid->SetCellValue( 2, COL_CURSOR_SIGNAL, signal );
2634 m_cursorsGrid->SetCellValue( 2, COL_CURSOR_X, formatValue( coords.x, 2, 0 ) );
2635 m_cursorsGrid->SetCellValue( 2, COL_CURSOR_Y, formatValue( coords.y, 2, 1 ) );
2636 }
2637
2638 // Set up the labels
2639 m_cursorsGrid->SetColLabelValue( COL_CURSOR_X, plotTab->GetLabelX() );
2640
2641 wxString valColName = _( "Value" );
2642
2643 if( !cursor1Name.IsEmpty() )
2644 {
2645 if( cursor2Name.IsEmpty() || cursor1Name == cursor2Name )
2646 valColName = cursor1Name;
2647 }
2648 else if( !cursor2Name.IsEmpty() )
2649 {
2650 valColName = cursor2Name;
2651 }
2652
2653 m_cursorsGrid->SetColLabelValue( COL_CURSOR_Y, valColName );
2654}
2655
2656
2657void SIMULATOR_FRAME_UI::onPlotCursorUpdate( wxCommandEvent& aEvent )
2658{
2660 OnModify();
2661}
2662
2663
2665{
2666 if( SIM_PLOT_TAB* plotTab = dynamic_cast<SIM_PLOT_TAB*>( GetCurrentSimTab() ) )
2667 plotTab->ResetScales( true );
2668
2669 m_simConsole->Clear();
2670
2671 // Do not export netlist, it is already stored in the simulator
2672 applyTuners();
2673
2674 m_refreshTimer.Start( REFRESH_INTERVAL, wxTIMER_ONE_SHOT );
2675}
2676
2677
2678void SIMULATOR_FRAME_UI::OnSimReport( const wxString& aMsg )
2679{
2680 m_simConsole->AppendText( aMsg + "\n" );
2681 m_simConsole->SetInsertionPointEnd();
2682}
2683
2684
2685std::vector<wxString> SIMULATOR_FRAME_UI::SimPlotVectors() const
2686{
2687 std::vector<wxString> signals;
2688
2689 for( const std::string& vec : simulator()->AllVectors() )
2690 signals.emplace_back( vec );
2691
2692 return signals;
2693}
2694
2695
2696std::vector<wxString> SIMULATOR_FRAME_UI::Signals() const
2697{
2698 std::vector<wxString> signals;
2699
2700 for( const wxString& signal : m_signals )
2701 signals.emplace_back( signal );
2702
2703 for( const auto& [ id, signal ] : m_userDefinedSignals )
2704 signals.emplace_back( signal );
2705
2706 sortSignals( signals );
2707
2708 return signals;
2709}
2710
2711
2713{
2714 if( aFinal )
2715 m_refreshTimer.Stop();
2716
2717 SIM_TAB* simTab = GetCurrentSimTab();
2718
2719 if( !simTab )
2720 return;
2721
2722 SIM_TYPE simType = simTab->GetSimType();
2723 wxString msg;
2724
2725 if( aFinal )
2726 {
2729 }
2730
2731 // If there are any signals plotted, update them
2732 if( SIM_TAB::IsPlottable( simType ) )
2733 {
2734 simTab->SetSpicePlotName( simulator()->CurrentPlotName() );
2735
2736 if( simType == ST_NOISE && aFinal )
2737 {
2738 m_simConsole->AppendText( _( "\n\nSimulation results:\n\n" ) );
2739 m_simConsole->SetInsertionPointEnd();
2740
2741 // The simulator will create noise1 & noise2 on the first run, noise3 and noise4
2742 // on the second, etc. The first plot for each run contains the spectral density
2743 // noise vectors and second contains the integrated noise.
2744 long number;
2745 simulator()->CurrentPlotName().Mid( 5 ).ToLong( &number );
2746
2747 for( const std::string& vec : simulator()->AllVectors() )
2748 {
2749 std::vector<double> val_list = simulator()->GetRealVector( vec, 1 );
2750 wxString value = SPICE_VALUE( val_list[ 0 ] ).ToSpiceString();
2751
2752 msg.Printf( wxS( "%s: %sV\n" ), vec, value );
2753
2754 m_simConsole->AppendText( msg );
2755 m_simConsole->SetInsertionPointEnd();
2756 }
2757
2758 simulator()->Command( fmt::format( "setplot noise{}", number - 1 ) );
2759 simTab->SetSpicePlotName( simulator()->CurrentPlotName() );
2760 }
2761
2762 SIM_PLOT_TAB* plotTab = dynamic_cast<SIM_PLOT_TAB*>( simTab );
2763 wxCHECK_RET( plotTab, wxT( "not a SIM_PLOT_TAB" ) );
2764
2765 struct TRACE_INFO
2766 {
2767 wxString Vector;
2768 int TraceType;
2769 bool ClearData;
2770 };
2771
2772 std::map<TRACE*, TRACE_INFO> traceMap;
2773
2774 for( const auto& [ name, trace ] : plotTab->GetTraces() )
2775 traceMap[ trace ] = { wxEmptyString, SPT_UNKNOWN, false };
2776
2777 // NB: m_signals are already broken out into gain/phase, but m_userDefinedSignals are
2778 // as the user typed them
2779
2780 for( const wxString& signal : m_signals )
2781 {
2782 int traceType = SPT_UNKNOWN;
2783 wxString vectorName = vectorNameFromSignalName( plotTab, signal, &traceType );
2784
2785 if( TRACE* trace = plotTab->GetTrace( vectorName, traceType ) )
2786 traceMap[ trace ] = { vectorName, traceType, false };
2787 }
2788
2789 for( const auto& [ id, signal ] : m_userDefinedSignals )
2790 {
2791 int traceType = SPT_UNKNOWN;
2792 wxString vectorName = vectorNameFromSignalName( plotTab, signal, &traceType );
2793
2794 if( simType == ST_AC )
2795 {
2796 int baseType = traceType &= ~( SPT_AC_GAIN | SPT_AC_PHASE );
2797
2798 for( int subType : { baseType | SPT_AC_GAIN, baseType | SPT_AC_PHASE } )
2799 {
2800 if( TRACE* trace = plotTab->GetTrace( vectorName, subType ) )
2801 traceMap[ trace ] = { vectorName, subType, !aFinal };
2802 }
2803 }
2804 else if( simType == ST_SP )
2805 {
2806 int baseType = traceType &= ~( SPT_SP_AMP | SPT_AC_PHASE );
2807
2808 for( int subType : { baseType | SPT_SP_AMP, baseType | SPT_AC_PHASE } )
2809 {
2810 if( TRACE* trace = plotTab->GetTrace( vectorName, subType ) )
2811 traceMap[trace] = { vectorName, subType, !aFinal };
2812 }
2813 }
2814 else
2815 {
2816 if( TRACE* trace = plotTab->GetTrace( vectorName, traceType ) )
2817 traceMap[ trace ] = { vectorName, traceType, !aFinal };
2818 }
2819 }
2820
2821 // Two passes so that DC-sweep sub-traces get deleted and re-created:
2822
2823 for( const auto& [ trace, traceInfo ] : traceMap )
2824 {
2825 if( traceInfo.Vector.IsEmpty() )
2826 plotTab->DeleteTrace( trace );
2827 }
2828
2829 for( const auto& [ trace, info ] : traceMap )
2830 {
2831 std::vector<double> data_x;
2832
2833 if( !info.Vector.IsEmpty() )
2834 updateTrace( info.Vector, info.TraceType, plotTab, &data_x, info.ClearData );
2835 }
2836
2837 plotTab->GetPlotWin()->UpdateAll();
2838
2839 if( aFinal )
2840 {
2841 for( int row = 0; row < m_measurementsGrid->GetNumberRows(); ++row )
2842 UpdateMeasurement( row );
2843
2844 plotTab->ResetScales( true );
2845 }
2846
2847 plotTab->GetPlotWin()->Fit();
2848
2850 }
2851 else if( simType == ST_OP && aFinal )
2852 {
2853 m_simConsole->AppendText( _( "\n\nSimulation results:\n\n" ) );
2854 m_simConsole->SetInsertionPointEnd();
2855
2856 for( const std::string& vec : simulator()->AllVectors() )
2857 {
2858 std::vector<double> val_list = simulator()->GetRealVector( vec, 1 );
2859
2860 if( val_list.empty() )
2861 continue;
2862
2863 wxString value = SPICE_VALUE( val_list[ 0 ] ).ToSpiceString();
2864 wxString signal;
2865 SIM_TRACE_TYPE type = circuitModel()->VectorToSignal( vec, signal );
2866
2867 const size_t tab = 25; //characters
2868 size_t padding = ( signal.length() < tab ) ? ( tab - signal.length() ) : 1;
2869
2870 switch( type )
2871 {
2872 case SPT_VOLTAGE: value.Append( wxS( "V" ) ); break;
2873 case SPT_CURRENT: value.Append( wxS( "A" ) ); break;
2874 case SPT_POWER: value.Append( wxS( "W" ) ); break;
2875 default: value.Append( wxS( "?" ) ); break;
2876 }
2877
2878 msg.Printf( wxT( "%s%s\n" ),
2879 ( signal + wxT( ":" ) ).Pad( padding, wxUniChar( ' ' ) ),
2880 value );
2881
2882 m_simConsole->AppendText( msg );
2883 m_simConsole->SetInsertionPointEnd();
2884
2885 if( type == SPT_VOLTAGE || type == SPT_CURRENT || type == SPT_POWER )
2886 signal = signal.SubString( 2, signal.Length() - 2 );
2887
2888 if( type == SPT_POWER )
2889 signal += wxS( ":power" );
2890
2891 m_schematicFrame->Schematic().SetOperatingPoint( signal, val_list.at( 0 ) );
2892 }
2893 }
2894 else if( simType == ST_PZ && aFinal )
2895 {
2896 m_simConsole->AppendText( _( "\n\nSimulation results:\n\n" ) );
2897 m_simConsole->SetInsertionPointEnd();
2898 simulator()->Command( "print all" );
2899 }
2900}
2901
2902
2904{
2906}
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:106
void GetFields(std::vector< SCH_FIELD * > &aVector, bool aVisibleOnly)
Populate a std::vector with SCH_FIELDs.
Definition: sch_symbol.cpp:982
const wxString GetRef(const SCH_SHEET_PATH *aSheet, bool aIncludeUnit=false) const override
Definition: sch_symbol.cpp:735
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
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.