SIM_LIB_MGR Class Reference

#include <sim_lib_mgr.h>

Public Member Functions
	SIM_LIB_MGR (const PROJECT *aPrj, REPORTER *aReporter=nullptr)
virtual	~SIM_LIB_MGR ()=default
void	SetReporter (REPORTER *aReporter)
void	Clear ()
void	SetLibrary (const wxString &aLibraryPath)
SIM_MODEL &	CreateModel (SIM_MODEL::TYPE aType, const std::vector< LIB_PIN * > &aPins)
SIM_MODEL &	CreateModel (const SIM_MODEL *aBaseModel, const std::vector< LIB_PIN * > &aPins)
template<typename T >
SIM_MODEL &	CreateModel (const SIM_MODEL *aBaseModel, const std::vector< LIB_PIN * > &aPins, const std::vector< T > &aFields)
SIM_LIBRARY::MODEL	CreateModel (const SCH_SHEET_PATH *aSheetPath, SCH_SYMBOL &aSymbol)
template<typename T >
SIM_LIBRARY::MODEL	CreateModel (const std::vector< T > &aFields, const std::vector< LIB_PIN * > &aPins, bool aResolved)
template<typename T >
SIM_LIBRARY::MODEL	CreateModel (const wxString &aLibraryPath, const std::string &aBaseModelName, const std::vector< T > &aFields, const std::vector< LIB_PIN * > &aPins)
void	SetModel (int aIndex, std::unique_ptr< SIM_MODEL > aModel)
std::map< wxString, std::reference_wrapper< const SIM_LIBRARY > >	GetLibraries () const
std::vector< std::reference_wrapper< SIM_MODEL > >	GetModels () const
std::string	ResolveEmbeddedLibraryPath (const std::string &aLibPath, const std::string &aRelativeLib)

Static Public Member Functions
static wxString	ResolveLibraryPath (const wxString &aLibraryPath, const PROJECT *aProject)

Private Attributes
const PROJECT *	m_project
REPORTER *	m_reporter
std::map< wxString, std::unique_ptr< SIM_LIBRARY > >	m_libraries
std::vector< std::unique_ptr< SIM_MODEL > >	m_models

Detailed Description

Definition at line 40 of file sim_lib_mgr.h.

Constructor & Destructor Documentation

SIM_LIB_MGR()

SIM_LIB_MGR::SIM_LIB_MGR	(	const PROJECT *	aPrj,
		REPORTER *	aReporter = nullptr
	)

Definition at line 42 of file sim_lib_mgr.cpp.

 :
 m_project( aPrj ),
 m_reporter( aReporter )
{
}

~SIM_LIB_MGR()

virtual SIM_LIB_MGR::~SIM_LIB_MGR ( )

virtualdefault

Member Function Documentation

Clear()

void SIM_LIB_MGR::Clear

(

)

Definition at line 49 of file sim_lib_mgr.cpp.

{
 m_libraries.clear();
 m_models.clear();
}

References m_libraries, and m_models.

Referenced by SetLibrary().

CreateModel() [1/6]

SIM_LIBRARY::MODEL SIM_LIB_MGR::CreateModel	(	const SCH_SHEET_PATH *	aSheetPath,
		SCH_SYMBOL &	aSymbol
	)

Definition at line 183 of file sim_lib_mgr.cpp.

{
 // Note: currently this creates a resolved model (all Kicad variables references are resolved
 // before building the model).
 //
 // That's not what we want if this is ever called from the Simulation Model Editor (or other
 // editors, but it is what we want if called to generate a netlist or other exported items.
 
 
 std::vector<SCH_FIELD> fields;
 
 for( int i = 0; i < aSymbol.GetFieldCount(); ++i )
 {
 fields.emplace_back( VECTOR2I(), i, &aSymbol, aSymbol.GetFields()[ i ].GetName() );
 
 if( i == REFERENCE_FIELD )
 fields.back().SetText( aSymbol.GetRef( aSheetPath ) );
 else
 fields.back().SetText( aSymbol.GetFields()[ i ].GetShownText( 0, false ) );
 }
 
 wxString deviceType;
 wxString modelType;
 wxString modelParams;
 wxString pinMap;
 bool storeInValue = false;
 
 // Infer RLC and VI models if they aren't specified
 if( SIM_MODEL::InferSimModel( aSymbol, &fields, true, SIM_VALUE_GRAMMAR::NOTATION::SI,
 &deviceType, &modelType, &modelParams, &pinMap ) )
 {
 fields.emplace_back( &aSymbol, -1, SIM_DEVICE_TYPE_FIELD );
 fields.back().SetText( deviceType );
 
 if( !modelType.IsEmpty() )
 {
 fields.emplace_back( &aSymbol, -1, SIM_TYPE_FIELD );
 fields.back().SetText( modelType );
 }
 
 fields.emplace_back( &aSymbol, -1, SIM_PARAMS_FIELD );
 fields.back().SetText( modelParams );
 
 fields.emplace_back( &aSymbol, -1, SIM_PINS_FIELD );
 fields.back().SetText( pinMap );
 
 storeInValue = true;
 }
 
 std::vector<LIB_PIN*> sourcePins = aSymbol.GetAllLibPins();
 
 std::sort( sourcePins.begin(), sourcePins.end(),
 []( const LIB_PIN* lhs, const LIB_PIN* rhs )
 {
 return StrNumCmp( lhs->GetNumber(), rhs->GetNumber(), true ) < 0;
 } );
 
 SIM_LIBRARY::MODEL model = CreateModel( fields, sourcePins, true );
 
 model.model.SetIsStoredInValue( storeInValue );
 
 return model;
}

