Work with parameters

Parameters are symbolic variables used in circuit element expressions. There are five ways of assigning values or expressions to these parameters:

Using built-in parameter definitions
In the netlist using the SPICE ‘.PARAM’ directive
In python using the circuit.defPar() method
In python using the pardefs argument in an instruction
In python using the specs2circuit() function

SLiCAP built-in parameters

SLiCAP has a number of predefined parameters. These parameters include default CMOS18 EKV model parameters.

SLiCAP library files

Notice, a SLiCAP library it like a circuit definition. The first line after any line starting with * is considered the title of the library. The last line must read .end

Circuit parameters

SLiCAP output displayed on this manual page, is generated with the script: parameters.py, imported by Manual.py.

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

"""
parameters.py: SLiCAP scripts for the HTML help file
"""
import SLiCAP as sl

###############################################################################
# work with parameters
###############################################################################

We will use a simple RC network to demonstrate how to use parameters.

# Define a circuit
RC_cir = sl.makeCircuit("kicad/myFirstRCnetwork/myFirstRCnetwork.kicad_sch")

Get all circuit parameters

A listing of all circuit parameters can be obtained as follows:

# Print the contents of the dictionary with circuit parameter definitions:
if len(RC_cir.parDefs.keys()):
    print("\nParameters with definitions:\n")
    for key in RC_cir.parDefs.keys():
        print(key, RC_cir.parDefs[key])
else: 
    print("\nFound no parameter definitions")
    
# Print the contents of the list with parameters that have no definition:
if len(RC_cir.params):
    print("\nParameters that have no definition:\n")
    for param in RC_cir.params:
        print(param)
else:
    print("\nFound no parameters without definition")

This yields:

Parameters with definitions:

R 1000
C 1/(2*pi*R*f_c)
f_c 1000

Parameters that have no definition:

V_s

Assign a value or an expression to a parameter

The method circuit.defPar() can be used to assign a value or an expression to a parameter.

# Define parameters        
RC_cir.defPar('R', 'tau/C') # Define R = tau/C
RC_cir.defPar('C', '10n')   # Define C = 10 nF
RC_cir.defPar('tau', '1u')  # Define tau = 1 us
print(RC_cir.parDefs)

This yields:

{R: tau/C, C: 1/100000000, f_c: 1000, tau: 1/1000000}

Assign values or expressions to multiple parameters

The method circuit.defPars() can be used to assign definitions to multiple parameters.

# Define multiple parameters
RC_cir.defPars({'R': 'tau/C', 'C': '10n', 'tau': '1/f_c'})
print(RC_cir.parDefs)

This yields:

{R: tau/C, C: 1/100000000, f_c: 1000, tau: 1/f_c}

Delete a parameter definition

You can delete a parameter definition using the method circuit.delPar() . This method does not delete the circuit parameter itself, it only clears its definition so that it can be used as a symbolic variable.

# Delete a parameter definition
RC_cir.delPar('f_c')           # Delete the definition of f_c

# Print the contents of the dictionary with circuit parameter definitions:
if len(RC_cir.parDefs.keys()):
    print("\nParameters with definitions:\n")
    for key in RC_cir.parDefs.keys():
        print(key, RC_cir.parDefs[key])
else: 
    print("\nFound no parameter definitions")
    
# Print the contents of the list with parameters that have no definition:
if len(RC_cir.params):
    print("\nParameters that have no definition:\n")
    for param in RC_cir.params:
        print(param)
else:   
    print("\nFound no parameters without definition")

This yields:

Parameters with definitions:

R tau/C
C 1/100000000
tau 1/f_c

Parameters that have no definition:

f_c
V_s

Obtain the value of a parameter

The method circuit.getParValue() returns the definition or the evaluated value of a parameter.

If the keyword argument substitute is True (default), all circuit parameter definitions are recursively substituted until a final value or expression is obtained (see fullSubs)

If the keyword argument numeric is True (default is False), functions and constants are numerically evaluated in floating point numbers.

# Obtain the value of a parameter
RC_cir.defPar('R', '1/2/pi/f_c/C')    # Define the value of R
RC_cir.defPar('C', '10n')             # Define the value of C
RC_cir.defPar('f_c', '1M')            # Define the value of tau

R_defined           = RC_cir.getParValue('R', substitute=False, numeric=False)
R_evaluated         = RC_cir.getParValue('R', substitute=True,  numeric=False)
R_defined_numeric   = RC_cir.getParValue('R', substitute=False, numeric=True)
R_evaluated_numeric = RC_cir.getParValue('R', substitute=True,  numeric=True)

print('\nR_defined            :', R_defined)
print('R_evaluated          :', R_evaluated)
print('R_defined_numeric    :', R_defined_numeric)
print('R_evaluated_numeric  :', R_evaluated_numeric)

This yields:

R_defined            : 1/(2*pi*C*f_c)
R_evaluated          : 50/pi
R_defined_numeric    : 0.159154943091895/(C*f_c)
R_evaluated_numeric  : 15.9154943091895

Obtain the values of multiple parameters

With a list of parameter names as argument, the method circuit.getParValue() returns a dictionary with key-value pairs. The keys are the names of the parameters and the values their defenition or evaluation of it.

If the keyword argument substitute is True (default), for each parameter, all circuit parameter definitions are recursively substituted until a final value or expression is obtained (see fullSubs)

If the keyword argument numeric is True (default is False), functions and constants are numerically evaluated in floating point numbers.

# Obtain the values of multiple parameters
print(RC_cir.getParValue(['R','C'], substitute=False, numeric=False))
print(RC_cir.getParValue(['R','C'], substitute=False, numeric=True))
print(RC_cir.getParValue(['R','C'], substitute=True,  numeric=False))
print(RC_cir.getParValue(['R','C'], substitute=True,  numeric=True))

This yields:

{R: 1/(2*pi*C*f_c), C: 1/100000000}
{R: 0.159154943091895/(C*f_c), C: 1.00000000000000e-8}
{R: 50/pi, C: 1/100000000}
{R: 15.9154943091895, C: 1.00000000000000e-8}

Display tables with parameters on HTML pages or in LaTeX documents

With the aid of the report module Create reports, tables with circuit parameter definitions and tables with undefined circuit parameters can be displayed on HTML pages or in LaTeX documents.

Below the script for generating table rst snippets for this help file.

# Generate RST snippets of tables with parameters for the Help file
rst = sl.RSTformatter()

rst.parDefs(RC_cir, 
            caption="RC circuit parameter definitions").save("table-RC_pardefs")
rst.params(RC_cir, 
           caption="RC circuit undefined parameters").save("table-RC_params")

Below, both tables for the RC circuit.

Table 4 RC circuit parameter definitions
Name	Symbolic	Numeric
\(R\)	\(\frac{0.5}{\pi C f_{c}}\)	\(15.92\)
\(C\)	\(1.0 \cdot 10^{-8}\)	\(1.0 \cdot 10^{-8}\)
\(\tau\)	\(\frac{1}{f_{c}}\)	\(1.0 \cdot 10^{-6}\)
\(f_{c}\)	\(1.0 \cdot 10^{6}\)	\(1.0 \cdot 10^{6}\)

Table 5 RC circuit undefined parameters
Name
\(V_{s}\)