PySpice

https://pyspice.fabrice-salvaire.fr/
Admin
PySpice is a Python interface to SPICE circuit simulators (Ngspice, Xyce) that enables circuit...
Tokens:503,783
Snippets:4,858
Trust Score:8.3
Update:6 months ago
Show doc for...
Tokens:
Raw
### PySpice Installation Guide

Source: https://pyspice.fabrice-salvaire.fr/releases/v1.5/api/PySpice/Spice.html

Instructions on how to install PySpice and its dependencies on various platforms (Windows, Linux, OSX). It also covers installing Ngspice or Xyce simulators and setting up the Python environment.

```bash
pip install PySpice
conda install -c conda-forge ngspice
```

```bash
git clone https://github.com/PySpice/PySpice.git
cd PySpice
pip install -e .
```

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

### PySpice Installation Guide

Source: https://pyspice.fabrice-salvaire.fr/releases/v1.5/examples/diode/RingModulator.html

Instructions on how to install PySpice and its dependencies on different platforms (Windows, Linux, OSX). It also covers installing Ngspice and Xyce simulators.

```bash
pip install PySpice
# On Linux/OSX, you might need to install Ngspice separately
# sudo apt-get install ngspice  (Debian/Ubuntu)
# brew install ngspice (macOS with Homebrew)

# For Xyce, refer to its official documentation for installation.
```

```bash
# Example for installing Ngspice on conda-forge
conda install -c conda-forge ngspice
```

```bash
# Installing from GitHub using pip
pip install git+https://github.com/PySpice/PySpice.git
```

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

### PySpice Installation from Source

Source: https://pyspice.fabrice-salvaire.fr/releases/v1.5/_modules/PySpice/Probe/Plot.html

Instructions for installing PySpice from its source code. This method provides more control and is often used by developers or for custom builds. It requires cloning the repository and then running the setup script. Dependencies should be installed beforehand.

```bash
git clone https://github.com/PySpice/PySpice.git
cd PySpice
pip install .
```

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

### Download PySpice Examples

Source: https://pyspice.fabrice-salvaire.fr/releases/v1.5/_sources/installation.rst.txt

Downloads example files for PySpice. These examples are not included in the standard pip or setup.py installation and need to be fetched separately.

```sh
pyspice-post-installation --download-example
```

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

### Download Ngspice DLL and Examples on Windows

Source: https://pyspice.fabrice-salvaire.fr/releases/v1.5/news.html

A post-installation tool is available to download the Ngspice DLL on Windows, ensuring proper integration with PySpice. This tool can also be used to download example circuits and the Ngspice PDF manual, aiding users in getting started and understanding PySpice's capabilities.

```python
from PySpice.Installer import post_install_tool
post_install_tool()
```

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

### Post-Installation Setup and Verification

Source: https://pyspice.fabrice-salvaire.fr/releases/v1.5/_sources/installation.rst.txt

Commands to automatically download the Ngspice DLL on Windows and verify the overall PySpice installation status.

```sh
pyspice-post-installation --install-ngspice-dll
pyspice-post-installation --check-install
```

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

### Running PySpice Examples in IPython Notebook

Source: https://pyspice.fabrice-salvaire.fr/releases/v1.5/_sources/example-introduction.rst.txt

Explains how to run PySpice examples using IPython Notebooks, which are ideal for interactive exploration and documentation. It includes the necessary command to start the notebook server and the Matplotlib backend configuration for embedding plots.

```sh
ipython notebook
```

```py
%matplotlib inline
```

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

### Build and Install PySpice from Source

Source: https://pyspice.fabrice-salvaire.fr/releases/v1.5/_sources/installation.rst.txt

Builds and installs PySpice from its source code after cloning the repository. Requires Python and setuptools.

```sh
python setup.py build
python setup.py install
```

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

### Running PySpice Examples in IPython

Source: https://pyspice.fabrice-salvaire.fr/releases/v1.5/_sources/example-introduction.rst.txt

Shows how to run PySpice examples within the IPython interactive environment. It includes commands to start IPython with Matplotlib integration and execute scripts using the magic command '%run'.

```sh
ipython --matplotlib
```

```sh
ipython --matplotlib-qt
```

```sh
ipython qtconsole
```

```py
%run examples/../foo.py
```

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

### PySpice API Documentation - Scripts pyspice_post_installation

Source: https://pyspice.fabrice-salvaire.fr/releases/v1.5/index.html

This documentation refers to the 'pyspice_post_installation' script within the Scripts module of PySpice. This script is executed after the initial installation to complete the setup.

```python
# Documentation reference for PySpice.Spice.Scripts.pyspice_post_installation
# This script is run after PySpice installation to finalize setup.
# Example usage (command line, typically run automatically after pip install):
# python -m PySpice.Spice.Scripts.pyspice_post_installation
pass

```

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

### PySpice NMOS Example

Source: https://pyspice.fabrice-salvaire.fr/releases/v1.5/news.html

An example demonstrating the simulation of an NMOS transistor has been added, contributed by cyber-g. This example helps users understand how to model and simulate NMOS devices within PySpice.

