::SpiceGenTcl::Xyce::SemiconductorDevicesTop, Main, Index

method constructor {name ncNode nbNode neNode args} {

    # Creates object of class `Bjt` that describes semiconductor bipolar junction transistor device.
    #  name - name of the device without first-letter designator Q
    #  ncNode - name of node connected to collector pin
    #  nbNode - name of node connected to base pin
    #  neNode - name of node connected to emitter pin
    #  -model - name of the model
    #  -area - scale factor, optional
    #  -m - multiplier of area and perimeter, optional
    #  -temp - device temperature, optional
    #  -ic1 - initial conditions for vbe, optional
    #  -ic2 - initial conditions for vce, optional
    #  -ns - name of node connected to substrate pin, optional
    #  -tj - name of node connected to thermal pin, optional, requires -ns
    # ```
    # QXXXXXXX nc nb ne <ns> <tj> mname <area=val> <areac=val>
    # + <areab=val> <m=val> <off> <ic=vbe,vce> <temp=val>
    # + <dtemp=val>
    # ```
    # Example of class initialization:
    # ```
    # ::SpiceGenTcl::Xyce::SemiconductorDevices::Bjt new 1 netc netb nete -model bjtmod -ns nets -area 1e-3
    # ```
    set arguments [argparse -inline {
        {-model= -required}
        -area=
        -m=
        -temp=
        {-off -boolean}
        -ic1=
        -ic2=
        -ns=
        {-tj= -require {ns}}
    }]
    lappend params "model [dict get $arguments model] -posnocheck"
    if {[dict exists $arguments area]} {
        set areaVal [dict get $arguments area]
        if {([llength $areaVal]>1) && ([lindex $areaVal 1]=="-eq")} {
            lappend params "area [lindex $areaVal 0] -poseq"
        } else {
            lappend params "area $areaVal -pos"
        }
    }
    dict for {paramName value} $arguments {
        if {$paramName ni {model area off ns tj}} {
            lappend params "$paramName $value"
        }
    }
    set pinList [list "nc $ncNode" "nb $nbNode" "ne $neNode"]
    if {[dict exists $arguments ns]} {
        lappend pinList "ns [dict get $arguments ns]"
        if {[dict exists $arguments tj]} {
            lappend pinList "tj [dict get $arguments tj]"
        }
    }
    next q$name $pinList $params
}

method genSPICEString {} {

    # Modify substrate pin string in order to complain square brackets enclosure,
    # see BJT info in reference manual of Xyce
    set SPICEStr [next]
    if {[dict exists [my getPins] ns]} {
        set SPICEList [split $SPICEStr]
        set SPICEStr [join [lreplace $SPICEList 4 4 "\[[lindex $SPICEList 4]\]"]]
    }
    return $SPICEStr
}

method constructor {name npNode nmNode args} {

    # Creates object of class `Diode` that describes semiconductor diode device.
    #  name - name of the device without first-letter designator D
    #  npNode - name of node connected to positive pin
    #  nmNode - name of node connected to negative pin
    #  -model - name of the model
    #  -area - area scale factor, optional
    #  -m - multiplier of area and perimeter, optional
    #  -pj - perimeter scale factor, optional
    #  -ic - initial condition, optional
    #  -temp - device temperature, optional
    #  -custparams - key that collects all arguments at the end of device definition, to provide an ability
    #  to add custom parameters in form `-custparams param1 param1Val param2 {param2eq -eq} param3 param3Val ...`
    #  Must be specified after all others options. Optional.
    # ```
    # D<name> <(+) node> <(-) node> <model name> [device parameters]
    # ```
    # Example of class initialization:
    # ```
    # ::SpiceGenTcl::Xyce::SemiconductorDevices::Diode new 1 netp netm -model diomod -area 1e-6
    # ```
    set arguments [argparse -inline {
        {-model= -required}
        -area=
        -pj=
        -ic=
        -m=
        -temp=
        {-custparams -catchall}
    }]
    lappend params "model [dict get $arguments model] -posnocheck"
    if {[dict exists $arguments area]} {
        set areaVal [dict get $arguments area]
        if {([llength $areaVal]>1) && ([lindex $areaVal 1]=="-eq")} {
            lappend params "area [lindex $areaVal 0] -poseq"
        } else {
            lappend params "area $areaVal -pos"
        }
    }
    if {[dict exists $arguments pj]} {
        set pjVal [dict get $arguments pj]
        if {([llength $pjVal]>1) && ([lindex $pjVal 1]=="-eq")} {
            lappend params "pj [lindex $pjVal 0] -poseq"
        } else {
            lappend params "pj $pjVal -pos"
        }
    }
    dict for {paramName value} $arguments {
        if {$paramName ni {model custparams area pj}} {
            lappend params "$paramName $value"
        }
    }
    if {[dict get $arguments custparams]!=""} {
        if {[llength [dict get $arguments custparams]]%2!=0} {
            error "Custom parameters list must be even length"
        }
        set custParamDict [dict create {*}[dict get $arguments custparams]]
        dict for {paramName value} $custParamDict {
            lappend params "$paramName $value"
        }
    }
    next d$name [list "np $npNode" "nm $nmNode"] $params
}

