engforge.test.test_four_bar.FourBar

class FourBar(*, name=NOTHING, parent=None, dynamic_input_vars=NOTHING, dynamic_state_vars=NOTHING, dynamic_output_vars=NOTHING, r1=0.02, gamma_zero=0.17452777777777778, gamma=0, theta=0, ra=0.03, x2=0.05, h2=0.0)

Bases: System

Method generated by attrs for class FourBar.

Methods

add_fields	Overwrite this to modify logging fields
change_all_log_lvl
check_ref_slot_type	recursively checks class slots for the key, and returns the slot type
clone	returns a clone of this system, often used to iterate the system without affecting the input values at the last convergence step.
cls_all_attrs_fields
cls_all_property_keys
cls_all_property_labels
cls_compile	compiles this class, override this to compile functionality for this class
collect_all_attributes	collects all the attributes for a system
collect_comp_refs	collects all the references for the system grouped by component
collect_dynamic_refs	collects the dynamics of the systems 1.
collect_inst_attributes	collects all the attributes for a system
collect_post_update_refs	checks all methods and creates ref's to execute them later
collect_solver_refs	collects all the references for the system grouped by function and prepended with the system key
collect_update_refs	checks all methods and creates ref's to execute them later
comp_references	A cached set of recursive references to any slot component #FIXME: by instance recache on iterative component change or other signals
compile_classes	compiles all subclass functionality
copy_config_at_state	copy the system at the current state recrusively to a certain level, by default copying everything :type levels_deep: int :param levels_deep: how many levels deep to copy, -1 is all :type level: :param level: the current level, defaults to 0 if not set
create_dynamic_matricies	creates a dynamics object for the system
create_feedthrough_matrix	creates the input matrix for the system, called D
create_input_matrix	creates the input matrix for the system, called B
create_output_constants	creates the input matrix for the system, called O
create_output_matrix	creates the input matrix for the system, called C
create_state_constants	creates the input matrix for the system, called F
create_state_matrix	creates the state matrix for the system
critical	A routine to communicate to the root of the server network that there is an issue
debug	Writes at a low level to the log file.
determine_nearest_stationary_state	determine the nearest stationary state
difference	a context manager that will allow you to dynamically change any information, then will change it back in a fail safe way.
error	Writes to log as a error
eval	Evaluates the system with pre/post execute methodology :type kw: :param kw: kwargs come from sys_kw input in run ect.
execute	Solves the system's system of constraints and integrates transients if any exist
extract_message
filter	This acts as the interface for logging.Filter Don't overwrite this, use add_fields instead.
format_columns
get_system_input_refs	Get the references to system input based on the specified criteria.
go_through_configurations	A generator that will go through all internal configurations up to a certain level if levels_to_descend is less than 0 ie(-1) it will go down, if it 0, None, or False it will only go through this configuration
hash	hash by parm or by input_kw, only input can be hashed by lookup as system properties can create a recursive loop and should be deterministic from input
hash_numeric_with
hash_with	Generates a hash for the object's dictionary representation, updated with additional keyword arguments.
info	Writes to log but with info category, these are important typically and inform about progress of process in general
input_attrs	Lists all input attributes for class
input_fields	no attr base types, no tuples, no lists, no dicts
installSTDLogger	We only want std logging to start
internal_components	get all the internal components
internal_configurations	go through all attributes determining which are configuration objects additionally this skip any configuration that start with an underscore (private variable)
internal_references	get references to all internal attributes and values, only saving when complete cache info is requested (vs numeric only)
internal_systems	get all the internal components
internal_tabulations	get all the internal tabulations
linear_output	simulate the system over the course of time.
linear_step	Optimal nonlinear steps
locate
locate_ref	Pass a string of a relative var or property on this system or pass a callable to get a reference to a function.
make_plots	makes plots and traces of all on this instance, and if a system is subsystems.
mark_all_comps_changed	mark all components as changed, useful for forcing a re-run of the system, or for marking data as saved
message_with_identiy	converts to color and string via the termcolor library :type message: str :param message: a string convertable entity :type color: :param color: a color in [grey,red,green,yellow,blue,magenta,cyan,white]
msg	Writes to log.
nonlinear_output	simulate the system over the course of time.
nonlinear_step	Optimal nonlinear steps
numeric_fields	no tuples,lists, dicts, strings, or attr base types
parent_configurations_cls	returns all subclasses that are a Configuration
parse_run_kwargs	ensures correct input for simulation.
parse_simulation_input	parses the simulation input
plot_attributes	Lists all plot attributes for class
post_run_callback	user callback for when run is complete
post_update	Kwargs comes from eval_kw in solver
pre_compile	an overrideable classmethod that executes when compiled, however will not execute as a subclass
pre_run_callback	user callback for when run is beginning
print_info
rate	simulate the system over the course of time.
rate_linear	simulate the system over the course of time.
rate_nonlinear	simulate the system over the course of time.
ref_dXdt	returns the reference to the time differential of the state
resetLog	reset log
resetSystemLogs	resets log on all internal instance LoggingMixins
run	the steady state run the solver for the system.
run_internal_systems	runs internal systems with potentially scoped kwargs
set_attr
set_time	sets the time of the system and context
setattrs	sets attributes from a dictionary
setup_global_dynamics	recursively creates numeric matricies for the simulation
signals_attributes	Lists all signals attributes for class
sim_matrix	simulate the system over the course of time.
simulate	runs a simulation over the course of time, and returns a dataframe of the results.
slack_notification
slot_refs	returns all slot references in this configuration
slots_attributes	Lists all slots attributes for class
smart_split_dataframe	splits dataframe between constant values and variants
solver	runs the system solver using the current system state and modifying it.
solver_vars	applies the default combo filter, and your keyword arguments to the collect_solver_refs to test the ref / vars creations
solvers_attributes	Lists all signals attributes for class
step
subclasses	return all subclasses of components, including their subclasses :type out: :param out: out is to pass when the middle of a recursive operation, do not use it!
subcls_compile	reliably compiles this method even for subclasses, override this to compile functionality for subclass interfaces & mixins
system_properties_classdef	Combine other parent-classes table properties into this one, in the case of subclassed system_properties
system_references	gather a list of references to attributes and
table_fields	the table attributes corresponding to
trace_attributes	Lists all trace attributes for class
transients_attributes	Lists all signals attributes for class
update	Kwargs comes from eval_kw in solver
update_dynamics	Updates dynamics when nonlinear is enabled, otherwise it will do nothing
update_feedthrough	override
update_input	override
update_output_constants	override
update_output_matrix	override
update_state	override
update_state_constants	override
validate_class	A customizeable validator at the end of class creation in forge
warning	Writes to log as a warning

