SLiCAPinstruction.py

SLiCAP instruction class definition.

Imported by the module SLiCAP.py.

class instruction

Prototype Instruction object.

check()

Checks the completeness and consistancy of the instruction data. Will be called by instruction.execute().

Example

>>> # create an instance of the instruction object
>>> my_instr = instruction()
>>> # check a netlist file and use the circuit from this file for this
>>> # instruction:
>>> my_instr.setCircuit('my_circuit.cir')

checkCircuit()

Checks if the circuit for this instruction is a SLiCAPprotos.circuit() object.

Called by instruction.execute().

checkConvType()

Checks if the circuit conversion type is defined correctly.”

Called by instruction.check() and by setConvType(<convType>).

checkDataType()

Checks if the data type is defined correctly.”

Called by instruction.check() and by setDataType(<dataType>).

checkDetector()

Checks if the detector has been defined and if it exists in the circuit.

Called by instruction.check() and by instruction.setDetector(<detector>).

checkGainType()

Checks if the gain type is defined correctly.”

Called by instruction.check() and by setGainType(<gainType>).

checkLGref()

Checks if the loop gain reference has been defined and if it exists in the circuit.

Called by instruction.check() and by instruction.setLGref(<lgRef>).

checkNumeric()

Checks if the simulation type is set to ‘numeric’. This is required for pole-zero analysis.

Called by instruction.check() in cases in which a numeric simulation is required.

checkPairExt(pairExt)

Check the list with extensions of paired nodes.

Parameters

varPairs (list) – list with extensions of paired nodes.

Returns

number of errors

Return type

int

checkPairedCircuits(circuitPairs)

Check the list with names of with paired subcircuits.

Parameters

cirPairs – list with refDes of two subcircuits

Returns

number of errors

Return type

int

checkSimType()

Checks if the simulation type is defined correctly.”

Called by instruction.check() and by setSimType(<simType>).

checkSource(need=True)

Checks if the source has been defined and if it exists in the circuit.

Called by instruction.check() and by instruction.setSource(<source>).

Parameters

need (bool) – If True, a source is required and an error message will be given if it missing. If False, only the presence of the indicated independent source in the circuit will be verified.

checkStep()

This method will check the completeness and the consistency of the instruction data for parameter stepping, before executing the instruction.

Called by instruction.check() in cases in which instruction.step == True

checkStepArray()

Checks if the array with step values is defined properly.

Called by instruction.checkStep() and by instruction.setStepArray(<stepArray>).

The step array is a list of lists. The number of lists must equal the number of step variables. The numbers in the lists are subsequent values of the associated step variable. All lists should have equal lengths.

checkStepList()

Checks if the list with step values is defined properly.

Called by instruction.checkStep() and by instruction.setStepList(<stepList>).

checkStepMethod()

Checks if the step method is defined correctly.

Called by instruction.checkStep and by instruction.setStepVMethod(<stepMethod>).

checkStepNum()

Checks if the number of steps is defined properly.

Called by :instruction.checkStep() and by instruction.setStepNum(<stepNum>).

Also called by and by instruction.setStepNum(<stepNum>).

checkStepStart()

Checks if the start value for parameter stepping is defined correctly.

Called by instruction.checkStep() and by instruction.stepStart(<stepStart>).

checkStepStop()

Checks if the end value for parameter steping is defined correctly.

Called by instruction.checkStep() and by instruction.stepStop(<stepStop>).

checkStepVar()

Checks if the step variable is defined correctly.

Called by instruction.checkStep() and by setStepVar(<stepVar>).

checkStepVars()

Checks if the step variables for array stepping are defined correctly.

Called by instruction.checkStep and by instruction.setStepVars(<stepVars>).

circuit

Circuit (SLiCAPprotos.circuit) used for this instruction. Can be assigned by setting this attribute, or will be defined by running: instruction.setCircuit(<fileName>).

Example

>>> # Create an instance of a circuit object by checking a netlist:
>>> my_circuit = checkCircuit('my_circuit.cir')
>>> # create an instance of an instruction object:
>>> my_instruction = instruction()
>>> Use the circuit 'my_circuit' or the instruction 'my_instruction'.
>>> my_instruction.circuit = my_circuit

