::SpiceGenTclTop, Main, Index

proc ::SpiceGenTcl::forgetCommon {} {

    # Forgets all ::SpiceGenTcl::Common commands from caller namespace
    uplevel 1 {foreach nameSpc [namespace children ::SpiceGenTcl::Common] {
        namespace forget ${nameSpc}::*
    }}
}

proc ::SpiceGenTcl::forgetLtspice {} {

    # Forgets all ::SpiceGenTcl::Ltspice commands from caller namespace
    uplevel 1 {foreach nameSpc [namespace children ::SpiceGenTcl::Ltspice] {
        namespace forget ${nameSpc}::*
    }}
}

proc ::SpiceGenTcl::forgetNgspice {} {

    # Forgets all ::SpiceGenTcl::Ngspice commands from caller namespace
    uplevel 1 {foreach nameSpc [namespace children ::SpiceGenTcl::Ngspice] {
        namespace forget ${nameSpc}::*
    }}
}

proc ::SpiceGenTcl::forgetXyce {} {

    # Forgets all ::SpiceGenTcl::Xyce commands from caller namespace
    uplevel 1 {foreach nameSpc [namespace children ::SpiceGenTcl::Xyce] {
        namespace forget ${nameSpc}::*
    }}
}

proc ::SpiceGenTcl::importCommon {} {

    # Imports all ::SpiceGenTcl::Common commands to caller namespace
    uplevel 1 {foreach nameSpc [namespace children ::SpiceGenTcl::Common] {
        namespace import ${nameSpc}::*
    }}
}

proc ::SpiceGenTcl::importLtspice {} {

    # Imports all ::SpiceGenTcl::Ltspice commands to caller namespace
    uplevel 1 {foreach nameSpc [namespace children ::SpiceGenTcl::Ltspice] {
        namespace import ${nameSpc}::*
    }}
}

proc ::SpiceGenTcl::importNgspice {} {

    # Imports all ::SpiceGenTcl::Ngspice commands to caller namespace
    uplevel 1 {foreach nameSpc [namespace children ::SpiceGenTcl::Ngspice] {
        namespace import ${nameSpc}::*
    }}
}

proc ::SpiceGenTcl::importXyce {} {

    # Imports all ::SpiceGenTcl::Xyce commands to caller namespace
    uplevel 1 {foreach nameSpc [namespace children ::SpiceGenTcl::Xyce] {
        namespace import ${nameSpc}::*
    }}
}

method constructor {args} {

    # Creates object of class `Analysis`.
    #  type - type of analysis, for example, tran, ac, dc, etc
    #  params - list of instance parameters in form
    #   `{{name value} {name -sw} {name Value -eq} {name Value -posnocheck} ...}`
    #  -name - name of the string that could be used to retrieve element from [::SpiceGenTcl::Netlist] object
    #    and its descendants, optional
    # Class models analysis statement.
    # Synopsis: type params ?-name value?
    my variable name
    set arguments [argparse -inline -help {Creates object of class 'Analysis'} -pfirst {
        {type -help {Type of analysis, for example, tran, ac, dc, etc}}
        {params -help {List of instance parameters in form '{{name value} {name -sw} {name Value -eq} {name Value -posnocheck} ...}'} -type list}
        {-name= -help {Name of the string that could be used to retrieve element from [::SpiceGenTcl::Netlist] object and its descendants}}
    }]
    if {[dexist $arguments name]} {
        my configure -name [dget $arguments name]
    } else {
        my configure -name [self object]
    }
    my configure -type [dget $arguments type]
    # create Analysis objects
    foreach param [dget $arguments params] {
        if {[llength $param]<2} {
            return -code error "Value '$param' is not a valid value"
        } else {
            my actOnParam -add {*}$param
        }
    }
}

method actOnParam {args} {

    # Acts on `Parameter` object with selected action
    #  -add - add new parameter to the device, requires pname argument
    #  -get - get parameter value, requires pname argument
    #  -set - set (or change) value of particular parameters, requires pname and value arguments
    #  -delete - delete existing parameter
    #  -all - option for getting the dictionary that contains parameters names as keys and parameters values #    as the dictionary values, requires -get
    #  -pos - parameter has strict position and only '$Value' is displayed in netlist, requires -add
    #  -eq - Parameter may contain equation in terms of functions and other parameters, printed as
    #    '$name={$equation}', requires -add
    #  -poseq - combination of both flags, print only, requires -add
    #  -posnocheck - positional parameter without check, requires -add
    #  -nocheck - normal parameter without check, requires -add
    #  -sw - switch parameter, requires -add
    #  -node - node parameter, requires -add
    #  -nodeeq - node parameter equation, requires -add
    #  pname - name of parameter
    #  value - value of parameter
    #  arguments - optional pairs of name-value for -set action, requires -set
    # Synopsis: -add ?-pos|eq|poseq|posnocheck|nocheck|sw|node|nodeeq? name value
    # Synopsis: -set name value ?name value ...?
    # Synopsis: -get name
    # Synopsis: -get -all
    # Synopsis: -delete name
    argparse -help {Applied selected actions on parameters of the device} {
        # {Actions selectors}
        {-add -key action -value add -require pname -help {Add new parameter to device}}
        {-get -key action -value get -help {Get parameter value}}
        {-set -key action -value set -require {pname value} -help {Sets (or change) value of particular parameters}}
        {-delete -key action -value delete -require pname -help {Delete existing parameter}}
        {-all -require get -forbid {pname value} -help {Option for getting the dictionary that contains parameters names as keys and parameters values as the dictionary values}}
        # {Param qualificators}
        {-pos -key paramQual -value pos -require add -help {Parameter has strict position and only '$Value' is displayed in netlist}}
        {-eq -key paramQual -value eq -require add -help {Parameter may contain equation in terms of functions and other parameters, printed as '$name={$equation}'}}
        {-poseq -key paramQual -value poseq -require add -help {Combination of both flags, print only '{$equation}'}}
        {-posnocheck -key paramQual -value posnocheck -require add -help {Positional parameter without check}}
        {-nocheck -key paramQual -value nocheck -default {} -require add -help {Normal parameter without check}}
        {-sw -key paramQual -value sw -require add -help {Switch parameter}}
        {-node -key paramQual -value node -require add -help {Node parameter}}
        {-nodeeq -key paramQual -value nodeeq -require add -help {Node parameter equation}}
        # {Actual name(s) and value(s) of Param}
        {pname -optional -help {Name of parameter}}
        {value -optional -help {Value of parameter}}
        {arguments -catchall -require set -help {Optional pairs of name-value for -set action}}
    }
    switch $action {
        add {
            set pname [string tolower $pname]
            if {[info exists Params]} {
                set params [dict keys $Params]
            }
            lappend params $pname
            if {[my DuplListCheck $params]} {
                return -code error "Parameters list '$params' has already contains parameter with name '$pname'"
            }
            switch $paramQual {
                sw {
                    dict append Params $pname [::SpiceGenTcl::ParameterSwitch new $pname]
                }
                pos {
                    dict append Params $pname [::SpiceGenTcl::ParameterPositional new $pname $value]
                }
                eq {
                    dict append Params $pname [::SpiceGenTcl::ParameterEquation new $pname $value]
                }
                poseq {
                    dict append Params $pname [::SpiceGenTcl::ParameterPositionalEquation new $pname $value]
                }
                posnocheck {
                    dict append Params $pname [::SpiceGenTcl::ParameterPositionalNoCheck new $pname $value]
                }
                nocheck {
                    dict append Params $pname [::SpiceGenTcl::ParameterNoCheck new $pname $value]
                }
                node {
                    dict append Params $pname [::SpiceGenTcl::ParameterNode new $pname $value]
                }
                nodeeq {
                    dict append Params $pname [::SpiceGenTcl::ParameterNodeEquation new $pname $value]
                }
                default {
                    dict append Params $pname [::SpiceGenTcl::Parameter new $pname $value]
                }
            }
        }
        get {
            if {![info exists Params]} {
                return
            }
            if {[info exists all]} {
                return [dict map {paramName param} $Params {$param configure -value}]
            } elseif {[info exists pname]} {
                set pname [string tolower $pname]
                if {[dexist $Params $pname]} {
                    return [dget $Params $pname]
                } else {
                    return -code error "Device '$name' doesn't have parameter with name '$pname'"
                }
            } else {
                return -code error "'-get' action requires 'pname' parameter or '-all' option"
            }
        }
        set {
            set arguments [list $pname $value {*}$arguments]
            if {[llength $arguments]%2!=0} {
                return -code error "Number of arguments to method '[dict get [info frame 0] method]' with '-set' switch must be even"
            }
            for {set i 0} {$i<[llength $arguments]} {incr i 2} {
                set paramName [string tolower [@ $arguments $i]]
                set paramValue [@ $arguments [= {$i+1}]]
                if {[catch {dget $Params $paramName}]} {
                    return -code error "Parameter with name '$paramName' was not found in element's '$name' list of parameters '[dkeys $Params]'"
                } else {
                    set param [dget $Params $paramName]
                }
                $param configure -value $paramValue
            }
        }
        delete {
            set pname [string tolower $pname]
            if {[catch {dget $Params $pname}]} {
                return -code error "Parameter with name '$pname' was not found in device's '$name' list of parameters '[dkeys $Params]'"
            } else {
                set Params [dict remove $Params $pname]
            }
        }
    }
    return
}

