::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
    argparse -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 {[info exists name]} {
        my configure -name $name
    } else {
        my configure -name [self object]
    }
    my configure -type $type
    # create Analysis objects
    foreach param $params {
        if {[llength $param]<2} {
            error "Value '$param' is not a valid value"
        } else {
            my addParam {*}$param
        }
    }
}

method addParam {args} {

    # Adds new parameter to device, and throws error on dublicated names.
    #  pname - name of parameter
    #  value - value of parameter
    #  -eq - parameter is of class [::SpiceGenTcl::ParameterEquation], optional, forbids other switches
    #  -poseq - parameter is of class [::SpiceGenTcl::ParameterPositionalEquation], optional, forbids other
    #    switches
    #  -posnocheck - parameter is of class [::SpiceGenTcl::ParameterPositionalNoCheck], optional, forbids other
    #    switches
    #  -pos - parameter is of class [::SpiceGenTcl::ParameterPositional], optional, forbids other switches
    #  -nocheck - parameter is of class [::SpiceGenTcl::ParameterNoCheck], optional, forbids other switches
    # Synopsis: pname value ?-name value? ?-eq|poseq|posnocheck|pos|nocheck?
    argparse -pfirst -help {Adds new parameter to device, and throws error on dublicated names} {
        {-pos -key paramQual -value pos -help {Parameter has strict position and only '$Value' is displayed in netlist}}
        {-eq -key paramQual -value eq -help {Parameter may contain equation in terms of functions and other parsmeters, printed as '$name={$equation}'}}
        {-poseq -key paramQual -value poseq -help {Combination of both flags, print only '{$equation}'}}
        {-posnocheck -key paramQual -value posnocheck -help {Positional parameter without check}}
        {-nocheck -key paramQual -value nocheck -default {} -help {Normal parameter without check}}
        {pname -help {Name of parameter}}
        {value -help {Value of parameter}}
    }
    # method adds new Parameter object to the list Params
    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'"
    }
    # select parameter object according to parameter qualificator
    if {$value eq {-sw}} {
        dict append Params $pname [::SpiceGenTcl::ParameterSwitch new $pname]
    } else {
        ##nagelfar variable paramQual
        switch $paramQual {
            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]
            }
            default {
                dict append Params $pname [::SpiceGenTcl::Parameter new $pname $value]
            }
        }
    }
    return
}

method deleteParam {args} {

    # Deletes existing `Parameter` object from list `Params`.
    #  pname - name of parameter that shhould be deleted
    # Synopsis: pname
    argparse -help {Deletes existing 'Parameter' object from list 'Params'} {
        {pname -help {Name of the parameter}}
    }
    set pname [string tolower $pname]
    if {[catch {dget $Params $pname}]} {
        return -code error "Parameter with name '$pname' was not found in device's '[my configure -name]' list of parameters '[dict keys [my getParams]]'"
    } 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 getParams {} {

    # Gets the dictionary that contains parameter name as keys and parameter values as the values.
    # Returns: parameters dictionary
    return [dict map {pname param} $Params {$param configure -value}]
}

method setParamValue {args} {

    # Sets (or change) value of particular parameters.
    #  pname - name of the parameter
    #  value - value of the parameter
    #  arguments - optional pairs of name-value
    # Synopsis: name value ?name value ...?
    argparse -help {Sets (or change) value of particular parameters} {
        {pname -help {Name of the parameter} -pass arguments}
        {value -help {Value of the parameter} -pass arguments}
        {arguments -catchall -help {Optional pairs of name-value}}
    }
    if {[llength $arguments]%2!=0} {
        return -code error "Number of arguments to method '[dict get [info frame 0] method]' 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 '[my configure -name]' list of parameters '[dict keys [my getParams]]'"
        } else {
            set param [dget $Params $paramName]
        }
        $param configure -value $paramValue
    }
    return
}

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
    argparse -help {Creates object of class 'CircuitNetlist'} {
        {name -help {Name of the tol-level circuit}}
    }
    next $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 {} {

    # 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 {} {

    # Method to get 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?
    argparse -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 {[info exists name]} {
        my configure -name $name
    } else {
        my configure -name [self object]
    }
    my configure -value $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
    argparse -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}}
    }
    my configure -name $name -type $type -len $len -numtype $numType
}