Example

>>> # create an instance of the instruction object
>>> my_instr = instruction()
>>> # check a netlist file and use the circuit from this file for this
>>> # instruction:
>>> my_instr.setCircuit('my_circuit.cir')

controlled()

Returns a list with names of controlled sources in instruction.circuit that can be used as loop gain reference.

Returns

list with names of controlled sources in instruction.circuit

Return type

list

Example

>>> # create an instance if a SLiCAP instruction
>>> my_instr = instruction()
>>> # create my_instr.circuit from the netlist 'myFirstRCnetwork.cir'
>>> my_instr.setCircuit('myFirstRCnetwork.cir')
>>> # Obtain a list with names of controlled sources:
>>> my_instr.controlled()
[]

convType

Defines the conversion type (None, ‘dd’, ‘dc’, ‘cd’, ‘cc’)

See instruction.setConvType(<convType>) for specification of instruction.convType.

dataType

Defines the simulation data type.

See instruction.setDataType(<dataType>) for specification of instruction.dataType.

defPar(parName, parValue)

Adds or modifies a parameter definition and updates the list instruction.circuit.params with names (sympy.Symbol) of undefined parameters.

Parameters

• parName (str, sympy.Symbol, sympy.Expr) – Name of the parameter.

• parValue – Value or expression.

Example

>>> # create an instance if a SLiCAP instruction
>>> my_instr = instruction()
>>> # create my_instr.circuit from the netlist 'myFirstRCnetwork.cir'
>>> my_instr.setCircuit('myFirstRCnetwork.cir')
>>> # Define the value of 'R' as 2000
>>> my_instr.defPar('R', '2k')
>>> # Or:
>>> my_instr.defPar('R', 2e3)

defPars(parDict)

Adds or modifies multiple parameter definitions and updates the list instruction.circuit.params with names (sympy.Symbol) of undefined parameters.

Params parDict

Dictionary with key-value pairs: key: parName (str, sympy.Symbol): name of the parameter. value: parValue (str, float, int, sp.Symbol) : value or expression of the parameter.

Example

>>> # create an instance if a SLiCAP instruction
>>> my_instr = instruction()
>>> # create my_instr.circuit from the netlist 'myFirstRCnetwork.cir'
>>> my_instr.setCircuit('myFirstRCnetwork.cir')
>>> # Define the value of 'R' as 2000 and 'C' as 5e-12:
>>> my_instr.defPars({'R': '2k', 'C': '5p'})

delPar(parName)

Deletes a parameter definition

After deletion of the parameter from the instruction.circuit.parDefs dictionary the list instruction.circuit.params with names (sympy.Symbol) of undefined parameters is updated.

Parameters

parName (str, sympy.Symbol) – Name of the parameter.

Example

>>> # create an instance if a SLiCAP instruction
>>> my_instr = instruction()
>>> # create my_instr.circuit from the netlist 'myFirstRCnetwork.cir'
>>> my_instr.setCircuit('myFirstRCnetwork.cir')
>>> # Delete the definition for the parameter 'R':
>>> my_instr.delPar('R')
>>> # Or:
>>> my_instr.circuit.delPar('R')

depVars()

Returns a list with names of nodal voltages and branch currents that can be used as detector.

Returns

list with names of nodal voltages and branch currents

Return type

list

Example

>>> # create an instance if a SLiCAP instruction
>>> my_instr = instruction()
>>> # create my_instr.circuit from the netlist 'myFirstRCnetwork.cir'
>>> my_instr.setCircuit('myFirstRCnetwork.cir')
>>> # Obtain a list with names of dependent variables:
>>> my_instr.depVars()
['I_V1', 'V_N001', 'V_out']

detLabel

Name for the detector quantity to be used in expressions or plots (automatically determined in instruction.checkDetector()).

detUnits

Detector units ‘V’ or ‘A’ (automatically detected in instruction.checkDetector()).

detector

Names of the positive and negative detector.

See instruction.setDetector(<detector>) for specification of the detector.

errors

