Nyancad

https://nyancad.com/docs
Admin
Nyancad is a modern schematic entry and simulation platform for analog IC design, enabling engineers...
Tokens:6,137
Snippets:40
Trust Score:4.5
Update:5 months ago
Show doc for...
Tokens:
Raw
### Install Nyancad and Dependencies in Pyodide

Source: https://nyancad.com

Installs necessary Python packages including holoviews, nyancad, and inspice within a Pyodide environment. It also downloads and unpacks the libngspice shared library.

```python
import sys
if "pyodide" in sys.modules:
    import micropip
    micropip.uninstall("narwhals")
    await micropip.install("holoviews==1.21.0")
    await micropip.install("nyancad")
    await micropip.install("inspice")
    from pyodide.http import pyfetch
    response = await pyfetch("/wasm-libs/libngspice-44.2.zip")
    await response.unpack_archive(format="zip", extract_dir="/usr/lib")
```

--------------------------------

### Import Nyancad Core Modules

Source: https://nyancad.com

Imports essential modules from Nyancad and other libraries for circuit simulation and plotting. This setup is typically used within a Marimo environment.

```python
import os
import marimo as mo
import pandas as pd
import numpy as np
import holoviews as hv
from nyancad.anywidget import schematic_bridge
from nyancad.netlist import inspice_netlist
from nyancad.plot import timeplot, sweepplot, bodeplot
from InSpice import Simulator
```

--------------------------------

### Configure Transient Analysis UI

Source: https://nyancad.com

Sets up UI elements for transient analysis, including maximum time step and an option to use initial conditions.

```python
tran_max = mo.ui.number(label="Max Time Step (s)", value=widget_state["tran_max"], step=1e-5)
tran_uic = mo.ui.checkbox(label="Use Initial Conditions", value=widget_state["tran_uic"])
```

--------------------------------

### Configure DC Sensitivity Analysis UI

Source: https://nyancad.com

Placeholder for DC Sensitivity Analysis UI configuration.

```python
dc_sens_output
```

--------------------------------

### Configure Noise Analysis UI

Source: https://nyancad.com

Sets up UI elements for noise analysis, including output and reference nodes, input source, frequency range, and point spacing.

```python
noise_output = mo.ui.dropdown(node_names, label="Output Node", 
                           value=get_dropdown_value(widget_state["noise_output"], node_names))
noise_ref = mo.ui.dropdown(node_names, label="Reference Node", 
                         value=get_dropdown_value(widget_state["noise_ref"], node_names))
noise_src = mo.ui.dropdown(element_names, label="Input Source", 
                        value=get_dropdown_value(widget_state["noise_src"], element_names))
noise_variation = mo.ui.dropdown(["dec", "oct", "lin"], value=widget_state["noise_variation"], label="Point Spacing")
noise_points = mo.ui.number(label="Number of Points", value=widget_state["noise_points"], step=1)
noise_start_freq = mo.ui.number(label="Start Frequency (Hz)", value=widget_state["noise_start_freq"], step=1)
noise_stop_freq = mo.ui.number(label="Stop Frequency (Hz)", value=widget_state["noise_stop_freq"], step=1000)
noise_summary = mo.ui.number(label="Points per Summary", value=widget_state["noise_summary"], step=1)
```

--------------------------------

### Configure Transfer Function Analysis UI

Source: https://nyancad.com

Sets up UI elements for transfer function analysis, specifying the output variable and input source.

```python
tf_output = mo.ui.text(label="Output Variable", value=widget_state["tf_output"])
tf_input = mo.ui.dropdown(element_names, label="Input Source", 
                        value=get_dropdown_value(widget_state["tf_input"], element_names))
```

--------------------------------

### Run Circuit Simulation with Simulator Factory

Source: https://nyancad.com

Initializes and runs a circuit simulation using the Simulator factory. It retrieves the simulation engine name and optionally the path to the Xyce executable from environment variables.

```python
xyce_command = os.environ.get("XYCE")
_simulator = Simulator.factory(simulator=simname.value, xyce_command=xyce_command)
```

--------------------------------

### Initialize Schematic Reader Widget

Source: https://nyancad.com

Creates an instance of the schematic reader widget, which is used to interact with and load circuit schematics.