method appendDataPoints {dataPoint} {

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

method getDataPoints {} {

    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 ?-pos|eq|poseq?} {Name Value ?-pos|eq|poseq?}
    #   {Name Value ?-pos|eq|poseq?} ...}` 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).
    argparse -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 ?-pos|eq|poseq|posnocheck|nocheck?} {Name1 Value1 ?-pos|eq|poseq|posnocheck|nocheck?} {Name2 Value2 ?-pos|eq|poseq|posnocheck|nocheck?} ...}'. Parameter list can be empty if device doesn't have instance parameters} -type list}
    }
    my configure -name $name
    # create Pins objects
    foreach pin $pins {
        my addPin {*}$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 $params {
        my addParam {*}$param
    }
}

method addParam {args} {

    # Adds new parameter to device, and throws error on dublicated names.
    #  pname - name of parameter
    #  value - value of parameter
    #  -eq - parameter is of class [::SpiceGenTcl::ParameterEquation], optional, forbids other switches
    #  -poseq - parameter is of class [::SpiceGenTcl::ParameterPositionalEquation], optional, forbids other
    #    switches
    #  -posnocheck - parameter is of class [::SpiceGenTcl::ParameterPositionalNoCheck], optional, forbids other
    #    switches
    #  -pos - parameter is of class [::SpiceGenTcl::ParameterPositional], optional, forbids other switches
    #  -nocheck - parameter is of class [::SpiceGenTcl::ParameterNoCheck], optional, forbids other switches
    # Synopsis: pname value ?-name value? ?-eq|poseq|posnocheck|pos|nocheck?
    argparse -pfirst -help {Adds new parameter to device, and throws error on dublicated names} {
        {-pos -key paramQual -value pos -help {Parameter has strict position and only '$Value' is displayed in netlist}}
        {-eq -key paramQual -value eq -help {Parameter may contain equation in terms of functions and other parsmeters, printed as '$name={$equation}'}}
        {-poseq -key paramQual -value poseq -help {Combination of both flags, print only '{$equation}'}}
        {-posnocheck -key paramQual -value posnocheck -help {Positional parameter without check}}
        {-nocheck -key paramQual -value nocheck -default {} -help {Normal parameter without check}}
        {pname -help {Name of parameter}}
        {value -help {Value of parameter}}
    }
    # method adds new Parameter object to the list Params
    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'"
    }
    # select parameter object according to parameter qualificator
    if {$value eq {-sw}} {
        dict append Params $pname [::SpiceGenTcl::ParameterSwitch new $pname]
    } else {
        ##nagelfar variable paramQual
        switch $paramQual {
            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]
            }
            default {
                dict append Params $pname [::SpiceGenTcl::Parameter new $pname $value]
            }
        }
    }
    return
}

method addPin {args} {

    # Adds new Pin object to the dictionary of `Pins`.
    #  pin - name of the pin
    #  node - name of the node connected to pin
    # Synopsis: pin node
    argparse -help {Adds new Pin object to the dictionary of 'Pins'} {
        {pin -help {Name of the pin}}
        {node -help {Name of the node that we want connect to pin}}
    }
    set pin [string tolower $pin]
    set node [string tolower $node]
    if {[info exists Pins]} {
        set pins [dict keys $Pins]
    }
    lappend pins $pin
    if {[my DuplListCheck $pins]} {
        return -code error "Pins list '$pins' has already contains pin with name '$pin'"
    }
    dict append Pins $pin [::SpiceGenTcl::Pin new $pin $node]
    return
}

