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