::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::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::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 {type params 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 {
        -name=
    }]
    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 {[@ $param 2]=={}} {
            my addParam [@ $param 0] [@ $param 1]
        } elseif {[@ $param 1]=="-sw"} {
            my addParam [@ $param 0] -sw
        } else {
            my addParam {*}$param
        }
    }
}

method addParam {paramName value args} {

    # Adds new parameter to device, and throws error on dublicated names.
    #  paramName - 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: paramName value ?-name value? ?-eq|-poseq|-posnocheck|-pos|-nocheck?
    argparse {
        {-pos -key paramQual -value pos}
        {-eq -key paramQual -value eq}
        {-poseq -key paramQual -value poseq}
        {-posnocheck -key paramQual -value posnocheck}
        {-nocheck -key paramQual -value nocheck -default ""}
    }
    # method adds new Parameter object to the list Params
    set paramName [string tolower $paramName]
    if {[info exists Params]} {
        set paramList [dict keys $Params]
    }
    lappend paramList $paramName
    if {[my duplListCheck $paramList]} {
        return -code error "Parameters list '$paramList' has already contains parameter with name '$paramName'"
    }
    # select parameter object according to parameter qualificator
    if {$value=="-sw"} {
        dict append Params $paramName [::SpiceGenTcl::ParameterSwitch new $paramName]
    } else {
        switch $paramQual {
            pos {
                dict append Params $paramName [::SpiceGenTcl::ParameterPositional new $paramName $value]
            }
            eq {
                dict append Params $paramName [::SpiceGenTcl::ParameterEquation new $paramName $value]
            }
            poseq {
                dict append Params $paramName [::SpiceGenTcl::ParameterPositionalEquation new $paramName $value]
            }
            posnocheck {
                dict append Params $paramName [::SpiceGenTcl::ParameterPositionalNoCheck new $paramName $value]
            }
            nocheck {
                dict append Params $paramName [::SpiceGenTcl::ParameterNoCheck new $paramName $value]
            }
            default {
                dict append Params $paramName [::SpiceGenTcl::Parameter new $paramName $value]
            }
        }
    }
    return
}

method deleteParam {paramName} {

    # Deletes existing `Parameter` object from list `Params`.
    #  paramName - name of parameter that will be deleted
    set paramName [string tolower $paramName]
    if {[catch {dget $Params $paramName}]} {
        return -code error "Parameter with name '$paramName' was not found in device's '[my configure -name]' list of parameters '[dict keys [my getParams]]'"
    } else {
        set Params [dict remove $Params $paramName]
    }
    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 {paramName param} $Params {$param configure -value}]
}