```python
from PySpice.Spice.Netlist import Circuit

circuit = Circuit('NMOS Example')
circuit.model('nmos_model', 'nmos', level=1, vto=1.0, kp=100e-6)
circuit.NMOS(1, 'd', 'g', 's', model='nmos_model')
circuit.V('d', 'd', circuit.gnd, 0)
circuit.V('g', 'g', circuit.gnd, 1.0) # Example gate voltage
circuit.save('d')
```

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

### Setting up Python Environment for PySpice on Linux

Source: https://pyspice.fabrice-salvaire.fr/releases/v1.5/api/PySpice/Spice/HighLevelElement.html

This guide explains how to set up the necessary Python environment on Linux for using PySpice. It typically involves creating a virtual environment and installing PySpice and its dependencies.

```bash
python -m venv pspice_env
source pspice_env/bin/activate
pip install PySpice
```

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

### Running PySpice Examples from Console

Source: https://pyspice.fabrice-salvaire.fr/releases/v1.5/_sources/example-introduction.rst.txt

Demonstrates how to execute a PySpice example script directly from the command line using the Python interpreter. This method is suitable for batch processing or when working with files in an editor.

```sh
python examples/.../foo.py
```

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

### Example Usage of AC Sensitivity Analysis in PySpice

Source: https://pyspice.fabrice-salvaire.fr/releases/v1.5/api/PySpice/Spice/Simulation.html

Example demonstrating how to initiate an AC sensitivity analysis using the CircuitSimulation class.

```python
analysis = simulator.ac_sensitivity(...)
```

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

### Internal Device Parameters Example

Source: https://pyspice.fabrice-salvaire.fr/releases/v1.5/examples/advanced-usages/internal-device-parameters.html

This example shows how to access internal device parameters, such as VDSAT, by defining subcircuits and performing a DC analysis.

```APIDOC
## Accessing Internal Device Parameters

### Description
This section demonstrates how to access internal device parameters of a MOSFET within a PySpice simulation. It involves defining subcircuits for a simple circuit and then using the simulator to probe specific parameters like VDSAT.

### Method
GET (Implicit, as we are simulating and retrieving data)

### Endpoint
N/A (This is a simulation script, not a REST endpoint)

### Parameters
None

### Request Example
```python
import PySpice.Logging.Logging as Logging
logger = Logging.setup_logging()

from PySpice.Doc.ExampleTools import find_libraries
from PySpice.Probe.Plot import plot
from PySpice.Spice.Library import SpiceLibrary
from PySpice.Spice.Netlist import Circuit, SubCircuit, SubCircuitFactory
from PySpice.Unit import *


class Level2(SubCircuitFactory):
    NAME = 'level2'
    NODES = ('d4', 'g4', 'v4')
    def __init__(self):
        super().__init__()
        self.M(1, 'd4', 'g4', 'v4', 'v4', model='NMOS', w=1e-5, l=3.5e-7)

class Level1(SubCircuitFactory):
    NAME = 'level1'
    NODES = ('d3', 'g3', 'v3')
    def __init__(self):
        super().__init__()
        self.X('mos2', 'level2', 'd3', 'g3', 'v3')
        self.subcircuit(Level2())

circuit = Circuit('Transistor output characteristics')
circuit.V('dd', 'd1', circuit.gnd, 2)
circuit.V('ss', 'vsss', circuit.gnd, 0)
circuit.V('sig', 'g1', 'vsss', 0)
circuit.X('mos1', 'level1', 'd1', 'g1', 'vsss')

if True:
    circuit.subcircuit(Level1())
else:
    subcircuit_level2 = SubCircuit('level2', 'd4', 'g4', 'v4')
    subcircuit_level2.M(1, 'd4', 'g4', 'v4', 'v4', model='NMOS', w=1e-5, l=3.5e-7)

    subcircuit_level1 = SubCircuit('level1', 'd3', 'g3', 'v3')
    subcircuit_level1.X('mos2', 'level2', 'd3', 'g3', 'v3')
    subcircuit_level1.subcircuit(subcircuit_level2)

    circuit.subcircuit(subcircuit_level1)

circuit.model('NMOS', 'NMOS', LEVEL=8)

print(str(circuit))


simulator = circuit.simulator(temperature=25, nominal_temperature=25)
# Fixme: python return code is not 0 on Windows if the following line is executed
#        but any error is reported
## analysis = simulator.dc(Vdd=slice(0, 5, .1)) # Fixme: ,Vsig=slice(1, 5, 1)

```

### Response
#### Success Response (200)
- **Simulation Output**: The script prints the netlist and would typically output simulation results if the analysis line was uncommented and executed.

#### Response Example
```
Circuit: Transistor output characteristics

# Component Definitions
# ... (Netlist details would be printed here) ...

# Simulation Results (if analysis was run):
# The output would typically be a data structure containing probed values.
```
```

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

### Basic PySpice Simulation Example

Source: https://pyspice.fabrice-salvaire.fr/releases/v1.5/index.html

This example demonstrates a fundamental simulation using PySpice. It likely involves defining a circuit, setting up simulation parameters, and running the simulation.