```python
reader = schematic_bridge()
reader
```

--------------------------------

### Configure AC Sensitivity Analysis UI

Source: https://nyancad.com

Sets up UI elements for AC sensitivity analysis, including point spacing, number of points, and frequency range. This is part of a larger tabbed interface for simulation analysis.

```python
ac_sens_output = mo.ui.text(label="Output Variable", value=widget_state["ac_sens_output"])
ac_sens_variation = mo.ui.dropdown(["dec", "oct", "lin"], value=widget_state["ac_sens_variation"], label="Point Spacing")
ac_sens_points = mo.ui.number(label="Number of Points", value=widget_state["ac_sens_points"], step=1)
ac_sens_start_freq = mo.ui.number(label="Start Frequency (Hz)", value=widget_state["ac_sens_start_freq"], step=1)
ac_sens_stop_freq = mo.ui.number(label="Stop Frequency (Hz)", value=widget_state["ac_sens_stop_freq"], step=1000)
```

--------------------------------

### Configure Distortion Analysis UI

Source: https://nyancad.com

Configures UI elements for distortion analysis, including point spacing, frequency range, F2/F1 ratio, and spectral analysis option.

```python
disto_variation = mo.ui.dropdown(["dec", "oct", "lin"], value=widget_state["disto_variation"], label="Point Spacing")
disto_points = mo.ui.number(label="Number of Points", value=widget_state["disto_points"], step=1)
disto_start_freq = mo.ui.number(label="Start Frequency (Hz)", value=widget_state["disto_start_freq"], step=1)
disto_stop_freq = mo.ui.number(label="Stop Frequency (Hz)", value=widget_state["disto_stop_freq"], step=1000)
disto_f2overf1 = mo.ui.number(label="F2/F1 Ratio (optional)", value=widget_state["disto_f2overf1"], step=0.1)
disto_spectral = mo.ui.checkbox(label="Spectral Analysis", value=widget_state["disto_spectral"])
```

--------------------------------

### Configure Pole-Zero Analysis UI

Source: https://nyancad.com

Configures UI elements for pole-zero analysis, allowing selection of input and output nodes, transfer function type, and analysis type.

```python
pz_node1 = mo.ui.dropdown(node_names, label="Input Node 1", 
                          value=get_dropdown_value(widget_state["pz_node1"], node_names))
pz_node2 = mo.ui.dropdown(node_names, label="Input Node 2", 
                          value=get_dropdown_value(widget_state["pz_node2"], node_names))
pz_node3 = mo.ui.dropdown(node_names, label="Output Node 1", 
                          value=get_dropdown_value(widget_state["pz_node3"], node_names))
pz_node4 = mo.ui.dropdown(node_names, label="Output Node 2", 
                          value=get_dropdown_value(widget_state["pz_node4"], node_names))
pz_tf_type = mo.ui.dropdown(["vol", "cur"], value=widget_state["pz_tf_type"], label="Transfer Function Type")
pz_pz_type = mo.ui.dropdown(["pol", "zer", "pz"], value=widget_state["pz_pz_type"], label="Analysis Type")
```

--------------------------------

### Generate SPICE Netlist from Schematic

Source: https://nyancad.com

Asynchronously generates a SPICE netlist from the provided schematic data. The netlist is then printed to the console.

```python
spice = await inspice_netlist(reader.name, reader.schematic_data)
print(spice)
```

--------------------------------

### Initialize Widget State Dictionary

Source: https://nyancad.com

Defines a comprehensive dictionary to store the state of UI widgets, ensuring persistence of values across UI rebuilds. Includes settings for various analysis types like DC, AC, Transient, Pole-Zero, Noise, Distortion, Transfer Function, and Sensitivity analyses.

