::SpiceGenTclTop, Main, Index

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} ...}`
    #  args - optional argument *-name*
    # Class models analysis statement.
    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 {[lindex $param 2]=={}} {
            my addParam [lindex $param 0] [lindex $param 1]
        } elseif {[lindex $param 1]=="-sw"} {
            my addParam [lindex $param 0] -sw
        } else {
            my addParam {*}$param
        }
    }
}

method addParam {paramName value args} {

    # Adds new Parameter object to the list `Params`.
    #  paramName - name of parameter
    #  value - value of parameter
    #  args - optional arguments *-eq* or *-posnocheck* as parameter qualificators
    set arguments [argparse {
        {-eq -forbid {posnocheck}}
        {-poseq -forbid {posnocheck}}
        {-posnocheck -forbid {eq}}
        {-pos -forbid {eq}}
        {-nocheck -forbid {eq}}
    }]
    set paramName [string tolower $paramName]
    if {[info exists Params]} {
        set paramList [dict keys $Params]
    }
    lappend paramList $paramName
    if {[my duplListCheck $paramList]} {
        error "Parameters list \{$paramList\} has already contains parameter with name \{$paramName\}"
    }
    if {$value=="-sw"} {
        dict append Params $paramName [::SpiceGenTcl::ParameterSwitch new $paramName]
    } elseif {[info exists eq]} {
        dict append Params $paramName [::SpiceGenTcl::ParameterEquation new $paramName $value]
    } elseif {[info exists poseq]} {
        dict append Params $paramName [::SpiceGenTcl::ParameterPositionalEquation new $paramName $value]
    } elseif {[info exists posnocheck]} {
        dict append Params $paramName [::SpiceGenTcl::ParameterPositionalNoCheck new $paramName $value]
    } elseif {[info exists pos]} {
        dict append Params $paramName [::SpiceGenTcl::ParameterPositional new $paramName $value]
    } elseif {[info exists nocheck]} {
        dict append Params $paramName [::SpiceGenTcl::ParameterNoCheck 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]
    set error [catch {dict get $Params $paramName}]
    if {$error>0} {
        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 '.$Type $Params'
    if {[info exists Params]} {
        dict for {paramName param} $Params {
            lappend params [$param genSPICEString]
        }
        return ".[my configure -Type] [join $params]"
    } 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
    set tempDict [dict create]
    dict for {paramName param} $Params {
        dict append tempDict $paramName [$param configure -Value]
    }
    return $tempDict
}

method setParamValue {paramName value} {

    # Sets (or changes) value of particular parameter.
    #  paramName - name of parameter
    #  value - the new value of parameter
    set paramName [string tolower $paramName]
    set error [catch {dict get $Params $paramName}]
    if {$error>0} {
        error "Parameter with name '$paramName' was not found in parameter analysis's '[my configure -Name]' list of parameters '[dict keys [my getParams]]'"
    } else {
        set param [dict get $Params $paramName]
    }
    $param configure -Value $value
    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 `Simulator`
    # object reference to make it able to run simulation. Results of last simulation attached as `RawData` class object
    # and can be retrieved by `getData` method.
    next $name
}

method add {element} {

    # Adds elements object to Elements dictionary.
    #  element - element object reference
    my variable Elements
    set elemName [string tolower [$element configure -Name]]
    if {([info object class $element {::SpiceGenTcl::Analysis}]) && ([info exists ContainAnalysis])} {
        error "Netlist '[my configure -Name]' already contains Analysis element"
    } elseif {[info object class $element {::SpiceGenTcl::Analysis}]} {
        set ContainAnalysis ""
    }
    if {[info exists Elements]} {
        set elemList [my getAllElemNames]
    }
    lappend elemList $elemName
    if {[my duplListCheck $elemList]} {
        error "Netlist '[my configure -Name]' already contains element with name $elemName"
    }
    dict append Elements [$element configure -Name] $element
    return
}

method del {elemName} {

    # Deletes element from the circuit by its name.
    #  elemName - name of element to delete
    my variable Elements
    set elemName [string tolower $elemName]
    set error [catch {dict get $Elements $elemName}]
    if {$error>0} {
        error "Element with name '$elemName' was not found in device's '[my configure -Name]' list of elements"
    } else {
        set Elements [dict remove $Elements $elemName]
        if {[info object class [dict get $Elements $elemName] {::SpiceGenTcl::Analysis}]} {
            unset ContainAnalysis
        }
    }
    return
}

method detachSimulator {} {

    # Removes `Simulator` object reference from `Circuit`.
    unset Simulator
    return
}

method genSPICEString {} {

    # Creates circuit string for SPICE netlist.
    # Returns: 'circuit string'
    my variable Elements
    lappend totalStr [my configure -Name]
    dict for {elemName element} $Elements {
        lappend totalStr [$element genSPICEString]
    }
    return [join $totalStr \n]
}

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
    my variable Elements
    set elemName [string tolower $elemName]
    set error [catch {dict get $Elements $elemName}]
    if {$error>0} {
        error "Element with name '$elemName' was not found in netlist's '[my configure -Name]' list of elements"
    } else {
        set foundElem [dict get $Elements $elemName]
    }
    return $foundElem
}

method runAndRead {} {

    # Invokes 'runAndRead', 'configure -Log' and 'configure -Data' methods from attached simulator.
    if {[info exists Simulator]==0} {
        error "Simulator is not attached to '[my configure -Name]' circuit"
    }
    $Simulator runAndRead [my genSPICEString]
    my configure -Log [$Simulator configure -Log]
    my configure -Data [$Simulator configure -Data]
}

method constructor {value args} {

    # Creates object of class `Comment`.
    #  value - value of the comment
    #  args - optional argument -name - represent name of comment string
    # Class represent comment string, it can be a multiline comment.
    set arguments [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: string '*$Value'
    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
    my configure -Type $type
    my configure -Len $len
    my configure -NumType $numType
}

method appendDataPoints {dataPoint} {

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

method getDataPoints {} {

    if {[info exists DataPoints]} {
        return $DataPoints
    } else {
        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 [lindex $pin 0] [lindex $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 {[lindex $param 2]=={}} {
                my addParam [lindex $param 0] [lindex $param 1]
            } elseif {[lindex $param 1]=="-sw"} {
                my addParam [lindex $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
    #  args - optional arguments that adds qualificator to parameter: -pos - positional parameter, -eq -
    #  equational parameter, -poseq - positional equation parameter
    set arguments [argparse {
        {-pos -forbid {poseq}}
        {-eq -forbid {poseq}}
        {-poseq -forbid {pos eq}}
        {-posnocheck -forbid {poseq eq pos}}
        {-nocheck -forbid {pos eq poseq}}
    }]
    # 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]} {
        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]
    } elseif {[info exists pos]} {
        dict append Params $paramName [::SpiceGenTcl::ParameterPositional new $paramName $value]
    } elseif {[info exists eq]} {
        dict append Params $paramName [::SpiceGenTcl::ParameterEquation new $paramName $value]
    } elseif {[info exists poseq]} {
        dict append Params $paramName [::SpiceGenTcl::ParameterPositionalEquation new $paramName $value]
    } elseif {[info exists posnocheck]} {
        dict append Params $paramName [::SpiceGenTcl::ParameterPositionalNoCheck new $paramName $value]
    } elseif {[info exists nocheck]} {
        dict append Params $paramName [::SpiceGenTcl::ParameterNoCheck new $paramName $value]
    } else {
        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]
    set error [catch {dict get $Params $paramName}]
    if {$error>0} {
        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: string '$Name $Nodes $Params'
    dict for {pinName pin} $Pins {
        set error [catch {$pin genSPICEString} errStr]
        if {$error!=1} {
            lappend nodes [$pin genSPICEString]
        } else {
            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 {
        dict for {paramName param} $Params {
            lappend 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
    set tempDict [dict create]
    dict for {paramName param} $Params {
        dict append tempDict $paramName [$param configure -Value]
    }
    return $tempDict
}

method getPins {} {

    # Gets the dictionary that contains pin name as keys and
    #  connected node name as the values.
    # Returns: parameters dictionary
    set tempDict [dict create]
    dict for {pinName pin} $Pins {
        dict append tempDict $pinName [$pin configure -NodeName]
    }
    return $tempDict
}

method setParamValue {paramName value} {

    # Sets (or change) value of particular parameter.
    #  paramName - name of parameter
    #  value - new value of parameter
    set paramName [string tolower $paramName]
    set error [catch {dict get $Params $paramName}]
    if {$error>0} {
        error "Parameter with name '$paramName' was not found in device's '[my configure -Name]' list of parameters '[dict keys [my getParams]]'"
    } else {
        set param [dict get $Params $paramName]
    }
    $param configure -Value $value
    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 {dict get $Pins $pinName}]
    if {$error>0} {
        error "Pin with name '$pinName' was not found in device's '[my configure -Name]' list of pins '[dict keys [my getPins]]'"
    } else {
        set pin [dict get $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 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
    #  args - optional argument -name - represent name of include statement
    # This class represent .include statement.
    set arguments [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: '.include $Value'
    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: string in form *-paramName= \n {-paramName= -alias aliasName} \n ...*
    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 "\{-[lindex $paramName 0]= -alias [lindex $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
    #  args - optional argument -name - represent name of library statement
    # Class represent .lib statement.
    set arguments [argparse {
        -name=
    }]
    if {[info exists name]} {
        my configure -Name $name
    } else {
        my configure -Name [self object]
    }
    my configure -Value $value
    my configure -LibValue $libValue
}

method genSPICEString {} {

    # Creates library string for SPICE netlist.
    # Returns: '.lib $Value $LibValue'
    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
    my configure -Type $type
    # create Params objects
    if {$params!=""} {
        foreach param $params {
            if {[lindex $param 2]=={}} {
                my addParam [lindex $param 0] [lindex $param 1]
            } elseif {[lindex $param 2]=="-eq"} {
                my addParam [lindex $param 0] [lindex $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
    #  args - optional arguments that adds qualificator to parameter: -pos - positional parameter, -eq -
    #  equational parameter, -poseq - positional equation parameter
    set arguments [argparse {
        {-pos -forbid {poseq}}
        {-eq -forbid {poseq}}
        {-poseq -forbid {pos eq}}
        {-posnocheck -forbid {poseq eq pos}}
        {-nocheck -forbid {pos eq poseq}}
    }]
    # 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]} {
        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]
    } elseif {[info exists pos]} {
        dict append Params $paramName [::SpiceGenTcl::ParameterPositional new $paramName $value]
    } elseif {[info exists eq]} {
        dict append Params $paramName [::SpiceGenTcl::ParameterEquation new $paramName $value]
    } elseif {[info exists poseq]} {
        dict append Params $paramName [::SpiceGenTcl::ParameterPositionalEquation new $paramName $value]
    } elseif {[info exists posnocheck]} {
        dict append Params $paramName [::SpiceGenTcl::ParameterPositionalNoCheck new $paramName $value]
    } elseif {[info exists nocheck]} {
        dict append Params $paramName [::SpiceGenTcl::ParameterNoCheck 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]
    set error [catch {dict get $Params $paramName}]
    if {$error>0} {
        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: string '.model $Name $Type $Params'
    if {($Params=="") || ([info exists Params]==0)} {
        lappend params ""
        return ".model [my configure -Name] [my configure -Type]"
    } else {
        dict for {paramName param} $Params {
            lappend 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
    set tempDict [dict create]
    dict for {paramName param} $Params {
        dict append tempDict $paramName [$param configure -Value]
    }
    return $tempDict
}

method setParamValue {paramName value} {

    # Sets (or change) value of particular parameter.
    #  paramName - name of parameter
    #  value - new value of parameter
    set paramName [string tolower $paramName]
    set error [catch {dict get $Params $paramName}]
    if {$error>0} {
        error "Parameter with name '$paramName' was not found in device's '[my configure -Name]' list of parameters '[dict keys [my getParams]]'"
    } else {
        set param [dict get $Params $paramName]
    }
    $param configure -Value $value
    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 {element} {

    # Adds elements object to Elements dictionary.
    #  element - element object reference
    set elementClass [info object class $element]
    if {$elementClass=={::SpiceGenTcl::Options}} {
        error "Options element can't be included in general netlist, only top-level Circuit"
    } elseif {$elementClass=={::SpiceGenTcl::Analysis}} {
        error "Analysis element can't be included in general netlist, only top-level Circuit"
    }
    set elemName [string tolower [$element configure -Name]]
    if {[info exists Elements]} {
        set elemList [my getAllElemNames]
    }
    lappend elemList $elemName
    if {[my duplListCheck $elemList]} {
        error "Netlist '[my configure -Name]' already contains element with name $elemName"
    }
    dict append Elements [$element configure -Name] $element
    return
}

method del {elemName} {

    # Deletes element from the netlist by its name.
    #  elemName - name of element to delete
    set elemName [string tolower $elemName]
    set error [catch {dict get $Elements $elemName}]
    if {$error>0} {
        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: 'netlist string'
    dict for {elemName element} $Elements {
        lappend totalStr [$element genSPICEString]
    }
    return [join $totalStr \n]
}

method getAllElemNames {} {

    # Gets names of all elements in netlist.
    # Returns: list of elements names
    dict for {elemName elem} $Elements {
        lappend names $elemName
    }
    return $names
}

method getElement {elemName} {

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

method constructor {params args} {

    # Creates object of class `Options`.
    #  name - name of the parameter
    #  params - list of instance parameters in form `{{Name Value ?-sw?} {Name Value ?-sw?} {Name Value ?-sw?} ...}`
    #  args - optional argument -name - represent name of library statement
    # This class represent .options statement.
    set arguments [argparse {
        -name=
    }]
    if {[info exists name]} {
        my configure -Name $name
    } else {
        my configure -Name [self object]
    }
    foreach param $params {
        if {[lindex $param 2]=={}} {
            if {[lindex $param 1]=="-sw"} {
                my addParam [lindex $param 0] -sw
            } else {
                my addParam [lindex $param 0] [lindex $param 1]
            }
        } else {
            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]} {
        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]
    set error [catch {dict get $Params $paramName}]
    if {$error>0} {
        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: '.options $Params'
    dict for {paramName param} $Params {
        lappend params [$param genSPICEString]
    }
    return ".options [join $params]"
}

method getParams {} {

    # Gets the dictionary that contains parameter name as keys and
    #  parameter values as the values.
    # Returns: parameters dictionary
    set tempDict [dict create]
    dict for {paramName param} $Params {
        # check if parameter doesn't have value, it means that we return {} for switch parameter
        if {[catch {$param configure -Value}]} {
            dict append tempDict $paramName ""
        } else {
            dict append tempDict $paramName [$param configure -Value]
        }
    }
    return $tempDict
}

method setParamValue {paramName value} {

    # Sets (or changes) value of particular parameter
    #  it throws a error if try to set a value of switch parameter.
    #  paramName - name of parameter
    #  value - new value of parameter
    set paramName [string tolower $paramName]
    set error [catch {dict get $Params $paramName}]
    if {$error>0} {
        error "Parameter with name '$paramName' was not found in options's '[my configure -Name]' list of parameters '[dict keys [my getParams]]'"
    } else {
        set param [dict get $Params $paramName]
    }
    $param configure -Value $value
    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
    my configure -Value $value
}

method genSPICEString {} {

    # Creates string for SPICE netlist.
    # Returns: '$Name=$Value'
    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: '$Name={$Value}'
    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: '$Value'
    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: '{$paramValue}'
    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: '$Value'
    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} ...}`
    #  args - optional argument -name - represent name of library statement
    # Class represent .param statement.
    set arguments [argparse {
        -name=
    }]
    if {[info exists name]} {
        my configure -Name $name
    } else {
        my configure -Name [self object]
    }
    foreach param $params {
        if {[lindex $param 2]=={}} {
            my addParam [lindex $param 0] [lindex $param 1]
        } elseif {[lindex $param 2]=="-eq"} {
            my addParam [lindex $param 0] [lindex $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
    #  args - optional parameter qualificator -eq
    set arguments [argparse {
        -eq
    }]
    set paramName [string tolower $paramName]
    if {[info exists Params]} {
        set paramList [dict keys $Params]
    }
    lappend paramList $paramName
    if {[my duplListCheck $paramList]} {
        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]
    set error [catch {dict get $Params $paramName}]
    if {$error>0} {
        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: '.param $Params'
    dict for {paramName param} $Params {
        lappend params [$param genSPICEString]
    }
    return ".param [join $params]"
}

method getParams {} {

    # Gets the dictionary that contains parameter name as keys and
    #  parameter values as the values.
    # Returns: parameters dictionary
    set tempDict [dict create]
    dict for {paramName param} $Params {
        dict append tempDict $paramName [$param configure -Value]
    }
    return $tempDict
}

method setParamValue {paramName value} {

    # Sets (or changes) value of particular parameter.
    #  paramName - name of parameter
    #  value - new value of parameter
    set paramName [string tolower $paramName]
    set error [catch {dict get $Params $paramName}]
    if {$error>0} {
        error "Parameter with name '$paramName' was not found in parameter statement's '[my configure -Name]' list of parameters '[dict keys [my getParams]]'"
    } else {
        set param [dict get $Params $paramName]
    }
    $param configure -Value $value
    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
    my configure -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: string '*$NodeName*'
    if {[my checkFloating]=="true"} {
        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 [dict create 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 {[lindex $lineList 0]=="Variables"} {
                        break
                    }
                    dict append RawParams [lindex $lineList 0] [string trim [lindex $lineList 1]]
                }
                my configure -NPoints [dict get [my configure -RawParams] "No. Points"]
                my configure -NVariables [dict get [my configure -RawParams] "No. Variables"]
                if {[dict get [my configure -RawParams] "Plotname"] in {"Operating Point" "Transfet Function"}} {
                    set hasAxis 0
                } else {
                    set hasAxis 1
                }
                set flags [split [dict get [my configure -RawParams] "Flags"]]
                if {("complex" in $flags) || ([dict get [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 [expr {($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 [lindex $scanFunctions $j]" $file]
                            set trace [lindex [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]] 1]} {incr j} {
                            set line [gets $file]
                            if {$line==""} {
                                continue
                            }
                            set lineList [textutil::split::splitx $line]
                            if {$firstVar=="true"} {
                                set firstVar false
                                set sPoint [lindex $lineList 1]
                                if {$i!=int($sPoint)} {
                                    error "Error reading file"
                                }
                                if {$numType=="complex"} {
                                    set value [split [lindex $lineList 2] ","]
                                } else {
                                    set value [lindex $lineList 2]
                                }
                            } else {
                                if {$numType=="complex"} {
                                    set value [split [lindex $lineList 1] ","]
                                } else {
                                    set value [lindex $lineList 1]
                                }
                            }
                            set trace [lindex [my configure -Traces] $j]
                            $trace appendDataPoints $value
                        }
                    }
                }
                close $file
}

method getCurrentsNames {} {

    # Returns list that contains names of all current variables
    foreach trace [my configure -Traces] {
        if {[$trace configure -Type]=="current"} {
            lappend currNames [$trace configure -Name]
        }
    }
    return $currNames
}

method getTrace {traceName} {

    # Returns trace object reference by it's name
    set traceFoundFlag false
    foreach trace [my configure -Traces] {
        if {[$trace configure -Name]==$traceName} {
            set traceFound $trace
            set traceFoundFlag true
            break
        }
    }
    if {$traceFoundFlag==false} {
        error "Trace with name '$traceName' was not found in raw file '[my configure -Path]' list of traces"
    }
    return $traceFound
}

method getTracesData {} {

    # Returns dictionary that contains all data in value and name as a key
    set dict [dict create]
    foreach trace [my configure -Traces] {
        dict append dict [$trace configure -Name] [$trace getDataPoints]
    }
    return $dict
}

method getTracesStr {} {

    # Returns information about all Traces in raw file in form of string
    foreach trace [my configure -Traces] {
        lappend tracesList "[$trace configure -Name] [$trace configure -Type] [$trace configure -NumType]"
    }
    return $tracesList
}

method getVariablesNames {} {

    # Returns list that contains names of all variables
    foreach trace [my configure -Traces] {
        lappend tracesNames [$trace configure -Name]
    }
    return $tracesNames
}

method getVoltagesNames {} {

    # Returns list that contains names of all voltage variables
    foreach trace [my configure -Traces] {
        if {[$trace configure -Type]=="voltage"} {
            lappend voltNames [$trace configure -Name]
        }
    }
    return $voltNames
}

method constructor {value args} {

    # Creates object of class `RawString`.
    #  value - value of the raw string
    # Class represent arbitary string.
    #  It can be used to pass any string directly into netlist,
    #  for example, it can add elements that doesn't have dedicated class.
    set arguments [argparse {
        -name=
    }]
    if {[info exists name]} {
        my configure -Name $name
    } else {
        my configure -Name [self object]
    }
    my configure -Value $value
}