```python
# Example of a basic simulation in PySpice
import PySpice.Logging.Logging as Logging
logger = Logging.setup_logging()

from PySpice.Spice.Netlist import Circuit
from PySpice.Unit import * # For units like *V, *A, *Ohm etc.

circuit = Circuit('Simple Voltage Source')

# Define the circuit components
circuit.V('input', 'node1', circuit.gnd, 1@u_V) # Voltage source of 1V
circuit.R(1, 'node1', circuit.gnd, 1@u_kOhm) # Resistor of 1kOhm

# Setup the simulation
simulator = circuit.simulator(temperature=25, nominal_temperature=25)
analysis = simulator.operating_point(circuit.V('input'))

# Access simulation results
voltage_at_node1 = analysis['node1']
current_through_R1 = -analysis['node1'] # Current flows from node1 to gnd through R1

print(f'Voltage at node1: {voltage_at_node1:.4f}')
print(f'Current through R1: {current_through_R1:.4f}')

```

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

### Install PySpice from GitHub

Source: https://pyspice.fabrice-salvaire.fr/releases/v1.5/installation.html

Installs the latest stable or development version of PySpice directly from the GitHub repository using pip.

```bash
pip install git+https://github.com/FabriceSalvaire/PySpice
pip install git+https://github.com/FabriceSalvaire/PySpice@devel
```

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

### PySpice Installation from GitHub using pip

Source: https://pyspice.fabrice-salvaire.fr/releases/v1.5/_modules/PySpice/Probe/Plot.html

This snippet shows how to install a more recent version of PySpice directly from its GitHub repository using pip. It's useful for users who need the latest features or bug fixes not yet released in a stable version. Ensure you have pip and Git installed.

```bash
pip install git+https://github.com/PySpice/PySpice.git
```

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

### PySpice API Documentation - ConfigInstall

Source: https://pyspice.fabrice-salvaire.fr/releases/v1.5/index.html

This section likely pertains to the configuration and installation aspects of the PySpice library. It may include details on setting up the environment or installing necessary dependencies.

```python
# Documentation reference for PySpice.Spice.Config.ConfigInstall
# This is a placeholder and does not contain executable code.
# Actual usage would involve importing and utilizing functions from this module.
pass

```

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

### Circuit Simulation Setup

Source: https://pyspice.fabrice-salvaire.fr/releases/v1.5/_modules/PySpice/Spice/Netlist.html

Shows how to create a simulator instance from a circuit object to prepare for circuit simulation.

```APIDOC
## Circuit Simulation Setup

### Description
This section describes the process of obtaining a simulator object from a defined circuit, which is the first step before running any SPICE analyses.

### Method
N/A (Illustrative Example)

### Endpoint
N/A

### Parameters
N/A

### Request Example
N/A

### Response
N/A

### Code Example
```python3
# Assuming 'circuit' is an instance of Circuit defined previously

simulator = circuit.simulator()
```
```

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

### PySpice Installation Script

Source: https://pyspice.fabrice-salvaire.fr/releases/v1.5/index.html

This script is part of the PySpice post-installation process. It likely handles setup or verification steps required after PySpice is installed.

```bash
pyspice_post_installation
```

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

### Initialize and Query SpiceLibrary

Source: https://pyspice.fabrice-salvaire.fr/releases/v1.5/_modules/PySpice/Spice/Library.html

Demonstrates how to instantiate the SpiceLibrary with a root path and retrieve the file path for a specific component definition like a 1N4148 diode.

```python
from pyspice.Library import SpiceLibrary

# Initialize the library
spice_library = SpiceLibrary('/path/to/spice/models/')

# Retrieve file path for a specific sub-circuit or model
path = spice_library['1N4148']
```

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

### Initialize and Execute SpiceServer

Source: https://pyspice.fabrice-salvaire.fr/releases/v1.5/_modules/PySpice/Spice/NgSpice/Server.html

Demonstrates how to instantiate the SpiceServer class with a custom command path and execute a simulation by passing input data. The call returns a RawFile instance containing the simulation results.

```python
spice_server = SpiceServer(spice_command='/path/to/ngspice')
raw_file = spice_server(spice_input)
```

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

### PySpice Configuration API

Source: https://pyspice.fabrice-salvaire.fr/releases/v1.5/examples/diode/index.html

APIs for configuring PySpice, including installation and setup.

```APIDOC
## PySpice Configuration API

### Description
Provides functionalities for configuring and setting up PySpice, including installation procedures.

### Method
N/A (Configuration module)

### Endpoint
N/A

### Parameters
N/A

### Request Example
N/A

### Response
N/A
```

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

### Initialize and Run Circuit Simulation (Python)

Source: https://pyspice.fabrice-salvaire.fr/releases/v1.5/_modules/PySpice/Spice/Netlist.html

Demonstrates the process of setting up and running a circuit simulation using PySpice. It involves creating a simulator instance from a defined circuit object.

```python3
simulator = circuit.simulator()
```

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

### GET /api/pyspice/config

Source: https://pyspice.fabrice-salvaire.fr/releases/v1.5/genindex.html

Retrieves the current installation and environment configuration for the PySpice library.