```python
widget_state = {
    "active_tab": "op",
    "selected_vectors": [], 

    "op_back_annotate": True,

    "dc_source": None, 
    "dc_start": 0,
    "dc_stop": 5,
    "dc_step": 0.1,

    "ac_variation": "dec",
    "ac_points": 10,
    "ac_start_freq": 1,
    "ac_stop_freq": 1e6,

    "tran_step": 1e-5,
    "tran_start": 0,
    "tran_stop": 1e-3,
    "tran_max": 1e-4,
    "tran_uic": False,

    "pz_node1": None,
    "pz_node2": None,
    "pz_node3": None,
    "pz_node4": None,
    "pz_tf_type": "vol",
    "pz_pz_type": "pz",

    "noise_output": None,
    "noise_ref": None,
    "noise_src": None,
    "noise_variation": "dec",
    "noise_points": 10,
    "noise_start_freq": 10,
    "noise_stop_freq": 1e5,
    "noise_summary": 1,

    "disto_variation": "dec",
    "disto_points": 10,
    "disto_start_freq": 100,
    "disto_stop_freq": 1e4,
    "disto_f2overf1": 0.9,
    "disto_spectral": False,

    "tf_output": "v(out)",
    "tf_input": None,

    "dc_sens_output": "v(out)",

    "ac_sens_output": "v(out)",
    "ac_sens_variation": "dec",
    "ac_sens_points": 10,
    "ac_sens_start_freq": 100,
    "ac_sens_stop_freq": 1e5
}
return (widget_state,)
```

--------------------------------

### Create Tabbed Simulation Analysis Interface

Source: https://nyancad.com

Constructs a tabbed interface for managing different simulation analysis types. Each tab contains specific UI elements and descriptive markdown for its respective analysis.

```python
simtabs = mo.ui.tabs({
    "op": mo.vstack([
        mo.md("**Operating Point Analysis**"),
        mo.md("Find the DC operating point with capacitors open and inductors shorted."),
        op_back_annotate
    ]),

    "dc": mo.vstack([
        mo.md("**DC Sweep Analysis**"),
        mo.md("Compute DC operating point while sweeping independent sources."),
        dc_source,
        dc_start,
        dc_stop,
        dc_step
    ]),

    "ac": mo.vstack([
        mo.md("**AC Small-Signal Analysis**"),
        mo.md("Perform small-signal AC analysis with linearized devices."),
        ac_variation,
        ac_points,
        ac_start_freq,
        ac_stop_freq
    ]),

    "tran": mo.vstack([
        mo.md("**Transient Analysis**"),
        mo.md("Perform non-linear time-domain simulation."),
        tran_step,
        tran_start,
        tran_stop,
        tran_max,
        tran_uic
    ]),

    "pz": mo.vstack([
        mo.md("**Pole-Zero Analysis**"),
        mo.md("Compute poles and zeros of the transfer function."),
        mo.md("*Input Nodes*"),
        pz_node1,
        pz_node2,
        mo.md("*Output Nodes*"),
        pz_node3,
        pz_node4,
        mo.md("*Analysis Options*"),
        pz_tf_type,
        pz_pz_type
    ]),

    "noise": mo.vstack([
        mo.md("**Noise Analysis**"),
        mo.md("Perform stochastic noise analysis at the DC operating point."),
        mo.md("*Signal Configuration*"),
        noise_output,
        noise_ref,
        noise_src,
        mo.md("*Frequency Sweep*"),
        noise_variation,
        noise_points,
        noise_start_freq,
        noise_stop_freq,
        mo.md("*Output Options*"),
        noise_summary
    ]),

    "disto": mo.vstack([
        mo.md("**Distortion Analysis**"),
        mo.md("Analyze harmonic or spectral d")
    ])
})
```

--------------------------------

### Execute Circuit Simulation Analysis

Source: https://nyancad.com

This code block sets up and runs various circuit simulation analyses based on the selected analysis type. It handles parameters for operating point, DC sweep, AC analysis, transient analysis, pole-zero analysis, noise analysis, distortion analysis, transfer function, and sensitivity analyses. Ensure all required simulation parameters are correctly defined before execution.