References CreateModel(), SCH_SYMBOL::GetAllLibPins(), SCH_SYMBOL::GetFieldCount(), SCH_SYMBOL::GetFields(), SCH_SYMBOL::GetRef(), SIM_MODEL::InferSimModel(), SIM_LIBRARY::MODEL::model, REFERENCE_FIELD, SIM_MODEL::SetIsStoredInValue(), SIM_VALUE_GRAMMAR::SI, SIM_DEVICE_TYPE_FIELD, SIM_PARAMS_FIELD, SIM_PINS_FIELD, and SIM_TYPE_FIELD.

CreateModel() [2/6]

SIM_MODEL & SIM_LIB_MGR::CreateModel	(	const SIM_MODEL *	aBaseModel,
		const std::vector< LIB_PIN * > &	aPins
	)

Definition at line 158 of file sim_lib_mgr.cpp.

{
 m_models.push_back( SIM_MODEL::Create( aBaseModel, aPins, m_reporter ) );
 return *m_models.back();
}

References SIM_MODEL::Create(), m_models, and m_reporter.

CreateModel() [3/6]

template<typename T >

SIM_MODEL & SIM_LIB_MGR::CreateModel	(	const SIM_MODEL *	aBaseModel,
		const std::vector< LIB_PIN * > &	aPins,
		const std::vector< T > &	aFields
	)

Definition at line 167 of file sim_lib_mgr.cpp.

{
 m_models.push_back( SIM_MODEL::Create( aBaseModel, aPins, aFields, m_reporter ) );
 return *m_models.back();
}

References SIM_MODEL::Create(), m_models, and m_reporter.

CreateModel() [4/6]

template<typename T >

SIM_LIBRARY::MODEL SIM_LIB_MGR::CreateModel	(	const std::vector< T > &	aFields,
		const std::vector< LIB_PIN * > &	aPins,
		bool	aResolved
	)

Definition at line 249 of file sim_lib_mgr.cpp.

{
 std::string libraryPath = SIM_MODEL::GetFieldValue( &aFields, SIM_LIBRARY::LIBRARY_FIELD );
 std::string baseModelName = SIM_MODEL::GetFieldValue( &aFields, SIM_LIBRARY::NAME_FIELD );
 
 if( libraryPath != "" )
 {
 return CreateModel( libraryPath, baseModelName, aFields, aPins );
 }
 else
 {
 m_models.push_back( SIM_MODEL::Create( aFields, aPins, aResolved, m_reporter ) );
 return { baseModelName, *m_models.back() };
 }
}

References SIM_MODEL::Create(), CreateModel(), SIM_MODEL::GetFieldValue(), SIM_LIBRARY::LIBRARY_FIELD, m_models, m_reporter, and SIM_LIBRARY::NAME_FIELD.

CreateModel() [5/6]

template<typename T >

SIM_LIBRARY::MODEL SIM_LIB_MGR::CreateModel	(	const wxString &	aLibraryPath,
		const std::string &	aBaseModelName,
		const std::vector< T > &	aFields,
		const std::vector< LIB_PIN * > &	aPins
	)

Definition at line 275 of file sim_lib_mgr.cpp.

