KiCad PCB EDA Suite
•All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Modules Pages Concepts
sim_model.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) 2022 Mikolaj Wielgus
5 * Copyright (C) 2022 CERN
6 * Copyright The KiCad Developers, see AUTHORS.txt for contributors.
7 *
8 * This program is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU General Public License
10 * as published by the Free Software Foundation; either version 3
11 * of the License, or (at your option) any later version.
12 *
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
17 *
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, you may find one here:
20 * https://www.gnu.org/licenses/gpl-3.0.html
21 * or you may search the http://www.gnu.org website for the version 3 license,
22 * or you may write to the Free Software Foundation, Inc.,
23 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
24 */
25
26#include <ki_exception.h>
27#include <lib_symbol.h>
28#include <sch_symbol.h>
29#include <string_utils.h>
30#include <wx/regex.h>
31
32#include <iterator>
33
34#include <sim/sim_model.h>
35#include <sim/sim_model_behavioral.h>
36#include <sim/sim_model_ideal.h>
37#include <sim/sim_model_l_mutual.h>
38#include <sim/sim_model_ngspice.h>
39#include <sim/sim_model_r_pot.h>
40#include <sim/sim_model_ibis.h>
41#include <sim/sim_model_source.h>
42#include <sim/sim_model_raw_spice.h>
43#include <sim/sim_model_subckt.h>
44#include <sim/sim_model_switch.h>
45#include <sim/sim_model_tline.h>
46#include <sim/sim_model_xspice.h>
47#include <sim/sim_lib_mgr.h>
48#include <sim/sim_library_ibis.h>
49
50#include <boost/algorithm/string.hpp>
51#include <fmt/core.h>
52#include <pegtl/contrib/parse_tree.hpp>
53
54
55#include "sim_model_spice_fallback.h"
56
57using TYPE = SIM_MODEL::TYPE;
58
59
60SIM_MODEL::DEVICE_INFO SIM_MODEL::DeviceInfo( DEVICE_T aDeviceType )
61{
62 switch( aDeviceType )
63 {
64 // | fieldValue | description | showInMenu |
65 // -------------------------------------------------------
66 //
67 case DEVICE_T::NONE: return { "", "", true };
68 case DEVICE_T::R: return { "R", "Resistor", true };
69 case DEVICE_T::C: return { "C", "Capacitor", true };
70 case DEVICE_T::L: return { "L", "Inductor", true };
71 case DEVICE_T::K: return { "K", "Mutual Inductance Statement", true };
72 case DEVICE_T::TLINE: return { "TLINE", "Transmission Line", true };
73 case DEVICE_T::SW: return { "SW", "Switch", true };
74
75 case DEVICE_T::D: return { "D", "Diode", true };
76 case DEVICE_T::NPN: return { "NPN", "NPN BJT", true };
77 case DEVICE_T::PNP: return { "PNP", "PNP BJT", true };
78
79 case DEVICE_T::NJFET: return { "NJFET", "N-channel JFET", true };
80 case DEVICE_T::PJFET: return { "PJFET", "P-channel JFET", true };
81
82 case DEVICE_T::NMOS: return { "NMOS", "N-channel MOSFET", true };
83 case DEVICE_T::PMOS: return { "PMOS", "P-channel MOSFET", true };
84 case DEVICE_T::NMES: return { "NMES", "N-channel MESFET", true };
85 case DEVICE_T::PMES: return { "PMES", "P-channel MESFET", true };
86
87 case DEVICE_T::V: return { "V", "Voltage Source", true };
88 case DEVICE_T::I: return { "I", "Current Source", true };
89 case DEVICE_T::E: return { "E", "Voltage Source", false };
90 case DEVICE_T::F: return { "F", "Current Source", false };
91 case DEVICE_T::G: return { "G", "Current Source", false };
92 case DEVICE_T::H: return { "H", "Voltage Source", false };
93
94 case DEVICE_T::KIBIS: return { "IBIS", "IBIS Model", false };
95
96 case DEVICE_T::SUBCKT: return { "SUBCKT", "Subcircuit", false };
97 case DEVICE_T::XSPICE: return { "XSPICE", "XSPICE Code Model", true };
98 case DEVICE_T::SPICE: return { "SPICE", "Raw SPICE Element", true };
99
100 default: wxFAIL; return {};
101 }
102}
103
104
105SIM_MODEL::INFO SIM_MODEL::TypeInfo( TYPE aType )
106{
107 switch( aType )
108 {
109 // | deviceType | fieldValue | description |
110 // ---------------------------------------------------------------------
111 //
112 case TYPE::NONE: return { DEVICE_T::NONE, "", "" };
113
114 case TYPE::R: return { DEVICE_T::R, "", "Ideal" };
115 case TYPE::R_POT: return { DEVICE_T::R, "POT", "Potentiometer" };
116 case TYPE::R_BEHAVIORAL: return { DEVICE_T::R, "=", "Behavioral" };
117
118 case TYPE::C: return { DEVICE_T::C, "", "Ideal" };
119 case TYPE::C_BEHAVIORAL: return { DEVICE_T::C, "=", "Behavioral" };
120
121 case TYPE::L: return { DEVICE_T::L, "", "Ideal" };
122 case TYPE::L_BEHAVIORAL: return { DEVICE_T::L, "=", "Behavioral" };
123
124 case TYPE::K: return { DEVICE_T::K, "", "Mutual Inductance Statement" };
125
126 case TYPE::TLINE_Z0: return { DEVICE_T::TLINE, "", "Characteristic impedance" };
127 case TYPE::TLINE_RLGC: return { DEVICE_T::TLINE, "RLGC", "RLGC" };
128
129 case TYPE::SW_V: return { DEVICE_T::SW, "V", "Voltage-controlled" };
130 case TYPE::SW_I: return { DEVICE_T::SW, "I", "Current-controlled" };
131
132 case TYPE::D: return { DEVICE_T::D, "", "" };
133
134 case TYPE::NPN_VBIC: return { DEVICE_T::NPN, "VBIC", "VBIC" };
135 case TYPE::PNP_VBIC: return { DEVICE_T::PNP, "VBIC", "VBIC" };
136 case TYPE::NPN_GUMMELPOON: return { DEVICE_T::NPN, "GUMMELPOON", "Gummel-Poon" };
137 case TYPE::PNP_GUMMELPOON: return { DEVICE_T::PNP, "GUMMELPOON", "Gummel-Poon" };
138 //case TYPE::BJT_MEXTRAM: return {};
139 case TYPE::NPN_HICUM2: return { DEVICE_T::NPN, "HICUML2", "HICUM level 2" };
140 case TYPE::PNP_HICUM2: return { DEVICE_T::PNP, "HICUML2", "HICUM level 2" };
141 //case TYPE::BJT_HICUM_L0: return {};
142
143 case TYPE::NJFET_SHICHMANHODGES: return { DEVICE_T::NJFET, "SHICHMANHODGES", "Shichman-Hodges" };
144 case TYPE::PJFET_SHICHMANHODGES: return { DEVICE_T::PJFET, "SHICHMANHODGES", "Shichman-Hodges" };
145 case TYPE::NJFET_PARKERSKELLERN: return { DEVICE_T::NJFET, "PARKERSKELLERN", "Parker-Skellern" };
146 case TYPE::PJFET_PARKERSKELLERN: return { DEVICE_T::PJFET, "PARKERSKELLERN", "Parker-Skellern" };
147
148 case TYPE::NMES_STATZ: return { DEVICE_T::NMES, "STATZ", "Statz" };
149 case TYPE::PMES_STATZ: return { DEVICE_T::PMES, "STATZ", "Statz" };
150 case TYPE::NMES_YTTERDAL: return { DEVICE_T::NMES, "YTTERDAL", "Ytterdal" };
151 case TYPE::PMES_YTTERDAL: return { DEVICE_T::PMES, "YTTERDAL", "Ytterdal" };
152 case TYPE::NMES_HFET1: return { DEVICE_T::NMES, "HFET1", "HFET1" };
153 case TYPE::PMES_HFET1: return { DEVICE_T::PMES, "HFET1", "HFET1" };
154 case TYPE::NMES_HFET2: return { DEVICE_T::NMES, "HFET2", "HFET2" };
155 case TYPE::PMES_HFET2: return { DEVICE_T::PMES, "HFET2", "HFET2" };
156
157 case TYPE::NMOS_VDMOS: return { DEVICE_T::NMOS, "VDMOS", "VDMOS" };
158 case TYPE::PMOS_VDMOS: return { DEVICE_T::PMOS, "VDMOS", "VDMOS" };
159 case TYPE::NMOS_MOS1: return { DEVICE_T::NMOS, "MOS1", "Classical quadratic (MOS1)" };
160 case TYPE::PMOS_MOS1: return { DEVICE_T::PMOS, "MOS1", "Classical quadratic (MOS1)" };
161 case TYPE::NMOS_MOS2: return { DEVICE_T::NMOS, "MOS2", "Grove-Frohman (MOS2)" };
162 case TYPE::PMOS_MOS2: return { DEVICE_T::PMOS, "MOS2", "Grove-Frohman (MOS2)" };
163 case TYPE::NMOS_MOS3: return { DEVICE_T::NMOS, "MOS3", "MOS3" };
164 case TYPE::PMOS_MOS3: return { DEVICE_T::PMOS, "MOS3", "MOS3" };
165 case TYPE::NMOS_BSIM1: return { DEVICE_T::NMOS, "BSIM1", "BSIM1" };
166 case TYPE::PMOS_BSIM1: return { DEVICE_T::PMOS, "BSIM1", "BSIM1" };
167 case TYPE::NMOS_BSIM2: return { DEVICE_T::NMOS, "BSIM2", "BSIM2" };
168 case TYPE::PMOS_BSIM2: return { DEVICE_T::PMOS, "BSIM2", "BSIM2" };
169 case TYPE::NMOS_MOS6: return { DEVICE_T::NMOS, "MOS6", "MOS6" };
170 case TYPE::PMOS_MOS6: return { DEVICE_T::PMOS, "MOS6", "MOS6" };
171 case TYPE::NMOS_BSIM3: return { DEVICE_T::NMOS, "BSIM3", "BSIM3" };
172 case TYPE::PMOS_BSIM3: return { DEVICE_T::PMOS, "BSIM3", "BSIM3" };
173 case TYPE::NMOS_MOS9: return { DEVICE_T::NMOS, "MOS9", "MOS9" };
174 case TYPE::PMOS_MOS9: return { DEVICE_T::PMOS, "MOS9", "MOS9" };
175 case TYPE::NMOS_B4SOI: return { DEVICE_T::NMOS, "B4SOI", "BSIM4 SOI (B4SOI)" };
176 case TYPE::PMOS_B4SOI: return { DEVICE_T::PMOS, "B4SOI", "BSIM4 SOI (B4SOI)" };
177 case TYPE::NMOS_BSIM4: return { DEVICE_T::NMOS, "BSIM4", "BSIM4" };
178 case TYPE::PMOS_BSIM4: return { DEVICE_T::PMOS, "BSIM4", "BSIM4" };
179 //case TYPE::NMOS_EKV2_6: return {};
180 //case TYPE::PMOS_EKV2_6: return {};
181 //case TYPE::NMOS_PSP: return {};
182 //case TYPE::PMOS_PSP: return {};
183 case TYPE::NMOS_B3SOIFD: return { DEVICE_T::NMOS, "B3SOIFD", "B3SOIFD (BSIM3 FD-SOI)" };
184 case TYPE::PMOS_B3SOIFD: return { DEVICE_T::PMOS, "B3SOIFD", "B3SOIFD (BSIM3 FD-SOI)" };
185 case TYPE::NMOS_B3SOIDD: return { DEVICE_T::NMOS, "B3SOIDD", "B3SOIDD (BSIM3 SOI)" };
186 case TYPE::PMOS_B3SOIDD: return { DEVICE_T::PMOS, "B3SOIDD", "B3SOIDD (BSIM3 SOI)" };
187 case TYPE::NMOS_B3SOIPD: return { DEVICE_T::NMOS, "B3SOIPD", "B3SOIPD (BSIM3 PD-SOI)" };
188 case TYPE::PMOS_B3SOIPD: return { DEVICE_T::PMOS, "B3SOIPD", "B3SOIPD (BSIM3 PD-SOI)" };
189 //case TYPE::NMOS_STAG: return {};
190 //case TYPE::PMOS_STAG: return {};
191 case TYPE::NMOS_HISIM2: return { DEVICE_T::NMOS, "HISIM2", "HiSIM2" };
192 case TYPE::PMOS_HISIM2: return { DEVICE_T::PMOS, "HISIM2", "HiSIM2" };
193 case TYPE::NMOS_HISIMHV1: return { DEVICE_T::NMOS, "HISIMHV1", "HiSIM_HV1" };
194 case TYPE::PMOS_HISIMHV1: return { DEVICE_T::PMOS, "HISIMHV1", "HiSIM_HV1" };
195 case TYPE::NMOS_HISIMHV2: return { DEVICE_T::NMOS, "HISIMHV2", "HiSIM_HV2" };
196 case TYPE::PMOS_HISIMHV2: return { DEVICE_T::PMOS, "HISIMHV2", "HiSIM_HV2" };
197
198 case TYPE::V: return { DEVICE_T::V, "DC", "DC", };
199 case TYPE::V_SIN: return { DEVICE_T::V, "SIN", "Sine" };
200 case TYPE::V_PULSE: return { DEVICE_T::V, "PULSE", "Pulse" };
201 case TYPE::V_EXP: return { DEVICE_T::V, "EXP", "Exponential" };
202 case TYPE::V_AM: return { DEVICE_T::V, "AM", "Amplitude modulated" };
203 case TYPE::V_SFFM: return { DEVICE_T::V, "SFFM", "Single-frequency FM" };
204 case TYPE::V_VCL: return { DEVICE_T::E, "", "Voltage-controlled" };
205 case TYPE::V_CCL: return { DEVICE_T::H, "", "Current-controlled" };
206 case TYPE::V_PWL: return { DEVICE_T::V, "PWL", "Piecewise linear" };
207 case TYPE::V_WHITENOISE: return { DEVICE_T::V, "WHITENOISE", "White noise" };
208 case TYPE::V_PINKNOISE: return { DEVICE_T::V, "PINKNOISE", "Pink noise (1/f)" };
209 case TYPE::V_BURSTNOISE: return { DEVICE_T::V, "BURSTNOISE", "Burst noise" };
210 case TYPE::V_RANDUNIFORM: return { DEVICE_T::V, "RANDUNIFORM", "Random uniform" };
211 case TYPE::V_RANDGAUSSIAN: return { DEVICE_T::V, "RANDGAUSSIAN", "Random Gaussian" };
212 case TYPE::V_RANDEXP: return { DEVICE_T::V, "RANDEXP", "Random exponential" };
213 case TYPE::V_RANDPOISSON: return { DEVICE_T::V, "RANDPOISSON", "Random Poisson" };
214 case TYPE::V_BEHAVIORAL: return { DEVICE_T::V, "=", "Behavioral" };
215
216 case TYPE::I: return { DEVICE_T::I, "DC", "DC", };
217 case TYPE::I_SIN: return { DEVICE_T::I, "SIN", "Sine" };
218 case TYPE::I_PULSE: return { DEVICE_T::I, "PULSE", "Pulse" };
219 case TYPE::I_EXP: return { DEVICE_T::I, "EXP", "Exponential" };
220 case TYPE::I_AM: return { DEVICE_T::I, "AM", "Amplitude modulated" };
221 case TYPE::I_SFFM: return { DEVICE_T::I, "SFFM", "Single-frequency FM" };
222 case TYPE::I_VCL: return { DEVICE_T::G, "", "Voltage-controlled" };
223 case TYPE::I_CCL: return { DEVICE_T::F, "", "Current-controlled" };
224 case TYPE::I_PWL: return { DEVICE_T::I, "PWL", "Piecewise linear" };
225 case TYPE::I_WHITENOISE: return { DEVICE_T::I, "WHITENOISE", "White noise" };
226 case TYPE::I_PINKNOISE: return { DEVICE_T::I, "PINKNOISE", "Pink noise (1/f)" };
227 case TYPE::I_BURSTNOISE: return { DEVICE_T::I, "BURSTNOISE", "Burst noise" };
228 case TYPE::I_RANDUNIFORM: return { DEVICE_T::I, "RANDUNIFORM", "Random uniform" };
229 case TYPE::I_RANDGAUSSIAN: return { DEVICE_T::I, "RANDGAUSSIAN", "Random Gaussian" };
230 case TYPE::I_RANDEXP: return { DEVICE_T::I, "RANDEXP", "Random exponential" };
231 case TYPE::I_RANDPOISSON: return { DEVICE_T::I, "RANDPOISSON", "Random Poisson" };
232 case TYPE::I_BEHAVIORAL: return { DEVICE_T::I, "=", "Behavioral" };
233
234 case TYPE::SUBCKT: return { DEVICE_T::SUBCKT, "", "Subcircuit" };
235 case TYPE::XSPICE: return { DEVICE_T::XSPICE, "", "" };
236
237 case TYPE::KIBIS_DEVICE: return { DEVICE_T::KIBIS, "DEVICE", "Device" };
238 case TYPE::KIBIS_DRIVER_DC: return { DEVICE_T::KIBIS, "DCDRIVER", "DC driver" };
239 case TYPE::KIBIS_DRIVER_RECT: return { DEVICE_T::KIBIS, "RECTDRIVER", "Rectangular wave driver" };
240 case TYPE::KIBIS_DRIVER_PRBS: return { DEVICE_T::KIBIS, "PRBSDRIVER", "PRBS driver" };
241
242 case TYPE::RAWSPICE: return { DEVICE_T::SPICE, "", "" };
243
244 default: wxFAIL; return {};
245 }
246}
247
248
249SIM_MODEL::SPICE_INFO SIM_MODEL::SpiceInfo( TYPE aType )
250{
251 switch( aType )
252 {
253 // | itemType | modelType | fnName | level |isDefaultLvl|hasExpr|version|
254 // -------------------------------------------------------------------------
255 case TYPE::R: return { "R", "" };
256 case TYPE::R_POT: return { "A", "" };
257 case TYPE::R_BEHAVIORAL: return { "R", "", "", "0", false, true };
258
259 case TYPE::C: return { "C", "" };
260 case TYPE::C_BEHAVIORAL: return { "C", "", "", "0", false, true };
261
262 case TYPE::L: return { "L", "" };
263 case TYPE::L_BEHAVIORAL: return { "L", "", "", "0", false, true };
264
265 case TYPE::K: return { "K", "" };
266
267 //case TYPE::TLINE_Z0: return { "T" };
268 case TYPE::TLINE_Z0: return { "O", "LTRA" };
269 case TYPE::TLINE_RLGC: return { "O", "LTRA" };
270
271 case TYPE::SW_V: return { "S", "SW" };
272 case TYPE::SW_I: return { "W", "CSW" };
273
274 case TYPE::D: return { "D", "D" };
275
276 case TYPE::NPN_VBIC: return { "Q", "NPN", "", "4" };
277 case TYPE::PNP_VBIC: return { "Q", "PNP", "", "4" };
278 case TYPE::NPN_GUMMELPOON: return { "Q", "NPN", "", "1", true };
279 case TYPE::PNP_GUMMELPOON: return { "Q", "PNP", "", "1", true };
280 case TYPE::NPN_HICUM2: return { "Q", "NPN", "", "8" };
281 case TYPE::PNP_HICUM2: return { "Q", "PNP", "", "8" };
282
283 case TYPE::NJFET_SHICHMANHODGES: return { "J", "NJF", "", "1", true };
284 case TYPE::PJFET_SHICHMANHODGES: return { "J", "PJF", "", "1", true };
285 case TYPE::NJFET_PARKERSKELLERN: return { "J", "NJF", "", "2" };
286 case TYPE::PJFET_PARKERSKELLERN: return { "J", "PJF", "", "2" };
287
288 case TYPE::NMES_STATZ: return { "Z", "NMF", "", "1", true };
289 case TYPE::PMES_STATZ: return { "Z", "PMF", "", "1", true };
290 case TYPE::NMES_YTTERDAL: return { "Z", "NMF", "", "2" };
291 case TYPE::PMES_YTTERDAL: return { "Z", "PMF", "", "2" };
292 case TYPE::NMES_HFET1: return { "Z", "NMF", "", "5" };
293 case TYPE::PMES_HFET1: return { "Z", "PMF", "", "5" };
294 case TYPE::NMES_HFET2: return { "Z", "NMF", "", "6" };
295 case TYPE::PMES_HFET2: return { "Z", "PMF", "", "6" };
296
297 case TYPE::NMOS_VDMOS: return { "M", "VDMOS NCHAN" };
298 case TYPE::PMOS_VDMOS: return { "M", "VDMOS PCHAN" };
299 case TYPE::NMOS_MOS1: return { "M", "NMOS", "", "1", true };
300 case TYPE::PMOS_MOS1: return { "M", "PMOS", "", "1", true };
301 case TYPE::NMOS_MOS2: return { "M", "NMOS", "", "2" };
302 case TYPE::PMOS_MOS2: return { "M", "PMOS", "", "2" };
303 case TYPE::NMOS_MOS3: return { "M", "NMOS", "", "3" };
304 case TYPE::PMOS_MOS3: return { "M", "PMOS", "", "3" };
305 case TYPE::NMOS_BSIM1: return { "M", "NMOS", "", "4" };
306 case TYPE::PMOS_BSIM1: return { "M", "PMOS", "", "4" };
307 case TYPE::NMOS_BSIM2: return { "M", "NMOS", "", "5" };
308 case TYPE::PMOS_BSIM2: return { "M", "PMOS", "", "5" };
309 case TYPE::NMOS_MOS6: return { "M", "NMOS", "", "6" };
310 case TYPE::PMOS_MOS6: return { "M", "PMOS", "", "6" };
311 case TYPE::NMOS_BSIM3: return { "M", "NMOS", "", "8" };
312 case TYPE::PMOS_BSIM3: return { "M", "PMOS", "", "8" };
313 case TYPE::NMOS_MOS9: return { "M", "NMOS", "", "9" };
314 case TYPE::PMOS_MOS9: return { "M", "PMOS", "", "9" };
315 case TYPE::NMOS_B4SOI: return { "M", "NMOS", "", "10" };
316 case TYPE::PMOS_B4SOI: return { "M", "PMOS", "", "10" };
317 case TYPE::NMOS_BSIM4: return { "M", "NMOS", "", "14" };
318 case TYPE::PMOS_BSIM4: return { "M", "PMOS", "", "14" };
319 //case TYPE::NMOS_EKV2_6: return {};
320 //case TYPE::PMOS_EKV2_6: return {};
321 //case TYPE::NMOS_PSP: return {};
322 //case TYPE::PMOS_PSP: return {};
323 case TYPE::NMOS_B3SOIFD: return { "M", "NMOS", "", "55" };
324 case TYPE::PMOS_B3SOIFD: return { "M", "PMOS", "", "55" };
325 case TYPE::NMOS_B3SOIDD: return { "M", "NMOS", "", "56" };
326 case TYPE::PMOS_B3SOIDD: return { "M", "PMOS", "", "56" };
327 case TYPE::NMOS_B3SOIPD: return { "M", "NMOS", "", "57" };
328 case TYPE::PMOS_B3SOIPD: return { "M", "PMOS", "", "57" };
329 //case TYPE::NMOS_STAG: return {};
330 //case TYPE::PMOS_STAG: return {};
331 case TYPE::NMOS_HISIM2: return { "M", "NMOS", "", "68" };
332 case TYPE::PMOS_HISIM2: return { "M", "PMOS", "", "68" };
333 case TYPE::NMOS_HISIMHV1: return { "M", "NMOS", "", "73", false, false, "1.2.4" };
334 case TYPE::PMOS_HISIMHV1: return { "M", "PMOS", "", "73", false, false, "1.2.4" };
335 case TYPE::NMOS_HISIMHV2: return { "M", "NMOS", "", "73", false, false, "2.2.0" };
336 case TYPE::PMOS_HISIMHV2: return { "M", "PMOS", "", "73", false, false, "2.2.0" };
337
338 case TYPE::V: return { "V", "", "DC" };
339 case TYPE::V_SIN: return { "V", "", "SIN" };
340 case TYPE::V_PULSE: return { "V", "", "PULSE" };
341 case TYPE::V_EXP: return { "V", "", "EXP" };
342 case TYPE::V_AM: return { "V", "", "AM" };
343 case TYPE::V_SFFM: return { "V", "", "SFFM" };
344 case TYPE::V_VCL: return { "E", "", "" };
345 case TYPE::V_CCL: return { "H", "", "" };
346 case TYPE::V_PWL: return { "V", "", "PWL" };
347 case TYPE::V_WHITENOISE: return { "V", "", "TRNOISE" };
348 case TYPE::V_PINKNOISE: return { "V", "", "TRNOISE" };
349 case TYPE::V_BURSTNOISE: return { "V", "", "TRNOISE" };
350 case TYPE::V_RANDUNIFORM: return { "V", "", "TRRANDOM" };
351 case TYPE::V_RANDGAUSSIAN: return { "V", "", "TRRANDOM" };
352 case TYPE::V_RANDEXP: return { "V", "", "TRRANDOM" };
353 case TYPE::V_RANDPOISSON: return { "V", "", "TRRANDOM" };
354 case TYPE::V_BEHAVIORAL: return { "B" };
355
356 case TYPE::I: return { "I", "", "DC" };
357 case TYPE::I_PULSE: return { "I", "", "PULSE" };
358 case TYPE::I_SIN: return { "I", "", "SIN" };
359 case TYPE::I_EXP: return { "I", "", "EXP" };
360 case TYPE::I_AM: return { "V", "", "AM" };
361 case TYPE::I_SFFM: return { "V", "", "SFFM" };
362 case TYPE::I_VCL: return { "G", "", "" };
363 case TYPE::I_CCL: return { "F", "", "" };
364 case TYPE::I_PWL: return { "I", "", "PWL" };
365 case TYPE::I_WHITENOISE: return { "I", "", "TRNOISE" };
366 case TYPE::I_PINKNOISE: return { "I", "", "TRNOISE" };
367 case TYPE::I_BURSTNOISE: return { "I", "", "TRNOISE" };
368 case TYPE::I_RANDUNIFORM: return { "I", "", "TRRANDOM" };
369 case TYPE::I_RANDGAUSSIAN: return { "I", "", "TRRANDOM" };
370 case TYPE::I_RANDEXP: return { "I", "", "TRRANDOM" };
371 case TYPE::I_RANDPOISSON: return { "I", "", "TRRANDOM" };
372 case TYPE::I_BEHAVIORAL: return { "B" };
373
374 case TYPE::SUBCKT: return { "X" };
375 case TYPE::XSPICE: return { "A" };
376
377 case TYPE::KIBIS_DEVICE: return { "X" };
378 case TYPE::KIBIS_DRIVER_DC: return { "X" };
379 case TYPE::KIBIS_DRIVER_RECT: return { "X" };
380 case TYPE::KIBIS_DRIVER_PRBS: return { "X" };
381
382 case TYPE::NONE:
383 case TYPE::RAWSPICE: return {};
384
385 default: wxFAIL; return {};
386 }
387}
388
389
390TYPE SIM_MODEL::ReadTypeFromFields( const std::vector<SCH_FIELD>& aFields, REPORTER& aReporter )
391{
392 std::string deviceTypeFieldValue = GetFieldValue( &aFields, SIM_DEVICE_FIELD );
393 std::string typeFieldValue = GetFieldValue( &aFields, SIM_DEVICE_SUBTYPE_FIELD );
394
395 if( !deviceTypeFieldValue.empty() )
396 {
397 for( TYPE type : TYPE_ITERATOR() )
398 {
399 if( typeFieldValue == TypeInfo( type ).fieldValue )
400 {
401 if( deviceTypeFieldValue == DeviceInfo( TypeInfo( type ).deviceType ).fieldValue )
402 return type;
403 }
404 }
405 }
406
407 if( typeFieldValue.empty() )
408 return TYPE::NONE;
409
410 wxString reference = GetFieldValue( &aFields, FIELD_T::REFERENCE );
411
412 if( !reference.IsEmpty() )
413 {
414 aReporter.Report( wxString::Format( _( "No simulation model definition found for "
415 "symbol '%s'." ),
416 reference ),
417 RPT_SEVERITY_ERROR );
418 }
419 else
420 {
421 aReporter.Report( _( "No simulation model definition found." ),
422 RPT_SEVERITY_ERROR );
423 }
424
425 return TYPE::NONE;
426}
427
428
429void SIM_MODEL::ReadDataFields( const std::vector<SCH_FIELD>* aFields,
430 const std::vector<SCH_PIN*>& aPins )
431{
432 bool diffMode = GetFieldValue( aFields, SIM_LIBRARY_IBIS::DIFF_FIELD ) == "1";
433 SwitchSingleEndedDiff( diffMode );
434
435 m_serializer->ParseEnable( GetFieldValue( aFields, SIM_LEGACY_ENABLE_FIELD_V7 ) );
436
437 createPins( aPins );
438 m_serializer->ParsePins( GetFieldValue( aFields, SIM_PINS_FIELD ) );
439
440 std::string paramsField = GetFieldValue( aFields, SIM_PARAMS_FIELD );
441
442 if( !m_serializer->ParseParams( paramsField ) )
443 m_serializer->ParseValue( GetFieldValue( aFields, SIM_VALUE_FIELD ) );
444}
445
446
447void SIM_MODEL::WriteFields( std::vector<SCH_FIELD>& aFields ) const
448{
449 // Remove duplicate fields: they are at the end of list
450 for( size_t ii = aFields.size() - 1; ii > 0; ii-- )
451 {
452 wxString currFieldName = aFields[ii].GetName();
453
454 auto end_candidate_list = aFields.begin() + ii - 1;
455
456 auto fieldIt = std::find_if( aFields.begin(), end_candidate_list,
457 [&]( const SCH_FIELD& f )
458 {
459 return f.GetName() == currFieldName;
460 } );
461
462 // If duplicate field found: remove current checked item
463 if( fieldIt != end_candidate_list )
464 aFields.erase( aFields.begin() + ii );
465 }
466
467 SetFieldValue( aFields, SIM_DEVICE_FIELD, m_serializer->GenerateDevice(), false );
468 SetFieldValue( aFields, SIM_DEVICE_SUBTYPE_FIELD, m_serializer->GenerateDeviceSubtype(),
469 false );
470
471 SetFieldValue( aFields, SIM_LEGACY_ENABLE_FIELD_V7, m_serializer->GenerateEnable(), false );
472 SetFieldValue( aFields, SIM_PINS_FIELD, m_serializer->GeneratePins(), false );
473
474 SetFieldValue( aFields, SIM_PARAMS_FIELD, m_serializer->GenerateParams(), false );
475
476 if( IsStoredInValue() )
477 SetFieldValue( aFields, SIM_VALUE_FIELD, m_serializer->GenerateValue(), false );
478}
479
480
481std::unique_ptr<SIM_MODEL> SIM_MODEL::Create( TYPE aType, const std::vector<SCH_PIN*>& aPins,
482 REPORTER& aReporter )
483{
484 std::unique_ptr<SIM_MODEL> model = Create( aType );
485
486 try
487 {
488 // Passing nullptr to ReadDataFields will make it act as if all fields were empty.
489 model->ReadDataFields( static_cast<const std::vector<SCH_FIELD>*>( nullptr ), aPins );
490 }
491 catch( IO_ERROR& )
492 {
493 wxFAIL_MSG( "Shouldn't throw reading empty fields!" );
494 }
495
496 return model;
497}
498
499
500std::unique_ptr<SIM_MODEL> SIM_MODEL::Create( const SIM_MODEL* aBaseModel,
501 const std::vector<SCH_PIN*>& aPins,
502 REPORTER& aReporter )
503{
504 std::unique_ptr<SIM_MODEL> model;
505
506 if( aBaseModel )
507 {
508 TYPE type = aBaseModel->GetType();
509
510 if( dynamic_cast<const SIM_MODEL_SPICE_FALLBACK*>( aBaseModel ) )
511 model = std::make_unique<SIM_MODEL_SPICE_FALLBACK>( type );
512 else if( dynamic_cast< const SIM_MODEL_RAW_SPICE*>( aBaseModel ) )
513 model = std::make_unique<SIM_MODEL_RAW_SPICE>();
514 else
515 model = Create( type );
516
517 model->SetBaseModel( *aBaseModel );
518 }
519 else // No base model means the model wasn't found in the library, so create a fallback
520 {
521 model = std::make_unique<SIM_MODEL_SPICE_FALLBACK>( TYPE::NONE );
522 }
523
524 try
525 {
526 model->ReadDataFields( static_cast<const std::vector<SCH_FIELD>*>( nullptr ), aPins );
527 }
528 catch( IO_ERROR& )
529 {
530 wxFAIL_MSG( "Shouldn't throw reading empty fields!" );
531 }
532
533 return model;
534}
535
536
537std::unique_ptr<SIM_MODEL> SIM_MODEL::Create( const SIM_MODEL* aBaseModel,
538 const std::vector<SCH_PIN*>& aPins,
539 const std::vector<SCH_FIELD>& aFields,
540 REPORTER& aReporter )
541{
542 std::unique_ptr<SIM_MODEL> model;
543
544 if( aBaseModel )
545 {
546 NULL_REPORTER devnull;
547 TYPE type = aBaseModel->GetType();
548 TYPE type_override = ReadTypeFromFields( aFields, devnull );
549
550 // Check for an override in the case of IBIS models.
551 // The other models require type to be set from the base model.
552 if( dynamic_cast<const SIM_MODEL_IBIS*>( aBaseModel ) &&
553 type_override != TYPE::NONE )
554 {
555 type = type_override;
556 }
557
558 if( dynamic_cast<const SIM_MODEL_SPICE_FALLBACK*>( aBaseModel ) )
559 model = std::make_unique<SIM_MODEL_SPICE_FALLBACK>( type );
560 else if( dynamic_cast< const SIM_MODEL_RAW_SPICE*>( aBaseModel ) )
561 model = std::make_unique<SIM_MODEL_RAW_SPICE>();
562 else
563 model = Create( type );
564
565 model->SetBaseModel( *aBaseModel );
566 }
567 else // No base model means the model wasn't found in the library, so create a fallback
568 {
569 TYPE type = ReadTypeFromFields( aFields, aReporter );
570 model = std::make_unique<SIM_MODEL_SPICE_FALLBACK>( type );
571 }
572
573 try
574 {
575 model->ReadDataFields( &aFields, aPins );
576 }
577 catch( IO_ERROR& err )
578 {
579 aReporter.Report( wxString::Format( _( "Error reading simulation model from "
580 "symbol '%s':\n%s" ),
581 GetFieldValue( &aFields, FIELD_T::REFERENCE ),
582 err.Problem() ),
583 RPT_SEVERITY_ERROR );
584 }
585
586 return model;
587}
588
589
590std::unique_ptr<SIM_MODEL> SIM_MODEL::Create( const std::vector<SCH_FIELD>& aFields,
591 const std::vector<SCH_PIN*>& aPins,
592 bool aResolved, REPORTER& aReporter )
593{
594 TYPE type = ReadTypeFromFields( aFields, aReporter );
595 std::unique_ptr<SIM_MODEL> model = SIM_MODEL::Create( type );
596
597 try
598 {
599 model->ReadDataFields( &aFields, aPins );
600 }
601 catch( const IO_ERROR& parse_err )
602 {
603 if( !aResolved )
604 {
605 aReporter.Report( parse_err.What(), RPT_SEVERITY_ERROR );
606 return model;
607 }
608
609 // Just because we can't parse it doesn't mean that a SPICE interpreter can't. Fall
610 // back to a raw spice code model.
611
612 std::string modelData = GetFieldValue( &aFields, SIM_PARAMS_FIELD );
613
614 if( modelData.empty() )
615 modelData = GetFieldValue( &aFields, SIM_VALUE_FIELD );
616
617 model = std::make_unique<SIM_MODEL_RAW_SPICE>( modelData );
618
619 try
620 {
621 model->createPins( aPins );
622 model->m_serializer->ParsePins( GetFieldValue( &aFields, SIM_PINS_FIELD ) );
623 }
624 catch( const IO_ERROR& err )
625 {
626 // We own the pin syntax, so if we can't parse it then there's an error.
627 aReporter.Report( wxString::Format( _( "Error reading simulation model from "
628 "symbol '%s':\n%s" ),
629 GetFieldValue( &aFields, FIELD_T::REFERENCE ),
630 err.Problem() ),
631 RPT_SEVERITY_ERROR );
632 }
633 }
634
635 return model;
636}
637
638
639SIM_MODEL::~SIM_MODEL() = default;
640
641
642void SIM_MODEL::AddPin( const SIM_MODEL_PIN& aPin )
643{
644 m_modelPins.push_back( aPin );
645}
646
647
648void SIM_MODEL::ClearPins()
649{
650 m_modelPins.clear();
651}
652
653
654int SIM_MODEL::FindModelPinIndex( const std::string& aSymbolPinNumber )
655{
656 for( int modelPinIndex = 0; modelPinIndex < GetPinCount(); ++modelPinIndex )
657 {
658 if( GetPin( modelPinIndex ).symbolPinNumber == aSymbolPinNumber )
659 return modelPinIndex;
660 }
661
662 return SIM_MODEL_PIN::NOT_CONNECTED;
663}
664
665
666void SIM_MODEL::AddParam( const PARAM::INFO& aInfo )
667{
668 m_params.emplace_back( aInfo );
669
670 // Enums are initialized with their default values.
671 if( aInfo.enumValues.size() >= 1 )
672 m_params.back().value = aInfo.defaultValue;
673}
674
675
676void SIM_MODEL::SetBaseModel( const SIM_MODEL& aBaseModel )
677{
678 wxASSERT_MSG( GetType() == aBaseModel.GetType(),
679 wxS( "Simulation model type must be the same as its base class!" ) );
680
681 m_baseModel = &aBaseModel;
682}
683
684
685std::vector<std::reference_wrapper<const SIM_MODEL_PIN>> SIM_MODEL::GetPins() const
686{
687 std::vector<std::reference_wrapper<const SIM_MODEL_PIN>> pins;
688
689 for( int modelPinIndex = 0; modelPinIndex < GetPinCount(); ++modelPinIndex )
690 pins.emplace_back( GetPin( modelPinIndex ) );
691
692 return pins;
693}
694
695void SIM_MODEL::AssignSymbolPinNumberToModelPin( int aModelPinIndex,
696 const wxString& aSymbolPinNumber )
697{
698 if( aModelPinIndex >= 0 && aModelPinIndex < (int) m_modelPins.size() )
699 m_modelPins.at( aModelPinIndex ).symbolPinNumber = aSymbolPinNumber;
700}
701
702
703void SIM_MODEL::AssignSymbolPinNumberToModelPin( const std::string& aModelPinName,
704 const wxString& aSymbolPinNumber )
705{
706 for( SIM_MODEL_PIN& pin : m_modelPins )
707 {
708 if( pin.modelPinName == aModelPinName )
709 {
710 pin.symbolPinNumber = aSymbolPinNumber;
711 return;
712 }
713 }
714
715 // If aPinName wasn't in fact a name, see if it's a raw (1-based) index. This is required
716 // for legacy files which didn't use pin names.
717 int pinIndex = (int) strtol( aModelPinName.c_str(), nullptr, 10 );
718
719 if( pinIndex < 1 || pinIndex > (int) m_modelPins.size() )
720 THROW_IO_ERROR( wxString::Format( _( "Unknown simulation model pin '%s'" ), aModelPinName ) );
721
722 m_modelPins[ --pinIndex /* convert to 0-based */ ].symbolPinNumber = aSymbolPinNumber;
723}
724
725
726const SIM_MODEL::PARAM& SIM_MODEL::GetParam( unsigned aParamIndex ) const
727{
728 if( m_baseModel && m_params.at( aParamIndex ).value == "" )
729 return m_baseModel->GetParam( aParamIndex );
730 else
731 return m_params.at( aParamIndex );
732}
733
734
735bool SIM_MODEL::PARAM::INFO::Matches( const std::string& aParamName ) const
736{
737 return boost::iequals( name, aParamName );
738}
739
740
741int SIM_MODEL::doFindParam( const std::string& aParamName ) const
742{
743 for( int ii = 0; ii < (int) GetParamCount(); ++ii )
744 {
745 if( GetParam( ii ).Matches( aParamName ) )
746 return ii;
747 }
748
749 return -1;
750}
751
752
753const SIM_MODEL::PARAM* SIM_MODEL::FindParam( const std::string& aParamName ) const
754{
755 int idx = doFindParam( aParamName );
756
757 return idx >= 0 ? &GetParam( idx ) : nullptr;
758}
759
760
761const SIM_MODEL::PARAM& SIM_MODEL::GetParamOverride( unsigned aParamIndex ) const
762{
763 return m_params.at( aParamIndex );
764}
765
766
767const SIM_MODEL::PARAM& SIM_MODEL::GetBaseParam( unsigned aParamIndex ) const
768{
769 if( m_baseModel )
770 return m_baseModel->GetParam( aParamIndex );
771 else
772 return m_params.at( aParamIndex );
773}
774
775
776void SIM_MODEL::doSetParamValue( int aParamIndex, const std::string& aValue )
777{
778 m_params.at( aParamIndex ).value = aValue;
779}
780
781
782void SIM_MODEL::SetParamValue( int aParamIndex, const std::string& aValue,
783 SIM_VALUE::NOTATION aNotation )
784{
785 // Notation conversion is very slow. Avoid if possible.
786
787 auto plainNumber =
788 []( const std::string& aString )
789 {
790 for( char c : aString )
791 {
792 if( c != '.' && ( c < '0' || c > '9' ) )
793 return false;
794 }
795
796 return true;
797 };
798
799
800 if( aValue.find( ',' ) != std::string::npos )
801 {
802 doSetParamValue( aParamIndex, SIM_VALUE::ConvertNotation( aValue, aNotation,
803 SIM_VALUE::NOTATION::SI ) );
804 }
805 else if( aNotation != SIM_VALUE::NOTATION::SI && !plainNumber( aValue ) )
806 {
807 doSetParamValue( aParamIndex, SIM_VALUE::ConvertNotation( aValue, aNotation,
808 SIM_VALUE::NOTATION::SI ) );
809 }
810 else
811 {
812 doSetParamValue( aParamIndex, aValue );
813 }
814}
815
816
817void SIM_MODEL::SetParamValue( const std::string& aParamName, const std::string& aValue,
818 SIM_VALUE::NOTATION aNotation )
819{
820 int idx = doFindParam( aParamName );
821
822 if( idx < 0 )
823 THROW_IO_ERROR( wxString::Format( "Unknown simulation model parameter '%s'", aParamName ) );
824
825 SetParamValue( idx, aValue, aNotation );
826}
827
828
829std::unique_ptr<SIM_MODEL> SIM_MODEL::Create( TYPE aType )
830{
831 switch( aType )
832 {
833 case TYPE::R:
834 case TYPE::C:
835 case TYPE::L:
836 return std::make_unique<SIM_MODEL_IDEAL>( aType );
837
838 case TYPE::R_POT:
839 return std::make_unique<SIM_MODEL_R_POT>();
840
841 case TYPE::K:
842 return std::make_unique<SIM_MODEL_L_MUTUAL>();
843
844 case TYPE::R_BEHAVIORAL:
845 case TYPE::C_BEHAVIORAL:
846 case TYPE::L_BEHAVIORAL:
847 case TYPE::V_BEHAVIORAL:
848 case TYPE::I_BEHAVIORAL:
849 return std::make_unique<SIM_MODEL_BEHAVIORAL>( aType );
850
851 case TYPE::TLINE_Z0:
852 case TYPE::TLINE_RLGC:
853 return std::make_unique<SIM_MODEL_TLINE>( aType );
854
855 case TYPE::SW_V:
856 case TYPE::SW_I:
857 return std::make_unique<SIM_MODEL_SWITCH>( aType );
858
859 case TYPE::V:
860 case TYPE::I:
861 case TYPE::V_SIN:
862 case TYPE::I_SIN:
863 case TYPE::V_PULSE:
864 case TYPE::I_PULSE:
865 case TYPE::V_EXP:
866 case TYPE::I_EXP:
867 case TYPE::V_AM:
868 case TYPE::I_AM:
869 case TYPE::V_SFFM:
870 case TYPE::I_SFFM:
871 case TYPE::V_VCL:
872 case TYPE::V_CCL:
873 case TYPE::V_PWL:
874 case TYPE::I_VCL:
875 case TYPE::I_CCL:
876 case TYPE::I_PWL:
877 case TYPE::V_WHITENOISE:
878 case TYPE::I_WHITENOISE:
879 case TYPE::V_PINKNOISE:
880 case TYPE::I_PINKNOISE:
881 case TYPE::V_BURSTNOISE:
882 case TYPE::I_BURSTNOISE:
883 case TYPE::V_RANDUNIFORM:
884 case TYPE::I_RANDUNIFORM:
885 case TYPE::V_RANDGAUSSIAN:
886 case TYPE::I_RANDGAUSSIAN:
887 case TYPE::V_RANDEXP:
888 case TYPE::I_RANDEXP:
889 case TYPE::V_RANDPOISSON:
890 case TYPE::I_RANDPOISSON:
891 return std::make_unique<SIM_MODEL_SOURCE>( aType );
892
893 case TYPE::SUBCKT:
894 return std::make_unique<SIM_MODEL_SUBCKT>();
895
896 case TYPE::XSPICE:
897 return std::make_unique<SIM_MODEL_XSPICE>( aType );
898
899 case TYPE::KIBIS_DEVICE:
900 case TYPE::KIBIS_DRIVER_DC:
901 case TYPE::KIBIS_DRIVER_RECT:
902 case TYPE::KIBIS_DRIVER_PRBS:
903 return std::make_unique<SIM_MODEL_IBIS>( aType );
904
905 case TYPE::RAWSPICE:
906 return std::make_unique<SIM_MODEL_RAW_SPICE>();
907
908 default:
909 return std::make_unique<SIM_MODEL_NGSPICE>( aType );
910 }
911}
912
913
914SIM_MODEL::SIM_MODEL( TYPE aType ) :
915 SIM_MODEL( aType, std::make_unique<SPICE_GENERATOR>( *this ),
916 std::make_unique<SIM_MODEL_SERIALIZER>( *this ) )
917{
918}
919
920
921SIM_MODEL::SIM_MODEL( TYPE aType, std::unique_ptr<SPICE_GENERATOR> aSpiceGenerator ) :
922 SIM_MODEL( aType, std::move( aSpiceGenerator ),
923 std::make_unique<SIM_MODEL_SERIALIZER>( *this ) )
924{
925}
926
927
928SIM_MODEL::SIM_MODEL( TYPE aType, std::unique_ptr<SPICE_GENERATOR> aSpiceGenerator,
929 std::unique_ptr<SIM_MODEL_SERIALIZER> aSerializer ) :
930 m_baseModel( nullptr ),
931 m_serializer( std::move( aSerializer ) ),
932 m_spiceGenerator( std::move( aSpiceGenerator ) ),
933 m_type( aType ),
934 m_isEnabled( true ),
935 m_isStoredInValue( false )
936{
937}
938
939
940void SIM_MODEL::createPins( const std::vector<SCH_PIN*>& aSymbolPins )
941{
942 // Default pin sequence: model pins are the same as symbol pins.
943 // Excess model pins are set as Not Connected.
944 // Note that intentionally nothing is added if `GetPinNames()` returns an empty vector.
945
946 // SIM_MODEL pins must be ordered by symbol pin numbers -- this is assumed by the code that
947 // accesses them.
948
949 std::vector<std::string> pinNames = GetPinNames();
950
951 for( unsigned modelPinIndex = 0; modelPinIndex < pinNames.size(); ++modelPinIndex )
952 {
953 wxString pinName = pinNames[ modelPinIndex ];
954 bool optional = false;
955
956 if( pinName.StartsWith( '<' ) && pinName.EndsWith( '>' ) )
957 {
958 pinName = pinName.Mid( 1, pinName.Length() - 2 );
959 optional = true;
960 }
961
962 if( modelPinIndex < aSymbolPins.size() )
963 {
964 AddPin( { pinNames.at( modelPinIndex ),
965 aSymbolPins[ modelPinIndex ]->GetNumber().ToStdString() } );
966 }
967 else if( !optional )
968 {
969 AddPin( { pinNames.at( modelPinIndex ), "" } );
970 }
971 }
972}
973
974
975bool SIM_MODEL::requiresSpiceModelLine( const SPICE_ITEM& aItem ) const
976{
977 // SUBCKTs are a single level; there's never a baseModel.
978 if( m_type == TYPE::SUBCKT )
979 return false;
980
981 // Model must be written if there's no base model or the base model is an internal model
982 if( !m_baseModel || aItem.baseModelName == "" )
983 return true;
984
985 for( int ii = 0; ii < GetParamCount(); ++ii )
986 {
987 const PARAM& param = m_params[ii];
988
989 // Instance parameters are written in item lines
990 if( param.info.isSpiceInstanceParam )
991 continue;
992
993 // Empty parameters are interpreted as default-value
994 if ( param.value == "" )
995 continue;
996
997 if( const SIM_MODEL* baseModel = dynamic_cast<const SIM_MODEL*>( m_baseModel ) )
998 {
999 const std::string& baseValue = baseModel->m_params[ii].value;
1000
1001 if( param.value == baseValue )
1002 continue;
1003
1004 // One more check for equivalence, mostly for early 7.0 files which wrote all
1005 // parameters to the Sim.Params field in normalized format
1006 if( param.value == SIM_VALUE::Normalize( SIM_VALUE::ToDouble( baseValue ) ) )
1007 continue;
1008
1009 // Overrides must be written
1010 return true;
1011 }
1012 }
1013
1014 return false;
1015}
1016
1017
1018template <class T>
1019bool SIM_MODEL::InferSimModel( T& aSymbol, std::vector<SCH_FIELD>* aFields, bool aResolve,
1020 SIM_VALUE_GRAMMAR::NOTATION aNotation, wxString* aDeviceType,
1021 wxString* aModelType, wxString* aModelParams, wxString* aPinMap )
1022{
1023 // SPICE notation is case-insensitive and locale-insensitve. This means it uses "Meg" for
1024 // mega (as both 'M' and 'm' must mean milli), and "." (always) for a decimal separator.
1025 //
1026 // KiCad's GUI uses the SI-standard 'M' for mega and 'm' for milli, and a locale-dependent
1027 // decimal separator.
1028 //
1029 // KiCad's Sim.* fields are in-between, using SI notation but a fixed decimal separator.
1030 //
1031 // So where does that leave inferred value fields? Behavioural models must be passed in
1032 // straight, because we don't (at present) know how to parse them.
1033 //
1034 // However, behavioural models _look_ like SPICE code, so it's not a stretch to expect them
1035 // to _be_ SPICE code. A passive capacitor model on the other hand, just looks like a
1036 // capacitance. Some users might expect 3,3u to work, while others might expect 3,300uF to
1037 // work.
1038 //
1039 // Checking the locale isn't reliable because it assumes the current computer's locale is
1040 // the same as the locale the schematic was authored in -- something that isn't true, for
1041 // instance, when sharing designs over DIYAudio.com.
1042 //
1043 // However, even the E192 series of preferred values uses only 3 significant digits, so a ','
1044 // or '.' followed by 3 digits _could_ reasonably-reliably be interpreted as a thousands
1045 // separator.
1046 //
1047 // Or we could just say inferred values are locale-independent, with "." used as a decimal
1048 // separator and "," used as a thousands separator. 3,300uF works, but 3,3 does not.
1049
1050 auto convertNotation =
1051 [&]( const wxString& units ) -> wxString
1052 {
1055 if( units == wxS( "µ" ) || units == wxS( "μ" ) )
1056 return wxS( "u" );
1057
1058 if( aNotation == SIM_VALUE_GRAMMAR::NOTATION::SPICE )
1059 {
1060 if( units == wxT( "M" ) )
1061 return wxT( "Meg" );
1062 }
1063 else if( aNotation == SIM_VALUE_GRAMMAR::NOTATION::SI )
1064 {
1065 if( units.Capitalize() == wxT( "Meg" ) )
1066 return wxT( "M" );
1067 }
1068
1069 return units;
1070 };
1071
1072 auto convertSeparators =
1073 []( wxString* mantissa )
1074 {
1075 mantissa->Replace( wxS( " " ), wxEmptyString );
1076
1077 wxChar ambiguousSeparator = '?';
1078 wxChar thousandsSeparator = '?';
1079 bool thousandsSeparatorFound = false;
1080 wxChar decimalSeparator = '?';
1081 bool decimalSeparatorFound = false;
1082 int digits = 0;
1083
1084 for( int ii = (int) mantissa->length() - 1; ii >= 0; --ii )
1085 {
1086 wxChar c = mantissa->GetChar( ii );
1087
1088 if( c >= '0' && c <= '9' )
1089 {
1090 digits += 1;
1091 }
1092 else if( c == '.' || c == ',' )
1093 {
1094 if( decimalSeparator != '?' || thousandsSeparator != '?' )
1095 {
1096 // We've previously found a non-ambiguous separator...
1097
1098 if( c == decimalSeparator )
1099 {
1100 if( thousandsSeparatorFound )
1101 return false; // decimal before thousands
1102 else if( decimalSeparatorFound )
1103 return false; // more than one decimal
1104 else
1105 decimalSeparatorFound = true;
1106 }
1107 else if( c == thousandsSeparator )
1108 {
1109 if( digits != 3 )
1110 return false; // thousands not followed by 3 digits
1111 else
1112 thousandsSeparatorFound = true;
1113 }
1114 }
1115 else if( ambiguousSeparator != '?' )
1116 {
1117 // We've previously found a separator, but we don't know for sure
1118 // which...
1119
1120 if( c == ambiguousSeparator )
1121 {
1122 // They both must be thousands separators
1123 thousandsSeparator = ambiguousSeparator;
1124 thousandsSeparatorFound = true;
1125 decimalSeparator = c == '.' ? ',' : '.';
1126 }
1127 else
1128 {
1129 // The first must have been a decimal, and this must be a
1130 // thousands.
1131 decimalSeparator = ambiguousSeparator;
1132 decimalSeparatorFound = true;
1133 thousandsSeparator = c;
1134 thousandsSeparatorFound = true;
1135 }
1136 }
1137 else
1138 {
1139 // This is the first separator...
1140
1141 // If it's preceeded by a '0' (only), or if it's followed by some
1142 // number of digits not equal to 3, then it -must- be a decimal
1143 // separator.
1144 //
1145 // In all other cases we don't really know what it is yet.
1146
1147 if( ( ii == 1 && mantissa->GetChar( 0 ) == '0' ) || digits != 3 )
1148 {
1149 decimalSeparator = c;
1150 decimalSeparatorFound = true;
1151 thousandsSeparator = c == '.' ? ',' : '.';
1152 }
1153 else
1154 {
1155 ambiguousSeparator = c;
1156 }
1157 }
1158
1159 digits = 0;
1160 }
1161 else
1162 {
1163 digits = 0;
1164 }
1165 }
1166
1167 // If we found nothing difinitive then we have to assume SPICE-native syntax
1168 if( decimalSeparator == '?' && thousandsSeparator == '?' )
1169 {
1170 decimalSeparator = '.';
1171 thousandsSeparator = ',';
1172 }
1173
1174 mantissa->Replace( thousandsSeparator, wxEmptyString );
1175 mantissa->Replace( decimalSeparator, '.' );
1176
1177 return true;
1178 };
1179
1180 wxString prefix = aSymbol.GetPrefix();
1181 wxString library = GetFieldValue( aFields, SIM_LIBRARY_FIELD, aResolve );
1182 wxString modelName = GetFieldValue( aFields, SIM_NAME_FIELD, aResolve );
1183 wxString value = GetFieldValue( aFields, SIM_VALUE_FIELD, aResolve );
1184 std::vector<SCH_PIN*> pins = aSymbol.GetPins();
1185
1186 *aDeviceType = GetFieldValue( aFields, SIM_DEVICE_FIELD, aResolve );
1187 *aModelType = GetFieldValue( aFields, SIM_DEVICE_SUBTYPE_FIELD, aResolve );
1188 *aModelParams = GetFieldValue( aFields, SIM_PARAMS_FIELD, aResolve );
1189 *aPinMap = GetFieldValue( aFields, SIM_PINS_FIELD, aResolve );
1190
1191 if( pins.size() != 2 )
1192 return false;
1193
1194 if( ( ( *aDeviceType == "R" || *aDeviceType == "L" || *aDeviceType == "C" )
1195 && aModelType->IsEmpty() )
1196 ||
1197 ( library.IsEmpty() && modelName.IsEmpty()
1198 && aDeviceType->IsEmpty()
1199 && aModelType->IsEmpty()
1200 && !value.IsEmpty()
1201 && ( prefix.StartsWith( "R" ) || prefix.StartsWith( "L" ) || prefix.StartsWith( "C" ) ) ) )
1202 {
1203 if( aModelParams->IsEmpty() )
1204 {
1205 wxRegEx idealVal( wxT( "^"
1206 "([0-9\\,\\. ]+)"
1207 "([fFpPnNuUmMkKgGtTμµ𝛍𝜇𝝁 ]|M(e|E)(g|G))?"
1208 "([fFhHΩΩ𝛀𝛺𝝮rR]|ohm)?"
1209 "([-1-9 ]*)"
1210 "([fFhHΩΩ𝛀𝛺𝝮rR]|ohm)?"
1211 "$" ) );
1212
1213 if( idealVal.Matches( value ) ) // Ideal
1214 {
1215 wxString valueMantissa( idealVal.GetMatch( value, 1 ) );
1216 wxString valueExponent( idealVal.GetMatch( value, 2 ) );
1217 wxString valueFraction( idealVal.GetMatch( value, 6 ) );
1218
1219 if( !convertSeparators( &valueMantissa ) )
1220 return false;
1221
1222 if( valueMantissa.Contains( wxT( "." ) ) || valueFraction.IsEmpty() )
1223 {
1224 aModelParams->Printf( wxT( "%s=\"%s%s\"" ),
1225 prefix.Left(1).Lower(),
1226 valueMantissa,
1227 convertNotation( valueExponent ) );
1228 }
1229 else
1230 {
1231 aModelParams->Printf( wxT( "%s=\"%s.%s%s\"" ),
1232 prefix.Left(1).Lower(),
1233 valueMantissa,
1234 valueFraction,
1235 convertNotation( valueExponent ) );
1236 }
1237 }
1238 else // Behavioral
1239 {
1240 *aModelType = wxT( "=" );
1241 aModelParams->Printf( wxT( "%s=\"%s\"" ), prefix.Left(1).Lower(), value );
1242 }
1243 }
1244
1245 if( aDeviceType->IsEmpty() )
1246 *aDeviceType = prefix.Left( 1 );
1247
1248 if( aPinMap->IsEmpty() )
1249 aPinMap->Printf( wxT( "%s=+ %s=-" ), pins[0]->GetNumber(), pins[1]->GetNumber() );
1250
1251 return true;
1252 }
1253
1254 if( ( ( *aDeviceType == wxT( "V" ) || *aDeviceType == wxT( "I" ) )
1255 && ( aModelType->IsEmpty() || *aModelType == wxT( "DC" ) ) )
1256 ||
1257 ( aDeviceType->IsEmpty()
1258 && aModelType->IsEmpty()
1259 && !value.IsEmpty()
1260 && ( prefix.StartsWith( "V" ) || prefix.StartsWith( "I" ) ) ) )
1261 {
1262 if( !value.IsEmpty() )
1263 {
1264 wxString param = "dc";
1265
1266 if( value.StartsWith( wxT( "DC " ) ) )
1267 {
1268 value = value.Right( value.Length() - 3 );
1269 }
1270 else if( value.StartsWith( wxT( "AC " ) ) )
1271 {
1272 value = value.Right( value.Length() - 3 );
1273 param = "ac";
1274 }
1275
1276 wxRegEx sourceVal( wxT( "^"
1277 "([0-9\\,\\. ]+)"
1278 "([fFpPnNuUmMkKgGtTμµ𝛍𝜇𝝁 ]|M(e|E)(g|G))?"
1279 "([vVaA])?"
1280 "([-1-9 ]*)"
1281 "([vVaA])?"
1282 "$" ) );
1283
1284 if( sourceVal.Matches( value ) )
1285 {
1286 wxString valueMantissa( sourceVal.GetMatch( value, 1 ) );
1287 wxString valueExponent( sourceVal.GetMatch( value, 2 ) );
1288 wxString valueFraction( sourceVal.GetMatch( value, 6 ) );
1289
1290 if( !convertSeparators( &valueMantissa ) )
1291 return false;
1292
1293 if( valueMantissa.Contains( wxT( "." ) ) || valueFraction.IsEmpty() )
1294 {
1295 aModelParams->Printf( wxT( "%s=\"%s%s\" %s" ),
1296 param,
1297 valueMantissa,
1298 convertNotation( valueExponent ),
1299 *aModelParams );
1300 }
1301 else
1302 {
1303 aModelParams->Printf( wxT( "%s=\"%s.%s%s\" %s" ),
1304 param,
1305 valueMantissa,
1306 valueFraction,
1307 convertNotation( valueExponent ),
1308 *aModelParams );
1309 }
1310 }
1311 else
1312 {
1313 aModelParams->Printf( wxT( "%s=\"%s\" %s" ),
1314 param,
1315 value,
1316 *aModelParams );
1317 }
1318 }
1319
1320 if( aDeviceType->IsEmpty() )
1321 *aDeviceType = prefix.Left( 1 );
1322
1323 if( aModelType->IsEmpty() )
1324 *aModelType = wxT( "DC" );
1325
1326 if( aPinMap->IsEmpty() )
1327 aPinMap->Printf( wxT( "%s=+ %s=-" ), pins[0]->GetNumber(), pins[1]->GetNumber() );
1328
1329 return true;
1330 }
1331
1332 return false;
1333}
1334
1335
1336template bool SIM_MODEL::InferSimModel<SCH_SYMBOL>( SCH_SYMBOL& aSymbol,
1337 std::vector<SCH_FIELD>* aFields, bool aResolve,
1338 SIM_VALUE_GRAMMAR::NOTATION aNotation,
1339 wxString* aDeviceType, wxString* aModelType,
1340 wxString* aModelParams, wxString* aPinMap );
1341template bool SIM_MODEL::InferSimModel<LIB_SYMBOL>( LIB_SYMBOL& aSymbol,
1342 std::vector<SCH_FIELD>* aFields, bool aResolve,
1343 SIM_VALUE_GRAMMAR::NOTATION aNotation,
1344 wxString* aDeviceType, wxString* aModelType,
1345 wxString* aModelParams, wxString* aPinMap );
1346
1347
1348template <typename T>
1349void SIM_MODEL::MigrateSimModel( T& aSymbol, const PROJECT* aProject )
1350{
1351 class FIELD_INFO
1352 {
1353 public:
1354 FIELD_INFO()
1355 {
1356 m_Visible = false;
1357 m_Attributes.m_Size = VECTOR2I( DEFAULT_SIZE_TEXT * schIUScale.IU_PER_MILS,
1358 DEFAULT_SIZE_TEXT * schIUScale.IU_PER_MILS );
1359 };
1360
1361 FIELD_INFO( const wxString& aText, SCH_FIELD* aField ) :
1362 m_Text( aText ),
1363 m_Visible( aField->IsVisible() ),
1364 m_Attributes( aField->GetAttributes() ),
1365 m_Pos( aField->GetPosition() )
1366 {}
1367
1368 bool IsEmpty() const { return m_Text.IsEmpty(); }
1369
1370 SCH_FIELD CreateField( T* aSymbol, const wxString& aFieldName )
1371 {
1372 SCH_FIELD field( aSymbol, FIELD_T::USER, aFieldName );
1373
1374 field.SetText( m_Text );
1375 field.SetVisible( m_Visible );
1376 field.SetAttributes( m_Attributes );
1377 field.SetPosition( m_Pos );
1378
1379 return field;
1380 }
1381
1382 public:
1383 wxString m_Text;
1384 bool m_Visible;
1385 TEXT_ATTRIBUTES m_Attributes;
1386 VECTOR2I m_Pos;
1387 };
1388
1389 SCH_FIELD* existing_deviceField = aSymbol.GetField( SIM_DEVICE_FIELD );
1390 SCH_FIELD* existing_deviceSubtypeField = aSymbol.GetField( SIM_DEVICE_SUBTYPE_FIELD );
1391 SCH_FIELD* existing_pinsField = aSymbol.GetField( SIM_PINS_FIELD );
1392 SCH_FIELD* existing_paramsField = aSymbol.GetField( SIM_PARAMS_FIELD );
1393
1394 wxString existing_deviceSubtype;
1395
1396 if( existing_deviceSubtypeField )
1397 existing_deviceSubtype = existing_deviceSubtypeField->GetShownText( false ).Upper();
1398
1399 if( existing_deviceField
1400 || existing_deviceSubtypeField
1401 || existing_pinsField
1402 || existing_paramsField )
1403 {
1404 // Has a current (V7+) model field.
1405
1406 // Up until 7.0RC2 we used '+' and '-' for potentiometer pins, which doesn't match
1407 // SPICE. Here we remap them to 'r0' and 'r1'.
1408 if( existing_deviceSubtype == wxS( "POT" ) )
1409 {
1410 if( existing_pinsField )
1411 {
1412 wxString pinMap = existing_pinsField->GetText();
1413 pinMap.Replace( wxS( "=+" ), wxS( "=r1" ) );
1414 pinMap.Replace( wxS( "=-" ), wxS( "=r0" ) );
1415 existing_pinsField->SetText( pinMap );
1416 }
1417 }
1418
1419 // Up until 8.0RC1 random voltage/current sources were a bit of a mess.
1420 if( existing_deviceSubtype.StartsWith( wxS( "RAND" ) ) )
1421 {
1422 // Re-fetch value without resolving references. If it's an indirect value then we
1423 // can't migrate it.
1424 existing_deviceSubtype = existing_deviceSubtypeField->GetText().Upper();
1425
1426 if( existing_deviceSubtype.Replace( wxS( "NORMAL" ), wxS( "GAUSSIAN" ) ) )
1427 existing_deviceSubtypeField->SetText( existing_deviceSubtype );
1428
1429 if( existing_paramsField )
1430 {
1431 wxString params = existing_paramsField->GetText().Lower();
1432 size_t count = 0;
1433
1434 // We used to support 'min' and 'max' instead of 'range' and 'offset', but we
1435 // wrote all 4 to the netlist which would cause ngspice to barf, so no one has
1436 // working documents with min and max specified. Just delete them if they're
1437 // uninitialized.
1438 count += params.Replace( wxS( "min=0 " ), wxEmptyString );
1439 count += params.Replace( wxS( "max=0 " ), wxEmptyString );
1440
1441 // We used to use 'dt', but the correct ngspice name is 'ts'.
1442 count += params.Replace( wxS( "dt=" ), wxS( "ts=" ) );
1443
1444 if( count )
1445 existing_paramsField->SetText( params );
1446 }
1447 }
1448
1449 // Up until 8.0.1 we treated a mutual inductance statement as a type of inductor --
1450 // which is confusing because it doesn't represent a device at all.
1451 if( existing_deviceSubtype == wxS( "MUTUAL" ) )
1452 {
1453 if( existing_deviceSubtypeField ) // Can't be null, but Coverity doesn't know that
1454 aSymbol.RemoveField( existing_deviceSubtypeField );
1455
1456 if( existing_deviceField )
1457 {
1458 existing_deviceField->SetText( wxS( "K" ) );
1459 }
1460 else
1461 {
1462 FIELD_INFO deviceFieldInfo;
1463 deviceFieldInfo.m_Text = wxS( "K" );
1464
1465 SCH_FIELD deviceField = deviceFieldInfo.CreateField( &aSymbol, SIM_DEVICE_FIELD );
1466 aSymbol.AddField( deviceField );
1467 }
1468 }
1469
1470 return;
1471 }
1472
1473 auto getSIValue =
1474 []( SCH_FIELD* aField )
1475 {
1476 if( !aField ) // no, not really, but it keeps Coverity happy
1477 return wxString( wxEmptyString );
1478
1479 wxRegEx regex( wxT( "([^a-z])(M)(e|E)(g|G)($|[^a-z])" ) );
1480 wxString value = aField->GetText();
1481
1482 // Keep prefix, M, and suffix, but drop e|E and g|G
1483 regex.ReplaceAll( &value, wxT( "\\1\\2\\5" ) );
1484
1485 return value;
1486 };
1487
1488 auto generateDefaultPinMapFromSymbol =
1489 []( const std::vector<SCH_PIN*>& sourcePins )
1490 {
1491 wxString pinMap;
1492
1493 // If we're creating the pinMap from the symbol it means we don't know what the
1494 // SIM_MODEL's pin names are, so just use indexes.
1495
1496 for( unsigned ii = 0; ii < sourcePins.size(); ++ii )
1497 {
1498 if( ii > 0 )
1499 pinMap.Append( wxS( " " ) );
1500
1501 pinMap.Append( wxString::Format( wxT( "%s=%u" ),
1502 sourcePins[ii]->GetNumber(),
1503 ii + 1 ) );
1504 }
1505
1506 return pinMap;
1507 };
1508
1509 wxString prefix = aSymbol.GetPrefix();
1510 SCH_FIELD* valueField = aSymbol.GetField( FIELD_T::VALUE );
1511 std::vector<SCH_PIN*> sourcePins = aSymbol.GetPins();
1512 bool sourcePinsSorted = false;
1513
1514 auto lazySortSourcePins =
1515 [&sourcePins, &sourcePinsSorted]()
1516 {
1517 if( !sourcePinsSorted )
1518 {
1519 std::sort( sourcePins.begin(), sourcePins.end(),
1520 []( const SCH_PIN* lhs, const SCH_PIN* rhs )
1521 {
1522 return StrNumCmp( lhs->GetNumber(), rhs->GetNumber(), true ) < 0;
1523 } );
1524 }
1525
1526 sourcePinsSorted = true;
1527 };
1528
1529 FIELD_INFO deviceInfo;
1530 FIELD_INFO modelInfo;
1531 FIELD_INFO deviceSubtypeInfo;
1532 FIELD_INFO libInfo;
1533 FIELD_INFO spiceParamsInfo;
1534 FIELD_INFO pinMapInfo;
1535 bool modelFromValueField = false;
1536
1537 if( aSymbol.GetField( SIM_LEGACY_PRIMITIVE_FIELD )
1538 || aSymbol.GetField( SIM_LEGACY_PINS_FIELD )
1539 || aSymbol.GetField( SIM_LEGACY_MODEL_FIELD )
1540 || aSymbol.GetField( SIM_LEGACY_ENABLE_FIELD )
1541 || aSymbol.GetField( SIM_LEGACY_LIBRARY_FIELD ) )
1542 {
1543 if( SCH_FIELD* primitiveField = aSymbol.GetField( SIM_LEGACY_PRIMITIVE_FIELD ) )
1544 {
1545 deviceInfo = FIELD_INFO( primitiveField->GetText(), primitiveField );
1546 aSymbol.RemoveField( primitiveField );
1547 }
1548
1549 if( SCH_FIELD* nodeSequenceField = aSymbol.GetField( SIM_LEGACY_PINS_FIELD ) )
1550 {
1551 const wxString delimiters( "{:,; }" );
1552 const wxString& nodeSequence = nodeSequenceField->GetText();
1553 wxString pinMap;
1554
1555 if( nodeSequence != "" )
1556 {
1557 wxStringTokenizer tkz( nodeSequence, delimiters );
1558
1559 for( long modelPinNumber = 1; tkz.HasMoreTokens(); ++modelPinNumber )
1560 {
1561 long symbolPinNumber = 1;
1562 tkz.GetNextToken().ToLong( &symbolPinNumber );
1563
1564 if( modelPinNumber != 1 )
1565 pinMap.Append( " " );
1566
1567 pinMap.Append( wxString::Format( "%ld=%ld", symbolPinNumber, modelPinNumber ) );
1568 }
1569 }
1570
1571 pinMapInfo = FIELD_INFO( pinMap, nodeSequenceField );
1572 aSymbol.RemoveField( nodeSequenceField );
1573 }
1574
1575 if( SCH_FIELD* modelField = aSymbol.GetField( SIM_LEGACY_MODEL_FIELD ) )
1576 {
1577 modelInfo = FIELD_INFO( getSIValue( modelField ), modelField );
1578 aSymbol.RemoveField( modelField );
1579 }
1580 else if( valueField )
1581 {
1582 modelInfo = FIELD_INFO( getSIValue( valueField ), valueField );
1583 modelFromValueField = true;
1584 }
1585
1586 if( SCH_FIELD* libFileField = aSymbol.GetField( SIM_LEGACY_LIBRARY_FIELD ) )
1587 {
1588 libInfo = FIELD_INFO( libFileField->GetText(), libFileField );
1589 aSymbol.RemoveField( libFileField );
1590 }
1591 }
1592 else
1593 {
1594 // Auto convert some legacy fields used in the middle of 7.0 development...
1595
1596 if( SCH_FIELD* legacyType = aSymbol.GetField( wxT( "Sim_Type" ) ) )
1597 {
1598 legacyType->SetName( SIM_DEVICE_SUBTYPE_FIELD );
1599 }
1600
1601 if( SCH_FIELD* legacyDevice = aSymbol.GetField( wxT( "Sim_Device" ) ) )
1602 {
1603 legacyDevice->SetName( SIM_DEVICE_FIELD );
1604 }
1605
1606 if( SCH_FIELD* legacyPins = aSymbol.GetField( wxT( "Sim_Pins" ) ) )
1607 {
1608 bool isPassive = prefix.StartsWith( wxT( "R" ) )
1609 || prefix.StartsWith( wxT( "L" ) )
1610 || prefix.StartsWith( wxT( "C" ) );
1611
1612 // Migrate pins from array of indexes to name-value-pairs
1613 wxString pinMap;
1614 wxArrayString pinIndexes;
1615
1616 wxStringSplit( legacyPins->GetText(), pinIndexes, ' ' );
1617
1618 lazySortSourcePins();
1619
1620 if( isPassive && pinIndexes.size() == 2 && sourcePins.size() == 2 )
1621 {
1622 if( pinIndexes[0] == wxT( "2" ) )
1623 {
1624 pinMap.Printf( wxT( "%s=- %s=+" ),
1625 sourcePins[0]->GetNumber(),
1626 sourcePins[1]->GetNumber() );
1627 }
1628 else
1629 {
1630 pinMap.Printf( wxT( "%s=+ %s=-" ),
1631 sourcePins[0]->GetNumber(),
1632 sourcePins[1]->GetNumber() );
1633 }
1634 }
1635 else
1636 {
1637 for( unsigned ii = 0; ii < pinIndexes.size() && ii < sourcePins.size(); ++ii )
1638 {
1639 if( ii > 0 )
1640 pinMap.Append( wxS( " " ) );
1641
1642 pinMap.Append( wxString::Format( wxT( "%s=%s" ),
1643 sourcePins[ii]->GetNumber(),
1644 pinIndexes[ ii ] ) );
1645 }
1646 }
1647
1648 legacyPins->SetName( SIM_PINS_FIELD );
1649 legacyPins->SetText( pinMap );
1650 }
1651
1652 if( SCH_FIELD* legacyParams = aSymbol.GetField( wxT( "Sim_Params" ) ) )
1653 {
1654 legacyParams->SetName( SIM_PARAMS_FIELD );
1655 }
1656
1657 return;
1658 }
1659
1660 wxString device = deviceInfo.m_Text.Trim( true ).Trim( false );
1661 wxString lib = libInfo.m_Text.Trim( true ).Trim( false );
1662 wxString model = modelInfo.m_Text.Trim( true ).Trim( false );
1663 wxString modelLineParams;
1664
1665 bool libraryModel = false;
1666 bool inferredModel = false;
1667 bool internalModel = false;
1668
1669 if( !lib.IsEmpty() )
1670 {
1671 WX_STRING_REPORTER reporter;
1672 SIM_LIB_MGR libMgr( aProject, nullptr );
1673 std::vector<SCH_FIELD> emptyFields;
1674
1675 if constexpr (std::is_same_v<T, SCH_SYMBOL>)
1676 libMgr.SetFiles( aSymbol.Schematic() );
1677 else
1678 libMgr.SetFiles( &aSymbol );
1679
1680 // Pull out any following parameters from model name
1681 model = model.BeforeFirst( ' ', &modelLineParams );
1682 modelInfo.m_Text = model;
1683
1684 lazySortSourcePins();
1685
1686 SIM_LIBRARY::MODEL simModel = libMgr.CreateModel( lib, model.ToStdString(),
1687 emptyFields, sourcePins, reporter );
1688
1689 if( reporter.HasMessage() )
1690 libraryModel = false; // Fall back to raw spice model
1691 else
1692 libraryModel = true;
1693
1694 if( pinMapInfo.IsEmpty() )
1695 {
1696 // Try to generate a default pin map from the SIM_MODEL's pins; if that fails,
1697 // generate one from the symbol's pins
1698 pinMapInfo.m_Text = wxString( simModel.model.Serializer().GeneratePins() );
1699
1700 if( pinMapInfo.IsEmpty() )
1701 pinMapInfo.m_Text = generateDefaultPinMapFromSymbol( sourcePins );
1702 }
1703 }
1704 else if( ( device == wxS( "R" )
1705 || device == wxS( "L" )
1706 || device == wxS( "C" )
1707 || device == wxS( "V" )
1708 || device == wxS( "I" ) )
1709 && prefix.StartsWith( device )
1710 && modelFromValueField )
1711 {
1712 inferredModel = true;
1713 }
1714 else if( device == wxS( "V" ) || device == wxS( "I" ) )
1715 {
1716 // See if we have a SPICE time-dependent function such as "sin(0 1 60)" or "sin 0 1 60"
1717 // that can be handled by a built-in SIM_MODEL_SOURCE.
1718
1719 wxStringTokenizer tokenizer( model, wxT( "() " ), wxTOKEN_STRTOK );
1720
1721 if( tokenizer.HasMoreTokens() )
1722 {
1723 deviceSubtypeInfo.m_Text = tokenizer.GetNextToken();
1724 deviceSubtypeInfo.m_Text.MakeUpper();
1725
1726 for( SIM_MODEL::TYPE type : SIM_MODEL::TYPE_ITERATOR() )
1727 {
1728 if( device == SIM_MODEL::SpiceInfo( type ).itemType
1729 && deviceSubtypeInfo.m_Text == SIM_MODEL::SpiceInfo( type ).functionName )
1730 {
1731 try
1732 {
1733 std::unique_ptr<SIM_MODEL> simModel = SIM_MODEL::Create( type );
1734
1735 if( deviceSubtypeInfo.m_Text == wxT( "DC" ) && tokenizer.CountTokens() == 1 )
1736 {
1737 wxCHECK( valueField, /* void */ );
1738 valueField->SetText( tokenizer.GetNextToken() );
1739 modelFromValueField = false;
1740 }
1741 else
1742 {
1743 for( int ii = 0; tokenizer.HasMoreTokens(); ++ii )
1744 {
1745 simModel->SetParamValue( ii, tokenizer.GetNextToken().ToStdString(),
1746 SIM_VALUE_GRAMMAR::NOTATION::SPICE );
1747 }
1748
1749 deviceSubtypeInfo.m_Text = SIM_MODEL::TypeInfo( type ).fieldValue;
1750
1751 spiceParamsInfo = modelInfo;
1752 spiceParamsInfo.m_Text = wxString( simModel->Serializer().GenerateParams() );
1753 }
1754
1755 internalModel = true;
1756
1757 if( pinMapInfo.IsEmpty() )
1758 {
1759 lazySortSourcePins();
1760
1761 // Generate a default pin map from the SIM_MODEL's pins
1762 simModel->createPins( sourcePins );
1763 pinMapInfo.m_Text = wxString( simModel->Serializer().GeneratePins() );
1764 }
1765 }
1766 catch( ... )
1767 {
1768 // Fall back to raw spice model
1769 }
1770
1771 break;
1772 }
1773 }
1774 }
1775 }
1776
1777 if( libraryModel )
1778 {
1779 SCH_FIELD libField = libInfo.CreateField( &aSymbol, SIM_LIBRARY_FIELD );
1780 aSymbol.AddField( libField );
1781
1782 SCH_FIELD nameField = modelInfo.CreateField( &aSymbol, SIM_NAME_FIELD );
1783 aSymbol.AddField( nameField );
1784
1785 if( !modelLineParams.IsEmpty() )
1786 {
1787 spiceParamsInfo = modelInfo;
1788 spiceParamsInfo.m_Pos.x += nameField.GetBoundingBox().GetWidth();
1789 spiceParamsInfo.m_Text = modelLineParams;
1790
1791 BOX2I nameBBox = nameField.GetBoundingBox();
1792 int nameWidth = nameBBox.GetWidth();
1793
1794 // Add space between model name and additional parameters
1795 nameWidth += KiROUND( nameBBox.GetHeight() * 1.25 );
1796
1797 if( nameField.GetHorizJustify() == GR_TEXT_H_ALIGN_RIGHT )
1798 spiceParamsInfo.m_Pos.x -= nameWidth;
1799 else
1800 spiceParamsInfo.m_Pos.x += nameWidth;
1801
1802 SCH_FIELD paramsField = spiceParamsInfo.CreateField( &aSymbol, SIM_PARAMS_FIELD );
1803 aSymbol.AddField( paramsField );
1804 }
1805
1806 if( modelFromValueField )
1807 valueField->SetText( wxT( "${SIM.NAME}" ) );
1808 }
1809 else if( inferredModel )
1810 {
1811 // DeviceType is left in the reference designator and Model is left in the value field,
1812 // so there's nothing to do here....
1813 }
1814 else if( internalModel )
1815 {
1816 SCH_FIELD deviceField = deviceInfo.CreateField( &aSymbol, SIM_DEVICE_FIELD );
1817 aSymbol.AddField( deviceField );
1818
1819 if( !deviceSubtypeInfo.m_Text.IsEmpty() )
1820 {
1821 SCH_FIELD subtypeField = deviceSubtypeInfo.CreateField( &aSymbol, SIM_DEVICE_SUBTYPE_FIELD );
1822 aSymbol.AddField( subtypeField );
1823 }
1824
1825 if( !spiceParamsInfo.IsEmpty() )
1826 {
1827 SCH_FIELD paramsField = spiceParamsInfo.CreateField( &aSymbol, SIM_PARAMS_FIELD );
1828 aSymbol.AddField( paramsField );
1829 }
1830
1831 if( modelFromValueField )
1832 valueField->SetText( wxT( "${SIM.PARAMS}" ) );
1833 }
1834 else // Insert a raw spice model as a substitute.
1835 {
1836 if( device.IsEmpty() && lib.IsEmpty() )
1837 {
1838 spiceParamsInfo = modelInfo;
1839 }
1840 else
1841 {
1842 spiceParamsInfo.m_Text.Printf( wxT( "type=\"%s\" model=\"%s\" lib=\"%s\"" ), device,
1843 model, lib );
1844 }
1845
1846 deviceInfo.m_Text = SIM_MODEL::DeviceInfo( SIM_MODEL::DEVICE_T::SPICE ).fieldValue;
1847
1848 SCH_FIELD deviceField = deviceInfo.CreateField( &aSymbol, SIM_DEVICE_FIELD );
1849 aSymbol.AddField( deviceField );
1850
1851 SCH_FIELD paramsField = spiceParamsInfo.CreateField( &aSymbol, SIM_PARAMS_FIELD );
1852 aSymbol.AddField( paramsField );
1853
1854 if( modelFromValueField )
1855 {
1856 // Get the current Value field, after previous changes.
1857 valueField = aSymbol.GetField( FIELD_T::VALUE );
1858
1859 if( valueField )
1860 valueField->SetText( wxT( "${SIM.PARAMS}" ) );
1861 }
1862
1863 // We know nothing about the SPICE model here, so we've got no choice but to generate
1864 // the default pin map from the symbol's pins.
1865
1866 if( pinMapInfo.IsEmpty() )
1867 {
1868 lazySortSourcePins();
1869 pinMapInfo.m_Text = generateDefaultPinMapFromSymbol( sourcePins );
1870 }
1871 }
1872
1873 if( !pinMapInfo.IsEmpty() )
1874 {
1875 SCH_FIELD pinsField = pinMapInfo.CreateField( &aSymbol, SIM_PINS_FIELD );
1876 aSymbol.AddField( pinsField );
1877 }
1878}
1879
1880
1881template void SIM_MODEL::MigrateSimModel<SCH_SYMBOL>( SCH_SYMBOL& aSymbol,
1882 const PROJECT* aProject );
1883template void SIM_MODEL::MigrateSimModel<LIB_SYMBOL>( LIB_SYMBOL& aSymbol,
1884 const PROJECT* aProject );
schIUScale
constexpr EDA_IU_SCALE schIUScale
Definition: base_units.h:110
BITMAPS::move
@ move
BITMAPS::pin
@ pin
BITMAPS::library
@ library
KiROUND
constexpr BOX2I KiROUND(const BOX2D &aBoxD)
Definition: box2.h:990
BOX2::GetWidth
constexpr size_type GetWidth() const
Definition: box2.h:214
BOX2::GetHeight
constexpr size_type GetHeight() const
Definition: box2.h:215
EDA_TEXT::GetText
virtual const wxString & GetText() const
Return the string associated with the text object.
Definition: eda_text.h:98
EDA_TEXT::IsVisible
virtual bool IsVisible() const
Definition: eda_text.h:174
EDA_TEXT::SetAttributes
void SetAttributes(const EDA_TEXT &aSrc, bool aSetPosition=true)
Set the text attributes from another instance.
Definition: eda_text.cpp:426
EDA_TEXT::GetHorizJustify
GR_TEXT_H_ALIGN_T GetHorizJustify() const
Definition: eda_text.h:187
EDA_TEXT::SetVisible
virtual void SetVisible(bool aVisible)
Definition: eda_text.cpp:379
EDA_TEXT::GetAttributes
const TEXT_ATTRIBUTES & GetAttributes() const
Definition: eda_text.h:218
IO_ERROR
Hold an error message and may be used when throwing exceptions containing meaningful error messages.
Definition: ki_exception.h:77
IO_ERROR::What
virtual const wxString What() const
A composite of Problem() and Where()
Definition: exceptions.cpp:30
IO_ERROR::Problem
virtual const wxString Problem() const
what was the problem?
Definition: exceptions.cpp:46
LIB_SYMBOL
Define a library symbol object.
Definition: lib_symbol.h:85
NULL_REPORTER
A singleton reporter that reports to nowhere.
Definition: reporter.h:204
PROJECT
Container for project specific data.
Definition: project.h:64
REPORTER
A pure virtual class used to derive REPORTER objects from.
Definition: reporter.h:73
REPORTER::Report
virtual REPORTER & Report(const wxString &aText, SEVERITY aSeverity=RPT_SEVERITY_UNDEFINED)=0
Report a string with a given severity.
SCH_FIELD
Definition: sch_field.h:42
SCH_FIELD::GetBoundingBox
const BOX2I GetBoundingBox() const override
Return the orthogonal bounding box of this object for display purposes.
Definition: sch_field.cpp:499
SCH_FIELD::GetPosition
VECTOR2I GetPosition() const override
Definition: sch_field.cpp:1314
SCH_FIELD::SetPosition
void SetPosition(const VECTOR2I &aPosition) override
Definition: sch_field.cpp:1294
SCH_FIELD::GetShownText
wxString GetShownText(const SCH_SHEET_PATH *aPath, bool aAllowExtraText, int aDepth=0) const
Definition: sch_field.cpp:192
SCH_FIELD::SetText
void SetText(const wxString &aText) override
Definition: sch_field.cpp:1069
SCH_PIN
Definition: sch_pin.h:40
SCH_SYMBOL
Schematic symbol object.
Definition: sch_symbol.h:75
SIM_LIBRARY_IBIS::DIFF_FIELD
static constexpr auto DIFF_FIELD
Definition: sim_library_ibis.h:38
SIM_LIB_MGR
Definition: sim_lib_mgr.h:40
SIM_LIB_MGR::CreateModel
SIM_MODEL & CreateModel(SIM_MODEL::TYPE aType, const std::vector< SCH_PIN * > &aPins, REPORTER &aReporter)
Definition: sim_lib_mgr.cpp:156
SIM_LIB_MGR::SetFiles
void SetFiles(EMBEDDED_FILES *aFiles)
Definition: sim_lib_mgr.h:49
SIM_MODEL_IBIS
Definition: sim_model_ibis.h:50
SIM_MODEL_RAW_SPICE
Definition: sim_model_raw_spice.h:49
SIM_MODEL_SERIALIZER
Serializes/deserializes a SIM_MODEL for storage in LIB_FIELDs/SCH_FIELDs.
Definition: sim_model_serializer.h:120
SIM_MODEL_SERIALIZER::GeneratePins
std::string GeneratePins() const
Definition: sim_model_serializer.cpp:124
SIM_MODEL_SPICE_FALLBACK
Definition: sim_model_spice_fallback.h:31
SIM_MODEL
Definition: sim_model.h:78
SIM_MODEL::FindModelPinIndex
int FindModelPinIndex(const std::string &aSymbolPinNumber)
Definition: sim_model.cpp:654
SIM_MODEL::MigrateSimModel
static void MigrateSimModel(T &aSymbol, const PROJECT *aProject)
Definition: sim_model.cpp:1349
SIM_MODEL::GetBaseParam
const PARAM & GetBaseParam(unsigned aParamIndex) const
Definition: sim_model.cpp:767
SIM_MODEL::AddParam
void AddParam(const PARAM::INFO &aInfo)
Definition: sim_model.cpp:666
SIM_MODEL::IsStoredInValue
bool IsStoredInValue() const
Definition: sim_model.h:502
SIM_MODEL::GetPinNames
virtual std::vector< std::string > GetPinNames() const
Definition: sim_model.h:462
SIM_MODEL::requiresSpiceModelLine
virtual bool requiresSpiceModelLine(const SPICE_ITEM &aItem) const
Definition: sim_model.cpp:975
SIM_MODEL::ClearPins
void ClearPins()
Definition: sim_model.cpp:648
SIM_MODEL::ReadTypeFromFields
static TYPE ReadTypeFromFields(const std::vector< SCH_FIELD > &aFields, REPORTER &aReporter)
Definition: sim_model.cpp:390
SIM_MODEL::m_modelPins
std::vector< SIM_MODEL_PIN > m_modelPins
Definition: sim_model.h:532
SIM_MODEL::TypeInfo
static INFO TypeInfo(TYPE aType)
Definition: sim_model.cpp:105
SIM_MODEL::GetPinCount
int GetPinCount() const
Definition: sim_model.h:464
SIM_MODEL::AddPin
void AddPin(const SIM_MODEL_PIN &aPin)
Definition: sim_model.cpp:642
SIM_MODEL::SpiceInfo
static SPICE_INFO SpiceInfo(TYPE aType)
Definition: sim_model.cpp:249
SIM_MODEL::Serializer
const SIM_MODEL_SERIALIZER & Serializer() const
Definition: sim_model.h:429
SIM_MODEL::ReadDataFields
void ReadDataFields(const std::vector< SCH_FIELD > *aFields, const std::vector< SCH_PIN * > &aPins)
Definition: sim_model.cpp:429
SIM_MODEL::GetParam
virtual const PARAM & GetParam(unsigned aParamIndex) const
Definition: sim_model.cpp:726
SIM_MODEL::InferSimModel
static bool InferSimModel(T &aSymbol, std::vector< SCH_FIELD > *aFields, bool aResolve, SIM_VALUE_GRAMMAR::NOTATION aNotation, wxString *aDeviceType, wxString *aModelType, wxString *aModelParams, wxString *aPinMap)
Definition: sim_model.cpp:1019
SIM_MODEL::createPins
void createPins(const std::vector< SCH_PIN * > &aSymbolPins)
Definition: sim_model.cpp:940
SIM_MODEL::WriteFields
void WriteFields(std::vector< SCH_FIELD > &aFields) const
Definition: sim_model.cpp:447
SIM_MODEL::SetBaseModel
virtual void SetBaseModel(const SIM_MODEL &aBaseModel)
Definition: sim_model.cpp:676
SIM_MODEL::SIM_MODEL
SIM_MODEL()=delete
SIM_MODEL::GetParamCount
int GetParamCount() const
Definition: sim_model.h:474
SIM_MODEL::AssignSymbolPinNumberToModelPin
void AssignSymbolPinNumberToModelPin(int aPinIndex, const wxString &aSymbolPinNumber)
Definition: sim_model.cpp:695
SIM_MODEL::DeviceInfo
static DEVICE_INFO DeviceInfo(DEVICE_T aDeviceType)
Definition: sim_model.cpp:60
SIM_MODEL::FindParam
const PARAM * FindParam(const std::string &aParamName) const
Definition: sim_model.cpp:753
SIM_MODEL::doSetParamValue
virtual void doSetParamValue(int aParamIndex, const std::string &aValue)
Definition: sim_model.cpp:776
SIM_MODEL::m_params
std::vector< PARAM > m_params
Definition: sim_model.h:531
SIM_MODEL::GetParamOverride
const PARAM & GetParamOverride(unsigned aParamIndex) const
Definition: sim_model.cpp:761
SIM_MODEL::~SIM_MODEL
virtual ~SIM_MODEL()
SIM_MODEL::Create
static std::unique_ptr< SIM_MODEL > Create(TYPE aType, const std::vector< SCH_PIN * > &aPins, REPORTER &aReporter)
Definition: sim_model.cpp:481
SIM_MODEL::SetParamValue
void SetParamValue(int aParamIndex, const std::string &aValue, SIM_VALUE::NOTATION aNotation=SIM_VALUE::NOTATION::SI)
Definition: sim_model.cpp:782
SIM_MODEL::SwitchSingleEndedDiff
virtual void SwitchSingleEndedDiff(bool aDiff)
Definition: sim_model.h:504
SIM_MODEL::GetPin
const SIM_MODEL_PIN & GetPin(unsigned aIndex) const
Definition: sim_model.h:465
SIM_MODEL::m_serializer
std::unique_ptr< SIM_MODEL_SERIALIZER > m_serializer
Definition: sim_model.h:534
SIM_MODEL::doFindParam
virtual int doFindParam(const std::string &aParamName) const
Definition: sim_model.cpp:741
SIM_MODEL::GetType
TYPE GetType() const
Definition: sim_model.h:457
SIM_MODEL::GetPins
std::vector< std::reference_wrapper< const SIM_MODEL_PIN > > GetPins() const
Definition: sim_model.cpp:685
SIM_MODEL::m_type
const TYPE m_type
Definition: sim_model.h:539
SIM_MODEL::m_baseModel
const SIM_MODEL * m_baseModel
Definition: sim_model.h:533
SIM_VALUE::Normalize
static std::string Normalize(double aValue)
Definition: sim_value.cpp:406
SIM_VALUE::ConvertNotation
static std::string ConvertNotation(const std::string &aString, NOTATION aFromNotation, NOTATION aToNotation)
Definition: sim_value.cpp:370
SIM_VALUE::ToDouble
static double ToDouble(const std::string &aString, double aDefault=NAN)
Definition: sim_value.cpp:442
SPICE_GENERATOR
Definition: spice_generator.h:46
TEXT_ATTRIBUTES
Definition: text_attributes.h:119
WX_STRING_REPORTER
A wrapper for reporting to a wxString object.
Definition: reporter.h:172
WX_STRING_REPORTER::HasMessage
bool HasMessage() const override
Returns true if the reporter client is non-empty.
Definition: reporter.cpp:100
_
#define _(s)
Definition: eda_3d_actions.cpp:36
DEFAULT_SIZE_TEXT
#define DEFAULT_SIZE_TEXT
This is the "default-of-the-default" hardcoded text size; individual application define their own def...
Definition: eda_text.h:70
ki_exception.h
THROW_IO_ERROR
#define THROW_IO_ERROR(msg)
Definition: ki_exception.h:39
lib_symbol.h
SIM_VALUE_GRAMMAR::NOTATION
NOTATION
Definition: sim_value.h:51
SIM_VALUE_GRAMMAR::NOTATION::SPICE
@ SPICE
SIM_VALUE_GRAMMAR::NOTATION::SI
@ SI
std
STL namespace.
RPT_SEVERITY_ERROR
@ RPT_SEVERITY_ERROR
Definition: report_severity.h:32
GetFieldValue
wxString GetFieldValue(const std::vector< SCH_FIELD > *aFields, FIELD_T aFieldType)
Definition: sch_field.h:406
SetFieldValue
void SetFieldValue(std::vector< SCH_FIELD > &aFields, const wxString &aFieldName, const std::string &aValue, bool aIsVisible=true)
Definition: sch_field.h:431
sch_symbol.h
sim_lib_mgr.h
sim_library_ibis.h
TYPE
SIM_MODEL::TYPE TYPE
Definition: sim_model.cpp:57
sim_model.h
SIM_PINS_FIELD
#define SIM_PINS_FIELD
Definition: sim_model.h:54
SIM_DEVICE_FIELD
#define SIM_DEVICE_FIELD
Definition: sim_model.h:52
SIM_NAME_FIELD
#define SIM_NAME_FIELD
Definition: sim_model.h:57
SIM_LIBRARY_FIELD
#define SIM_LIBRARY_FIELD
Definition: sim_model.h:56
SIM_LEGACY_ENABLE_FIELD
#define SIM_LEGACY_ENABLE_FIELD
Definition: sim_model.h:64
SIM_LEGACY_ENABLE_FIELD_V7
#define SIM_LEGACY_ENABLE_FIELD_V7
Definition: sim_model.h:60
SIM_LEGACY_MODEL_FIELD
#define SIM_LEGACY_MODEL_FIELD
Definition: sim_model.h:62
SIM_LEGACY_PINS_FIELD
#define SIM_LEGACY_PINS_FIELD
Definition: sim_model.h:63
SIM_LEGACY_LIBRARY_FIELD
#define SIM_LEGACY_LIBRARY_FIELD
Definition: sim_model.h:65
SIM_PARAMS_FIELD
#define SIM_PARAMS_FIELD
Definition: sim_model.h:55
SIM_VALUE_FIELD
#define SIM_VALUE_FIELD
Definition: sim_model.h:50
SIM_LEGACY_PRIMITIVE_FIELD
#define SIM_LEGACY_PRIMITIVE_FIELD
Definition: sim_model.h:61
SIM_DEVICE_SUBTYPE_FIELD
#define SIM_DEVICE_SUBTYPE_FIELD
Definition: sim_model.h:53
sim_model_behavioral.h
sim_model_ibis.h
sim_model_ideal.h
sim_model_l_mutual.h
sim_model_ngspice.h
sim_model_r_pot.h
sim_model_raw_spice.h
sim_model_source.h
sim_model_spice_fallback.h
sim_model_subckt.h
sim_model_switch.h
sim_model_tline.h
sim_model_xspice.h
convertSeparators
bool convertSeparators(wxString *value)
Definition: string_utils.cpp:1004
wxStringSplit
void wxStringSplit(const wxString &aText, wxArrayString &aStrings, wxChar aSplitter)
Split aString to a string list separated at aSplitter.
Definition: string_utils.cpp:1332
string_utils.h
EDA_IU_SCALE::IU_PER_MILS
const double IU_PER_MILS
Definition: base_units.h:77
SIM_LIBRARY::MODEL
Definition: sim_library.h:39
SIM_LIBRARY::MODEL::model
SIM_MODEL & model
Definition: sim_library.h:41
SIM_MODEL::PARAM::INFO
Definition: sim_model.h:344
SIM_MODEL::PARAM::INFO::enumValues
std::vector< std::string > enumValues
Definition: sim_model.h:388
SIM_MODEL::PARAM::INFO::defaultValue
std::string defaultValue
Definition: sim_model.h:382
SIM_MODEL::PARAM::INFO::name
std::string name
Definition: sim_model.h:376
SIM_MODEL::PARAM::INFO::isSpiceInstanceParam
bool isSpiceInstanceParam
Definition: sim_model.h:384
SIM_MODEL::PARAM
Definition: sim_model.h:315
SIM_MODEL::PARAM::Matches
bool Matches(const std::string &aName) const
Definition: sim_model.h:395
SIM_MODEL::PARAM::value
std::string value
Definition: sim_model.h:400
SIM_MODEL::PARAM::info
const INFO & info
Definition: sim_model.h:401
SIM_MODEL::SPICE_INFO
Definition: sim_model.h:303
SIM_MODEL::SPICE_INFO::functionName
std::string functionName
Definition: sim_model.h:306
SIM_MODEL_PIN
Definition: sim_model.h:69
SIM_MODEL_PIN::NOT_CONNECTED
static constexpr auto NOT_CONNECTED
Definition: sim_model.h:73
SIM_MODEL_PIN::symbolPinNumber
wxString symbolPinNumber
Definition: sim_model.h:71
SPICE_ITEM
Definition: spice_generator.h:34
SPICE_ITEM::baseModelName
std::string baseModelName
Definition: spice_generator.h:38
GR_TEXT_H_ALIGN_RIGHT
@ GR_TEXT_H_ALIGN_RIGHT
Definition: text_attributes.h:46
VECTOR2I
VECTOR2< int32_t > VECTOR2I
Definition: vector2d.h:695