```APIDOC
## GET /api/pyspice/config

### Description
Fetches the configuration settings for the PySpice installation, including paths to external binaries.

### Method
GET

### Endpoint
/api/pyspice/config

### Parameters
None

### Response
#### Success Response (200)
- **version** (string) - Current PySpice version.
- **paths** (object) - Configured paths for simulators.

#### Response Example
{
  "version": "1.5.0",
  "paths": {
    "ngspice": "/usr/bin/ngspice"
  }
}
```

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

### GET /api/pyspice/config/install

Source: https://pyspice.fabrice-salvaire.fr/releases/v1.5/api/PySpice/Config.html

Retrieves the current installation configuration settings for the PySpice environment.

```APIDOC
## GET /api/pyspice/config/install

### Description
Fetches the configuration details related to the PySpice installation, including paths and environment variables required for simulation execution.

### Method
GET

### Endpoint
/api/pyspice/config/install

### Parameters
#### Query Parameters
- **format** (string) - Optional - The response format (e.g., json, yaml).

### Request Example
GET /api/pyspice/config/install?format=json

### Response
#### Success Response (200)
- **install_path** (string) - The root directory of the PySpice installation.
- **version** (string) - The current version of the installed package.
- **ngspice_path** (string) - Path to the NgSpice binary.

#### Response Example
{
  "install_path": "/usr/local/lib/python3.x/site-packages/PySpice",
  "version": "1.5.0",
  "ngspice_path": "/usr/bin/ngspice"
}
```

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

### XyceServer Initialization and Usage

Source: https://pyspice.fabrice-salvaire.fr/releases/v1.5/_modules/PySpice/Spice/Xyce/Server.html

Demonstrates how to initialize the XyceServer and use it to run a SPICE simulation.

```APIDOC
## XyceServer

### Description
This class wraps the execution of Xyce and converts the output to a Python data structure.

### Method
`__init__(self, xyce_command=None)`

### Parameters
- **xyce_command** (str) - Optional - The path to the Xyce executable. Defaults to `XyceServer.XYCE_COMMAND`.

### Usage Example
```python
from PySpice.Spice.XyceServer import XyceServer

# Initialize XyceServer with a custom command path
spice_server = XyceServer(xyce_command='/path/to/Xyce')

# Or use the default command path
# spice_server = XyceServer()

# Define your SPICE input
spice_input = """
* Simple RC circuit

V1 1 0 5V
R1 1 2 1k
C1 2 0 1uF
.tran 1u 10m
.save V(2)
.end
"""

# Run the simulation
raw_file = spice_server(spice_input)

# The 'raw_file' object is a PySpice.Spice.RawFile instance
# You can now access simulation data from it
print(raw_file.get_trace_names())
```

### `__call__` Method

#### Description
Runs SPICE in server mode as a subprocess for the given input and returns a :obj:`PySpice.RawFile.RawFile` instance.

#### Method
`__call__(self, spice_input)`

#### Parameters
- **spice_input** (str) - The SPICE netlist input as a string.

#### Returns
- **RawFile** - A `PySpice.Spice.RawFile` instance containing the simulation output.

#### Raises
- **NameError** - If errors or simulation failures are detected in Xyce's output.

#### Request Example
(This method is called internally by the `XyceServer` instance)

#### Response Example
(The return value is a `RawFile` object, not a direct JSON response)

```python
# Example of accessing data from the returned RawFile object
# Assuming 'raw_file' is the result of spice_server(spice_input)

times = raw_file['time']
voltage_at_node_2 = raw_file['V(2)']

# You can then plot or process these values
# import matplotlib.pyplot as plt
# plt.plot(times, voltage_at_node_2)
# plt.xlabel('Time (s)')
# plt.ylabel('Voltage at Node 2 (V)')
# plt.title('Transient Analysis')
# plt.grid(True)
# plt.show()
```
```

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

### Install PySpice with Anaconda/conda-forge

Source: https://pyspice.fabrice-salvaire.fr/releases/v1.5/news.html

This section describes how to install PySpice and Ngspice using Anaconda or conda-forge, simplifying the setup process on Windows, macOS, and Linux platforms. It also mentions a post-installation tool for downloading Ngspice DLLs and checking the installation on Windows.

```bash
conda install -c conda-forge pypyspice
conda install -c conda-forge ngspice
```

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

### Initialize and Query SpiceLibrary

Source: https://pyspice.fabrice-salvaire.fr/releases/v1.5/api/PySpice/Spice/Library.html

Demonstrates how to instantiate the SpiceLibrary class with a root path and retrieve a specific sub-circuit or model definition by its name.

```python
from PySpice.Spice.Library import SpiceLibrary

# Initialize the library by scanning a directory path
spice_library = SpiceLibrary('/some/path/')

# Retrieve the file path for a specific sub-circuit or model
model_path = spice_library['1N4148']
```

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

### Buck Converter Circuit Setup and Simulation (Python)

Source: https://pyspice.fabrice-salvaire.fr/releases/v1.5/_sources/examples/switched-power-supplies/buck-converter.rst.txt

This Python script sets up a buck converter circuit using PySpice. It calculates necessary component values like inductance (L), output capacitance (Cout), and input capacitance (Cin) based on desired voltage, current, and ripple specifications. The script then defines the circuit netlist, includes necessary Spice libraries for components like diodes and MOSFETs, and simulates the transient behavior of the converter. Finally, it plots the output voltage and source voltage over time.