{
 wxString path;
 wxString msg;
 SIM_LIBRARY* library = nullptr;
 SIM_MODEL* baseModel = nullptr;
 std::string modelName;
 
 try
 {
 path = ResolveLibraryPath( aLibraryPath, m_project );
 
 std::function<std::string( const std::string&, const std::string& )> f2 =
 std::bind( &SIM_LIB_MGR::ResolveEmbeddedLibraryPath, this, _1, _2 );
 
 auto it = m_libraries.try_emplace( path, SIM_LIBRARY::Create( path, m_reporter, &f2 ) ).first;
 library = &*it->second;
 }
 catch( const IO_ERROR& e )
 {
 if( m_reporter )
 {
 msg.Printf( _( "Error loading simulation model library '%s': %s" ),
 path,
 e.What() );
 
 m_reporter->Report( msg, RPT_SEVERITY_ERROR );
 }
 }
 
 if( aBaseModelName == "" )
 {
 if( m_reporter )
 {
 msg.Printf( _( "Error loading simulation model: no '%s' field" ),
 SIM_LIBRARY::NAME_FIELD );
 
 m_reporter->Report( msg, RPT_SEVERITY_ERROR );
 }
 
 modelName = _( "unknown" ).ToStdString();
 }
 else if( library )
 {
 baseModel = library->FindModel( aBaseModelName );
 modelName = aBaseModelName;
 
 if( !baseModel )
 {
 if( m_reporter )
 {
 msg.Printf( _( "Error loading simulation model: could not find base model '%s' "
 "in library '%s'" ),
 aBaseModelName,
 path );
 
 m_reporter->Report( msg, RPT_SEVERITY_ERROR );
 }
 }
 }
 
 m_models.push_back( SIM_MODEL::Create( baseModel, aPins, aFields, m_reporter ) );
 
 return { modelName, *m_models.back() };
}

References _, SIM_LIBRARY::Create(), SIM_MODEL::Create(), library, m_libraries, m_models, m_project, m_reporter, SIM_LIBRARY::NAME_FIELD, path, REPORTER::Report(), ResolveEmbeddedLibraryPath(), ResolveLibraryPath(), RPT_SEVERITY_ERROR, and IO_ERROR::What().

CreateModel() [6/6]

SIM_MODEL & SIM_LIB_MGR::CreateModel	(	SIM_MODEL::TYPE	aType,
		const std::vector< LIB_PIN * > &	aPins
	)

Definition at line 151 of file sim_lib_mgr.cpp.

{
 m_models.push_back( SIM_MODEL::Create( aType, aPins, m_reporter ) );
 return *m_models.back();
}

References SIM_MODEL::Create(), m_models, and m_reporter.

Referenced by CreateModel(), SIM_MODEL::MigrateSimModel(), DIALOG_SCH_FIELD_PROPERTIES::onScintillaCharAdded(), NETLIST_EXPORTER_SPICE::readModel(), SCH_EDIT_FRAME::RefreshOperatingPointDisplay(), ERC_TESTER::TestSimModelIssues(), and SIMULATOR_FRAME::UpdateTunerValue().

GetLibraries()

std::map< wxString, std::reference_wrapper< const SIM_LIBRARY > > SIM_LIB_MGR::GetLibraries

(

)

const

Definition at line 351 of file sim_lib_mgr.cpp.

{
 std::map<wxString, std::reference_wrapper<const SIM_LIBRARY>> libraries;
 
 for( auto& [path, library] : m_libraries )
 libraries.try_emplace( path, *library );
 
 return libraries;
}

References library, m_libraries, and path.

Referenced by NETLIST_EXPORTER_SPICE::writeIncludes().

GetModels()

std::vector< std::reference_wrapper< SIM_MODEL > > SIM_LIB_MGR::GetModels

(

)

const

Definition at line 362 of file sim_lib_mgr.cpp.

{
 std::vector<std::reference_wrapper<SIM_MODEL>> models;
 
 for( const std::unique_ptr<SIM_MODEL>& model : m_models )
 models.emplace_back( *model );
 
 return models;
}

References m_models.

ResolveEmbeddedLibraryPath()

std::string SIM_LIB_MGR::ResolveEmbeddedLibraryPath	(	const std::string &	aLibPath,
		const std::string &	aRelativeLib
	)

Definition at line 91 of file sim_lib_mgr.cpp.

{
 wxFileName testPath( aLibPath );
 wxString fullPath( aLibPath );
 
 if( !testPath.IsAbsolute() && !aRelativeLib.empty() )
 {
 wxString relLib( aRelativeLib );
 
 try
 {
 relLib = ResolveLibraryPath( relLib, m_project );
 }
 catch( ... )
 {}
 
 wxFileName fn( relLib );
 
 testPath.MakeAbsolute( fn.GetPath( true ) );
 fullPath = testPath.GetFullPath();
 }
 
 try
 {
 wxFileName fn( fullPath );
 
 if( !fn.Exists() )
 fullPath = aLibPath;
 
 fullPath = ResolveLibraryPath( fullPath, m_project );
 }
 catch( ... )
 {}
 
 return fullPath.ToStdString();
}