Number of errors found in the definition of this instruction.

Note

The instruction.errors attribute should not be modified directly by the user. It is determined automatically when executing the instruction.

execute()

Checks the instruction and executes it if no errors are found.

if no errors are found it returns a allResults object with the results of the instruction.

Returns

allResults object with results of the execution

Return type

SLiCAPprotos.allResults

>>> # create an instance if a SLiCAP instruction
>>> my_instr = instruction()
>>> # create my_instr.circuit from the netlist 'myFirstRCnetwork.cir'
>>> my_instr.setCircuit('myFirstRCnetwork.cir')
>>> # Assign 'V1' signal source:
>>> my_instr.source = 'V1'
>>> # Assign 'V_out' detector:
>>> my_instr.detector = 'V_out'
>>> # Set the simulation type to 'symbolic'
>>> my_instr.simType = 'symbolic'
>>> # Set the gain type to 'gain'
>>> my_instr.gainType = 'gain'
>>> # Set the data type to 'laplace'
>>> my_instr.dataType = 'laplace'
>>> result = my_instr.execute()
>>> print result.laplace

gainType

Defines the simulation gain type.

See instruction.setGainType(<gainType>) for specification of instruction.gainType.

getElementValue(elementID, param='value')

Returns the value or expression of one or more circuit elements.

If instruction.numeric == True it will perform a full recursive substitution of all circuit parameter definitions.

This method calls instruction.circuit.getElementValue() with numeric = True if instruction.simType is set to ‘numeric’.

Parameters

• elementID (str, list) – name(s) of the element(s)

• param (str) –

  name of the parameter (equal for all elements):

  • ’value’: Laplace value

  • ’dc’: DC value (independent sources only)

  • ’noise’: Noise spectral density (independent sources only)

  • ’dcvar’: DC variance (independent sources only)

  Defaults to ‘value’.

Returns

if type(param) == list:

return value = dict with key-value pairs: key (sympy.Symbol): name of the parameter, value (int, float, sympy expression): value of the parameter

else: value or expression

Return type

dict, float, int, sympy.Expr

Example

>>> # Create an instance if a SLiCAP instruction
>>> my_instr = instruction()
>>> # Create my_instr.circuit from the netlist 'myFirstRCnetwork.cir'
>>> my_instr.setCircuit('myFirstRCnetwork.cir')
>>> # Obtain the numeric value of 'R1' and 'C1':
>>> my_instr.symType = 'numeric'
>>> print my_instr.getElementValue(['R1', 'C1'])
{'C1': 5.0e-7/pi, 'R1': 1000.00000000000}

getParValue(parName)

Returns the value or expression of one or more parameters.

If instruction.numeric == True it will perform a full recursive substitution of all circuit parameter definitions.

This method calls instruction.circuit.getParValue() with keyword arg numeric = True if instruction.simType is set to ‘numeric’.

Parameters

parName (str, sympy.Symbol, list) – name(s) of the parameter(s)

Returns

if type(parNames) == list:

return value = dict with key-value pairs: key (sympy.Symbol): name of the parameter, value (int, float, sympy expression): value of the parameter

else: value or expression

Return type

dict, float, int, sympy.Expr

Example

>>> # create an instance if a SLiCAP instruction
>>> my_instr = instruction()
>>> # create my_instr.circuit from the netlist 'myFirstRCnetwork.cir'
>>> my_instr.setCircuit('myFirstRCnetwork.cir')
>>> # Obtain the numeric parameter definitions of of 'R' and 'C':
>>> my_instr.symType = 'numeric'
>>> my_instr.getParValue(['R', 'C'])

indepVars()

Returns a list with names of independent sources in instruction.circuit

Returns

list with names of independent sources in instruction.circuit

Return type

list

Example

>>> # create an instance if a SLiCAP instruction
>>> my_instr = instruction()
>>> # create my_instr.circuit from the netlist 'myFirstRCnetwork.cir'
>>> my_instr.setCircuit('myFirstRCnetwork.cir')
>>> # Obtain a list with names of independent sources:
>>> my_instr.indepVars()
['V1']

label

Label to be used in plots.