method genSPICEString {} {

    # Creates analysis for SPICE netlist.
    # Returns: string SPICE netlist's string
    if {[info exists Params]} {
        return ".[my configure -type] [join [lmap param [dict values $Params] {$param genSPICEString}]]"
    } else {
        return .[my configure -type]
    }
}

method readComplex {file} {

    # Reads two 8 byte numbers from file.
    #  file - file handler
    # Returns: list of two values.
    set s [read $file 16]
    binary scan $s dd re im
    return [list $re $im]
}

method readFloat32 {file} {

    # Reads 4 bytes number from file.
    #  file - file handler
    # Returns: value of number.
    set s [read $file 4]
    binary scan $s f num
    return $num
}

method readFloat64 {file} {

    # Reads 8 bytes number from file .
    #  file - file handler
    # Returns: value of number.
    set s [read $file 8]
    binary scan $s d num
    return $num
}

method skip4bytes {file} {

    # Moves pointer of position in file forward in 4 bytes.
    #  file - file handler
    read $file 4
    return
}

method skip8bytes {file} {

    # Moves pointer of position in file forward in 8 bytes.
    #  file - file handler
    read $file 8
    return
}

method skip16bytes {file} {

    # Moves pointer of position in file forward in 16 bytes.
    #  file - file handler
    read $file 16
    return
}

method constructor {args} {

    # Creates object of class `CircuitNetlist`.
    #  name - name of the tol-level circuit
    # Class implements a top level netlist which is run in SPICE. We should add [::SpiceGenTcl::Simulator]
    # object reference to make it able to run simulation.
    # Synopsis: name
    set arguments [argparse -inline -help {Creates object of class 'CircuitNetlist'} {
        {name -help {Name of the tol-level circuit}}
    }]
    next [dget $arguments name]
}

method add {args} {

    # Adds elements object to Circuit `Elements` dictionary.
    #  elements - elements objects references
    # Synopsis: element ?element ...?
    argparse -help {Adds elements objects to Circuit 'Elements' dictionary} {
        {elements -catchall -help {Elements objects references}}
    }
    foreach element $elements {
        if {([info object class $element {::SpiceGenTcl::Analysis}]) && ([info exists ContainAnalysis])} {
            return -code error "Netlist '[my configure -name]' already contains Analysis element"
        } elseif {[info object class $element {::SpiceGenTcl::Analysis}]} {
            set ContainAnalysis {}
        }
        lappend elementsNamesList [string tolower [$element configure -name]]
    }
    if {[info exists Elements]} {
        lappend elementsNamesList {*}[my getAllElemNames]
    }
    set dup [my DuplListCheckRet $elementsNamesList]
    if {$dup ne {}} {
        return -code error "Netlist '[my configure -name]' already contains element with name $dup"
    }
    foreach element $elements {
        set elemName [$element configure -name]
        dict append Elements $elemName $element
    }
    return
}

method del {args} {

    # Deletes elements from the circuit by its name.
    #  args - elements names
    # Synopsis: elementName ?elementName ...?
    argparse -help {Deletes elements from the circuit by its name} {
        {elementsNames -catchall -help {Elements names}}
    }
    if {![info exists Elements]} {
        return -code error "Netlist '[my configure -name]' doesn't have attached elements"
    }
    foreach elemName $elementsNames {
        set elemName [string tolower $elemName]
        if {[catch {dget $Elements $elemName}]} {
            return -code error "Element with name '$elemName' was not found in circuit's '[my configure -name]' list of elements"
        } else {
            if {[info object class [dget $Elements $elemName] {::SpiceGenTcl::Analysis}]} {
                unset ContainAnalysis
            }
            set Elements [dict remove $Elements $elemName]
        }
    }
    return
}

method detachSimulator {args} {

    # Removes `Simulator` object reference from `Circuit`.
    argparse -help {Removes 'Simulator' object reference from 'Circuit'} {}
    unset simulator
    return
}

method genSPICEString {} {

    # Creates circuit string for SPICE netlist.
    # Returns: SPICE netlist's string
    lappend totalStr [my configure -name] {*}[lmap element [dict values $Elements] {$element genSPICEString}]
    return [join $totalStr \n]
}

method getDataCsv {args} {

    # Returns string with csv formatting containing all data
    #  -all - select all traces
    #  -traces - select names of traces to return
    #  -sep - separator of columns, default is comma
    # Synopsis: ?-all? ?-traces list? ?-sep value?
    return [[my configure -data] getTracesCsv {*}$args]
}

method getDataDict {args} {

    # Gets dictionary with raw data vectors.
    # Returns: dict with vectors data, keys - names of vectors
    argparse -help {Gets dictionary with raw data vectors. Returns: dict with vectors data, keys - names of vectors} {}
    return [[my configure -data] getTracesData]
}

method runAndRead {args} {

    # Invokes `runAndRead`, `configure -log` and `configure -data` methods from attached simulator.
    #  -nodelete - flag to forbid simulation file deletion
    # Synopsis: ?-nodelete?
    argparse -help {Invokes 'runAndRead', 'configure -log' and 'configure -data' methods from attached simulator.} {
        {-nodelete -help {Flag to forbid simulation file deletion}}
    }
    if {![info exists simulator]} {
        return -code error "Simulator is not attached to '[my configure -name]' circuit"
    }
    if {[info exists nodelete]} {
        $simulator runAndRead [my genSPICEString] -nodelete
    } else {
        $simulator runAndRead [my genSPICEString]
    }
    my configure -log [$simulator configure -log] -data [$simulator configure -data]
}

method constructor {args} {

    # Creates object of class `Comment`.
    #  value - value of the comment
    #  -name - name of the string that could be used to retrieve element from [::SpiceGenTcl::Netlist] object
    #    and its descendants, optional
    # Class represent comment string, it can be a multiline comment.
    # Synopsis: value ?-name value?
    set arguments [argparse -inline -pfirst -help {Creates object of class 'Comment'} {
        {value -help {Value of the comment}}
        {-name= -help {Name of the string that could be used to retrieve element from [::SpiceGenTcl::Netlist] object and its descendants}}
    }]
    if {[dexist $arguments name]} {
        my configure -name [dget $arguments name]
    } else {
        my configure -name [self object]
    }
    my configure -value [dget $arguments value]
}