```python
import matplotlib.pyplot as plt

import PySpice.Logging.Logging as Logging
logger = Logging.setup_logging()

from PySpice.Doc.ExampleTools import find_libraries
from PySpice.Probe.Plot import plot
from PySpice.Spice.Library import SpiceLibrary
from PySpice.Spice.Netlist import Circuit
from PySpice.Unit import *

libraries_path = find_libraries()
spice_library = SpiceLibrary(libraries_path)


circuit = Circuit('Buck Converter')

circuit.include(spice_library['1N5822']) # Schottky diode
circuit.include(spice_library['irf150'])

# From Microchip WebSeminars - Buck Converter Design Example

Vin = 12@u_V
Vout = 5@u_V
ratio = Vout / Vin

Iload = 2@u_A
Rload = Vout / (.8 * Iload)

frequency = 400@u_kHz
period = frequency.period
duty_cycle = ratio * period

ripple_current = .3 * Iload # typically 30 %
ripple_voltage = 50@u_mV

print('ratio =', ratio)
print('RLoad =', Rload)
print('period =', period.canonise())
print('duty_cycle =', duty_cycle.canonise())
print('ripple_current =', ripple_current)


L = (Vin - Vout) * duty_cycle / ripple_current
RL = 37@u_mÎ©


ESR = 30@u_mÎ©
ESL = 0
Cout = (ripple_current * duty_cycle) / (ripple_voltage - ripple_current * ESR)

ripple_current_in = Iload / 2
ripple_voltage_in = 200@u_mV
ESR_in = 120@u_mÎ©
Cin = duty_cycle / (ripple_voltage_in / ripple_current_in - ESR_in)

L = L.canonise()
Cout = Cout.canonise()
Cin = Cin.canonise()

print('L =', L)
print('Cout =', Cout)
print('Cint =', Cin)

circuit.V('in', 'in', circuit.gnd, Vin)
circuit.C('in', 'in', circuit.gnd, Cin)

# Fixme: out drop from 12V to 4V
# circuit.VCS('switch', 'gate', circuit.gnd, 'in', 'source', model='Switch', initial_state='off')
# circuit.PulseVoltageSource('pulse', 'gate', circuit.gnd, 0@u_V, Vin, duty_cycle, period)
# circuit.model('Switch', 'SW', ron=1@u_mÎ©, roff=10@u_MÎ©)

# Fixme: Vgate => Vout ???
circuit.X('Q', 'irf150', 'in', 'gate', 'source')
# circuit.PulseVoltageSource('pulse', 'gate', 'source', 0@u_V, Vin, duty_cycle, period)
circuit.R('gate', 'gate', 'clock', 1@u_Î©)
circuit.PulseVoltageSource('pulse', 'clock', circuit.gnd, 0@u_V, 2.*Vin, duty_cycle, period)

circuit.X('D', '1N5822', circuit.gnd, 'source')
circuit.L(1, 'source', 1, L)
circuit.R('L', 1, 'out', RL)
circuit.C(1, 'out', circuit.gnd, Cout) # , initial_condition=0@u_V
circuit.R('load', 'out', circuit.gnd, Rload)

simulator = circuit.simulator(temperature=25, nominal_temperature=25)
analysis = simulator.transient(step_time=period/300, end_time=period*150)

figure, ax = plt.subplots(figsize=(20, 10))

ax.plot(analysis.out)
ax.plot(analysis['source'])
# ax.plot(analysis['source'] - analysis['out'])
# ax.plot(analysis['gate'])
ax.axhline(y=float(Vout), color='red')
ax.legend(('Vout [V]', 'Vsource [V]'), loc=(.8,.8))
ax.grid()
ax.set_xlabel('t [s]')
ax.set_ylabel('[V]')

plt.tight_layout()
plt.show()
```

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

### File and Directory Management with PySpice

Source: https://pyspice.fabrice-salvaire.fr/releases/v1.5/api/PySpice/Tools/File.html

Example demonstrating the usage of the Path, File, and Directory classes for file system operations.

```python
from PySpice.Tools.File import File, Directory, Path

# Working with a file
my_file = File('example.txt', path='/tmp')
print(f"Filename: {my_file.filename}")
print(f"SHA256: {my_file.shasum}")

# Working with a directory
my_dir = Directory('/home/user/projects')
for file_path in my_dir.iter_file():
    print(f"Found file: {file_path}")

# Path manipulation
my_path = Path('/etc/config')
if my_path.is_directory():
    print("Path is a directory")
```

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

### Setting up PySpice Development Environment

Source: https://pyspice.fabrice-salvaire.fr/releases/v1.5/examples/diode/voltage-multiplier.html

Tips for setting up a development environment for PySpice. This includes installing necessary dependencies and configuring the environment for active development and testing. It's crucial for contributors to the PySpice project.

```bash
# Example: Install development dependencies
pip install -r requirements-dev.txt
# Example: Set up pre-commit hooks
pre-commit install
```

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

### Initialize PySpice Circuit and Library