method checkFloatingPins {} {

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

method deleteParam {args} {

    # Deletes existing `Parameter` object from list `Params`.
    #  pname - name of parameter that shhould be deleted
    # Synopsis: pname
    argparse -help {Deletes existing 'Parameter' object from list 'Params'} {
        {pname -help {Name of the parameter}}
    }
    set pname [string tolower $pname]
    if {[catch {dget $Params $pname}]} {
        return -code error "Parameter with name '$pname' was not found in device's '[my configure -name]' list of parameters '[dict keys [my getParams]]'"
    } else {
        set Params [dict remove $Params $pname]
    }
    return
}

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 getParams {} {

    # Gets the dictionary that contains parameter name as keys and parameter values as the values.
    # Returns: parameters dictionary
    return [dict map {pname param} $Params {$param configure -value}]
}

method getPins {} {

    # Gets the dictionary that contains pin name as keys and
    #  connected node name as the values.
    # Returns: parameters dictionary
    return [dict map {pinName pin} $Pins {$pin configure -nodename}]
}

method setParamValue {args} {

    # Sets (or change) value of particular parameters.
    #  pname - name of the parameter
    #  value - value of the parameter
    #  arguments - optional pairs of name-value
    # Synopsis: name value ?name value ...?
    argparse -help {Sets (or change) value of particular parameters} {
        {pname -help {Name of the parameter} -pass arguments}
        {value -help {Value of the parameter} -pass arguments}
        {arguments -catchall -help {Optional pairs of name-value}}
    }
    if {[llength $arguments]%2!=0} {
        return -code error "Number of arguments to method '[dict get [info frame 0] method]' 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 '[my configure -name]' list of parameters '[dict keys [my getParams]]'"
        } else {
            set param [dget $Params $paramName]
        }
        $param configure -value $paramValue
    }
    return
}

method setPinNodeName {args} {

    # Sets node name of particular pin, so,
    #  in other words, connect particular pin to particular node.
    #  pin - name of the pin
    #  node - name of the node that we want connect to pin
    argparse -help {Sets node name of particular pin, so, in other words, connect particular pin to particular node} {
        {pin -help {Name of the pin}}
        {node -help {Name of the node that we want connect to pin}}
    }
    if {[catch {dget $Pins $pin}]} {
        return -code error "Pin with name '$pin' was not found in device's '[my configure -name]' list of pins '[dict keys [my getPins]]'"
    } else {
        set pinInst [dget $Pins $pin]
    }
    $pinInst configure -nodename $node
    return
}

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?
    argparse -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 {[info exists name]} {
        my configure -name $name
    } else {
        my configure -name [self object]
    }
    my addNets $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?
    argparse -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 {[info exists name]} {
        my configure -name $name
    } else {
        my configure -name [self object]
    }
    foreach param $params {
        if {[llength $param]<2} {
            error "Value '$param' is not a valid value"
        } else {
            my addParam {*}$param
        }
    }
}

method addParam {args} {

    # Adds new Parameter object to the list Params.
    #  pname - name of parameter
    #  value - value of parameter
    #  -eq - optional parameter qualificator
    # Synopsis: pname value ?-eq?
    argparse -pfirst -help {Adds new 'Parameter' object to the dictionary 'Params'} {
        {pname -help {Name of parameter}}
        {value -help {Value of parameter}}
        {-eq -help {Parameter qualificator defining parameter value as equation}}
    }
    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'"
    }
    if {[info exists eq]} {
        dict append Params $pname [::SpiceGenTcl::ParameterNodeEquation new $pname $value]
    } else {
        dict append Params $pname [::SpiceGenTcl::ParameterNode new $pname $value]
    }
    return
}