Attributes

Ut_ref	alias for input values
Xt_ref	alias for state values
Yt_ref	alias for output values
anything_changed	use the on_setattr method to determine if anything changed, also assume that stat_tab could change without input changes
as_dict	returns values as they are in the class instance
attrs_fields
classname	Shorthand for the classname
converged([fget, fset, fdel, doc])	this property notifies the system this is a property to be tabulated in the dataframe output.
dXtdt_ref	a dictionary of state var rates
dataframe	Returns a pandas DataFrame based on the current context.
dataframe_constants
dataframe_variants
displayname
dynamic_A
dynamic_B
dynamic_C
dynamic_D
dynamic_F
dynamic_K
dynamic_input
dynamic_input_vars
dynamic_output
dynamic_output_vars
dynamic_state
dynamic_state_vars
filename	A nice to have, good to override
gamma_goal([fget, fset, fdel, doc])	this property notifies the system this is a property to be tabulated in the dataframe output.
identity	A customizeable property that will be in the log by default
input_as_dict	returns values as they are in the class instance, but converts classes inputs to their input_as_dict
input_hash
l3_gamma([fget, fset, fdel, doc])	this property notifies the system this is a property to be tabulated in the dataframe output.
l3_zero([fget, fset, fdel, doc])	this property notifies the system this is a property to be tabulated in the dataframe output.
last_context	get the last context run, or the parent's
log_fmt
log_level
log_on
log_silo
logger
nonlinear
numeric_as_dict	recursively gets internal components numeric_as_dict as well as its own numeric values
numeric_hash
plotable_variables	Checks columns for ones that only contain numeric types or haven't been explicitly skipped
r3_x([fget, fset, fdel, doc])	this property notifies the system this is a property to be tabulated in the dataframe output.
r3_x_zero([fget, fset, fdel, doc])	this property notifies the system this is a property to be tabulated in the dataframe output.
run_id([fget, fset, fdel, doc])	this property notifies the system this is a property to be tabulated in the dataframe output.
skip_plot_vars	accesses '_skip_plot_vars' if it exists, otherwise returns empty list
slack_webhook_url
solved
static_A
static_B
static_C
static_D
static_F
static_K
stored_plots
system_id	returns an instance unique id based on id(self)
table_hash
table_row_dict	returns values as they would be put in a table row from this instance ignoring any sub components
time
unique_hash
update_interval
y([fget, fset, fdel, doc])	this property notifies the system this is a property to be tabulated in the dataframe output.
y_zero([fget, fset, fdel, doc])	this property notifies the system this is a property to be tabulated in the dataframe output.
r1
gamma_zero
gamma
theta
ra
x2
h2
parent
name