Source: https://pyspice.fabrice-salvaire.fr/releases/v1.5/_sources/examples/diode/diode-recovery-time.rst.txt

Sets up the logging environment and initializes the Spice library required for circuit simulations.

```python
import PySpice.Logging.Logging as Logging
logger = Logging.setup_logging()
from PySpice.Doc.ExampleTools import find_libraries
from PySpice.Spice.Library import SpiceLibrary
libraries_path = find_libraries()
spice_library = SpiceLibrary(libraries_path)
```

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

### AC Coupled Amplifier Circuit

Source: https://pyspice.fabrice-salvaire.fr/releases/v1.5/examples/basic-usages/index.html

Demonstrates the setup for an AC-coupled amplifier using a transistor. This example is useful for understanding basic analog circuit design and simulation.

```python
from PySpice.Spice.Netlist import Circuit
from PySpice.Unit import *

circuit = Circuit('AC Coupled Amplifier')

# Define transistor (e.g., NPN BJT)
# Example: Q1 collector base emitter NPN_model
circuit.BJT(1, 'collector', 'base', 'emitter')

# Define biasing resistors and capacitors
circuit.R(1, 'vin', 'base', 100@u_kOhm) # Input resistor
circuit.C(1, 'vin', circuit.gnd, 1@u_uF) # Input coupling capacitor
circuit.R(2, 'collector', 'vcc', 1@u_kOhm) # Collector resistor
circuit.R(3, 'base', circuit.gnd, 47@u_kOhm) # Base bias resistor
circuit.R(4, 'emitter', circuit.gnd, 1@u_kOhm) # Emitter resistor
circuit.C(2, 'emitter', circuit.gnd, 10@u_uF) # Emitter bypass capacitor
circuit.C(3, 'collector', 'out', 1@u_uF) # Output coupling capacitor

# Define power supply
circuit.V('power', 'vcc', circuit.gnd, 5@u_V)

# Define input signal (e.g., AC source for AC analysis)
# circuit.SinusoidalVoltageSource('input', 'vin', circuit.gnd, amplitude=1@u_mV, frequency=1@u_kHz)

# Simulation commands would follow...
```

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

### Configure Simulator Instance

Source: https://pyspice.fabrice-salvaire.fr/releases/v1.5/faq.html

Demonstrates how to specify the simulator type or executable path when creating a simulator instance from a circuit object.

```python
simulator = circuit.simulator(simulator='ngspice-shared')
simulator = circuit.simulator(spice_command='/path/to/ngspice')
simulator = circuit.simulator(xyce_command='/path/to/xyce')
```

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

### Simulate Half-Wave and Full-Wave Rectification

Source: https://pyspice.fabrice-salvaire.fr/releases/v1.5/_sources/examples/diode/rectification.rst.txt

Demonstrates the setup and transient simulation of half-wave and full-wave rectifier circuits. It includes examples of adding capacitive filtering to smooth the output signal.

```python
import matplotlib.pyplot as plt
import PySpice.Logging.Logging as Logging
logger = Logging.setup_logging()
from PySpice.Doc.ExampleTools import find_libraries
from PySpice.Probe.Plot import plot
from PySpice.Spice.Library import SpiceLibrary
from PySpice.Spice.Netlist import Circuit
from PySpice.Unit import *
libraries_path = find_libraries()
spice_library = SpiceLibrary(libraries_path)
figure1, ((ax1, ax2), (ax3, ax4)) = plt.subplots(2, 2, figsize=(20, 10))
circuit = Circuit('half-wave rectification')
circuit.include(spice_library['1N4148'])
source = circuit.SinusoidalVoltageSource('input', 'in', circuit.gnd, amplitude=10@u_V, frequency=50@u_Hz)
circuit.X('D1', '1N4148', 'in', 'output')
circuit.R('load', 'output', circuit.gnd, 100@u_Ω)
simulator = circuit.simulator(temperature=25, nominal_temperature=25)
analysis = simulator.transient(step_time=source.period/200, end_time=source.period*2)
ax1.set_title('Half-Wave Rectification')
ax1.plot(analysis['in'])
ax1.plot(analysis.output)
circuit.C('1', 'output', circuit.gnd, 1@u_mF)
simulator = circuit.simulator(temperature=25, nominal_temperature=25)
analysis = simulator.transient(step_time=source.period/200, end_time=source.period*2)
ax2.set_title('Half-Wave Rectification with filtering')
ax2.plot(analysis['in'])
ax2.plot(analysis.output)
circuit = Circuit('half-wave rectification')
circuit.include(spice_library['1N4148'])
source = circuit.SinusoidalVoltageSource('input', 'in', circuit.gnd, amplitude=10, frequency=50)
circuit.X('D1', '1N4148', 'in', 'output_plus')
circuit.R('load', 'output_plus', 'output_minus', 100@u_Ω)
circuit.X('D2', '1N4148', 'output_minus', circuit.gnd)
circuit.X('D3', '1N4148', circuit.gnd, 'output_plus')
circuit.X('D4', '1N4148', 'output_minus', 'in')
simulator = circuit.simulator(temperature=25, nominal_temperature=25)
analysis = simulator.transient(step_time=source.period/200, end_time=source.period*2)
ax3.set_title('Full-Wave Rectification')
ax3.plot(analysis['in'])
ax3.plot(analysis.output_plus - analysis.output_minus)
circuit.C('1', 'output_plus', 'output_minus', 1@u_mF)
simulator = circuit.simulator(temperature=25, nominal_temperature=25)
analysis = simulator.transient(step_time=source.period/200, end_time=source.period*2)
ax4.set_title('Full-Wave Rectification with filtering')
ax4.plot(analysis['in'])
ax4.plot(analysis.output_plus - analysis.output_minus)
plt.tight_layout()
```

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