method setParamValue {args} {

    # Sets (or change) value of particular parameters.
    #  name - name of the parameter
    #  value - value of the parameter
    # Synopsis: name value ?name value ...?
    if {[llength $args]%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 $args]} {incr i 2} {
        set paramName [string tolower [@ $args [= {$i}]]]
        set paramValue [@ $args [= {$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 {name type len {numType real}} {

    # initialize axis
    #  name - name of the axis
    #  type - type of axis
    #  len - total number of points
    #  numType - numerical type of axis
    next $name $type $len $numType
}

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

    # 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.
    next $name
}

method add {args} {

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

method del {args} {

    # Deletes elements from the circuit by its name.
    #  args - name of element to delete
    if {![info exists Elements]} {
        return -code error "Netlist '[my configure -name]' doesn't have attached elements"
    }
    foreach arg $args {
        set elemName [string tolower $arg]
        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 getElement {elemName} {

    # Gets particular element object reference by its name.
    #  elemName - name of element
    set elemName [string tolower $elemName]
    set error [catch {dget $Elements $elemName}]
    if {$error>0} {
        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 runAndRead {args} {

    # Invokes 'runAndRead', 'configure -log' and 'configure -data' methods from attached simulator.
    #  -nodelete - flag to forbid simulation file deletion
    # Synopsis: ?-nodelete?
    set arguments [argparse {
        -nodelete
    }]
    if {[info exists simulator]==0} {
        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 {value 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 {
        -name=
    }
    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 {name type len {numType real}} {

    # initialize dataset
    #  name - name of the dataset
    #  type - type of dataset
    #  len - total number of points
    #  numType - 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 {name pins params} {

    # 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).

    my configure -name $name
    # create Pins objects
    foreach pin $pins {
        my AddPin [@ $pin 0] [@ $pin 1]
    }
    #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}'
    if {$params!=""} {
        foreach param $params {
            if {[@ $param 2]=={}} {
                my addParam [@ $param 0] [@ $param 1]
            } elseif {[@ $param 1]=="-sw"} {
                my addParam [@ $param 0] -sw
            } else {
                my addParam {*}$param
            }
        }
    } else {
        set Params ""
    }
}

method addParam {paramName value args} {

    # Adds new parameter to device, and throws error on dublicated names.
    #  paramName - 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: paramName value ?-name value? ?-eq|-poseq|-posnocheck|-pos|-nocheck?
    argparse {
        {-pos -key paramQual -value pos}
        {-eq -key paramQual -value eq}
        {-poseq -key paramQual -value poseq}
        {-posnocheck -key paramQual -value posnocheck}
        {-nocheck -key paramQual -value nocheck -default ""}
    }
    # method adds new Parameter object to the list Params
    set paramName [string tolower $paramName]
    if {[info exists Params]} {
        set paramList [dict keys $Params]
    }
    lappend paramList $paramName
    if {[my duplListCheck $paramList]} {
        return -code error "Parameters list '$paramList' has already contains parameter with name '$paramName'"
    }
    # select parameter object according to parameter qualificator
    if {$value=="-sw"} {
        dict append Params $paramName [::SpiceGenTcl::ParameterSwitch new $paramName]
    } else {
        switch $paramQual {
            pos {
                dict append Params $paramName [::SpiceGenTcl::ParameterPositional new $paramName $value]
            }
            eq {
                dict append Params $paramName [::SpiceGenTcl::ParameterEquation new $paramName $value]
            }
            poseq {
                dict append Params $paramName [::SpiceGenTcl::ParameterPositionalEquation new $paramName $value]
            }
            posnocheck {
                dict append Params $paramName [::SpiceGenTcl::ParameterPositionalNoCheck new $paramName $value]
            }
            nocheck {
                dict append Params $paramName [::SpiceGenTcl::ParameterNoCheck new $paramName $value]
            }
            default {
                dict append Params $paramName [::SpiceGenTcl::Parameter new $paramName $value]
            }
        }
    }
    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]=="true"} {
            lappend floatingPins [$pin configure -name]
        }
    }
    return $floatingPins
}

method deleteParam {paramName} {

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

method genSPICEString {} {

    # Creates device string for SPICE netlist.
    # Returns: SPICE netlist's string
    dict for {pinName pin} $Pins {
        set error [catch {$pin genSPICEString} errStr]
        if {$error!=1} {
            lappend nodes [$pin genSPICEString]
        } else {
            return -code error "Device '[my configure -name]' can't be netlisted because '$pinName' pin is floating"
        }
    }
    if {($Params=="") || ([info exists Params]==0)} {
        lappend params ""
        return "[my configure -name] [join $nodes]"
    } else {
        set params [lmap param [dict values $Params] {$param genSPICEString}]
        return "[my configure -name] [join $nodes] [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 {paramName 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.
    #  name - name of the parameter
    #  value - value of the parameter
    # Synopsis: name value ?name value ...?
    if {[llength $args]%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 $args]} {incr i 2} {
        set paramName [string tolower [@ $args [= {$i}]]]
        set paramValue [@ $args [= {$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 {pinName nodeName} {

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

method duplListCheck {list} {

    # Checks if list contains duplicates.
    #  list - list to check
    # Returns: 0 if there are no duplicates and 1 if there are.
    set flag 0
    set new {}
    foreach item $list {
        if {[lsearch $new $item] < 0} {
            lappend new $item
        } else {
            set flag 1
            break
        }
    }
    return $flag
}

method duplListCheckRet {list} {

    # Checks if list contains duplicates and return value of first duplicate.
    #  list - list to check
    # Returns: empty list if no duplicate or value of first duplicate.
    set itemDup ""
    set new {}
    foreach item $list {
        if {[lsearch $new $item] < 0} {
            lappend new $item
        } else {
            set itemDup $item
            break
        }
    }
    return $itemDup
}

method constructor {name type len {numType real}} {

    # initialize dummy trace
    #  name - name of the dummy trace
    #  type - type of dummy trace
    #  len - total number of points
    #  axis - name of axis that is linked to dummy trace
    #  numType - numerical type of dummy trace
    next $name $type $len $numType
}

method getDataPoints {} {

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

method constructor {value 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 {
        -name=
    }
    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 argsPreprocess {paramsNames args} {

    # Calls argparse and constructs list for passing to Device constructor.
    #  paramsNames - list of parameter names, define alias for parameter name by
    #  using two element list {paramName aliasName}
    #  args - argument list with key names and it's values
    # Returns: list of parameters formatted for Device/Model constructor
    set paramDefList [my buildArgStr $paramsNames]
    set arguments [argparse -inline "
        $paramDefList
    "]
    set params ""
    dict for {paramName value} $arguments {
        lappend params "$paramName $value"
    }
    return $params
}

method buildArgStr {paramsNames} {

    # Builds argument list for argparse.
    #  paramsNames - list of parameter names, define alias for parameter name by
    #  using two element list {paramName aliasName}
    # Returns: string in form *-paramName= \n {-paramName= -alias aliasName} \n ...*
    foreach paramName $paramsNames {
        if {[llength $paramName]>1} {
            lappend paramDefList "\{-[@ $paramName 0]= -alias [@ $paramName 1]\}"
        } else {
            lappend paramDefList "-${paramName}="
        }
    }
    set paramDefStr [join $paramDefList \n]
    return $paramDefStr
}

method constructor {value libValue 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 {
        -name=
    }
    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 {name type params} {

    # 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.
    my configure -name $name -type $type
    # create Params objects
    if {$params!=""} {
        foreach param $params {
            if {[@ $param 2]=={}} {
                my addParam [@ $param 0] [@ $param 1]
            } elseif {[@ $param 2]=="-eq"} {
                my addParam [@ $param 0] [@ $param 1] -eq
            } else {
                error "Wrong parameter definition in model $name"
            }
        }
    } else {
        set Params ""
    }
}

method addParam {paramName value args} {

    # Adds new parameter to device, and throws error on dublicated names.
    #  paramName - 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: paramName value ?-name value? ?-eq|-poseq|-posnocheck|-pos|-nocheck?
    argparse {
        {-pos -key paramQual -value pos}
        {-eq -key paramQual -value eq}
        {-poseq -key paramQual -value poseq}
        {-posnocheck -key paramQual -value posnocheck}
        {-nocheck -key paramQual -value nocheck -default ""}
    }
    # method adds new Parameter object to the list Params
    set paramName [string tolower $paramName]
    if {[info exists Params]} {
        set paramList [dict keys $Params]
    }
    lappend paramList $paramName
    if {[my duplListCheck $paramList]} {
        return -code error "Parameters list '$paramList' has already contains parameter with name '$paramName'"
    }
    # select parameter object according to parameter qualificator
    if {$value=="-sw"} {
        dict append Params $paramName [::SpiceGenTcl::ParameterSwitch new $paramName]
    } else {
        switch $paramQual {
            pos {
                dict append Params $paramName [::SpiceGenTcl::ParameterPositional new $paramName $value]
            }
            eq {
                dict append Params $paramName [::SpiceGenTcl::ParameterEquation new $paramName $value]
            }
            poseq {
                dict append Params $paramName [::SpiceGenTcl::ParameterPositionalEquation new $paramName $value]
            }
            posnocheck {
                dict append Params $paramName [::SpiceGenTcl::ParameterPositionalNoCheck new $paramName $value]
            }
            nocheck {
                dict append Params $paramName [::SpiceGenTcl::ParameterNoCheck new $paramName $value]
            }
            default {
                dict append Params $paramName [::SpiceGenTcl::Parameter new $paramName $value]
            }
        }
    }
    return
}

method deleteParam {paramName} {

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

method genSPICEString {} {

    # Creates model string for SPICE netlist.
    # Returns: SPICE netlist's string
    if {($Params=="") || ([info exists Params]==0)} {
        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 {paramName param} $Params {$param configure -value}]
}

method setParamValue {args} {

    # Sets (or change) value of particular parameters.
    #  name - name of the parameter
    #  value - value of the parameter
    # Synopsis: name value ?name value ...?
    if {[llength $args]%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 $args]} {incr i 2} {
        set paramName [string tolower [@ $args [= {$i}]]]
        set paramValue [@ $args [= {$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 {name} {

    # 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.
    my configure -name $name
}

method add {args} {

    # Adds elements objects to Elements dictionary.
    #  args - elements objects references
    foreach arg $args {
        set argClass [info object class $arg]
        if {$argClass in {::SpiceGenTcl::Options ::SpiceGenTcl::Analysis}} {
            return -code error "$argClass element can't be included in general netlist"
        }
        lappend elementsNamesList [string tolower [$arg configure -name]]
    }
    if {[info exists Elements]} {
        lappend elementsNamesList {*}[my getAllElemNames]
    }
    set dup [my duplListCheckRet $elementsNamesList]
    if {$dup!=""} {
        return -code error "Netlist '[my configure -name]' already contains element with name $dup"
    }
    foreach arg $args {
        set elemName [$arg configure -name]
        dict append Elements $elemName $arg
    }
    return
}

method del {args} {

    # Deletes elements from the netlist by its name.
    #  args - names of elements to delete
    if {![info exists Elements]} {
        return -code error "Netlist '[my configure -name]' doesn't have attached elements"
    }
    foreach arg $args {
        set elemName [string tolower $arg]
        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
    return [join [lmap element [dict values $Elements] {$element genSPICEString}] \n]
}

method getAllElemNames {} {

    # Gets names of all elements in netlist.
    # Returns: list of elements names
    return [dict keys $Elements]
}

method getElement {elemName} {

    # Gets particular element object reference by its name.
    #  elemName - name of element
    set elemName [string tolower $elemName]
    set error [catch {dget $Elements $elemName}]
    if {$error>0} {
        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 constructor {params 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 {
        -name=
    }
    if {[info exists name]} {
        my configure -name $name
    } else {
        my configure -name [self object]
    }
    foreach param $params {
        if {[@ $param 2]=={}} {
            if {[@ $param 1]=="-sw"} {
                my addParam [@ $param 0] -sw
            } else {
                my addParam [@ $param 0] [@ $param 1]
            }
        } else {
            return -code error "Wrong parameter definition in Options"
        }
    }
}

method addParam {paramName value} {

    # Creates new parameter object and add it to the list `Params`.
    #  paramName - name of parameter
    #  value - value of parameter, with optional qualificator -eq
    set paramName [string tolower $paramName]
    if {[info exists Params]} {
        set paramList [dict keys $Params]
    }
    lappend paramList $paramName
    if {[my duplListCheck $paramList]} {
        return -code error "Parameters list '$paramList' has already contains parameter with name '$paramName'"
    }
    if {$value=="-sw"} {
        dict append Params $paramName [::SpiceGenTcl::ParameterSwitch new $paramName]
    } else {
        dict append Params $paramName [::SpiceGenTcl::ParameterNoCheck new $paramName $value]
    }
    return
}

method deleteParam {paramName} {

    # Deletes existing `Parameter` object from list `Params`.
    #  paramName - name of parameter that will be deleted
    set paramName [string tolower $paramName]
    if {[catch {dget $Params $paramName}]} {
        return -code error "Parameter with name '$paramName' was not found in device's '[my configure -name]' list of parameters '[dict keys [my getParams]]'"
    } else {
        set Params [dict remove $Params $paramName]
    }
    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.
    #  name - name of the parameter
    #  value - value of the parameter
    # Synopsis: name value ?name value ...?
    if {[llength $args]%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 $args]} {incr i 2} {
        set paramName [string tolower [@ $args [= {$i}]]]
        set paramValue [@ $args [= {$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 {name value} {

    # 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".
    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 {name value defValue} {

    # 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`.
    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 {name value} {

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

method genSPICEString {} {

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

method constructor {name value} {

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

method constructor {name value} {

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

method genSPICEString {} {

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

method constructor {name value} {

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

method genSPICEString {} {

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

method constructor {name value} {

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

method genSPICEString {} {

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

method constructor {name} {

    # 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.
    my configure -name $name
}

method genSPICEString {} {

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

method constructor {params args} {

    # Creates object of class `ParamStatement`.
    #  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 .param statement.
    # Synopsis: params ?-name value?
    argparse {
        -name=
    }
    if {[info exists name]} {
        my configure -name $name
    } else {
        my configure -name [self object]
    }
    foreach param $params {
        if {[@ $param 2]=={}} {
            my addParam [@ $param 0] [@ $param 1]
        } elseif {[@ $param 2]=="-eq"} {
            my addParam [@ $param 0] [@ $param 1] -eq
        } else {
            error "Wrong parameter definition in ParamStatement"
        }
    }
}

method addParam {paramName value args} {

    # Adds new Parameter object to the list Params.
    #  paramName - name of parameter
    #  value - value of parameter
    #  -eq - optional parameter qualificator
    # Synopsis: paramName value ?-eq?
    argparse {
        -eq
    }
    set paramName [string tolower $paramName]
    if {[info exists Params]} {
        set paramList [dict keys $Params]
    }
    lappend paramList $paramName
    if {[my duplListCheck $paramList]} {
        return -code error "Parameters list '$paramList' has already contains parameter with name '$paramName'"
    }
    if {[info exists eq]} {
        dict append Params $paramName [::SpiceGenTcl::ParameterEquation new $paramName $value]
    } else {
        dict append Params $paramName [::SpiceGenTcl::Parameter new $paramName $value]
    }
    return
}

method deleteParam {paramName} {

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

method genSPICEString {} {

    # Creates parameter statement string for SPICE netlist.
    # Returns: SPICE netlist's string
    return ".param [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 {paramName param} $Params {$param configure -value}]
}

method setParamValue {args} {

    # Sets (or change) value of particular parameters.
    #  name - name of the parameter
    #  value - value of the parameter
    # Synopsis: name value ?name value ...?
    if {[llength $args]%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 $args]} {incr i 2} {
        set paramName [string tolower [@ $args [= {$i}]]]
        set paramValue [@ $args [= {$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 {name nodeName} {

    # Creates object of class `Pin` with name and connected node
    #  name - name of the pin
    #  nodeName - name of the node that connected to pin
    # Class models electrical pin of device/subcircuit,
    # it has name and name of the node connected to it.
    # It has general interface method `genSPICEString` that returns
    # name of the node connected to it, this method must be called only
    # in method with the same name in other classes. We can check if pin is
    # floating by checking the name of connected node in method `checkFloating` -
    # if is contains empty string it is floating.
    # Floating pin can't be netlisted, so it throws error when try to
    # do so. Set pin name empty by special method `unsetNodeName`.
    my configure -name $name -nodename $nodeName
}

method checkFloating {} {

    # Determines if pin is connected to the node.
    # Returns: `true` if connected and `false` if not
    if {[my configure -nodename]=={}} {
        set floating true
    } else {
        set floating false
    }
    return $floating
}

method genSPICEString {} {

    # Creates string for SPICE netlist.
    # Returns: SPICE netlist's string
    if {[my checkFloating]=="true"} {
        return -code error "Pin '[my configure -name]' is not connected to the node so can't be netlisted"
    }
    return "[my configure -nodename]"
}

method unsetNodeName {} {

    # Makes pin floating by setting `nodename` with empty string.
    my configure -nodename {}
}

method constructor {path {traces2read *} {simulator ngspice}} {

                # Creates RawFile object.
                #  path - path to raw file including it's file name
                #  traces2read - list of traces that will be readed, default value is \*,
                #   that means reading all traces
                #  simulator - simulator that produced this raw file, default is ngspice
                my configure -Path $path
                set fileSize [file size $path]
                set file [open $path r]
                fconfigure $file -translation binary

    ####  read header

                set ch [read $file 6]
                if {$ch=={Title:}} {
                    set encSize 1
                    set encode "utf-8"
                    set line "Title:"
                } elseif {$ch=={Tit}} {
                    set encSize 2
                    set encode "utf-16-le"
                    set line "Tit"
                } else {
                    error "Unknown encoding"
                }
                my configure -RawParams [dcreate Filename $path]
                set header ""
                set binaryStart 6
                while true {
                    set ch [read $file $encSize]
                    incr binaryStart $encSize
                    if {$ch=="\n"} {
                        if {$encode=="utf-8"} {
                            set line [string trimright $line "\r"]
                        }
                        lappend header $line
                        if {$line in {Binary: Values:}} {
                            set rawType $line
                            break
                        }
                        set line ""
                    } else {
                        append line $ch
                    }
                }

    ####  save header parameters

                foreach line $header {
                    set lineList [split $line ":"]
                    if {[@ $lineList 0]=="Variables"} {
                        break
                    }
                    dict append RawParams [@ $lineList 0] [string trim [@ $lineList 1]]
                }
                my configure -NPoints [dget [my configure -RawParams] "No. Points"] -NVariables [dget [my configure -RawParams] "No. Variables"]
                if {[dget [my configure -RawParams] "Plotname"] in {"Operating Point" "Transfet Function"}} {
                    set hasAxis 0
                } else {
                    set hasAxis 1
                }
                set flags [split [dget [my configure -RawParams] "Flags"]]
                if {("complex" in $flags) || ([dget [my configure -RawParams] "Plotname"]=="AC Analysis")} {
                    set numType complex
                } else {
                    if {("double" in $flags) || ($simulator=="ngspice")} {
                        set numType double
                    } else {
                        set numType real
                    }
                }

    ####  parse variables

                set i [lsearch $header "Variables:"]
                set ivar 0
                foreach line [lrange $header [+ $i 1] end-1] {
                    set lineList [split [string trim $line] \t]
                    lassign $lineList idx name varType
                    if {$ivar==0} {
                        if {$numType=="real"} {
                            set axisNumType double
                        } else {
                            set axisNumType $numType
                        }
                        my configure -Axis [::SpiceGenTcl::Axis new $name $varType $NPoints $axisNumType]
                        set trace $Axis
                    } elseif {($traces2read=="*") || ($name in $traces2read)} {
                        if {$hasAxis} {
                            set trace [::SpiceGenTcl::Trace new $name $varType $NPoints [[my configure -Axis] configure -name] $numType]
                        } else {
                            set trace [::SpiceGenTcl::Trace new $name $varType $NPoints {} $numType]
                        }
                    } else {
                        set trace [::SpiceGenTcl::EmptyTrace new $name $varType $NPoints $numType]
                    }
                    lappend Traces $trace
                    incr ivar
                }
                if {($traces2read=="") || ([llength $traces2read]==0)} {
                    close $file
                    return
                }

    ####  read data

                if {$rawType=="Binary:"} {
                    my configure -BlockSize [= {($fileSize - $binaryStart)/$NPoints}]
                    set scanFunctions ""
                    set calcBlockSize 0
                    foreach trace [my configure -Traces] {
                        if {[$trace configure -NumType]=="double"} {
                            incr calcBlockSize 8
                            if {[info object class $trace ::SpiceGenTcl::EmptyTrace]} {
                                set fun skip8bytes
                            } else {
                                set fun readFloat64
                            }
                        } elseif {[$trace configure -NumType]=="complex"} {
                            incr calcBlockSize 16
                            if {[info object class $trace ::SpiceGenTcl::EmptyTrace]} {
                                set fun skip16bytes
                            } else {
                                set fun readComplex
                            }
                        } elseif {[$trace configure -NumType]=="real"} {
                            incr calcBlockSize 4
                            if {[info object class $trace ::SpiceGenTcl::EmptyTrace]} {
                                set fun skip4bytes
                            } else {
                                set fun readFloat32
                            }
                        } else {
                            error "Invalid data type '[$trace configure -NumType]' for trace '[$trace configure -name]'"
                        }
                        lappend scanFunctions $fun
                    }
                    if {$calcBlockSize!=[my configure -BlockSize]} {
                        error "Error in calculating the block size. Expected '[my configure -BlockSize]' bytes, but found '$calcBlockSize' bytes"
                    }
                     for {set i 0} {$i<$NPoints} {incr i} {
                        for {set j 0} {$j<[llength [my configure -Traces]]} {incr j} {
                            set value [eval "my [@ $scanFunctions $j]" $file]
                            set trace [@ [my configure -Traces] $j]
                            if {[info object class $trace]!="::SpiceGenTcl::EmptyTrace"} {
                                $trace appendDataPoints $value
                            }
                        }
                    }
                } elseif {$rawType=="Values:"} {
                    for {set i 0} {$i<$NPoints} {incr i} {
                        set firstVar true
                        for {set j 0} {$j<[llength [my configure -Traces]]} {incr j} {
                            set line [gets $file]
                            if {$line==""} {
                                continue
                            }
                            set lineList [textutil::split::splitx $line]
                            if {$firstVar=="true"} {
                                set firstVar false
                                set sPoint [@ $lineList 0]
                                if {$i!=int($sPoint)} {
                                    error "Error reading file"
                                }
                                if {$numType=="complex"} {
                                    set value [split [@ $lineList 1] ","]
                                } else {
                                    set value [@ $lineList 1]
                                }
                            } else {
                                if {$numType=="complex"} {
                                    set value [split [@ $lineList 1] ","]
                                } else {
                                    set value [@ $lineList 1]
                                }
                            }
                            set trace [@ [my configure -Traces] $j]
                            $trace appendDataPoints $value
                        }
                    }
                }
                close $file
}