lgRef

Refdes of the controlled source(s) that is (are) assigned as loop gain reference. A second controlled source is required for decomposition of circuits in common-mode and differential-mode equivalents.

See instruction.setLGref(<detector>) for specification of the loop gain reference.

lgValue

Value of the loopgain reference will be stored during execution of the instruction.

numeric

Variable used during analysis an presentation of analysis results.

Note

The instruction.numeric attribute should not be modified directly by the user. Use the method instruction.setSimType(<simTipe>) to alter the simulation method!

pairExt

Extensions used to indicate paired nodes or elements. Default is: [None, None].

parDefs

Parameter definitions for the instruction. Will be updated by executing the instruction.

removePairSubName

If True, the subcircuit ID extension will be removed from parameters in expressions of paired elements in sub circuits. Defaults to True.

Note

Warning: this may result in undesired behavior if global parameters carry the name of parameters in paired sub circuits.

setCircuit(fileName)

Defines the circuit for this instruction.

• Checks the netlist file ‘fileName’

• Creates a circuit object from it

• Makes it the ciruit object for this instruction.

Parameters

fileName (str) – Name of the netlist file.

Example

>>> # create an instance of the instruction object
>>> my_instr = instruction()
>>> # check a netlist file and use the circuit from this file for this
>>> # instruction:
>>> my_instr.setCircuit('my_circuit.cir')

setConvType(convType)

Defines the circuit conversion type for the instruction.

Parameters

convType – gain type for the instruction: None, ‘dd’, ‘dc’, ‘cd’, ‘cc’, or ‘all’.

setDataType(dataType)

Defines the data type for the instruction.

Parameters

dataType (str) – data type for the instruction: ‘dc’, ‘dcsolve’, ‘dcvar’, ‘denom’, ‘impulse’, ‘laplace’, ‘matrix’, ‘noise’, ‘numer’, ‘params’, ‘poles’, ‘pz’, ‘solve’, ‘step’, ‘time’ or ‘zeros’.

Example

>>> # Create an instance of the instruction object
>>> my_instr = instruction()
>>> # Set data type to 'laplace':
>>> my_instr.setDataType('laplace')

setDetector(detector)

Defines the signal detector

Parameters

detector (list, str) – Name(s) of one or two nodal voltages or of one or two dependent currents.

detector can defined as:

• None: no detector has been defined

• str: a single detector, name of a nodal voltage or a branch current

• list: with names of either two nodal voltages or two branch currents.

instruction.checkDetector converts the detector definition into a list with a positive and a negative detector [<detP>, <detN>], where detP and detN are the names (str) of either two nodal voltages or two branch currents. One of those can be ‘None’.

A list with names of dependent variables that can be used as signal detector is returned by the method: instruction.depVars().

Example

>>> # create an instance if a SLiCAP instruction
>>> my_instr = instruction()
>>> # create my_instr.circuit from the netlist 'myFirstRCnetwork.cir'
>>> my_instr.setCircuit('myFirstRCnetwork.cir')
>>> # Display a list with names of nodal voltages and branch currents
>>> # that can be assigned to the detector.
>>> my_instr.depVars()
['I_V1', 'V_0', 'V_N001', 'V_out']
>>> # Voltage at node 'out':
>>> my_instr.setDetector('V_out')
>>> # Differential voltage between node 'N001' and 'out':
>>> my_instr.setDetector(['V_N001', 'V_out'])
>>> # Current through `V1':
>>> my_instr.setDetector('I_V1')

Note

The voltage ‘V_0’ at the reference node ‘0’ equals zero.

setGainType(gainType)

Defines the gain type for the instruction.

Parameters

gainType (str) – gain type for the instruction: ‘gain’, ‘asymptotic’, ‘loopgain’, ‘servo’, ‘direct’, or ‘vi’.

Example

>>> # Create an instance of the instruction object
>>> my_instr = instruction()
>>> # Set gain type to 'gain':
>>> my_instr.setGainType('gain')

setLGref(lgRef)

Defines the loop gain reference (name of a controlled source).

A list with names of dependent (controlled) sources is returned by the method instruction.controlled().