```python
simulation = _simulator.simulation(spice)

_analysis_type = simtabs.value
print(f"Running {_analysis_type} analysis...")

if _analysis_type == "op":
    analysis = _simulation.operating_point()
elif _analysis_type == "dc":
    analysis = _simulation.dc(**{dc_source.value: slice(dc_start.value, dc_stop.value, dc_step.value)})
elif _analysis_type == "ac":
    analysis = _simulation.ac(
        variation=ac_variation.value,
        number_of_points=int(ac_points.value),
        start_frequency=ac_start_freq.value,
        stop_frequency=ac_stop_freq.value
    )
elif _analysis_type == "tran":
    analysis = _simulation.transient(
        step_time=tran_step.value,
        end_time=tran_stop.value,
        start_time=tran_start.value,
        max_time=tran_max.value if tran_max.value > 0 else None,
        use_initial_condition=tran_uic.value
    )
elif _analysis_type == "pz":
    analysis = _simulation.polezero(
        node1=pz_node1.value,
        node2=pz_node2.value,
        node3=pz_node3.value,
        node4=pz_node4.value,
        tf_type=pz_tf_type.value,
        pz_type=pz_pz_type.value
    )
elif _analysis_type == "noise":
    analysis = _simulation.noise(
        output_node=noise_output.value,
        ref_node=noise_ref.value,
        src=noise_src.value,
        variation=noise_variation.value,
        points=int(noise_points.value),
        start_frequency=noise_start_freq.value,
        stop_frequency=noise_stop_freq.value,
        points_per_summary=int(noise_summary.value) if noise_summary.value > 0 else None
    )
elif _analysis_type == "disto":
    analysis = _simulation.distortion(
        variation=disto_variation.value,
        points=int(disto_points.value),
        start_frequency=disto_start_freq.value,
        stop_frequency=disto_stop_freq.value,
        f2overf1=disto_f2overf1.value if disto_spectral.value else None
    )
elif _analysis_type == "tf":
    analysis = _simulation.transfer_function(
        outvar=tf_output.value,
        insrc=tf_input.value
    )
elif _analysis_type == "dc_sens":
    analysis = _simulation.dc_sensitivity(
        output_variable=dc_sens_output.value
    )
elif _analysis_type == "ac_sens":
    analysis = _simulation.ac_sensitivity(
        output_variable=ac_sens_output.value,
        variation=ac_sens_variation.value,
        number_of_points=int(ac_sens_points.value),
        start_frequency=ac_sens_start_freq.value,
        stop_frequency=ac_sens_stop_freq.value
    )

print("Analysis completed successfully!")
return (analysis,)
```

--------------------------------

### Run Nyancad Application

Source: https://nyancad.com

This is the main entry point for running the Nyancad application. It calls the app.run() function when the script is executed directly.

```python
if __name__ == "__main__":
    app.run()
```

--------------------------------

### Marimo App Cell for Circuit Analysis Widgets

Source: https://nyancad.com

This Marimo app cell creates various UI widgets for different circuit analysis types (Operating Point, DC, AC, Transient). It utilizes persisted widget states and helper functions for dropdowns.

```python
@app.cell(hide_code=True)
def _(mo, spice, widget_state):
    # Create all widgets using circuit data and persisted state
    element_names = list(spice.element_names)
    node_names = list(spice.node_names)

    # Helper function to get dropdown value with fallback
    def get_dropdown_value(stored_value, options):
        if stored_value is not None and stored_value in options:
            return stored_value
        return options[0] if options else None

    # Operating Point Analysis UI
    op_back_annotate = mo.ui.checkbox(label="Back-annotate", value=widget_state["op_back_annotate"])

    # DC Analysis UI
    dc_source = mo.ui.dropdown(element_names, label="Source Name", 
                                value=get_dropdown_value(widget_state["dc_source"], element_names))
    dc_start = mo.ui.number(label="Start Value", value=widget_state["dc_start"], step=0.1)
    dc_stop = mo.ui.number(label="Stop Value", value=widget_state["dc_stop"], step=0.1)
    dc_step = mo.ui.number(label="Step Value", value=widget_state["dc_step"], step=0.01)

    # AC Analysis UI
    ac_variation = mo.ui.dropdown(["dec", "oct", "lin"], value=widget_state["ac_variation"], label="Point Spacing")
    ac_points = mo.ui.number(label="Number of Points", value=widget_state["ac_points"], step=1)
    ac_start_freq = mo.ui.number(label="Start Frequency (Hz)", value=widget_state["ac_start_freq"], step=1)
    ac_stop_freq = mo.ui.number(label="Stop Frequency (Hz)", value=widget_state["ac_stop_freq"], step=1000)

    # Transient Analysis UI
    tran_step = mo.ui.number(label="Step Time (s)", value=widget_state["tran_step"], step=1e-6)
    tran_start = mo.ui.number(label="Start Time (s)", value=widget_state["tran_start"], step=1e-6)
    tran_stop = mo.ui.number(label="End Time (s)", value=widget_state["tran_stop"], step=1e-
```