References m_project, and ResolveLibraryPath().

Referenced by CreateModel(), and SetLibrary().

ResolveLibraryPath()

wxString SIM_LIB_MGR::ResolveLibraryPath ( const wxString &  aLibraryPath, const PROJECT *  aProject  )

static

Definition at line 56 of file sim_lib_mgr.cpp.

{
 wxString expandedPath = ExpandEnvVarSubstitutions( aLibraryPath, aProject );
 wxFileName fn( expandedPath );
 
 if( fn.IsAbsolute() )
 return fn.GetFullPath();
 
 wxFileName projectFn( aProject ? aProject->AbsolutePath( expandedPath ) : expandedPath );
 
 if( projectFn.Exists() )
 return projectFn.GetFullPath();
 
 wxFileName spiceLibFn( expandedPath );
 wxString spiceLibDir;
 
 wxGetEnv( wxT( "SPICE_LIB_DIR" ), &spiceLibDir );
 
 if( !spiceLibDir.IsEmpty() && spiceLibFn.MakeAbsolute( spiceLibDir ) && spiceLibFn.Exists() )
 return spiceLibFn.GetFullPath();
 
 if( projectFn.GetFullPath() == spiceLibFn.GetFullPath() )
 {
 THROW_IO_ERROR( wxString::Format( _( "Simulation model library not found at '%s'" ),
 spiceLibFn.GetFullPath() ) );
 }
 else
 {
 THROW_IO_ERROR( wxString::Format( _( "Simulation model library not found at '%s' or '%s'" ),
 projectFn.GetFullPath(),
 spiceLibFn.GetFullPath() ) );
 }
}

References _, PROJECT::AbsolutePath(), ExpandEnvVarSubstitutions(), Format(), and THROW_IO_ERROR.

Referenced by CreateModel(), SPICE_GENERATOR_KIBIS::IbisDevice(), ResolveEmbeddedLibraryPath(), and SetLibrary().

SetLibrary()

void SIM_LIB_MGR::SetLibrary

(

const wxString &

aLibraryPath

)

Definition at line 130 of file sim_lib_mgr.cpp.

{
 try
 {
 wxString path = ResolveLibraryPath( aLibraryPath, m_project );
 
 std::function<std::string(const std::string&, const std::string&)> f2 =
 std::bind( &SIM_LIB_MGR::ResolveEmbeddedLibraryPath, this, _1, _2 );
 
 std::unique_ptr<SIM_LIBRARY> library = SIM_LIBRARY::Create( path, m_reporter, &f2 );
 
 Clear();
 m_libraries[path] = std::move( library );
 }
 catch( const IO_ERROR& e )
 {
 m_reporter->Report( e.What() );
 }
}

References Clear(), SIM_LIBRARY::Create(), library, m_libraries, m_project, m_reporter, path, REPORTER::Report(), ResolveEmbeddedLibraryPath(), ResolveLibraryPath(), and IO_ERROR::What().

SetModel()

void SIM_LIB_MGR::SetModel	(	int	aIndex,
		std::unique_ptr< SIM_MODEL >	aModel
	)

Definition at line 345 of file sim_lib_mgr.cpp.

{
 m_models.at( aIndex ) = std::move( aModel );
}

References m_models.

SetReporter()

void SIM_LIB_MGR::SetReporter ( REPORTER *  aReporter )

inline

Definition at line 46 of file sim_lib_mgr.h.

{ m_reporter = aReporter; }

References m_reporter.

Referenced by NETLIST_EXPORTER_SPICE::WriteNetlist().

Member Data Documentation

m_libraries

std::map<wxString, std::unique_ptr<SIM_LIBRARY> > SIM_LIB_MGR::m_libraries

private

Definition at line 86 of file sim_lib_mgr.h.

Referenced by Clear(), CreateModel(), GetLibraries(), and SetLibrary().

m_models

std::vector<std::unique_ptr<SIM_MODEL> > SIM_LIB_MGR::m_models

private

Definition at line 87 of file sim_lib_mgr.h.

Referenced by Clear(), CreateModel(), GetModels(), and SetModel().

m_project

const PROJECT* SIM_LIB_MGR::m_project

private

Definition at line 84 of file sim_lib_mgr.h.

Referenced by CreateModel(), ResolveEmbeddedLibraryPath(), and SetLibrary().

m_reporter

REPORTER* SIM_LIB_MGR::m_reporter

private

Definition at line 85 of file sim_lib_mgr.h.

Referenced by CreateModel(), SetLibrary(), and SetReporter().

---

The documentation for this class was generated from the following files:

• sim_lib_mgr.h
• sim_lib_mgr.cpp