Parameters

lgRef (str, sympy.Symbol) – Name of the loop gain reference.

Example

>>> # create an instance of the instruction object
>>> my_instr = instruction()
>>> # check a netlist file and use the circuit from this file for this
>>> # instruction:
>>> my_instr.setCircuit('my_circuit.cir')
>>> # Display a list with controlled sources of the circuit:
>>> my_instr.controlled()

setPairExt(pairExt)

Defines the extension to element or node IDs for DM and CM pairs.

Parameters

pairExt (list) – list with extensions for paired nodes.

setPairedCircuits(cirPairs)

Defines the paired subcircuits for matrix conversion.

Parameters

varPairs (tuple) – list with tuples of names (str) of subcircuits that must be considered pairs.

setSimType(simType)

Defines the simulation type for the instruction.

Parameters

simType (str) – Simulation type: ‘symbolic’ or ‘numeric’

Example

>>> # Create an instance of the instruction object
>>> my_instr = instruction()
>>> # Set the simulation type to numeric:
>>> my_instr.setSimType('numeric')
>>> # Set the simulation type to symbolic:
>>> my_instr.setSimType('symbolic')

Note

SLiCAP always uses symbolic calculation methods. Only in a limited number of cases SLiCAP calulates with floats (pole-zero analysis, determination of the phase margin, etc.).

With the simulation type set to ‘numeric’ SLiCAP recursively substitutes all circuit parameter definitions into expressions used for element values. Hence, component values can be expressions with symbolic parameters.

The default number of recursive substitutions is 10. It is defined by ini.recSubst and can be changed by the user. For using the built-in MOS EKV models a value of eight is the minumum for full substitution.

Example

>>> ini.recSubst = 12 # For deeply nested expressions!

setSource(source)

Defines the signal source.

Parameters

source (str) – Name of an independent voltage or current source that exists in the circuit.

Example

>>> # Create an instance of the instruction object
>>> my_instr = instruction()
>>> # check a netlist file and use the circuit from this file for this
>>> # instruction:
>>> my_instr.setCircuit('my_circuit.cir')
>>> # Define the voltage source 'V1' as signal source:
>>> my_instr.setSource('V1')

Note

A list with names of independent voltage and current sources that can be assigned as signal source can be obtained from the method: instruction.idepVars():

Example

>>> # Create an instance of the instruction object
>>> my_instr = instruction()
>>> # check a netlist file and use the circuit from this file for this
>>> # instruction:
>>> my_instr.setCircuit('my_circuit.cir')
>>> # Obtaine a list with names of independent sources:
>>> my_instr.circuit.idepVars()

setStepArray(stepArray)

Defines the array with values for step method array.

Parameters

stepArray (list) – Nested list: list[i] carries the step values for the step variable in instruction.stepVars[i]. The lists should have equal lengths.

Example

>>> # Create an instance of the instruction object
>>> my_instr = instruction()
>>> # check a netlist file and use the circuit from this file for this
>>> # instruction:
>>> my_instr.setCircuit('my_circuit.cir')
>>> # Define 'array' type stepping:
>>> my_instr.setStepMethod('array')
>>> # Define circuit parameters 'R_a' and 'C_a' as step variables:
>>> my_instr.setStepVars(['R_a', 'C_a'])
>>> Define the step values for 'R_a and 'C_a':
>>> my_instr.setStepArray([['1k', 1200, 1.2e3],['1u', 10e-6, 0.0001]])
>>> # Enable parameter stepping
>>> my_instr.stepOn()

setStepList(stepList)

Defines the list with step values for step method ‘list’. This list will be overwritten if the instruction is executed with the step method set to ‘lin’ or ‘log’.

Parameters

stepList (list) – List with step values for the step parameter.

Example

>>> # Create an instance of the instruction object
>>> my_instr = instruction()
>>> # check a netlist file and use the circuit from this file for this
>>> # instruction:
>>> my_instr.setCircuit('my_circuit.cir')
>>> # Define 'list' type stepping:
>>> my_instr.setStepMethod('list')
>>> # Define the circuit parameter 'alpha' as step parameter:
>>> my_instr.setStepVar('alpha')
>>> # Define a list of step values for this parameter.
>>> my_instr.setStepList(['10m', '20m', '50m', 0.1, 0.2, 0.5, 1, 2, 5])
>>> # Enable parameter stepping
>>> my_instr.stepOn()