--------------------------------

### Marimo App Cell for Vector Selection UI

Source: https://nyancad.com

This Marimo app cell generates a multiselect dropdown for choosing simulation vectors. It handles initial selection persistence and includes probed net functionality.

```python
@app.cell(hide_code=True)
def _(analysis, mo, probed_net, widget_state):
    _options = [*analysis.nodes.keys(), *analysis.branches.keys()]

    # Start with persisted selection or default to all options
    _value = widget_state["selected_vectors"]

    # Append probed net if it exists and not already selected
    if probed_net:
        if probed_net not in _value:
            _value = [*_value, probed_net]
        else:
            _value = [v for v in _value if v != probed_net]
    # Filter to only valid options
    _value = [v for v in _value if v in _options]

    vectors = mo.ui.multiselect(
        options=_options,
        label="Vectors",
        value=_value,
    )
    vectors
    return (vectors,)

```

--------------------------------

### Define Analysis Function Parameters

Source: https://nyancad.com

Defines a function that accepts numerous parameters for configuring various simulation analyses, including AC, DC, Distortion, Noise, Pole-Zero, and Sensitivity analyses. These parameters control simulation settings like frequency ranges, step sizes, number of points, and output nodes.

```python
def (
    ac_points,
    ac_sens_output,
    ac_sens_points,
    ac_sens_start_freq,
    ac_sens_stop_freq,
    ac_sens_variation,
    ac_start_freq,
    ac_stop_freq,
    ac_variation,
    dc_sens_output,
    dc_source,
    dc_start,
    dc_step,
    dc_stop,
    disto_f2overf1,
    disto_points,
    disto_spectral,
    disto_start_freq,
    disto_stop_freq,
    disto_variation,
    noise_output,
    noise_points,
    noise_ref,
    noise_src,
    noise_start_freq,
    noise_stop_freq,
    noise_summary,
    noise_variation,
    op_back_annotate,
    pz_node1,
    pz_node2,
)
```

--------------------------------

### Configure Nyancad Analysis Widget States

Source: https://nyancad.com

This code updates the widget_state dictionary with parameters for various analysis types. It's used to persist UI settings across rebuilds and configure specific analysis parameters like steps, frequencies, and node selections.

```python
widget_state["active_tab"] = simtabs.value
widget_state["selected_vectors"] = vectors.value

# Operating Point
widget_state["op_back_annotate"] = op_back_annotate.value

# DC Analysis
widget_state["dc_source"] = dc_source.value
widget_state["dc_start"] = dc_start.value
widget_state["dc_stop"] = dc_stop.value
widget_state["dc_step"] = dc_step.value

# AC Analysis
widget_state["ac_variation"] = ac_variation.value
widget_state["ac_points"] = ac_points.value
widget_state["ac_start_freq"] = ac_start_freq.value
widget_state["ac_stop_freq"] = ac_stop_freq.value

# Transient Analysis
widget_state["tran_step"] = tran_step.value
widget_state["tran_start"] = tran_start.value
widget_state["tran_stop"] = tran_stop.value
widget_state["tran_max"] = tran_max.value
widget_state["tran_uic"] = tran_uic.value

# Pole-Zero Analysis
widget_state["pz_node1"] = pz_node1.value
widget_state["pz_node2"] = pz_node2.value
widget_state["pz_node3"] = pz_node3.value
widget_state["pz_node4"] = pz_node4.value
widget_state["pz_tf_type"] = pz_tf_type.value
widget_state["pz_pz_type"] = pz_pz_type.value

# Noise Analysis
widget_state["noise_output"] = noise_output.value
widget_state["noise_ref"] = noise_ref.value
widget_state["noise_src"] = noise_src.value
widget_state["noise_variation"] = noise_variation.value
widget_state["noise_points"] = noise_points.value
widget_state["noise_start_freq"] = noise_start_freq.value
widget_state["noise_stop_freq"] = noise_stop_freq.value
widget_state["noise_summary"] = noise_summary.value

# Distortion Analysis
widget_state["disto_variation"] = disto_variation.value
widget_state["disto_points"] = disto_points.value
widget_state["disto_start_freq"] = disto_start_freq.value
widget_state["disto_stop_freq"] = disto_stop_freq.value
widget_state["disto_f2overf1"] = disto_f2overf1.value
widget_state["disto_spectral"] = disto_spectral.value

# Transfer Function Analysis
widget_state["tf_output"] = tf_output.value
widget_state["tf_input"] = tf_input.value

# DC Sensitivity Analysis
widget_state["dc_sens_output"] = dc_sens_output.value

# AC Sensitivity Analysis
widget_state["ac_sens_output"] = ac_sens_output.value
widget_state["ac_sens_variation"] = ac_sens_variation.value
widget_state["ac_sens_points"] = ac_sens_points.value
widget_state["ac_sens_start_freq"] = ac_sens_start_freq.value
widget_state["ac_sens_stop_freq"] = ac_sens_stop_freq.value
return
```