method genSPICEString {} {

    # Creates comment string for SPICE netlist.
    # Returns: SPICE netlist's string
    set splitted [split [my configure -value] \n]
    set prepared [join [lmap line $splitted {set result *$line}] \n]
    return $prepared
}

method constructor {args} {

    # initialize dataset
    #  name - name of the dataset
    #  type - type of dataset
    #  len - total number of points
    #  numtype - numerical type of dataset
    set arguments [argparse -inline -help {Initialize object 'Dataset'} {
        {name -help {Name of the dataset}}
        {type -help {Type of dataset}}
        {len -help {Total number of points}}
        {numtype -optional -default real -help {Numerical type of dataset}}
    }]
    dict for {elName elValue} $arguments {
        my configure -$elName $elValue
    }
}

method appendDataPoints {dataPoint} {

    # method to set the data points
    lappend DataPoints $dataPoint
    return
}

method getDataPoints {args} {

    argparse -help {Gets all data points} {}
    if {[info exists DataPoints]} {
        return $DataPoints
    } else {
        return -code error "Dataset with name '[my configure -name]' doesn't contain non-zero points"
    }
    return
}

method getStr {} {

    return "Name: '[my configure -name]', Type: '[my configure -type]', Length: '[my configure -len]', Numerical type: '[my configure -numtype]'"
}

method setDataPoints {dataPoints} {

    # method to set the data points
    set DataPoints $dataPoints
    return
}