method constructor {name ndNode ngNode nsNode args} {

    # Creates object of class `Jfet` that describes semiconductor junction FET device.
    #  name - name of the device without first-letter designator J
    #  ndNode - name of node connected to drain pin
    #  ngNode - name of node connected to gate pin
    #  nsNode - name of node connected to source pin
    #  -model - name of the model
    #  -area - scale factor, optional
    #  -temp - device temperature, optional
    # ```
    # J<name> <drain node> <gate node> <source node> <model name> [area value] [device parameters]
    # ```
    # Example of class initialization:
    # ```
    # ::SpiceGenTcl::Xyce::SemiconductorDevices::Jfet new 1 netd netg nets -model jfetmod -area {area*2 -eq} -temp 25
    # ```
    set arguments [argparse -inline {
        {-model= -required}
        -area=
        -temp=
    }]
    lappend params "model [dict get $arguments model] -posnocheck"
    if {[dict exists $arguments area]} {
        set areaVal [dict get $arguments area]
        if {([llength $areaVal]>1) && ([lindex $areaVal 1]=="-eq")} {
            lappend params "area [lindex $areaVal 0] -poseq"
        } else {
            lappend params "area $areaVal -pos"
        }
    }
    dict for {paramName value} $arguments {
        if {$paramName ni {model area}} {
            lappend params "$paramName $value"
        }
    }
    next j$name [list "nd $ndNode" "ng $ngNode" "ns $nsNode"] $params
}

method constructor {name ndNode ngNode nsNode args} {

    # Creates object of class `Mesfet` that describes semiconductor MESFET device.
    #  name - name of the device without first-letter designator Z
    #  ndNode - name of node connected to drain pin
    #  ngNode - name of node connected to gate pin
    #  nsNode - name of node connected to source pin
    #  -model - name of the model
    #  -area - emitter scale factor, optional
    #  -temp - device temperature, optional
    # ```
    # Z<name> < drain node> <gate node> <source node> <model name> [area value] [device parameters]
    # ```
    # Example of class initialization:
    # ```
    # ::SpiceGenTcl::Xyce::SemiconductorDevices::Mesfet new 1 netd netg nets -model mesfetmod -area {area*2 -eq}
    # ```
    set arguments [argparse -inline {
        {-model= -required}
        -area=
        -temp=
    }]
    lappend params "model [dict get $arguments model] -posnocheck"
    if {[dict exists $arguments area]} {
        set areaVal [dict get $arguments area]
        if {([llength $areaVal]>1) && ([lindex $areaVal 1]=="-eq")} {
            lappend params "area [lindex $areaVal 0] -poseq"
        } else {
            lappend params "area $areaVal -pos"
        }
    }
    dict for {paramName value} $arguments {
        if {$paramName ni {model area}} {
            lappend params "$paramName $value"
        }
    }
    next z$name [list "nd $ndNode" "ng $ngNode" "ns $nsNode"] $params
}