--------------------------------

### Create DataFrame for Analysis

Source: https://nyancad.com

Generates a pandas DataFrame indexed by time or frequency based on the analysis type. Populates the DataFrame with specified vectors from the analysis results.

```python
df = pd.DataFrame(index=np.array(analysis.time))
elif _analysis_type == "ac":
    df = pd.DataFrame(index=np.array(analysis.frequency))
else:
    df = pd.DataFrame()

for vec in vectors.value:
    df[vec] = np.array(analysis[vec])
return (df,)
```

--------------------------------

### Marimo App Cell for Plotting Analysis

Source: https://nyancad.com

This Marimo app cell dynamically selects and displays plots based on the selected analysis type (DC, transient, or AC). It requires several Marimo objects and dataframes as input.

```python
import marimo

__generated_with = "0.23.1"
app = marimo.App()


@app.cell(hide_code=True)
def _(bodeplot, df, hv, simtabs, sweepplot, timeplot):
    _analysis_type = simtabs.value

    if _analysis_type == "dc":
        plot = sweepplot(df).opts(responsive=True, height=500)
    elif _analysis_type == "tran":
        plot = timeplot(df).opts(responsive=True, height=500)
    elif _analysis_type == "ac":
        plot = bodeplot(df).opts(
            hv.opts.Curve(responsive=True, height=200)
        )
    else:
        plot = df

    plot
    return

```

--------------------------------

### Process DC or Transient Analysis Results

Source: https://nyancad.com

This code snippet processes the results of a DC or transient analysis. For DC analysis, it creates a Pandas DataFrame indexed by the sweep values. For transient analysis, it is intended for further processing, though the specific logic is not shown.

```python
_analysis_type = simtabs.value

if _analysis_type == "dc":
    df = pd.DataFrame(index=np.array(analysis.sweep))
elif _analysis_type == "tran":
    
```

--------------------------------

### Process Operating Point Simulation Data

Source: https://nyancad.com

This Python function processes operating point simulation data when the selected tab is 'op' and back annotation is enabled. It extracts node values and stores them in the reader's simulation_data.

```python
@app.cell
def _(analysis, op_back_annotate, reader, simtabs):
    if simtabs.value == "op" and op_back_annotate.value:
        data = {k: float(v[0]) for k, v in analysis.nodes.items()}
        reader.simulation_data = {"op": data}
    return
```

--------------------------------

### Resolve Probed Net Name from Schematic Element

Source: https://nyancad.com

Determines the net name associated with a probed element in the schematic. It handles wires and ports, converting their names to lowercase.

```python
_probed_element_id = reader.probed_element_id
reader.probed_element_id = ""

probed_net = ""
if _probed_element_id:
    _docs = reader.schematic_data[reader.name]
    _doc = _docs.get(_probed_element_id, {})
    if _doc.get('type') == 'wire':
        probed_net = (_doc.get('net') or '').lower()
    elif _doc.get('type') == 'port':
        probed_net = (_doc.get('name') or '').lower()
return (probed_net,)
```
Tokens:
Raw