setStepMethod(stepMethod)

Defines the parameter stepping method.

Parameters

stepMethod (str) – ‘lin’, ‘log’, ‘list’ or ‘array’.

Example

>>> # Create an instance of the instruction object
>>> my_instr = instruction()
>>> # check a netlist file and use the circuit from this file for this
>>> # instruction:
>>> my_instr.setCircuit('my_circuit.cir')
>>> # Define 'linear' type stepping:
>>> my_instr.setStepMethod('lin')
>>> # Enable parameter stepping
>>> my_instr.stepOn()

setStepNum(stepNum)

Defines the number of steps for ‘lin’ and ‘log’ parameter stepping.

Parameters

stepNumber – Number of steps for stepping methods ‘lin’ and ‘log’.

Example

>>> # Create an instance of the instruction object
>>> my_instr = instruction()
>>> # check a netlist file and use the circuit from this file for this
>>> # instruction:
>>> my_instr.setCircuit('my_circuit.cir')
>>> # Define linear stepping:
>>> my_instr.stepMethod = 'lin'
>>> # Define the start value
>>> my_instr.setStepStop('1M')  # 1E6
>>> my_instr.setStepStop(1e6)   # 1E6
>>> # Enable parameter stepping
>>> my_instr.stepOn()

setStepStart(stepStart)

Start value for parameter stepping methods ‘lin’ and ‘log’.

Parameters

stepStart (str, int, float) – Start value for parameter stepping methods ‘lin’ and ‘log’.

Example

>>> # Create an instance of the instruction object
>>> my_instr = instruction()
>>> # check a netlist file and use the circuit from this file for this
>>> # instruction:
>>> my_instr.setCircuit('my_circuit.cir')
>>> # Define linear stepping:
>>> my_instr.stepMethod = 'lin'
>>> # Define the start value
>>> my_instr.setStepStart('1k')  # 1E3
>>> my_instr.setStepStart(1000)  # 1E3
>>> my_instr.setStepStart(1e3)   # 1E3
>>> # Enable parameter stepping
>>> my_instr.stepOn()

setStepStop(stepStop)

End value for parameter stepping methods ‘lin’ and ‘log’.

Parameters

stepStop (str, int, float) – End value for parameter stepping methods ‘lin’ and ‘log’.

Example

>>> # Create an instance of the instruction object
>>> my_instr = instruction()
>>> # check a netlist file and use the circuit from this file for this
>>> # instruction:
>>> my_instr.setCircuit('my_circuit.cir')
>>> # Define linear stepping:
>>> my_instr.stepMethod = 'lin'
>>> # Define the start value
>>> my_instr.setStepStop('1M')  # 1E6
>>> my_instr.setStepStop(1e6)   # 1E6
>>> # Enable parameter stepping
>>> my_instr.stepOn()

setStepVar(stepVar)

Defines the step variable for parameter step types ‘lin’, ‘log’ and ‘list’.

Parameters

stepVar (str, sympy.Symbol) – step variable

Example

>>> # Create an instance of the instruction object
>>> my_instr = instruction()
>>> # Define the circuit parameter 'alpha' as step variable:
>>> my_instr.setStepVar('alpha')
>>> # Enable parameter stepping
>>> my_instr.stepOn()

Note

A list with names (sympy.Symbol) that can be used as stepping parameter is obtained as follows:

Example

>>> # Create an instance of the instruction object
>>> my_instr = instruction()
>>> # check a netlist file and use the circuit from this file for this
>>> # instruction:
>>> my_instr.setCircuit('my_circuit.cir')
>>> # print the list with names of all parameters that can be stepped:
>>> print instr.circuit.params + list(instr.circuit.parDefs.keys())

setStepVars(stepVars)

Defines the step variables for ‘array’ type stepping.

Parameters