Parameters:

• name (str)

• parent (Component | System)

• dynamic_input_vars (list)

• dynamic_state_vars (list)

• dynamic_output_vars (list)

• r1 (float)

• gamma_zero (float)

• gamma (float)

• theta (float)

• ra (float)

• x2 (float)

• h2 (float)

property Ut_ref

alias for input values

property Xt_ref

alias for state values

property Yt_ref

alias for output values

add_fields(record)

Overwrite this to modify logging fields

property anything_changed

use the on_setattr method to determine if anything changed, also assume that stat_tab could change without input changes

property as_dict

returns values as they are in the class instance

classmethod check_ref_slot_type(sys_key)

recursively checks class slots for the key, and returns the slot type

Return type:

list

Parameters:

sys_key (str)

property classname

Shorthand for the classname

clone()

returns a clone of this system, often used to iterate the system without affecting the input values at the last convergence step.

classmethod cls_compile()

compiles this class, override this to compile functionality for this class

classmethod collect_all_attributes()

collects all the attributes for a system

collect_comp_refs(conf=None, **kw)

collects all the references for the system grouped by component

Parameters:

conf (Configuration | None)

collect_dynamic_refs(conf=None, **kw)

collects the dynamics of the systems 1. Time.integrate 2. Dynamic Instances

Return type:

dict

Parameters:

conf (Configuration | None)

collect_inst_attributes(**kw)

collects all the attributes for a system

collect_post_update_refs(eval_kw=None, ignore=None)

checks all methods and creates ref’s to execute them later

collect_solver_refs(conf=None, check_atr_f=None, check_kw=None, check_dynamics=True, **kw)

collects all the references for the system grouped by function and prepended with the system key

Parameters:

conf (Configuration | None)

collect_update_refs(eval_kw=None, ignore=None)

checks all methods and creates ref’s to execute them later

comp_references(ignore_none_comp=True, **kw)

A cached set of recursive references to any slot component #FIXME: by instance recache on iterative component change or other signals

classmethod compile_classes()

compiles all subclass functionality

copy_config_at_state(level=None, levels_deep=-1, changed=None, **kw)

copy the system at the current state recrusively to a certain level, by default copying everything :type levels_deep: int :param levels_deep: how many levels deep to copy, -1 is all :type level: :param level: the current level, defaults to 0 if not set