### Kicad Netlist Example (Spice)

Source: https://pyspice.fabrice-salvaire.fr/releases/v1.5/examples/spice-parser/kicad-example.html

This is a sample netlist file generated by Kicad's Eeschema. It defines components like Opamp, JackIn, JackOut, and PowerIn, along with their connections and resistor values. Note the use of numbered nodes and subcircuit definitions starting with _X_.

```spice
* /home/gv/fabrice/developpement/PySpice/examples/spice-parser/kicad-pyspice-example/kicad-pyspice-example.cir

* EESchema Netlist Version 1.1 (Spice format) creation date: dim. 29 nov. 2015 18:04:33 CET

* To exclude a component from the Spice Netlist add [Spice_Netlist_Enabled] user FIELD set to: N
* To reorder the component spice node sequence add [Spice_Node_Sequence] user FIELD and define sequence: 2,1,0

* Sheet Name: /
X3  7 6 5 4 1 Opamp
X1  2 5 5 JackIn
X4  7 3 5 JackOut
R2  6 7 50K
R1  2 6 2K
R3  5 3 2K
X2  4 5 1 PowerIn

.end

```

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

### PySpice Circuit Setup and Logging

Source: https://pyspice.fabrice-salvaire.fr/releases/v1.5/examples/fundamental-laws/thevenin-norton-theorem.html

Initializes PySpice logging and imports necessary classes for circuit definition and unit handling.

```python
import PySpice.Logging.Logging as Logging
logger = Logging.setup_logging()

from PySpice.Spice.Netlist import Circuit
from PySpice.Unit import *
```

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

### Install PySpice from GitHub

Source: https://pyspice.fabrice-salvaire.fr/releases/v1.5/_sources/installation.rst.txt

Installs a specific version of PySpice directly from its GitHub repository. Supports installing the stable or development branches.

```sh
pip install git+https://github.com/FabriceSalvaire/PySpice

pip install git+https://github.com/FabriceSalvaire/PySpice@devel
```

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

### PySpice ngspice DLL Installation Check

Source: https://pyspice.fabrice-salvaire.fr/releases/v1.5/_modules/PySpice/Scripts/pyspice_post_installation.html

This Python code checks if the ngspice DLL installation should proceed. It verifies if the operating system is Windows ('nt') or if a force installation is requested. If neither condition is met, the function returns without performing the installation.

```python
import os

if not(os.name == 'nt' or self._args.force_install_ngspice_dll):
    return
```

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

### Install PySpice using Conda or Pip

Source: https://pyspice.fabrice-salvaire.fr/releases/v1.5/_sources/installation.rst.txt

Installs the PySpice library using either the conda package manager (for Anaconda/Miniconda users) or pip. It also includes a command to check the installation.

```sh
conda install -c conda-forge pyspice

# or

pip install PySpice

# and eventually

pyspice-post-installation --check-install
```

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

### Basic Circuit Simulation with PySpice

Source: https://pyspice.fabrice-salvaire.fr/releases/v1.5/api/PySpice/Spice.html

Example demonstrating how to define a simple circuit netlist, simulate it using PySpice, and access simulation results. This includes setting up the circuit, running the simulation, and plotting waveforms.

```python
import PySpice.Logging.Logging as Logging
from PySpice.Spice.Netlist import Circuit

logger = Logging.setup_logging()

circuit = Circuit('Simple Resistor Circuit')

# Define components
circuit.R(1, 'in', 'out', 1@u_kOhm)
circuit.V(1, 'in', circuit.gnd, 5@u_V)

# Simulation
simulator = circuit.simulator(temperature=25, nominal_temperature=25)
analysis = simulator.dc(V1=slice(0, 10@u_V, 0.1@u_V))

# Access results
voltage = analysis['out']
current = analysis['in'] - analysis['out']

print(f'Voltage at out node: {voltage}')
print(f'Current through R1: {current}')
```

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

### Import PySpice Libraries and Setup

Source: https://pyspice.fabrice-salvaire.fr/releases/v1.5/examples/transistor/ac-coupled-amplifier.html

Imports necessary libraries from PySpice for circuit simulation, logging, and plotting. It also includes a utility to find Spice libraries and sets up logging.

```python
import matplotlib.pyplot as plt


import PySpice.Logging.Logging as Logging
logger = Logging.setup_logging()


from PySpice.Doc.ExampleTools import find_libraries
from PySpice.Probe.Plot import plot
from PySpice.Spice.Library import SpiceLibrary
from PySpice.Spice.Netlist import Circuit
from PySpice.Unit import *


libraries_path = find_libraries()
spice_library = SpiceLibrary(libraries_path)
```

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