stepVars (list) – List with names (str, sympy.Symbol) of step variables for array type stepping.

Example

>>> # Create an instance of the instruction object
>>> my_instr = instruction()
>>> # check a netlist file and use the circuit from this file for this
>>> # instruction:
>>> my_instr.setCircuit('my_circuit.cir')
>>> # Define 'array' type stepping:
>>> my_instr.stepMethod = 'array'
>>> # Define circuit parameters 'R_a' and 'C_a' as step variables:
>>> my_instr.setStepVars(['R_a', 'C_a'])
>>> Define the step values for 'R_a and 'C_a':
>>> my_instr.setStepArray ([['1k', 1200, 1.2e3],['1u', 10e-6, 0.0001]])
>>> # Enable parameter stepping
>>> my_instruction.stepOn()

Note

A list with names (sympy.Symbol) that can be used as stepping parameter is obtained as follows:

Example

>>> # Create an instance of the instruction object
>>> my_instr = instruction()
>>> # check a netlist file and use the circuit from this file for this
>>> # instruction:
>>> my_instr.setCircuit('my_circuit.cir')
>>> # print the list with names of all parameters that can be stepped:
>>> print instr.circuit.params + list(instr.circuit.parDefs.keys())

simType

Defines the simulation gain type.

See instruction.setSimType(<simType>) for specification of instruction.simType.

source

Refdes of the signal source (independent v or i source).

See instruction.setSource(<source>) for specification of the source.

srcUnits

Source units ‘V’ or ‘A’ (automatically detected in instruction.checkSource()).

step

Setting for parameter stepping.

See instruction.setStepOn() and instruction.setStepOff() for specification of instruction.step.

stepArray

Array (list of lists) with values for step method array.

See instruction.setStepArray(<stepArray>) for specification of instruction.stepArray.

stepDict

Dictionary with key-value pairs:

key: name of a step parameter (sympy.Symbol) value: list with values for this parameter

stepList

List with values for step method ‘list’.

See instruction.setStepList(<stepList>) for specification of instruction.stepList.

stepMethod

Step method for parameter stepping.

See instruction.setStepMethod(<stepMethod>) for specification of instruction.stepMethod.

stepNum

Number of steps for step methods ‘lin’ and ‘log’.

See instruction.setStepNum(<stepNum>) for specification of instruction.stepNum.

stepOff()

Disables parameter stepping.

Does not change other settings for parameter stepping.

Example

>>> # Create an instance of the instruction object
>>> my_instr = instruction()
>>> # Disable parameter stepping
>>> my_instruction.stepOff()

stepOn()

Enables parameter stepping.

Does not change other settings for parameter stepping.

Example

>>> # Create an instance of the instruction object
>>> my_instr = instruction()
>>> # Enable parameter stepping
>>> my_instruction.stepOn()

stepStart

Start value for stepping methods ‘lin’ and ‘log’.

See instruction.setStepStart(<stepStart>) for specification of instruction.stepStart.

stepStop

Stop value for stepping methods ‘lin’ and ‘log’.

See instruction.setStepStop(<stepStop>) for specification of instruction.stepStop.

stepVar

Defines the step variable (str) for step types ‘lin’, ‘log’ and ‘list’.

See instruction.setStepVar(<stepVar>) for specification of instruction.stepVar.

stepVars

Defines the step variables for ‘array’ type parameter stepping.

See instruction.setStepVars(<stepVars>) for specification of instruction.stepVars.

useMatrixConversion(method=None)

Converts the basis of the MNA matrices. Execution of the instruction will be performed with this matrix conversion.

Built-in conversion conversion methods are:

• None : No conversion, MNA matrix equation (default)

• DM : Differential-mode transfer

• CM : Common-mode transfer

• DMCM : Differential-mode to common-mode transfer

• CMDM : Common-mode to differential-mode transfer

Parameters

method (str) – Conversion method can be one of the above.

Returns

None

RType

NoneType

listPZ(pzResult)

Prints lists with poles and zeros.

Parameters

pzResult (SLiCAPprotos.allResults) – SLiCAP execution results of pole-zero analysis.

Returns

None

Return type

NoneType