method deleteParam {args} {

    # Deletes existing `Parameter` object from list `Params`.
    #  pname - name of parameter that shhould be deleted
    # Synopsis: pname
    argparse -help {Deletes existing 'Parameter' object from list 'Params'} {
        {pname -help {Name of the parameter}}
    }
    set pname [string tolower $pname]
    if {[catch {dget $Params $pname}]} {
        return -code error "Parameter with name '$pname' was not found in device's '[my configure -name]' list of parameters '[dict keys [my getParams]]'"
    } 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 getParams {} {

    # Gets the dictionary that contains parameter name as keys and parameter values as the values.
    # Returns: parameters dictionary
    return [dict map {pname param} $Params {$param configure -value}]
}

method setParamValue {args} {

    # Sets (or change) value of particular parameters.
    #  pname - name of the parameter
    #  value - value of the parameter
    #  arguments - optional pairs of name-value
    # Synopsis: name value ?name value ...?
    argparse -help {Sets (or change) value of particular parameters} {
        {pname -help {Name of the parameter} -pass arguments}
        {value -help {Value of the parameter} -pass arguments}
        {arguments -catchall -help {Optional pairs of name-value}}
    }
    if {[llength $arguments]%2!=0} {
        return -code error "Number of arguments to method '[dict get [info frame 0] method]' 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 '[my configure -name]' list of parameters '[dict keys [my getParams]]'"
        } else {
            set param [dget $Params $paramName]
        }
        $param configure -value $paramValue
    }
    return
}

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?
    argparse -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 {[info exists name]} {
        my configure -name $name
    } else {
        my configure -name [self object]
    }
    my configure -value $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?
    argparse -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 {[info exists name]} {
        my configure -name $name
    } else {
        my configure -name [self object]
    }
    my configure -value $value -libvalue $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.
    argparse -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 $name -type $type
    # create Params objects
    if {[info exists params]} {
        foreach param $params {
            my addParam {*}$param
        }
    }
}

method addParam {args} {

    # Adds new parameter to device, and throws error on dublicated names.
    #  pname - name of parameter
    #  value - value of parameter
    #  -eq - parameter is of class [::SpiceGenTcl::ParameterEquation], optional, forbids other switches
    #  -poseq - parameter is of class [::SpiceGenTcl::ParameterPositionalEquation], optional, forbids other
    #    switches
    #  -posnocheck - parameter is of class [::SpiceGenTcl::ParameterPositionalNoCheck], optional, forbids other
    #    switches
    #  -pos - parameter is of class [::SpiceGenTcl::ParameterPositional], optional, forbids other switches
    #  -nocheck - parameter is of class [::SpiceGenTcl::ParameterNoCheck], optional, forbids other switches
    # Synopsis: pname value ?-name value? ?-eq|poseq|posnocheck|pos|nocheck?
    argparse -pfirst -help {Adds new parameter to device, and throws error on dublicated names} {
        {-pos -key paramQual -value pos -help {Parameter has strict position and only '$Value' is displayed in netlist}}
        {-eq -key paramQual -value eq -help {Parameter may contain equation in terms of functions and other parsmeters, printed as '$name={$equation}'}}
        {-poseq -key paramQual -value poseq -help {Combination of both flags, print only '{$equation}'}}
        {-posnocheck -key paramQual -value posnocheck -help {Positional parameter without check}}
        {-nocheck -key paramQual -value nocheck -default {} -help {Normal parameter without check}}
        {pname -help {Name of parameter}}
        {value -help {Value of parameter}}
    }
    # method adds new Parameter object to the list Params
    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'"
    }
    # select parameter object according to parameter qualificator
    if {$value eq {-sw}} {
        dict append Params $pname [::SpiceGenTcl::ParameterSwitch new $pname]
    } else {
        ##nagelfar variable paramQual
        switch $paramQual {
            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]
            }
            default {
                dict append Params $pname [::SpiceGenTcl::Parameter new $pname $value]
            }
        }
    }
    return
}