Parameters:

• levels_deep (int)

• changed (dict | None)

create_dynamic_matricies(**kw)

creates a dynamics object for the system

create_feedthrough_matrix(**kwargs)

creates the input matrix for the system, called D

Return type:

ndarray

create_input_matrix(**kwargs)

creates the input matrix for the system, called B

Return type:

ndarray

create_output_constants(**kwargs)

creates the input matrix for the system, called O

Return type:

ndarray

create_output_matrix(**kwargs)

creates the input matrix for the system, called C

Return type:

ndarray

create_state_constants(**kwargs)

creates the input matrix for the system, called F

Return type:

ndarray

create_state_matrix(**kwargs)

creates the state matrix for the system

Return type:

ndarray

critical(*args)

A routine to communicate to the root of the server network that there is an issue

property dXtdt_ref

a dictionary of state var rates

property dataframe

Returns a pandas DataFrame based on the current context.

This method checks for the presence of last_context and its dataframe attribute. If they exist, it returns the dataframe from last_context. If not, it checks for the _patch_dataframe attribute and returns it if it exists. If neither condition is met, it returns an empty DataFrame.

Returns:

A pandas DataFrame based on the current context or an empty DataFrame if no context is available.

Return type:

pandas.DataFrame

debug(*args)

Writes at a low level to the log file… usually this should be detailed messages about what exactly is going on

determine_nearest_stationary_state(t=0, X=None, U=None)

determine the nearest stationary state

Return type:

ndarray

difference(**kwargs)

a context manager that will allow you to dynamically change any information, then will change it back in a fail safe way.

with self.difference(name=’new_name’, value = new_value) as new_config:

#do stuff with config, ok to fail

you may not access any “private” variable that starts with an _ as in _whatever

difference is useful for saving slight differences in configuration in conjunction with solve you might create wrappers for eval, or implement a strategy pattern.

only attributes may be changed.

#TODO: allow recursive operation with sub comps or systems. #TODO: make a full system copy so the system can be reverted later

error(error, msg='')

Writes to log as a error

eval(Xo=None, eval_kw=None, sys_kw=None, cb=None, **kw)

Evaluates the system with pre/post execute methodology :type kw: :param kw: kwargs come from sys_kw input in run ect. :type cb: :param cb: an optional callback taking the system as an argument of the form (self,eval_kw,sys_kw,**kw)

Parameters:

• eval_kw (dict | None)

• sys_kw (dict | None)

execute(**kw)

Solves the system’s system of constraints and integrates transients if any exist

Override this function for custom solving functions, and call solver to use default solver functionality.

Returns:

the result of this function is returned from solver()

property filename

A nice to have, good to override

filter(record)

This acts as the interface for logging.Filter Don’t overwrite this, use add_fields instead.

get_system_input_refs(strings=False, numeric=True, misc=False, all=False, boolean=False, **kw)

Get the references to system input based on the specified criteria.

Parameters:

• strings – Include system properties of string type.

• numeric – Include system properties of numeric type (float, int).

• misc – Include system properties of miscellaneous type.

• all – Include all system properties regardless of type.

• boolean – Include system properties of boolean type.

• kw – Additional keyword arguments passed to recursive config loop

Returns:

A dictionary of system property references.

Return type:

dict

go_through_configurations(level=0, levels_to_descend=-1, parent_level=0, only_inst=True, **kw)

A generator that will go through all internal configurations up to a certain level if levels_to_descend is less than 0 ie(-1) it will go down, if it 0, None, or False it will only go through this configuration

Returns:

level,config

hash(*args, **input_kw)

hash by parm or by input_kw, only input can be hashed by lookup as system properties can create a recursive loop and should be deterministic from input

hash_with(**input_kw)

Generates a hash for the object’s dictionary representation, updated with additional keyword arguments. :type **input_kw: :param **input_kw: Arbitrary keyword arguments to update the object’s dictionary representation.