### PySpice Examples as Python Files and Jupyter Notebooks

Source: https://pyspice.fabrice-salvaire.fr/releases/v1.5/news.html

Examples for PySpice are now available in both standard Python (.py) files and Jupyter Notebook (.ipynb) formats. This provides flexibility for users to run and experiment with the examples in their preferred environment.

```python
# This entry represents a change in how examples are distributed.
# Actual code would be within the example files themselves.
# Example: A simple circuit definition in a Python file:
# from PySpice.Spice.Netlist import Circuit
# circuit = Circuit('Simple Example')
# circuit.V(1, 'in', circuit.gnd, 1@u_V)
# circuit.R(1, 'in', 'out', 1@u_kOhm)
# circuit.save(circuit.nodes.out)
```

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

### Initialize PySpice Environment

Source: https://pyspice.fabrice-salvaire.fr/releases/v1.5/_sources/examples/diode/diode-characteristic-curve.rst.txt

Sets up the logging and library paths required for PySpice simulations. This is a prerequisite step before defining any circuit components.

```python
import numpy as np
import matplotlib.pyplot as plt
import matplotlib.ticker as ticker
import PySpice.Logging.Logging as Logging
logger = Logging.setup_logging()
from PySpice.Doc.ExampleTools import find_libraries
from PySpice.Spice.Netlist import Circuit
from PySpice.Spice.Library import SpiceLibrary
from PySpice.Unit import *
from PySpice.Physics.SemiConductor import ShockleyDiode
libraries_path = find_libraries()
spice_library = SpiceLibrary(libraries_path)
```

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

### PySpice Post Installation Module

Source: https://pyspice.fabrice-salvaire.fr/releases/v1.5/api/PySpice/Scripts/pyspice_post_installation.html

Provides utilities for checking PySpice installation and managing ngspice components.

```APIDOC
## PySpice Post Installation Scripts

### Description
This module contains scripts to perform post-installation checks and setup for PySpice.

### Classes

#### `PySpice.Scripts.pyspice_post_installation.CircuitTest`

##### Description
Provides methods for testing circuit functionalities.

##### Methods

- **`test_spinit()`**
  Performs a test related to SPICE initialization.

#### `PySpice.Scripts.pyspice_post_installation.PySpicePostInstallation`

##### Description
A class that manages the post-installation process, including checking installation status and downloading ngspice.

##### Constants

- **`GITHUB_URL`**: URL for the PySpice GitHub repository.
- **`NGSPICE_BASE_URL`**: Base URL for ngspice downloads.
- **`NGSPICE_MANUAL_OLD_URL`**: URL template for older ngspice manual downloads.
- **`NGSPICE_MANUAL_URL`**: URL template for ngspice manual downloads.
- **`NGSPICE_RELEASE_URL`**: URL for ngspice release information.
- **`NGSPICE_WINDOWS_DLL_OLD_URL`**: URL template for older ngspice Windows DLL downloads.
- **`NGSPICE_WINDOWS_DLL_URL`**: URL template for ngspice Windows DLL downloads.

##### Methods

- **`check_installation()`**
  Tool to check if PySpice is correctly installed.
- **`download_example()`**
  Downloads example files.
- **`download_ngspice_manual()`**
  Downloads the ngspice manual.
- **`install_ngspice_dll()`**
  Installs the ngspice DLL for Windows.
- **`run()`**
  Executes the post-installation routine.

##### Properties

- **`ngspice_version`** (property)
  Gets the installed ngspice version.

### Functions

#### `PySpice.Scripts.pyspice_post_installation.main()`

##### Description
Entry point for the post-installation script.

```

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

### Circuit Simulation Setup

Source: https://pyspice.fabrice-salvaire.fr/releases/v1.5/_modules/PySpice/Spice/Simulation.html

Core class for setting up and configuring circuit simulations in PySpice.

```APIDOC
## Circuit Simulation

### Description
This class provides the core functionality to define and generate SPICE instructions for circuit simulations. It manages various simulation aspects like options, measurements, initial conditions, and analyses.

### Method
`__init__` - Initializes the `CircuitSimulation` object with a circuit and optional parameters.
`options` - Sets simulation options (e.g., `.options` command).

### Properties
- `circuit` (Circuit) - The circuit object to be simulated.
- `temperature` (Degree) - The simulation temperature.
- `nominal_temperature` (Degree) - The nominal temperature for the simulation.

### Parameters for `__init__`
- `circuit` (Circuit) - The circuit to simulate.
- `**kwargs` - Additional keyword arguments for simulation setup, such as `temperature` and `nominal_temperature`.

### Parameters for `options`
- `*args` - String arguments to be added to the `.options` command.
- `**kwargs` - Key-value pairs to be set as options (e.g., `reltol=1e-3`).

### Example Usage
```python
from PySpice.Spice.Netlist import Circuit
from PySpice.Unit import * # For units like u_Degree

circuit = Circuit('My Circuit')
# ... add components to the circuit ...

simulation = CircuitSimulation(circuit, temperature=u_Degree(25))
simulation.options(reltol=1e-3, chgtol=1e-6)
```
```
Tokens:
Raw