method deleteParam {args} {

    # Deletes existing `Parameter` object from list `Params`.
    #  pname - name of parameter that shhould be deleted
    # Synopsis: pname
    argparse -help {Deletes existing 'Parameter' object from list 'Params'} {
        {pname -help {Name of the parameter}}
    }
    set pname [string tolower $pname]
    if {[catch {dget $Params $pname}]} {
        return -code error "Parameter with name '$pname' was not found in device's '[my configure -name]' list of parameters '[dict keys [my getParams]]'"
    } 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 getParams {} {

    # Gets the dictionary that contains parameter name as keys and parameter values as the values.
    # Returns: parameters dictionary
    return [dict map {pname param} $Params {$param configure -value}]
}

method setParamValue {args} {

    # Sets (or change) value of particular parameters.
    #  pname - name of the parameter
    #  value - value of the parameter
    #  arguments - optional pairs of name-value
    # Synopsis: name value ?name value ...?
    argparse -help {Sets (or change) value of particular parameters} {
        {pname -help {Name of the parameter} -pass arguments}
        {value -help {Value of the parameter} -pass arguments}
        {arguments -catchall -help {Optional pairs of name-value}}
    }
    if {[llength $arguments]%2!=0} {
        return -code error "Number of arguments to method '[dict get [info frame 0] method]' 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 '[my configure -name]' list of parameters '[dict keys [my getParams]]'"
        } else {
            set param [dget $Params $paramName]
        }
        $param configure -value $paramValue
    }
    return
}

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.
    argparse -help {Creates object of class 'Netlist'} {
        {name -help {Name of the netlist}}
    }
    my configure -name $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 {} {

    # 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?
    argparse -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 {[info exists name]} {
        my configure -name $name
    } else {
        my configure -name [self object]
    }
    foreach param $params {
        if {[llength $param]<2} {
            error "Value '$param' is not a valid value"
        } else {
            my addParam {*}$param
        }
    }
}

method addParam {args} {

    # Creates new parameter object and add it to the list `Params`.
    #  pname - name of parameter
    #  value - value of parameter, could be equal to -sw
    #  -eq - parameter qualificator defining parameter value as equation
    # Synopsis: pname value ?-eq?
    argparse -pfirst -help {} {
        {pname -help {Name of parameter}}
        {value -help {Value of parameter, could be equal to '-sw'}}
        {-eq -help {Parameter qualificator defining parameter value as equation}}
    }
    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'"
    }
    if {$value eq {-sw}} {
        dict append Params $pname [::SpiceGenTcl::ParameterSwitch new $pname]
    } elseif {[info exists eq]} {
        dict append Params $pname [::SpiceGenTcl::ParameterEquation new $pname $value]
    } else {
        dict append Params $pname [::SpiceGenTcl::ParameterNoCheck new $pname $value]
    }
    return
}