Returns:

The hash value of the updated dictionary.

Raises:

Any exceptions raised by deepdiff.DeepHash if hashing fails. –

property identity

A customizeable property that will be in the log by default

info(*args)

Writes to log but with info category, these are important typically and inform about progress of process in general

property input_as_dict

returns values as they are in the class instance, but converts classes inputs to their input_as_dict

classmethod input_attrs()

Lists all input attributes for class

classmethod input_fields(add_ign_types=None)

no attr base types, no tuples, no lists, no dicts

Parameters:

add_ign_types (list | None)

installSTDLogger()

We only want std logging to start

internal_components(recache=False)

get all the internal components

Return type:

dict

internal_configurations(check_config=True, use_dict=True, none_ok=False)

go through all attributes determining which are configuration objects additionally this skip any configuration that start with an underscore (private variable)

Return type:

dict

internal_references(recache=False, numeric_only=False)

get references to all internal attributes and values, only saving when complete cache info is requested (vs numeric only)

Return type:

dict

internal_systems(recache=False)

get all the internal components

Return type:

dict

internal_tabulations(recache=False)

get all the internal tabulations

Return type:

dict

property last_context

get the last context run, or the parent’s

linear_output(t, dt, X, U=None)

simulate the system over the course of time. Return time differential of the state.

Parameters:

• dt (float) – interval to integrate over in time

• X (np.ndarray) – state input

• U (np.ndarray) – control input

Returns:

time differential of the state

Return type:

np.array

linear_step(t, dt, X, U=None, set_Y=False)

Optimal nonlinear steps

classmethod locate(key, fail=True)

Return type:

type

Returns:

the class or attribute by key if its in this system class or a subcomponent. If nothing is found raise an error

locate_ref(key, fail=True, **kw)

Pass a string of a relative var or property on this system or pass a callable to get a reference to a function. If the key has a . in it the comp the lowest level component will be returned, unless a callable is passed in which case this component will be used or the comp passed in the kw will be used. :type key: :param key: the key to locate, or a callable to be used as a reference :param comp: the component to use if a callable is passed :returns: the instance assigned to this system. If the key has a . in it the comp the lowest level component will be returned

make_plots(analysis=None, store_figures=True, pre=None)

makes plots and traces of all on this instance, and if a system is subsystems. Analysis should call make plots however it can be called on a system as well :type analysis: Analysis :param analysis: the analysis that has triggered this plot :param store_figure: a boolean or dict, if neither a dictionary will be created and returend from this function :returns: the dictionary from store_figures logic

Parameters:

• analysis (Analysis)

• store_figures (bool)

mark_all_comps_changed(inpt)

mark all components as changed, useful for forcing a re-run of the system, or for marking data as saved

Parameters:

inpt (bool)

message_with_identiy(message, color=None)

converts to color and string via the termcolor library :type message: str :param message: a string convertable entity :type color: :param color: a color in [grey,red,green,yellow,blue,magenta,cyan,white]

Parameters:

message (str)

msg(*args, lvl=5)

Writes to log… this should be for raw data or something… least priorty

nonlinear_output(t, dt, X, U=None, update=True)

simulate the system over the course of time. Return time differential of the state.

Parameters:

• dt (float) – interval to integrate over in time

• X (np.ndarray) – state input

• U (np.ndarray) – control input

Returns:

time differential of the state

Return type:

np.array

nonlinear_step(t, dt, X, U=None, set_Y=False)

Optimal nonlinear steps

property numeric_as_dict

recursively gets internal components numeric_as_dict as well as its own numeric values

classmethod numeric_fields()

no tuples,lists, dicts, strings, or attr base types

classmethod parent_configurations_cls()

returns all subclasses that are a Configuration

Return type:

list

parse_run_kwargs(**kwargs)

ensures correct input for simulation. :returns: first set of input for initalization, and all input dictionaries as tuple.