method constructor {args} {

    # Creates object of class `Device`.
    #  name - name of the device
    #  pins - list of pins in the order they appear in SPICE device's definition together
    #   with connected node in form: `{{Name0 NodeName} {Name1 NodeName} {Name2 NodeName} ...}`
    #   Nodes string values could be empty.
    #  params - list of instance parameters in form `{{Name Value ?-sw|pos|eq|poseq|posnocheck|nocheck?}
    #   {Name Value ?-sw|pos|eq|poseq|posnocheck|nocheck?} {Name Value ?-sw|pos|eq|poseq|posnocheck|nocheck?} ...}`
    #   Parameter list can be empty if device doesn't have instance parameters.
    # Class models general device in SPICE, number of which
    # must be assembled (connected) to get the circuit to simulate. This class provides basic machinery
    # for creating any device that can be connected to net in circuit. It can be instantiated to create
    # device that contains:
    #  - reference name, like R1, L1, M1, etc;
    #  - list of pins in the order of appearence of device's definition, for example, 'drain gate source' for
    #     MOS transistor;
    #  - list of parameters, that could be positional (+equation), keyword (+equation) parameters, like
    #     `R1 nm np 100 tc1=1 tc2={tc0*tc12}`, where 100 - positional parameter, tc1 - keyword parameters and
    #     tc2 - keyword parameter with equation
    # This class accept definition that contains elements listed above, and generates classes: Pin, Parameter,
    # PositionalParameter with compositional relationship (has a).
    set arguments [argparse -inline -help {Creates object of class 'Device'} {
        {name -help {Name of the device}}
        {pins -help {List of pins in the order they appear in SPICE device's definition together with connected node in form: '{{Name0 NodeName} {Name1 NodeName} {Name2 NodeName} ...}'. Nodes string values could be empty. Nodes list can be empty if device doesn't have pins} -type list}
        {params -help {List of instance parameters in form '{{Name0 Value0 ?-sw|pos|eq|poseq|posnocheck|nocheck?} {Name1 Value1 ?-sw|pos|eq|poseq|posnocheck|nocheck?} {Name2 Value2 ?-sw|pos|eq|poseq|posnocheck|nocheck?} ...}'. Parameter list can be empty if device doesn't have instance parameters} -type list}
    }]
    my configure -name [dget $arguments name]
    # create Pins objects
    foreach pin [dget $arguments pins] {
        my actOnPin -add {*}$pin
    }
    #ruff
    # Each parameter definition could be modified by
    #  optional flags:
    #  -pos - parameter has strict position and only '$Value' is displayed in netlist
    #  -eq - parameter may contain equation in terms of functions and other parsmeters,
    #    printed as '$name={$equation}'
    #  -poseq - combination of both flags, print only '{$equation}'
    #  -posnocheck - positional parameter without check
    #  -nocheck - normal parameter without check
    foreach param [dget $arguments params] {
        my actOnParam -add {*}$param
    }
}

method actOnParam {args} {

    # Acts on `Parameter` object with selected action
    #  -add - add new parameter to the device, requires pname argument
    #  -get - get parameter value, requires pname argument
    #  -set - set (or change) value of particular parameters, requires pname and value arguments
    #  -delete - delete existing parameter
    #  -all - option for getting the dictionary that contains parameters names as keys and parameters values #    as the dictionary values, requires -get
    #  -pos - parameter has strict position and only '$Value' is displayed in netlist, requires -add
    #  -eq - Parameter may contain equation in terms of functions and other parameters, printed as
    #    '$name={$equation}', requires -add
    #  -poseq - combination of both flags, print only, requires -add
    #  -posnocheck - positional parameter without check, requires -add
    #  -nocheck - normal parameter without check, requires -add
    #  -sw - switch parameter, requires -add
    #  -node - node parameter, requires -add
    #  -nodeeq - node parameter equation, requires -add
    #  pname - name of parameter
    #  value - value of parameter
    #  arguments - optional pairs of name-value for -set action, requires -set
    # Synopsis: -add ?-pos|eq|poseq|posnocheck|nocheck|sw|node|nodeeq? name value
    # Synopsis: -set name value ?name value ...?
    # Synopsis: -get name
    # Synopsis: -get -all
    # Synopsis: -delete name
    argparse -help {Applied selected actions on parameters of the device} {
        # {Actions selectors}
        {-add -key action -value add -require pname -help {Add new parameter to device}}
        {-get -key action -value get -help {Get parameter value}}
        {-set -key action -value set -require {pname value} -help {Sets (or change) value of particular parameters}}
        {-delete -key action -value delete -require pname -help {Delete existing parameter}}
        {-all -require get -forbid {pname value} -help {Option for getting the dictionary that contains parameters names as keys and parameters values as the dictionary values}}
        # {Param qualificators}
        {-pos -key paramQual -value pos -require add -help {Parameter has strict position and only '$Value' is displayed in netlist}}
        {-eq -key paramQual -value eq -require add -help {Parameter may contain equation in terms of functions and other parameters, printed as '$name={$equation}'}}
        {-poseq -key paramQual -value poseq -require add -help {Combination of both flags, print only '{$equation}'}}
        {-posnocheck -key paramQual -value posnocheck -require add -help {Positional parameter without check}}
        {-nocheck -key paramQual -value nocheck -default {} -require add -help {Normal parameter without check}}
        {-sw -key paramQual -value sw -require add -help {Switch parameter}}
        {-node -key paramQual -value node -require add -help {Node parameter}}
        {-nodeeq -key paramQual -value nodeeq -require add -help {Node parameter equation}}
        # {Actual name(s) and value(s) of Param}
        {pname -optional -help {Name of parameter}}
        {value -optional -help {Value of parameter}}
        {arguments -catchall -require set -help {Optional pairs of name-value for -set action}}
    }
    switch $action {
        add {
            set pname [string tolower $pname]
            if {[info exists Params]} {
                set params [dict keys $Params]
            }
            lappend params $pname
            if {[my DuplListCheck $params]} {
                return -code error "Parameters list '$params' has already contains parameter with name '$pname'"
            }
            switch $paramQual {
                sw {
                    dict append Params $pname [::SpiceGenTcl::ParameterSwitch new $pname]
                }
                pos {
                    dict append Params $pname [::SpiceGenTcl::ParameterPositional new $pname $value]
                }
                eq {
                    dict append Params $pname [::SpiceGenTcl::ParameterEquation new $pname $value]
                }
                poseq {
                    dict append Params $pname [::SpiceGenTcl::ParameterPositionalEquation new $pname $value]
                }
                posnocheck {
                    dict append Params $pname [::SpiceGenTcl::ParameterPositionalNoCheck new $pname $value]
                }
                nocheck {
                    dict append Params $pname [::SpiceGenTcl::ParameterNoCheck new $pname $value]
                }
                node {
                    dict append Params $pname [::SpiceGenTcl::ParameterNode new $pname $value]
                }
                nodeeq {
                    dict append Params $pname [::SpiceGenTcl::ParameterNodeEquation new $pname $value]
                }
                default {
                    dict append Params $pname [::SpiceGenTcl::Parameter new $pname $value]
                }
            }
        }
        get {
            if {![info exists Params]} {
                return
            }
            if {[info exists all]} {
                return [dict map {paramName param} $Params {$param configure -value}]
            } elseif {[info exists pname]} {
                set pname [string tolower $pname]
                if {[dexist $Params $pname]} {
                    return [dget $Params $pname]
                } else {
                    return -code error "Device '$name' doesn't have parameter with name '$pname'"
                }
            } else {
                return -code error "'-get' action requires 'pname' parameter or '-all' option"
            }
        }
        set {
            set arguments [list $pname $value {*}$arguments]
            if {[llength $arguments]%2!=0} {
                return -code error "Number of arguments to method '[dict get [info frame 0] method]' with '-set' switch must be even"
            }
            for {set i 0} {$i<[llength $arguments]} {incr i 2} {
                set paramName [string tolower [@ $arguments $i]]
                set paramValue [@ $arguments [= {$i+1}]]
                if {[catch {dget $Params $paramName}]} {
                    return -code error "Parameter with name '$paramName' was not found in element's '$name' list of parameters '[dkeys $Params]'"
                } else {
                    set param [dget $Params $paramName]
                }
                $param configure -value $paramValue
            }
        }
        delete {
            set pname [string tolower $pname]
            if {[catch {dget $Params $pname}]} {
                return -code error "Parameter with name '$pname' was not found in device's '$name' list of parameters '[dkeys $Params]'"
            } else {
                set Params [dict remove $Params $pname]
            }
        }
    }
    return
}

method actOnPin {args} {

    # Acts on `Pin` object with selected action
    #  -add - add new pin to the device, requires pin and node arguments
    #  -get - get node name connected to pin, requires pin argument
    #  -set - set node name connected to pin, requires pin and node arguments
    #  -all - option for getting the dictionary that contains pin name as keys and connected node name as the
    #    values, requires -get
    #  pin - name of the pin
    #  node - name of the node connected to pin
    # Synopsis: -add pin node
    # Synopsis: -set pin node
    # Synopsis: -get pin
    # Synopsis: -get -all
     argparse -help {Applied selected actions on pin of the device} {
        {-add -key action -value add -require {pin node} -help {Add new pin to the device}}
        {-get -key action -value get -help {Get node name connected to pin}}
        {-set -key action -value set -require {pin node} -help {Set node name connected to pin}}
        {-all -require get -forbid {pin node} -help {Option for getting the dictionary that contains pin name as keys and connected node name as the values}}
        {pin -optional -help {Name of the pin}}
        {node -optional -help {Name of the node connected to pin}}
    }
    switch $action {
        add {
            set pin [string tolower $pin]
            set node [string tolower $node]
            if {[info exists Pins]} {
                set pins [dkeys $Pins]
            }
            lappend pins $pin
            if {[my DuplListCheck $pins]} {
                return -code error "Pins list '$pins' has already contains pin with name '$pin'"
            }
            dappend Pins $pin [::SpiceGenTcl::Pin new $pin $node]
        }
        get {
            if {![info exists Pins]} {
                return
            }
            if {[info exists all]} {
                return [dict map {pinName pin} $Pins {$pin configure -node}]
            } elseif {[info exists pin]} {
                set pin [string tolower $pin]
                if {[dexist $Pins $pin]} {
                    return [dget $Pins $pin]
                } else {
                    return -code error "Device '$name' doesn't have pin with name '$pin'"
                }
            } else {
                return -code error "'-get' action requires 'pin' parameter or '-all' option"
            }
        }
        set {
            set pin [string tolower $pin]
            set node [string tolower $node]
            if {![info exists Pins]} {
                return -code error "Device '$name' doesn't have pins"
            }
            if {[dexist $Pins $pin]} {
                [dget $Pins $pin] configure -node $node
            } else {
                return -code error "Pin with name '$pin' was not found in device's '$name' list of pins '[dkeys $Pins]'"
            }
        }
    }
    return
}

method checkFloatingPins {args} {

    # Check if some pin device doesn't have connected nodes and return list of them.
    # Returns: list of floating pins
    argparse -help {Check if some pin device doesn't have connected nodes and return list of them} {}
    set floatingPins {}
    dict for {pinName pin} $Pins {
        if {[$pin checkFloating]} {
            lappend floatingPins [$pin configure -name]
        }
    }
    return $floatingPins
}

method genSPICEString {} {

    # Creates device string for SPICE netlist.
    # Returns: SPICE netlist's string
    if {[info exists Pins]} {
        dict for {pinName pin} $Pins {
            if {![catch {$pin genSPICEString}]} {
                lappend nodes [$pin genSPICEString]
            } else {
                return -code error "Device '[my configure -name]' can't be netlisted because '$pinName' pin is floating"
            }
        }
    }
    if {[info exists Params]} {
        set params [lmap param [dict values $Params] {$param genSPICEString}]
        if {[info exists Pins]} {
            return "[my configure -name] [join $nodes] [join $params]"
        } else {
            return "[my configure -name] [join $params]"
        }
    } else {
        if {[info exists Pins]} {
            return "[my configure -name] [join $nodes]"
        } else {
            return [my configure -name]
        }
    }
}

method getDataPoints {} {

    if {[info exists DataPoints]} {
        return {}
    }
    return
}

method constructor {args} {

    # Creates object of class `Global`.
    #  nets - list of nets in form `{net0 net1 ...}`
    #  -name - name of the library that could be used to retrieve element from [::SpiceGenTcl::Netlist] object
    #    and its descendants, optional
    # Class represent .global statement.
    # Synopsis: nets ?-name value?
    set arguments [argparse -inline -pfirst -help {Creates object of class 'Global'} {
        {nets -help {List of nets in form '{net0 net1 ...}'} -type list}
        {-name= -help {Name of the string that could be used to retrieve element from [::SpiceGenTcl::Netlist] object and its descendants}}
    }]
    if {[dexist $arguments name]} {
        my configure -name [dget $arguments name]
    } else {
        my configure -name [self object]
    }
    my addNets [dget $arguments nets]
}

method addNets {args} {

    argparse -help {Adds nets to the class} {
        {nets -help {List of nets} -type list}
    }
    if {[info exists Nets]} {
        set netsList $Nets
    }
    foreach net $nets {
        if {$net ne {}} {
            lappend netsList $net
            if {[my DuplListCheck $netsList]} {
                error "Net with name '$net' is already attached to the object '[my configure -name]'"
            }
        } else {
            return -code error {Net name couldn't be empty}
        }
    }
    set Nets $netsList
    return
}

method deleteNet {args} {

    argparse -help {Deletes net from the 'Nets' list} {
        {net -help {Name of the net}}
    }
    set netsList $Nets
    if {[set index [lsearch -exact $netsList $net]] !=-1} {
        set netsList [lremove $netsList $index]
    } else {
        error "Global statement '$name' doesn't have attached net with name '$net'"
    }
    set Nets $netsList
    return
}

method genSPICEString {} {

    # Creates global statement string for SPICE netlist.
    # Returns: SPICE netlist's string
    return ".global [join $Nets]"
}

method constructor {args} {

    # Creates object of class `Ic`.
    #  params - list of instance parameters in form `{{name value} {name value} {name equation -eq} ...}`
    #  -name - name of the library that could be used to retrieve element from [::SpiceGenTcl::Netlist] object
    #    and its descendants, optional
    # Class represent .ic statement.
    # Synopsis: params ?-name value?
    set arguments [argparse -inline -pfirst -help {Creates object of class 'Ic'} {
        {params -help {list of instance parameters in form '{{name value ?-eq?} {name value ?-eq?} ...}'} -type list}
        {-name= -help {Name of the string that could be used to retrieve element from [::SpiceGenTcl::Netlist] object and its descendants}}
    }]
    if {[dexist $arguments name]} {
        my configure -name [dget $arguments name]
    } else {
        my configure -name [self object]
    }
    foreach param [dget $arguments params] {
        if {[llength $param]<2} {
            error "Value '$param' is not a valid value"
        } else {
            if {[@ $param 0] eq {-eq}} {
                my actOnParam -add -nodeeq [@ $param 1] [@ $param 2]
            } else {
                my actOnParam -add -node {*}$param
            }
        }
    }
}

method actOnParam {args} {

    # Acts on `Parameter` object with selected action
    #  -add - add new parameter to the device, requires pname argument
    #  -get - get parameter value, requires pname argument
    #  -set - set (or change) value of particular parameters, requires pname and value arguments
    #  -delete - delete existing parameter
    #  -all - option for getting the dictionary that contains parameters names as keys and parameters values #    as the dictionary values, requires -get
    #  -pos - parameter has strict position and only '$Value' is displayed in netlist, requires -add
    #  -eq - Parameter may contain equation in terms of functions and other parameters, printed as
    #    '$name={$equation}', requires -add
    #  -poseq - combination of both flags, print only, requires -add
    #  -posnocheck - positional parameter without check, requires -add
    #  -nocheck - normal parameter without check, requires -add
    #  -sw - switch parameter, requires -add
    #  -node - node parameter, requires -add
    #  -nodeeq - node parameter equation, requires -add
    #  pname - name of parameter
    #  value - value of parameter
    #  arguments - optional pairs of name-value for -set action, requires -set
    # Synopsis: -add ?-pos|eq|poseq|posnocheck|nocheck|sw|node|nodeeq? name value
    # Synopsis: -set name value ?name value ...?
    # Synopsis: -get name
    # Synopsis: -get -all
    # Synopsis: -delete name
    argparse -help {Applied selected actions on parameters of the device} {
        # {Actions selectors}
        {-add -key action -value add -require pname -help {Add new parameter to device}}
        {-get -key action -value get -help {Get parameter value}}
        {-set -key action -value set -require {pname value} -help {Sets (or change) value of particular parameters}}
        {-delete -key action -value delete -require pname -help {Delete existing parameter}}
        {-all -require get -forbid {pname value} -help {Option for getting the dictionary that contains parameters names as keys and parameters values as the dictionary values}}
        # {Param qualificators}
        {-pos -key paramQual -value pos -require add -help {Parameter has strict position and only '$Value' is displayed in netlist}}
        {-eq -key paramQual -value eq -require add -help {Parameter may contain equation in terms of functions and other parameters, printed as '$name={$equation}'}}
        {-poseq -key paramQual -value poseq -require add -help {Combination of both flags, print only '{$equation}'}}
        {-posnocheck -key paramQual -value posnocheck -require add -help {Positional parameter without check}}
        {-nocheck -key paramQual -value nocheck -default {} -require add -help {Normal parameter without check}}
        {-sw -key paramQual -value sw -require add -help {Switch parameter}}
        {-node -key paramQual -value node -require add -help {Node parameter}}
        {-nodeeq -key paramQual -value nodeeq -require add -help {Node parameter equation}}
        # {Actual name(s) and value(s) of Param}
        {pname -optional -help {Name of parameter}}
        {value -optional -help {Value of parameter}}
        {arguments -catchall -require set -help {Optional pairs of name-value for -set action}}
    }
    switch $action {
        add {
            set pname [string tolower $pname]
            if {[info exists Params]} {
                set params [dict keys $Params]
            }
            lappend params $pname
            if {[my DuplListCheck $params]} {
                return -code error "Parameters list '$params' has already contains parameter with name '$pname'"
            }
            switch $paramQual {
                sw {
                    dict append Params $pname [::SpiceGenTcl::ParameterSwitch new $pname]
                }
                pos {
                    dict append Params $pname [::SpiceGenTcl::ParameterPositional new $pname $value]
                }
                eq {
                    dict append Params $pname [::SpiceGenTcl::ParameterEquation new $pname $value]
                }
                poseq {
                    dict append Params $pname [::SpiceGenTcl::ParameterPositionalEquation new $pname $value]
                }
                posnocheck {
                    dict append Params $pname [::SpiceGenTcl::ParameterPositionalNoCheck new $pname $value]
                }
                nocheck {
                    dict append Params $pname [::SpiceGenTcl::ParameterNoCheck new $pname $value]
                }
                node {
                    dict append Params $pname [::SpiceGenTcl::ParameterNode new $pname $value]
                }
                nodeeq {
                    dict append Params $pname [::SpiceGenTcl::ParameterNodeEquation new $pname $value]
                }
                default {
                    dict append Params $pname [::SpiceGenTcl::Parameter new $pname $value]
                }
            }
        }
        get {
            if {![info exists Params]} {
                return
            }
            if {[info exists all]} {
                return [dict map {paramName param} $Params {$param configure -value}]
            } elseif {[info exists pname]} {
                set pname [string tolower $pname]
                if {[dexist $Params $pname]} {
                    return [dget $Params $pname]
                } else {
                    return -code error "Device '$name' doesn't have parameter with name '$pname'"
                }
            } else {
                return -code error "'-get' action requires 'pname' parameter or '-all' option"
            }
        }
        set {
            set arguments [list $pname $value {*}$arguments]
            if {[llength $arguments]%2!=0} {
                return -code error "Number of arguments to method '[dict get [info frame 0] method]' with '-set' switch must be even"
            }
            for {set i 0} {$i<[llength $arguments]} {incr i 2} {
                set paramName [string tolower [@ $arguments $i]]
                set paramValue [@ $arguments [= {$i+1}]]
                if {[catch {dget $Params $paramName}]} {
                    return -code error "Parameter with name '$paramName' was not found in element's '$name' list of parameters '[dkeys $Params]'"
                } else {
                    set param [dget $Params $paramName]
                }
                $param configure -value $paramValue
            }
        }
        delete {
            set pname [string tolower $pname]
            if {[catch {dget $Params $pname}]} {
                return -code error "Parameter with name '$pname' was not found in device's '$name' list of parameters '[dkeys $Params]'"
            } else {
                set Params [dict remove $Params $pname]
            }
        }
    }
    return
}

method genSPICEString {} {

    # Creates ic statement string for SPICE netlist.
    # Returns: SPICE netlist's string
    return ".ic [join [join [lmap param [dict values $Params] {$param genSPICEString}]]]"
}

method constructor {args} {

    # Creates object of class `Include`.
    #  value - value of the include path
    #  -name - name of the string that could be used to retrieve element from [::SpiceGenTcl::Netlist] object
    #    and its descendants, optional
    # This class represent .include statement.
    # Synopsis: value ?-name value?
    set arguments [argparse -inline -pfirst -help {Creates object of class 'Include'} {
        {value -help {Value of the include path}}
        {-name= -help {Name of the string that could be used to retrieve element from [::SpiceGenTcl::Netlist] object and its descendants}}
    }]
    if {[dexist $arguments name]} {
        my configure -name [dget $arguments name]
    } else {
        my configure -name [self object]
    }
    my configure -value [dget $arguments value]
}

method genSPICEString {} {

    # Creates include string for SPICE netlist.
    # Returns: SPICE netlist's string
    return ".include [my configure -value]"
}

method constructor {args} {

    # Creates object of class `Library`.
    #  value - value of the include file
    #  libvalue - value of selected library
    #  -name - name of the string that could be used to retrieve element from [::SpiceGenTcl::Netlist] object
    #    and its descendants, optional
    # Class represent .lib statement.
    # Synopsis: value libvalue ?-name value?
    set arguments [argparse -inline -pfirst -help {Creates object of class 'Library'} {
        {value -help {Value of the include path}}
        {libvalue -help {Value of selected library}}
        {-name= -help {Name of the string that could be used to retrieve element from [::SpiceGenTcl::Netlist] object and its descendants}}
    }]
    if {[dexist $arguments name]} {
        my configure -name [dget $arguments name]
    } else {
        my configure -name [self object]
    }
    my configure -value [dget $arguments value] -libvalue [dget $arguments libvalue]
}

method genSPICEString {} {

    # Creates library string for SPICE netlist.
    # Returns: SPICE netlist's string
    return ".lib [my configure -value] [my configure -libvalue]"
}

method constructor {args} {

    # Creates object of class `Model`.
    #  name - name of the model
    #  type - type of model, for example, diode, npn, etc
    #  instParams - list of instance parameters in form `{{name value ?-pos|eq|poseq?}
    #   {name value ?-pos|eq|poseq?} {name value ?-pos|eq|poseq?} ...}`
    # Class represents model card in SPICE netlist.
    set arguments [argparse -inline -help {Creates object of class 'Model'} -pfirst {
        {name -help {Name of the model}}
        {type -help {Type of model, for example, diode, npn, etc}}
        {params -optional -help {{List of instance parameters in form '{{Name0 Value0 ?-pos|eq|poseq|posnocheck|nocheck?} {Name1 Value1 ?-pos|eq|poseq|posnocheck|nocheck?} {Name2 Value2 ?-pos|eq|poseq|posnocheck|nocheck?} ...}'}} -type list}
    }]
    my configure -name [dget $arguments name] -type [dget $arguments type]
    # create Params objects
    if {[dexist $arguments params]} {
        foreach param [dget $arguments params] {
            my actOnParam -add {*}$param
        }
    }
}

method actOnParam {args} {

    # Acts on `Parameter` object with selected action
    #  -add - add new parameter to the device, requires pname argument
    #  -get - get parameter value, requires pname argument
    #  -set - set (or change) value of particular parameters, requires pname and value arguments
    #  -delete - delete existing parameter
    #  -all - option for getting the dictionary that contains parameters names as keys and parameters values #    as the dictionary values, requires -get
    #  -pos - parameter has strict position and only '$Value' is displayed in netlist, requires -add
    #  -eq - Parameter may contain equation in terms of functions and other parameters, printed as
    #    '$name={$equation}', requires -add
    #  -poseq - combination of both flags, print only, requires -add
    #  -posnocheck - positional parameter without check, requires -add
    #  -nocheck - normal parameter without check, requires -add
    #  -sw - switch parameter, requires -add
    #  -node - node parameter, requires -add
    #  -nodeeq - node parameter equation, requires -add
    #  pname - name of parameter
    #  value - value of parameter
    #  arguments - optional pairs of name-value for -set action, requires -set
    # Synopsis: -add ?-pos|eq|poseq|posnocheck|nocheck|sw|node|nodeeq? name value
    # Synopsis: -set name value ?name value ...?
    # Synopsis: -get name
    # Synopsis: -get -all
    # Synopsis: -delete name
    argparse -help {Applied selected actions on parameters of the device} {
        # {Actions selectors}
        {-add -key action -value add -require pname -help {Add new parameter to device}}
        {-get -key action -value get -help {Get parameter value}}
        {-set -key action -value set -require {pname value} -help {Sets (or change) value of particular parameters}}
        {-delete -key action -value delete -require pname -help {Delete existing parameter}}
        {-all -require get -forbid {pname value} -help {Option for getting the dictionary that contains parameters names as keys and parameters values as the dictionary values}}
        # {Param qualificators}
        {-pos -key paramQual -value pos -require add -help {Parameter has strict position and only '$Value' is displayed in netlist}}
        {-eq -key paramQual -value eq -require add -help {Parameter may contain equation in terms of functions and other parameters, printed as '$name={$equation}'}}
        {-poseq -key paramQual -value poseq -require add -help {Combination of both flags, print only '{$equation}'}}
        {-posnocheck -key paramQual -value posnocheck -require add -help {Positional parameter without check}}
        {-nocheck -key paramQual -value nocheck -default {} -require add -help {Normal parameter without check}}
        {-sw -key paramQual -value sw -require add -help {Switch parameter}}
        {-node -key paramQual -value node -require add -help {Node parameter}}
        {-nodeeq -key paramQual -value nodeeq -require add -help {Node parameter equation}}
        # {Actual name(s) and value(s) of Param}
        {pname -optional -help {Name of parameter}}
        {value -optional -help {Value of parameter}}
        {arguments -catchall -require set -help {Optional pairs of name-value for -set action}}
    }
    switch $action {
        add {
            set pname [string tolower $pname]
            if {[info exists Params]} {
                set params [dict keys $Params]
            }
            lappend params $pname
            if {[my DuplListCheck $params]} {
                return -code error "Parameters list '$params' has already contains parameter with name '$pname'"
            }
            switch $paramQual {
                sw {
                    dict append Params $pname [::SpiceGenTcl::ParameterSwitch new $pname]
                }
                pos {
                    dict append Params $pname [::SpiceGenTcl::ParameterPositional new $pname $value]
                }
                eq {
                    dict append Params $pname [::SpiceGenTcl::ParameterEquation new $pname $value]
                }
                poseq {
                    dict append Params $pname [::SpiceGenTcl::ParameterPositionalEquation new $pname $value]
                }
                posnocheck {
                    dict append Params $pname [::SpiceGenTcl::ParameterPositionalNoCheck new $pname $value]
                }
                nocheck {
                    dict append Params $pname [::SpiceGenTcl::ParameterNoCheck new $pname $value]
                }
                node {
                    dict append Params $pname [::SpiceGenTcl::ParameterNode new $pname $value]
                }
                nodeeq {
                    dict append Params $pname [::SpiceGenTcl::ParameterNodeEquation new $pname $value]
                }
                default {
                    dict append Params $pname [::SpiceGenTcl::Parameter new $pname $value]
                }
            }
        }
        get {
            if {![info exists Params]} {
                return
            }
            if {[info exists all]} {
                return [dict map {paramName param} $Params {$param configure -value}]
            } elseif {[info exists pname]} {
                set pname [string tolower $pname]
                if {[dexist $Params $pname]} {
                    return [dget $Params $pname]
                } else {
                    return -code error "Device '$name' doesn't have parameter with name '$pname'"
                }
            } else {
                return -code error "'-get' action requires 'pname' parameter or '-all' option"
            }
        }
        set {
            set arguments [list $pname $value {*}$arguments]
            if {[llength $arguments]%2!=0} {
                return -code error "Number of arguments to method '[dict get [info frame 0] method]' with '-set' switch must be even"
            }
            for {set i 0} {$i<[llength $arguments]} {incr i 2} {
                set paramName [string tolower [@ $arguments $i]]
                set paramValue [@ $arguments [= {$i+1}]]
                if {[catch {dget $Params $paramName}]} {
                    return -code error "Parameter with name '$paramName' was not found in element's '$name' list of parameters '[dkeys $Params]'"
                } else {
                    set param [dget $Params $paramName]
                }
                $param configure -value $paramValue
            }
        }
        delete {
            set pname [string tolower $pname]
            if {[catch {dget $Params $pname}]} {
                return -code error "Parameter with name '$pname' was not found in device's '$name' list of parameters '[dkeys $Params]'"
            } else {
                set Params [dict remove $Params $pname]
            }
        }
    }
    return
}

method genSPICEString {} {

    # Creates model string for SPICE netlist.
    # Returns: SPICE netlist's string
    if {![info exists Params]} {
        lappend params {}
        return ".model [my configure -name] [my configure -type]"
    } else {
        set params [lmap param [dict values $Params] {$param genSPICEString}]
        return ".model [my configure -name] [my configure -type]([join $params])"
    }
}

method constructor {args} {

    # Creates object of class `Netlist`.
    #  name - name of the netlist
    # Class implements netlist as a collection of SPICE elements. Any element that has SPICEElement
    # as a parent class can be added to Netlist, except Options and Analysis.
    set arguments [argparse -inline -help {Creates object of class 'Netlist'} {
        {name -help {Name of the netlist}}
    }]
    my configure -name [dget $arguments name]
}

method add {args} {

    # Adds elements objects to Elements dictionary.
    #  elements - elements objects references
    # Synopsis: element ?element ...?
    argparse -help {Adds elements objects to 'Elements' dictionary} {
        {elements -catchall -help {Elements objects references}}
    }
    foreach element $elements {
        lappend elementsNamesList [string tolower [$element configure -name]]
    }
    if {[info exists Elements]} {
        lappend elementsNamesList {*}[my getAllElemNames]
    }
    set dup [my DuplListCheckRet $elementsNamesList]
    if {$dup ne {}} {
        return -code error "Netlist '[my configure -name]' already contains element with name $dup"
    }
    foreach element $elements {
        set elemName [$element configure -name]
        dict append Elements $elemName $element
    }
    return
}

method del {args} {

    # Deletes elements from the netlist by its name.
    #  elementsNames - names of elements to delete
    # Synopsis: elementName ?elementName ...?
    argparse -help {Deletes elements from the netlist by its name} {
        {elementsNames -catchall -help {Elements names}}
    }
    if {![info exists Elements]} {
        return -code error "Netlist '[my configure -name]' doesn't have attached elements"
    }
    foreach elemName $elementsNames {
        set elemName [string tolower $elemName]
        if {[catch {dget $Elements $elemName}]} {
            return -code error "Element with name '$elemName' was not found in netlist's '[my configure -name]' list of elements"
        } else {
            set Elements [dict remove $Elements $elemName]
        }
    }
    return
}

method genSPICEString {} {

    # Creates netlist string for SPICE netlist.
    # Returns: SPICE netlist's string
    if {![info exists Elements]} {
        return -code error "Netlist '[my configure -name]' doesn't have attached elements"
    }
    return [join [lmap element [dict values $Elements] {$element genSPICEString}] \n]
}

method getAllElemNames {args} {

    # Gets names of all elements in netlist.
    # Returns: list of elements names
    argparse -help {Gets names of all elements in netlist. Returns: list of elements names} {}
    if {![info exists Elements]} {
        return -code error "Netlist '[my configure -name]' doesn't have attached elements"
    }
    return [dict keys $Elements]
}

method getElement {args} {

    # Gets particular element object reference by its name.
    #  elemName - name of element
    # Synopsis: elemName
    argparse -help {Gets particular element object reference by its name} {
        {elemName -help {Name of element}}
    }
    set elemName [string tolower $elemName]
    if {[catch {dget $Elements $elemName}]} {
        return -code error "Element with name '$elemName' was not found in netlist's '[my configure -name]' list of elements"
    } else {
        set foundElem [dget $Elements $elemName]
    }
    return $foundElem
}

method genSPICEString {} {

    # Creates nodeset statement string for SPICE netlist.
    # Returns: SPICE netlist's string
    return ".nodeset [join [join [lmap param [dict values $Params] {$param genSPICEString}]]]"
}

method constructor {args} {

    # Creates object of class `Options`.
    #  params - list of instance parameters in form `{{name value ?-sw?} {name value ?-sw?}
    #   {name value ?-sw?} ...}`
    #  -name - name of the string that could be used to retrieve element from [::SpiceGenTcl::Netlist] object
    #    and its descendants, optional
    # This class represent .options statement.
    # Synopsis: params ?-name value?
    set arguments [argparse -inline -pfirst -help {Creates object of class 'Options'} {
        {params -help {list of instance parameters in form '{{name value ?-sw?} {name value ?-sw?} {name value ?-sw?} ...}'}}
        {-name= -help {Name of the string that could be used to retrieve element from [::SpiceGenTcl::Netlist] object and its descendants}}
    }]
    if {[dexist $arguments name]} {
        my configure -name [dget $arguments name]
    } else {
        my configure -name [self object]
    }
    foreach param [dget $arguments params] {
        if {[llength $param]<2} {
            error "Value '$param' is not a valid value"
        } else {
            my actOnParam -add {*}$param
        }
    }
}

method actOnParam {args} {

    # Acts on `Parameter` object with selected action
    #  -add - add new parameter to the device, requires pname argument
    #  -get - get parameter value, requires pname argument
    #  -set - set (or change) value of particular parameters, requires pname and value arguments
    #  -delete - delete existing parameter
    #  -all - option for getting the dictionary that contains parameters names as keys and parameters values #    as the dictionary values, requires -get
    #  -pos - parameter has strict position and only '$Value' is displayed in netlist, requires -add
    #  -eq - Parameter may contain equation in terms of functions and other parameters, printed as
    #    '$name={$equation}', requires -add
    #  -poseq - combination of both flags, print only, requires -add
    #  -posnocheck - positional parameter without check, requires -add
    #  -nocheck - normal parameter without check, requires -add
    #  -sw - switch parameter, requires -add
    #  -node - node parameter, requires -add
    #  -nodeeq - node parameter equation, requires -add
    #  pname - name of parameter
    #  value - value of parameter
    #  arguments - optional pairs of name-value for -set action, requires -set
    # Synopsis: -add ?-pos|eq|poseq|posnocheck|nocheck|sw|node|nodeeq? name value
    # Synopsis: -set name value ?name value ...?
    # Synopsis: -get name
    # Synopsis: -get -all
    # Synopsis: -delete name
    argparse -help {Applied selected actions on parameters of the device} {
        # {Actions selectors}
        {-add -key action -value add -require pname -help {Add new parameter to device}}
        {-get -key action -value get -help {Get parameter value}}
        {-set -key action -value set -require {pname value} -help {Sets (or change) value of particular parameters}}
        {-delete -key action -value delete -require pname -help {Delete existing parameter}}
        {-all -require get -forbid {pname value} -help {Option for getting the dictionary that contains parameters names as keys and parameters values as the dictionary values}}
        # {Param qualificators}
        {-pos -key paramQual -value pos -require add -help {Parameter has strict position and only '$Value' is displayed in netlist}}
        {-eq -key paramQual -value eq -require add -help {Parameter may contain equation in terms of functions and other parameters, printed as '$name={$equation}'}}
        {-poseq -key paramQual -value poseq -require add -help {Combination of both flags, print only '{$equation}'}}
        {-posnocheck -key paramQual -value posnocheck -require add -help {Positional parameter without check}}
        {-nocheck -key paramQual -value nocheck -default {} -require add -help {Normal parameter without check}}
        {-sw -key paramQual -value sw -require add -help {Switch parameter}}
        {-node -key paramQual -value node -require add -help {Node parameter}}
        {-nodeeq -key paramQual -value nodeeq -require add -help {Node parameter equation}}
        # {Actual name(s) and value(s) of Param}
        {pname -optional -help {Name of parameter}}
        {value -optional -help {Value of parameter}}
        {arguments -catchall -require set -help {Optional pairs of name-value for -set action}}
    }
    switch $action {
        add {
            set pname [string tolower $pname]
            if {[info exists Params]} {
                set params [dict keys $Params]
            }
            lappend params $pname
            if {[my DuplListCheck $params]} {
                return -code error "Parameters list '$params' has already contains parameter with name '$pname'"
            }
            switch $paramQual {
                sw {
                    dict append Params $pname [::SpiceGenTcl::ParameterSwitch new $pname]
                }
                pos {
                    dict append Params $pname [::SpiceGenTcl::ParameterPositional new $pname $value]
                }
                eq {
                    dict append Params $pname [::SpiceGenTcl::ParameterEquation new $pname $value]
                }
                poseq {
                    dict append Params $pname [::SpiceGenTcl::ParameterPositionalEquation new $pname $value]
                }
                posnocheck {
                    dict append Params $pname [::SpiceGenTcl::ParameterPositionalNoCheck new $pname $value]
                }
                nocheck {
                    dict append Params $pname [::SpiceGenTcl::ParameterNoCheck new $pname $value]
                }
                node {
                    dict append Params $pname [::SpiceGenTcl::ParameterNode new $pname $value]
                }
                nodeeq {
                    dict append Params $pname [::SpiceGenTcl::ParameterNodeEquation new $pname $value]
                }
                default {
                    dict append Params $pname [::SpiceGenTcl::Parameter new $pname $value]
                }
            }
        }
        get {
            if {![info exists Params]} {
                return
            }
            if {[info exists all]} {
                return [dict map {paramName param} $Params {$param configure -value}]
            } elseif {[info exists pname]} {
                set pname [string tolower $pname]
                if {[dexist $Params $pname]} {
                    return [dget $Params $pname]
                } else {
                    return -code error "Device '$name' doesn't have parameter with name '$pname'"
                }
            } else {
                return -code error "'-get' action requires 'pname' parameter or '-all' option"
            }
        }
        set {
            set arguments [list $pname $value {*}$arguments]
            if {[llength $arguments]%2!=0} {
                return -code error "Number of arguments to method '[dict get [info frame 0] method]' with '-set' switch must be even"
            }
            for {set i 0} {$i<[llength $arguments]} {incr i 2} {
                set paramName [string tolower [@ $arguments $i]]
                set paramValue [@ $arguments [= {$i+1}]]
                if {[catch {dget $Params $paramName}]} {
                    return -code error "Parameter with name '$paramName' was not found in element's '$name' list of parameters '[dkeys $Params]'"
                } else {
                    set param [dget $Params $paramName]
                }
                $param configure -value $paramValue
            }
        }
        delete {
            set pname [string tolower $pname]
            if {[catch {dget $Params $pname}]} {
                return -code error "Parameter with name '$pname' was not found in device's '$name' list of parameters '[dkeys $Params]'"
            } else {
                set Params [dict remove $Params $pname]
            }
        }
    }
    return
}

method genSPICEString {} {

    # Creates options string for SPICE netlist.
    # Returns: SPICE netlist's string
    return ".options [join [lmap param [dict values $Params] {$param genSPICEString}]]"
}

method constructor {args} {

    # Creates object of class `Parameter` with parameter name and value.
    #  name - name of the parameter
    #  value - value of the parameter
    # Class models parameter that has a name and a value - the most
    # common type of parameters in SPICE netlist. Its representation in netlist is
    # 'name=value', and can be called "keyword parameter".
    set arguments [argparse -inline -help {Creates object of class 'Parameter' with parameter name and value} {
        {name -help {Name of the parameter}}
        {value -help {Value of the parameter}}
    }]
    dict for {elName elValue} $arguments {
        my configure -$elName $elValue
    }
}

method genSPICEString {} {

    # Creates string for SPICE netlist.
    # Returns: SPICE netlist's string
    return [my configure -name]=[my configure -value]
}

method constructor {args} {

    # Creates object of class `ParameterDefault` with parameter name, value and default value.
    #  name - name of the parameter
    #  value - value of the parameter
    #  defValue - default value of the parameter
    # Class models parameter that has a name and a value, but it differs from
    # parent class in sense of having default value, so it has special ability to reset its value to default
    # value by special method `resetValue`.
    set arguments [argparse -inline -help {Creates object of class 'ParameterDefault' with parameter name and value} {
        {name -help {Name of the parameter}}
        {value -help {Value of the parameter}}
        {defValue -help {Default of the parameter}}
    }]
    my configure -defvalue [dget $arguments defValue]
    next [dget $arguments name] [dget $arguments value]
}

method resetValue {args} {

    # Resets value of the parameter to it's default value.
    argparse -help {Resets value of the parameter to it's default value} {}
    my configure -value [my configure -defvalue]
    return
}

method constructor {args} {

    # Creates object of class `ParameterEquation` with parameter name and value as an equation.
    #  name - name of the parameter
    #  value - value of the parameter
    # Class models parameter that has representation as an equation.
    # Example: R={R1+R2}
    set arguments [argparse -inline -help {Creates object of class 'ParameterEquation' with parameter name and value as an equation} {
        {name -help {Name of the parameter}}
        {value -help {Value of the parameter}}
    }]
    next {*}[dvalues $arguments]
}

method genSPICEString {} {

    # Creates string for SPICE netlist.
    # Returns: SPICE netlist's string
    return [my configure -name]=\{[my configure -value]\}
}

method constructor {args} {

    # Creates object of class `ParameterNoCheck` with parameter name and value.
    #  name - name of the parameter
    #  value - value of the parameter
    # Class models parameter the same as described by `Parameter` but without check for value form.
    set arguments [argparse -inline -help {Creates object of class 'ParameterNoCheck' with parameter name and value} {
        {name -help {Name of the parameter}}
        {value -help {Value of the parameter}}
    }]
    next {*}[dvalues $arguments]
}

method constructor {args} {

    # Creates object of class `ParameterNode` with parameter name and value.
    #  name - name of the parameter
    #  value - value of the parameter
    set arguments [argparse -inline -help {Creates object of class 'ParameterNode' with parameter name and value} {
        {name -help {Name of the parameter}}
        {value -help {Value of the parameter}}
    }]
    dict for {elName elValue} $arguments {
        my configure -$elName $elValue
    }
}

method genSPICEString {} {

    # Creates string for SPICE netlist.
    # Returns: SPICE netlist's string
    return [my configure -name]=[my configure -value]
}

method constructor {args} {

    # Creates object of class `ParameterNodeEquation` with parameter name and value.
    #  name - name of the parameter
    #  value - value of the parameter
    set arguments [argparse -inline -help {Creates object of class 'ParameterNodeEquation' with parameter name and value} {
        {name -help {Name of the parameter}}
        {value -help {Value of the parameter}}
    }]
    dict for {elName elValue} $arguments {
        my configure -$elName $elValue
    }
}

method genSPICEString {} {

    # Creates string for SPICE netlist.
    # Returns: SPICE netlist's string
    return "[my configure -name]=\{[my configure -value]\}"
}

method constructor {args} {

    # Creates object of class `ParameterPositional` with parameter name and value.
    #  name - name of parameter
    #  value - value of parameter
    # Class models parameter that has a name and a value, but it differs from
    # parent class in the sense of netlist representation: this parameter represents only
    # by the value in the netlist. It's meaning for holding element is taken from
    # it's position in the element's definition, for example, R1 np nm 100 tc1=1 tc2=0 - resistor
    # with positional parameter R=100, you can't put it after parameters tc1 and tc2, it must be placed
    # right after the pins definition.
    set arguments [argparse -inline -help {Creates object of class 'ParameterPositional' with parameter name and value} {
        {name -help {Name of the parameter}}
        {value -help {Value of the parameter}}
    }]
    next {*}[dvalues $arguments]
}