method deleteParam {args} {

    # Deletes existing `Parameter` object from list `Params`.
    #  pname - name of parameter that shhould be deleted
    # Synopsis: pname
    argparse -help {Deletes existing 'Parameter' object from list 'Params'} {
        {pname -help {Name of the parameter}}
    }
    set pname [string tolower $pname]
    if {[catch {dget $Params $pname}]} {
        return -code error "Parameter with name '$pname' was not found in device's '[my configure -name]' list of parameters '[dict keys [my getParams]]'"
    } 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 getParams {} {

    # Gets the dictionary that contains parameter name as keys and
    #  parameter values as the values.
    # Returns: parameters dictionary
    return [dict map {paramName param} $Params {expr {[catch {$param configure -value}] ? {} : [$param configure -value]}}]
}

method setParamValue {args} {

    # Sets (or change) value of particular parameters.
    #  pname - name of the parameter
    #  value - value of the parameter
    #  arguments - optional pairs of name-value
    # Synopsis: name value ?name value ...?
    argparse -help {Sets (or change) value of particular parameters} {
        {pname -help {Name of the parameter} -pass arguments}
        {value -help {Value of the parameter} -pass arguments}
        {arguments -catchall -help {Optional pairs of name-value}}
    }
    if {[llength $arguments]%2!=0} {
        return -code error "Number of arguments to method '[dict get [info frame 0] method]' 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 '[my configure -name]' list of parameters '[dict keys [my getParams]]'"
        } else {
            set param [dget $Params $paramName]
        }
        $param configure -value $paramValue
    }
    return
}

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".
    argparse -help {Creates object of class 'Parameter' with parameter name and value} {
        {name -help {Name of the parameter}}
        {value -help {Value of the parameter}}
    }
    my configure -name $name -value $value
}

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`.
    argparse -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 $defValue
    next $name $value
}

method resetValue {} {

    # 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}
    argparse -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 $name $value
}

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.
    argparse -help {Creates object of class 'ParameterNoCheck' with parameter name and value} {
        {name -help {Name of the parameter}}
        {value -help {Value of the parameter}}
    }
    next $name $value
}

method constructor {args} {

    # Creates object of class `ParameterNode` with parameter name and value.
    #  name - name of the parameter
    #  value - value of the parameter
    argparse -help {Creates object of class 'ParameterNode' with parameter name and value} {
        {name -help {Name of the parameter}}
        {value -help {Value of the parameter}}
    }
    my configure -name $name -value $value
}

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
    argparse -help {Creates object of class 'ParameterNodeEquation' with parameter name and value} {
        {name -help {Name of the parameter}}
        {value -help {Value of the parameter}}
    }
    my configure -name $name -value $value
}

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.
    argparse -help {Creates object of class 'ParameterPositional' with parameter name and value} {
        {name -help {Name of the parameter}}
        {value -help {Value of the parameter}}
    }
    next $name $value
}

method genSPICEString {} {

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

method constructor {args} {

    # Creates object of class `ParameterPositionalEquation` with parameter name and value as an equation in
    # positional form.
    #  name - name of the parameter
    #  value - value of the parameter
    # Class models parameter that has representation as an equation, but in form of
    # positional parameter. Example: {R1+R2}
    argparse -help {Creates object of class 'ParameterPositionalEquation' with parameter name and value as an equation} {
        {name -help {Name of the parameter}}
        {value -help {Value of the parameter}}
    }
    next $name $value
}

method genSPICEString {} {

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

method constructor {args} {

    # Creates object of class `ParameterPositionalNoCheck`.
    #  name - name of parameter
    #  value - value of parameter
    # Class models parameter the same as described by `ParameterPositional` but without check for value form.
    argparse -help {Creates object of class 'ParameterPositionalNoCheck' with parameter name and value} {
        {name -help {Name of the parameter}}
        {value -help {Value of the parameter}}
    }
    next $name $value
}

method genSPICEString {} {

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

method constructor {args} {

    # Creates object of class `ParameterSwitch` with parameter name.
    #  name - name of the parameter
    # Class models base parameter acting like a switch -
    # its presence gives us information that something it controls is on.
    # This parameter doesn't have a value, and it is the most basic class
    # in Parameter class family.
    argparse -help {Creates object of class 'ParameterSwitch' with parameter name} {
        {name -help {Name of the parameter}}
    }
    my configure -name $name
}

method genSPICEString {} {

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

method constructor {args} {

    # Creates object of class `ParamStatement`.
    #  params - list of instance parameters in form `{{name value ?-eq?} {name value ?-eq?} ...}`
    #  -name - name of the library that could be used to retrieve element from [::SpiceGenTcl::Netlist] object
    #    and its descendants, optional
    # Class represent .param statement.
    # Synopsis: params ?-name value?
    argparse -pfirst -help {Creates object of class 'ParamStatement'} {
        {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 {[info exists name]} {
        my configure -name $name
    } else {
        my configure -name [self object]
    }
    foreach param $params {
        if {[llength $param]<2} {
            error "Value '$param' is not a valid value"
        } else {
            my addParam {*}$param
        }
    }
}