parse_simulation_input(**kwargs)

parses the simulation input

Parameters:

• dt – timestep in s, required for transients

• endtime – when to end the simulation

classmethod plot_attributes()

Lists all plot attributes for class

Return type:

Dict[str, Attribute]

property plotable_variables

Checks columns for ones that only contain numeric types or haven’t been explicitly skipped

post_run_callback(**kwargs)

user callback for when run is complete

post_update(parent, *args, **kwargs)

Kwargs comes from eval_kw in solver

classmethod pre_compile()

an overrideable classmethod that executes when compiled, however will not execute as a subclass

pre_run_callback(**kwargs)

user callback for when run is beginning

rate(t, dt, X, U, *args, **kwargs)

simulate the system over the course of time.

Parameters:

• dt (float) – interval to integrate over in time

• X (np.ndarray) – state input

• U (np.ndarray) – control input

• subsystems (bool, optional) – simulate subsystems. Defaults to True.

Returns:

tabulated data

Return type:

dataframe

rate_linear(t, dt, X, U=None)

simulate the system over the course of time. Return time differential of the state.

rate_nonlinear(t, dt, X, U=None, update=True)

simulate the system over the course of time. Return time differential of the state.

Parameters:

• t (float) – time

• dt (float) – interval to integrate over in time

• X (np.ndarray) – state input

• U (np.ndarray) – control input

Returns:

time differential of the state

Return type:

np.array

ref_dXdt(name)

returns the reference to the time differential of the state

Parameters:

name (str)

resetLog()

reset log

resetSystemLogs(reseted=None)

resets log on all internal instance LoggingMixins

run(**kwargs)

the steady state run the solver for the system. It will run the system with the input vars and return the system with the results. Dynamics systems will be run so they are in a steady state nearest their initial position.

run_internal_systems(sys_kw=None)

runs internal systems with potentially scoped kwargs

set_time(t, system=True, subcomponents=True)

sets the time of the system and context

setattrs(dict)

sets attributes from a dictionary

setup_global_dynamics(**kwargs)

recursively creates numeric matricies for the simulation

classmethod signals_attributes()

Lists all signals attributes for class

Return type:

Dict[str, Attribute]

sim_matrix(eval_kw=None, sys_kw=None, **kwargs)

simulate the system over the course of time. return a dictionary of dataframes

simulate(dt, endtime, X0=None, cb=None, eval_kw=None, sys_kw=None, min_kw=None, run_solver=False, return_system=False, return_data=False, return_all=False, debug_fail=False, **kwargs)

runs a simulation over the course of time, and returns a dataframe of the results.

A copy of this system is made, and the simulation is run on the copy, so as to not affect the state of the original system.

#TODO:

Return type:

DataFrame

property skip_plot_vars: list

accesses ‘_skip_plot_vars’ if it exists, otherwise returns empty list

classmethod slot_refs(recache=False)

returns all slot references in this configuration

classmethod slots_attributes(attr_type=False)

Lists all slots attributes for class

Return type:

Dict[str, Attribute]

smart_split_dataframe(df=None, split_groups=0, key_f=<function <lambda>>)

splits dataframe between constant values and variants

solver(enter_refresh=True, save_on_exit=True, **kw)

runs the system solver using the current system state and modifying it. This is the default solver for the system, and it is recommended to add additional options or methods via the execute method.

Parameters:

• obj – the objective function to minimize, by default will minimize the sum of the squares of the residuals. Objective function should be a function(system,Xs,Xt) where Xs is the system state and Xt is the system transient state. The objective function will be argmin(X)|(1+custom_objective)*residual_RSS when add_obj is True in kw otherwise argmin(X)|custom_objective with constraints on the system as balances instead of first objective being included.

• cons – the constraints to be used in the solver, by default will use the system’s constraints will be enabled when True. If a dictionary is passed the solver will use the dictionary as the constraints in addition to system constraints. These can be individually disabled by key=None in the dictionary.