method constructor {name ndNode ngNode nsNode args} {

    # Creates object of class `Mosfet` that describes semiconductor MOSFET device.
    #  name - name of the device without first-letter designator M
    #  ndNode - name of node connected to drain pin
    #  ngNode - name of node connected to gate pin
    #  nsNode - name of node connected to source pin
    #  -model - name of the model
    #  -m - multiplier, optional
    #  -l - length of channel, optional
    #  -w - width of channel, optional
    #  -ad - diffusion area of drain, optional, forbid -nrd
    #  -as - diffusion area of source, optional,forbid -nrs
     #  -pd - perimeter area of drain, optional
    #  -ps - perimeter area of source, optional
    #  -nrd - equivalent number of squares of the drain diffusions
    #  -nrs - equivalent number of squares of the source diffusions
    #  -temp - device temperature
    #  -ic - initial conditions for vds, vgs and vbs, in form of two element list, optional, require 4th node
    #  -off - initial state, optional
    #  -n4 - name of 4th node;
    #  -n5 - name of 5th node, require -n4, optional
    #  n6 - name of 6th node, require -n5, optional
    #  -n7 - name of 7th node, require -n6, optional
    #  -custparams - key that collects all arguments at the end of device definition, to provide an ability
    #  to add custom parameters in form `-custparams param1 param1Val param2 {param2eq -eq} param3 param3Val ...`
    #  Must be specified after all others options. Optional.
    # ```
    # M<name> <drain node> <gate node> <source node>
    # + <bulk/substrate node> <model name>
    # + [L=<value>] [W=<value>]
    # + [AD=<value>] [AS=<value>]
    # + [PD=<value>] [PS=<value>]
    # + [NRD=<value>] [NRS=<value>]
    # + [M=<value] [IC=<value, ...>]
    # ```
    # Example of class initialization:
    # ```
    # ::SpiceGenTcl::Xyce::Mosfet new 1 netd netg nets -model mosfetmod -l 1e-6 -w 10e-3 -n4 netsub -n5 net5
    # ```
    set arguments [argparse -inline {
        {-model= -required}
        -m=
        -l=
        -w=
        {-ad= -forbid {nrd}}
        {-as= -forbid {nrs}}
        -pd=
        -ps=
        {-nrd= -forbid {ad}}
        {-nrs= -forbid {as}}
        -temp=
        {-ic= -validate {[llength $arg]==3}}
        -n4=
        {-n5= -require {n4}}
        {-n6= -require {n5}}
        {-n7= -require {n7}}
        {-custparams -catchall}
    }]
    lappend params "model [dict get $arguments model] -posnocheck"
    if {[dict exists $arguments ic]} {
        lappend params "ic [join [dict get $arguments ic] ,] -nocheck"
    }
    dict for {paramName value} $arguments {
        if {$paramName ni {model off ic n4 n5 n6 n7 custparams}} {
            lappend params "$paramName $value"
        }
    }
    if {[dict get $arguments custparams]!=""} {
        if {[llength [dict get $arguments custparams]]%2!=0} {
            error "Custom parameters list must be even length"
        }
        set custParamDict [dict create {*}[dict get $arguments custparams]]
        dict for {paramName value} $custParamDict {
            lappend params "$paramName $value"
        }
    }
    set pinList [list "nd $ndNode" "ng $ngNode" "ns $nsNode"]
    if {[dict exists $arguments n4]} {
        lappend pinList "n4 [dict get $arguments n4]"
        if {[dict exists $arguments n5]} {
            lappend pinList "n5 [dict get $arguments n5]"
            if {[dict exists $arguments n6]} {
                lappend pinList "n6 [dict get $arguments n6]"
                if {[dict exists $arguments n7]} {
                    lappend pinList "n7 [dict get $arguments n7]"
                }
            }
        }
    }
    next m$name $pinList $params
}