KiCad PCB EDA Suite
Loading...
Searching...
No Matches
sim_model_kibis.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 KiCad Developers, see AUTHORS.txt for contributors.
5 *
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License
8 * as published by the Free Software Foundation; either version 3
9 * of the License, or (at your option) any later version.
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, you may find one here:
18 * https://www.gnu.org/licenses/gpl-3.0.html
19 * or you may search the http://www.gnu.org website for the version 3 license,
20 * or you may write to the Free Software Foundation, Inc.,
21 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
22 */
23
24#include <sim/kibis/kibis.h>
25#include <sim/sim_model_kibis.h>
27#include <fmt/core.h>
28#include <wx/filename.h>
29#include <kiway.h>
30#include "sim_lib_mgr.h"
31
32std::string SPICE_GENERATOR_KIBIS::ModelName( const SPICE_ITEM& aItem ) const
33{
34 return fmt::format( "{}.{}", aItem.refName, aItem.baseModelName );
35}
36
37
38std::string SPICE_GENERATOR_KIBIS::ModelLine( const SPICE_ITEM& aItem ) const
39{
40 return "";
41}
42
43std::vector<std::reference_wrapper<const SIM_MODEL::PARAM>> SPICE_GENERATOR_KIBIS::GetInstanceParams() const
44{
45 std::vector<std::reference_wrapper<const SIM_MODEL::PARAM>> vec;
46 return vec;
47}
48
49
50std::vector<std::string> SPICE_GENERATOR_KIBIS::CurrentNames( const SPICE_ITEM& aItem ) const
51{
52 std::vector<std::string> currentNames;
53
54 for( const SIM_MODEL::PIN& pin : GetPins() )
55 currentNames.push_back( fmt::format( "I({}:{})", ItemName( aItem ), pin.name ) );
56
57 return currentNames;
58}
59
60
61std::string SPICE_GENERATOR_KIBIS::IbisDevice( const SPICE_ITEM& aItem, const PROJECT& aProject,
62 const wxString& aCacheDir ) const
63{
64 std::string ibisLibFilename = SIM_MODEL::GetFieldValue( &aItem.fields, SIM_LIBRARY::LIBRARY_FIELD );
65 std::string ibisCompName = SIM_MODEL::GetFieldValue( &aItem.fields, SIM_LIBRARY::NAME_FIELD );
66 std::string ibisPinName = SIM_MODEL::GetFieldValue( &aItem.fields, SIM_LIBRARY_KIBIS::PIN_FIELD );
67 std::string ibisModelName = SIM_MODEL::GetFieldValue( &aItem.fields, SIM_LIBRARY_KIBIS::MODEL_FIELD );
68 bool diffMode = SIM_MODEL::GetFieldValue( &aItem.fields, SIM_LIBRARY_KIBIS::DIFF_FIELD ) == "1";
69
70 wxString path = SIM_LIB_MGR::ResolveLibraryPath( ibisLibFilename, &aProject );
71
72 KIBIS kibis( std::string( path.c_str() ) );
73 kibis.m_cacheDir = std::string( aCacheDir.c_str() );
74
75 if( !kibis.m_valid )
76 THROW_IO_ERROR( wxString::Format( _( "Invalid IBIS file '%s'" ), ibisLibFilename ) );
77
78 KIBIS_COMPONENT* kcomp = kibis.GetComponent( std::string( ibisCompName ) );
79
80 if( !kcomp )
81 THROW_IO_ERROR( wxString::Format( _( "Could not find IBIS component '%s'" ), ibisCompName ) );
82
83 KIBIS_PIN* kpin = kcomp->GetPin( ibisPinName );
84
85
86 if( !kcomp->m_valid )
87 THROW_IO_ERROR( wxString::Format( _( "Invalid IBIS component '%s'" ), ibisCompName ) );
88
89 if( !kpin )
90 {
91 THROW_IO_ERROR( wxString::Format( _( "Could not find IBIS pin '%s' in component '%s'" ),
92 ibisPinName,
93 ibisCompName ) );
94 }
95
96 if( !kpin->m_valid )
97 {
98 THROW_IO_ERROR( wxString::Format( _( "Invalid IBIS pin '%s' in component '%s'" ),
99 ibisPinName,
100 ibisCompName ) );
101 }
102
103 KIBIS_MODEL* kmodel = kibis.GetModel( ibisModelName );
104
105 if( !kmodel )
106 THROW_IO_ERROR( wxString::Format( _( "Could not find IBIS model '%s'" ), ibisModelName ) );
107
108 if( !kmodel->m_valid )
109 THROW_IO_ERROR( wxString::Format( _( "Invalid IBIS model '%s'" ), ibisModelName ) );
110
111 KIBIS_PARAMETER kparams;
112
113 if( const SIM_MODEL::PARAM* vcc = m_model.FindParam( "vcc" ) )
114 kparams.SetCornerFromString( kparams.m_supply, vcc->value );
115
116 if( const SIM_MODEL::PARAM* rpin = m_model.FindParam( "rpin" ) )
117 kparams.SetCornerFromString( kparams.m_Rpin, rpin->value );
118
119 if( const SIM_MODEL::PARAM* lpin = m_model.FindParam( "lpin" ) )
120 kparams.SetCornerFromString( kparams.m_Lpin, lpin->value );
121
122 if( const SIM_MODEL::PARAM* cpin = m_model.FindParam( "cpin" ) )
123 kparams.SetCornerFromString( kparams.m_Cpin, cpin->value );
124
125 //kparams.SetCornerFromString( kparams.m_Ccomp, FindParam( "ccomp" )->value );
126
127 std::string result;
128
129 switch( m_model.GetType() )
130 {
131 case SIM_MODEL::TYPE::KIBIS_DEVICE:
132 if( diffMode )
133 kpin->writeSpiceDiffDevice( &result, aItem.modelName, *kmodel, kparams );
134 else
135 kpin->writeSpiceDevice( &result, aItem.modelName, *kmodel, kparams );
136 break;
137
138 case SIM_MODEL::TYPE::KIBIS_DRIVER_DC:
139 {
140 std::string paramValue = "";
141
142 if( const SIM_MODEL::PARAM* dc = m_model.FindParam( "dc" ) )
143 paramValue = dc->value;
144
145 if( paramValue == "hi-Z" )
146 {
147 kparams.m_waveform = static_cast<KIBIS_WAVEFORM*>( new KIBIS_WAVEFORM_HIGH_Z( &kibis ) );
148 }
149 else if( paramValue == "low" )
150 {
151 kparams.m_waveform = static_cast<KIBIS_WAVEFORM*>( new KIBIS_WAVEFORM_STUCK_LOW( &kibis ) );
152 }
153 else if( paramValue == "high" )
154 {
155 kparams.m_waveform = static_cast<KIBIS_WAVEFORM*>( new KIBIS_WAVEFORM_STUCK_HIGH( &kibis ) );
156 }
157
158 if( diffMode )
159 kpin->writeSpiceDiffDriver( &result, aItem.modelName, *kmodel, kparams );
160 else
161 kpin->writeSpiceDriver( &result, aItem.modelName, *kmodel, kparams );
162 break;
163 }
164
165 case SIM_MODEL::TYPE::KIBIS_DRIVER_RECT:
166 {
168
169 if( const SIM_MODEL::PARAM* ton = m_model.FindParam( "ton" ) )
170 waveform->m_ton = SIM_VALUE::ToDouble( ton->value, 1 );
171
172 if( const SIM_MODEL::PARAM* toff = m_model.FindParam( "toff" ) )
173 waveform->m_toff = SIM_VALUE::ToDouble( toff->value, 1 );
174
175 if( const SIM_MODEL::PARAM* td = m_model.FindParam( "td" ) )
176 waveform->m_delay = SIM_VALUE::ToDouble( td->value, 0 );
177
178 if( const SIM_MODEL::PARAM* n = m_model.FindParam( "n" ) )
179 waveform->m_cycles = SIM_VALUE::ToInt( n->value, 1 );
180
181 kparams.m_waveform = waveform;
182
183 if( diffMode )
184 kpin->writeSpiceDiffDriver( &result, aItem.modelName, *kmodel, kparams );
185 else
186 kpin->writeSpiceDriver( &result, aItem.modelName, *kmodel, kparams );
187 break;
188 }
189
190 case SIM_MODEL::TYPE::KIBIS_DRIVER_PRBS:
191 {
192 KIBIS_WAVEFORM_PRBS* waveform = new KIBIS_WAVEFORM_PRBS( &kibis );
193
194 if( const SIM_MODEL::PARAM* f0 = m_model.FindParam( "f0" ) )
195 waveform->m_bitrate = SIM_VALUE::ToDouble( f0->value, 0 );
196
197 if( const SIM_MODEL::PARAM* td = m_model.FindParam( "td" ) )
198 waveform->m_delay = SIM_VALUE::ToDouble( td->value, 0 );
199
200 if( const SIM_MODEL::PARAM* n = m_model.FindParam( "n" ) )
201 waveform->m_bits = SIM_VALUE::ToInt( n->value, 0 );
202
203 kparams.m_waveform = waveform;
204
205 if( diffMode )
206 kpin->writeSpiceDiffDriver( &result, aItem.modelName, *kmodel, kparams );
207 else
208 kpin->writeSpiceDriver( &result, aItem.modelName, *kmodel, kparams );
209 break;
210 }
211
212 default:
213 wxFAIL_MSG( "Unknown IBIS model type" );
214 return "";
215 }
216
217 return result;
218}
219
220
222 SIM_MODEL( aType, std::make_unique<SPICE_GENERATOR_KIBIS>( *this ) ),
223 m_enableDiff( false ),
224 m_sourceModel( nullptr )
225{
226 static std::vector<PARAM::INFO> device = makeParamInfos( TYPE::KIBIS_DEVICE );
227 static std::vector<PARAM::INFO> dcDriver = makeParamInfos( TYPE::KIBIS_DRIVER_DC );
228 static std::vector<PARAM::INFO> rectDriver = makeParamInfos( TYPE::KIBIS_DRIVER_RECT );
229 static std::vector<PARAM::INFO> prbsDriver = makeParamInfos( TYPE::KIBIS_DRIVER_PRBS );
230
231 std::vector<PARAM::INFO>* paramInfos = nullptr;
232
233 switch( aType )
234 {
235 case SIM_MODEL::TYPE::KIBIS_DEVICE: paramInfos = &device; break;
236 case SIM_MODEL::TYPE::KIBIS_DRIVER_DC: paramInfos = &dcDriver; break;
237 case SIM_MODEL::TYPE::KIBIS_DRIVER_RECT: paramInfos = &rectDriver; break;
238 case SIM_MODEL::TYPE::KIBIS_DRIVER_PRBS: paramInfos = &prbsDriver; break;
239
240 default:
241 wxFAIL;
242 return;
243 }
244
245 for( const PARAM::INFO& paramInfo : *paramInfos )
246 AddParam( paramInfo );
247
248 SwitchSingleEndedDiff( false );
249}
250
251
253{
254 ClearPins();
255
256 if( aDiff )
257 {
258 AddPin( { "GND", "1" } );
259 AddPin( { "+", "2" } );
260 AddPin( { "-", "3" } );
261 }
262 else
263 {
264 AddPin( { "GND", "1" } );
265 AddPin( { "IN/OUT", "2" } );
266 }
267}
268
270 SIM_MODEL_KIBIS( aType )
271{
272 for( PARAM& param1 : m_params )
273 {
274 for( auto& param2refwrap : aSource.GetParams() )
275 {
276 const PARAM& param2 = param2refwrap.get();
277
278 if( param1.info.name == param2.info.name )
279 param1.value = param2.value;
280 }
281 }
282
284
285 m_ibisPins = aSource.GetIbisPins();
286 m_ibisModels = aSource.GetIbisModels();
287
288 m_enableDiff = aSource.CanDifferential();
289}
290
291
292bool SIM_MODEL_KIBIS::ChangePin( const SIM_LIBRARY_KIBIS& aLib, std::string aPinNumber )
293{
294 KIBIS_COMPONENT* kcomp = aLib.m_kibis.GetComponent( std::string( GetComponentName() ) );
295
296 if( !kcomp )
297 return false;
298
299 KIBIS_PIN* kpin = kcomp->GetPin( std::string( aPinNumber.c_str() ) );
300
301 if( !kpin )
302 return false;
303
304 m_ibisModels.clear();
305
306 for( KIBIS_MODEL* kmodel : kpin->m_models )
307 m_ibisModels.push_back( kmodel->m_name );
308
309 return true;
310}
311
312
314{
315 // Actual base models can only be of the same type, which is not the case here, as in addition
316 // to IBIS device model type we have multiple types of drivers available for the same sourced
317 // model. And we don't want to inherit the default values anyway. So we just store these models
318 // and use the only for Spice code generation.
319 m_sourceModel = dynamic_cast<const SIM_MODEL_KIBIS*>( &aBaseModel );
320}
321
322
323std::vector<SIM_MODEL::PARAM::INFO> SIM_MODEL_KIBIS::makeParamInfos( TYPE aType )
324{
325 std::vector<PARAM::INFO> paramInfos;
326 PARAM::INFO paramInfo;
327
328 paramInfo.name = "vcc";
329 paramInfo.type = SIM_VALUE::TYPE_STRING;
330 paramInfo.unit = "";
332 paramInfo.defaultValue = "typ";
333 paramInfo.description = _( "Power supply" );
334 paramInfo.spiceModelName = "";
335 paramInfo.enumValues = { "typ", "min", "max" };
336 paramInfos.push_back( paramInfo );
337
338 paramInfo.name = "rpin";
339 paramInfo.type = SIM_VALUE::TYPE_STRING;
340 paramInfo.unit = "";
342 paramInfo.defaultValue = "typ";
343 paramInfo.description = _( "Parasitic pin resistance" );
344 paramInfo.spiceModelName = "";
345 paramInfo.enumValues = { "typ", "min", "max" };
346 paramInfos.push_back( paramInfo );
347
348 paramInfo.name = "lpin";
349 paramInfo.type = SIM_VALUE::TYPE_STRING;
350 paramInfo.unit = "";
352 paramInfo.defaultValue = "typ";
353 paramInfo.description = _( "Parasitic pin inductance" );
354 paramInfo.spiceModelName = "";
355 paramInfo.enumValues = { "typ", "min", "max" };
356 paramInfos.push_back( paramInfo );
357
358 paramInfo.name = "cpin";
359 paramInfo.type = SIM_VALUE::TYPE_STRING;
360 paramInfo.unit = "";
362 paramInfo.defaultValue = "typ";
363 paramInfo.description = _( "Parasitic pin capacitance" );
364 paramInfo.spiceModelName = "";
365 paramInfo.enumValues = { "typ", "min", "max" };
366 paramInfos.push_back( paramInfo );
367
368 std::vector<PARAM::INFO> dc = makeDcWaveformParamInfos();
369 std::vector<PARAM::INFO> rect = makeRectWaveformParamInfos();
370 std::vector<PARAM::INFO> prbs = makePrbsWaveformParamInfos();
371
372 switch( aType )
373 {
374 case TYPE::KIBIS_DRIVER_DC:
375 for( const PARAM::INFO& param : makeDcWaveformParamInfos() )
376 paramInfos.push_back( param );
377 break;
378
379 case TYPE::KIBIS_DRIVER_RECT:
380 for( const PARAM::INFO& param : makeRectWaveformParamInfos() )
381 paramInfos.push_back( param );
382 break;
383
384 case TYPE::KIBIS_DRIVER_PRBS:
385 for( const PARAM::INFO& param : makePrbsWaveformParamInfos() )
386 paramInfos.push_back( param );
387 break;
388
389 default:
390 break;
391 }
392
393 return paramInfos;
394}
395
396
397std::vector<SIM_MODEL::PARAM::INFO> SIM_MODEL_KIBIS::makeDcWaveformParamInfos()
398{
399 std::vector<PARAM::INFO> paramInfos;
400 PARAM::INFO paramInfo;
401
402 paramInfo.name = "dc";
403 paramInfo.type = SIM_VALUE::TYPE_STRING;
404 paramInfo.unit = "";
406 paramInfo.defaultValue = "hi-Z";
407 paramInfo.description = _( "DC Value" );
408 paramInfo.enumValues = { "hi-Z", "low", "high" };
409 paramInfos.push_back( paramInfo );
410
411 return paramInfos;
412}
413
414
415std::vector<SIM_MODEL::PARAM::INFO> SIM_MODEL_KIBIS::makeRectWaveformParamInfos()
416{
417 std::vector<PARAM::INFO> paramInfos;
418 PARAM::INFO paramInfo;
419
420 paramInfo.name = "ton";
421 paramInfo.type = SIM_VALUE::TYPE_FLOAT;
422 paramInfo.unit = "s";
424 paramInfo.defaultValue = "";
425 paramInfo.description = _( "ON time" );
426 paramInfos.push_back( paramInfo );
427
428 paramInfo.name = "toff";
429 paramInfo.type = SIM_VALUE::TYPE_FLOAT;
430 paramInfo.unit = "s";
432 paramInfo.defaultValue = "";
433 paramInfo.description = _( "OFF time" );
434 paramInfos.push_back( paramInfo );
435
436 paramInfo.name = "td";
437 paramInfo.type = SIM_VALUE::TYPE_FLOAT;
438 paramInfo.unit = "s";
440 paramInfo.defaultValue = "0";
441 paramInfo.description = _( "Delay" );
442 paramInfos.push_back( paramInfo );
443
444 paramInfo.name = "n";
445 paramInfo.type = SIM_VALUE::TYPE_INT;
446 paramInfo.unit = "";
448 paramInfo.defaultValue = "1";
449 paramInfo.description = _( "Number of cycles" );
450 paramInfos.push_back( paramInfo );
451
452 return paramInfos;
453}
454
455
456std::vector<SIM_MODEL::PARAM::INFO> SIM_MODEL_KIBIS::makePrbsWaveformParamInfos()
457{
458 std::vector<PARAM::INFO> paramInfos;
459 PARAM::INFO paramInfo;
460
461 paramInfo.name = "f0";
462 paramInfo.type = SIM_VALUE::TYPE_FLOAT;
463 paramInfo.unit = "Hz";
465 paramInfo.defaultValue = "";
466 paramInfo.description = _( "Bitrate" );
467 paramInfos.push_back( paramInfo );
468
469 paramInfo.name = "td";
470 paramInfo.type = SIM_VALUE::TYPE_FLOAT;
471 paramInfo.unit = "s";
473 paramInfo.defaultValue = "";
474 paramInfo.description = _( "Delay" );
475 paramInfos.push_back( paramInfo );
476
477 paramInfo.name = "n";
478 paramInfo.type = SIM_VALUE::TYPE_INT;
479 paramInfo.unit = "";
481 paramInfo.defaultValue = "";
482 paramInfo.description = _( "Number of bits" );
483 paramInfos.push_back( paramInfo );
484
485 return paramInfos;
486}
487
bool m_valid
Definition: kibis.h:49
KIBIS_PIN * GetPin(std::string aPinNumber)
Get a pin by its number ( 1, 2, A1, A2, ... )
Definition: kibis.cpp:331
std::string m_name
Definition: kibis.h:244
IBIS_CORNER m_supply
Definition: kibis.h:189
IBIS_CORNER m_Cpin
Definition: kibis.h:187
IBIS_CORNER m_Lpin
Definition: kibis.h:186
IBIS_CORNER m_Rpin
Definition: kibis.h:185
void SetCornerFromString(IBIS_CORNER &aCorner, std::string aString)
Definition: kibis.cpp:1426
KIBIS_WAVEFORM * m_waveform
Definition: kibis.h:190
bool writeSpiceDiffDriver(std::string *aDest, std::string aName, KIBIS_MODEL &aModel, KIBIS_PARAMETER &aParam)
Definition: kibis.cpp:1309
bool writeSpiceDiffDevice(std::string *aDest, std::string aName, KIBIS_MODEL &aModel, KIBIS_PARAMETER &aParam)
Definition: kibis.cpp:1360
std::vector< KIBIS_MODEL * > m_models
Definition: kibis.h:359
bool writeSpiceDriver(std::string *aDest, std::string aName, KIBIS_MODEL &aModel, KIBIS_PARAMETER &aParam)
Definition: kibis.cpp:1135
bool writeSpiceDevice(std::string *aDest, std::string aName, KIBIS_MODEL &aModel, KIBIS_PARAMETER &aParam)
Definition: kibis.cpp:1257
double m_delay
Definition: kibis.h:116
double m_bitrate
Definition: kibis.h:115
Definition: kibis.h:216
KIBIS_COMPONENT * GetComponent(std::string aName)
Return the component with name aName .
Definition: kibis.cpp:1415
KIBIS_MODEL * GetModel(std::string aName)
Return the model with name aName .
Definition: kibis.cpp:1404
std::string m_cacheDir
Absolute path of the directory that will be used for caching.
Definition: kibis.h:231
Container for project specific data.
Definition: project.h:62
static constexpr auto DIFF_FIELD
static constexpr auto MODEL_FIELD
static constexpr auto PIN_FIELD
static constexpr auto LIBRARY_FIELD
Definition: sim_library.h:35
static constexpr auto NAME_FIELD
Definition: sim_library.h:36
static wxString ResolveLibraryPath(const wxString &aLibraryPath, const PROJECT *aProject)
Definition: sim_lib_mgr.cpp:56
SIM_MODEL_KIBIS(TYPE aType)
bool ChangePin(const SIM_LIBRARY_KIBIS &aLib, std::string aPinNumber)
update the list of available models based on the pin number.
void SetBaseModel(const SIM_MODEL &aBaseModel) override
const SIM_MODEL_KIBIS * m_sourceModel
static std::vector< PARAM::INFO > makeRectWaveformParamInfos()
std::vector< std::string > GetIbisModels() const
static std::vector< PARAM::INFO > makeParamInfos(TYPE aType)
static std::vector< PARAM::INFO > makePrbsWaveformParamInfos()
std::string m_componentName
std::vector< std::pair< std::string, std::string > > m_ibisPins
static std::vector< PARAM::INFO > makeDcWaveformParamInfos()
std::vector< std::string > m_ibisModels
std::string GetComponentName() const
bool CanDifferential() const
void SwitchSingleEndedDiff(bool aDiff) override
std::vector< std::pair< std::string, std::string > > GetIbisPins() const
void AddParam(const PARAM::INFO &aInfo)
Definition: sim_model.cpp:726
void ClearPins()
Definition: sim_model.cpp:708
static std::string GetFieldValue(const std::vector< T > *aFields, const wxString &aFieldName, bool aResolve=true)
Definition: sim_model.cpp:621
void AddPin(const PIN &aPin)
Definition: sim_model.cpp:702
const PARAM * FindParam(const std::string &aParamName) const
Definition: sim_model.cpp:814
std::vector< PARAM > m_params
Definition: sim_model.h:551
std::vector< std::reference_wrapper< const PARAM > > GetParams() const
Definition: sim_model.cpp:822
TYPE GetType() const
Definition: sim_model.h:469
@ TYPE_INT
Definition: sim_value.h:68
@ TYPE_FLOAT
Definition: sim_value.h:69
@ TYPE_STRING
Definition: sim_value.h:71
static double ToDouble(const std::string &aString, double aDefault=NAN)
Definition: sim_value.cpp:418
static int ToInt(const std::string &aString, int aDefault=-1)
Definition: sim_value.cpp:443
std::string ModelLine(const SPICE_ITEM &aItem) const override
std::vector< std::reference_wrapper< const SIM_MODEL::PARAM > > GetInstanceParams() const override
std::string IbisDevice(const SPICE_ITEM &aItem, const PROJECT &aProject, const wxString &aCacheDir) const
std::string ModelName(const SPICE_ITEM &aItem) const override
std::vector< std::string > CurrentNames(const SPICE_ITEM &aItem) const override
virtual std::string ItemName(const SPICE_ITEM &aItem) const
virtual std::vector< std::reference_wrapper< const SIM_MODEL::PIN > > GetPins() const
const SIM_MODEL & m_model
#define _(s)
#define THROW_IO_ERROR(msg)
Definition: ki_exception.h:39
STL namespace.
SIM_MODEL::TYPE TYPE
Definition: sim_model.cpp:53
std::string spiceModelName
Definition: sim_model.h:386
std::vector< std::string > enumValues
Definition: sim_model.h:388
SIM_VALUE::TYPE type
Definition: sim_model.h:379
std::string defaultValue
Definition: sim_model.h:382
std::string description
Definition: sim_model.h:383
std::string value
Definition: sim_model.h:400
const INFO & info
Definition: sim_model.h:401
std::string refName
std::vector< SCH_FIELD > fields
std::string modelName
std::string baseModelName