• X0 – the initial guess for the solver, by default will use the current system state. If a dictionary is passed the solver will use the dictionary as the initial guess in addition to the system state.

• dXdt – can be 0 to indicate steady-state, or None to not run the transient constraints. Otherwise a partial dictionary of vars for the dynamics rates can be given, those not given will be assumed steady state or 0.

• kw – additional options for the solver, such as the solver_option, or the solver method options. Described below

• combos – a csv str or list of combos to include, including wildcards. the default means all combos will be run unless ign_combos or only combos alters behavior. The initial selection of combos is made by matching any case with the full name of the combo, or a parial name with a wildcard(s) in the combo name Ignore and only combos will further filter the selection. Wildcards / queries per fnmatch

• ign_combos – a list of combo vars to ignore.

• only_combos – a list of combo vars to include exclusively.

• add_var – a csv str or variables to include, including wildcards. the default means all combos will be run unless ign_combos or only combos alters behavior. The initial selection of combos is made by matching any case with the full name of the combo, or a parial name with a wildcard(s) in the combo name Ignore and only combos will further filter the selection. Wildcards / queries per fnmatch

• ign_var – a list of combo vars to ignore.

• only_var – a list of combo vars to include exclusively.

• add_obj – a flag to add the objective to the system constraints, by default will add the objective to the system constraints. If False the objective will be the only constraint.

• only_active – default True, will only look at active variables objectives and constraints

• activate – default None, a list of solver vars to activate

• deactivate – default None, a list of solver vars to deactivate (if not activated above)

solver_vars(check_dynamics=True, addable=None, **kwargs)

applies the default combo filter, and your keyword arguments to the collect_solver_refs to test the ref / vars creations

parses add_vars in kwargs to append to the collected solver vars :param add_vars: can be a str, a list or a dictionary of variables: solver_instance kwargs. If a str or list the variable will be added with positive only constraints. If a dictionary is chosen, it can have keys as parameters, and itself have a subdictionary with keys: min / max, where each respective value is placed in the constraints list, which may be a callable(sys,prob) or numeric. If nothing is specified the default is min=0,max=None, ie positive only.

classmethod solvers_attributes()

Lists all signals attributes for class

Return type:

Dict[str, Attribute]

classmethod subclasses(out=None)

return all subclasses of components, including their subclasses :type out: :param out: out is to pass when the middle of a recursive operation, do not use it!

classmethod subcls_compile()

reliably compiles this method even for subclasses, override this to compile functionality for subclass interfaces & mixins

property system_id: str

returns an instance unique id based on id(self)

classmethod system_properties_classdef(recache=False)

Combine other parent-classes table properties into this one, in the case of subclassed system_properties

system_references(recache=False, numeric_only=False, **kw)

gather a list of references to attributes and

classmethod table_fields()

the table attributes corresponding to

property table_row_dict

returns values as they would be put in a table row from this instance ignoring any sub components

classmethod trace_attributes()

Lists all trace attributes for class

Return type:

Dict[str, Attribute]

classmethod transients_attributes()

Lists all signals attributes for class

Return type:

Dict[str, Attribute]

update(parent, *args, **kwargs)

Kwargs comes from eval_kw in solver

update_dynamics(t, X, U)

Updates dynamics when nonlinear is enabled, otherwise it will do nothing

update_feedthrough(t, D, X, U)

override

Return type:

ndarray

update_input(t, B, X, U)

override

Return type:

ndarray

update_output_constants(t, O, X)

override

Return type:

ndarray

update_output_matrix(t, C, X)

override

Return type:

ndarray

update_state(t, A, X)

override

Return type:

ndarray

update_state_constants(t, F, X)

override

Return type:

ndarray

classmethod validate_class()

A customizeable validator at the end of class creation in forge

warning(*args)

Writes to log as a warning