OptiCommPy 0.11.0

Open-source simulation of fiber optic communication systems with Python

OptiCommPy is a Python framework to simulate fiber optic communication systems, from the bits at the transmitter to the performance metrics at the receiver. It brings together physical models of optical and optoelectronic devices, linear and nonlinear fiber propagation, optical amplification, receiver digital signal processing (DSP), forward error correction (FEC) and performance metrics, so that complete IM-DD and coherent optical links can be built and studied in a few lines of code.

It is designed for students learning optical communications, researchers prototyping and benchmarking new DSP algorithms or system concepts, and engineers who need a transparent, scriptable simulation environment.

Contents

• Why OptiCommPy?
• Features
• Installation
• Quick start
• Examples
• Documentation
• Contributing
• Citing OptiCommPy
• License

Why OptiCommPy?

• End-to-end simulation: transmitter, fiber channel, amplifiers, receiver front-end, DSP, FEC and metrics in a single package, with a consistent API.
• Physically meaningful models: devices and channels are described by their physical parameters (V_π, extinction ratio, responsivity, noise figure, fiber loss, dispersion, nonlinearity, laser linewidth, ...).
• Fast: performance-critical routines are compiled with Numba, and the most demanding ones (split-step fiber propagation, digital backpropagation, blind phase search) also run on NVIDIA GPUs via CuPy.
• Transparent and hackable: plain NumPy/SciPy code that is easy to read, modify and extend, ideal for teaching and for prototyping new algorithms.
• Peer reviewed and tested: published in the Journal of Open Source Software, with an automated test suite.

Features

Installation

OptiCommPy requires Python 3.10 or newer. Install the latest release from PyPI:

pip install OptiCommPy

or install the development version from GitHub:

git clone https://github.com/edsonportosilva/OptiCommPy.git
cd OptiCommPy
pip install .

GPU support (optional): to run the GPU implementations, install CuPy for your CUDA version, for example:

pip install cupy-cuda12x

Quick start

Simulate a 10 Gb/s NRZ-OOK transmission over 100 km of optical fiber with a direct-detection receiver, and measure its bit error rate:

import numpy as np
from optic.comm.sources import bitSource
from optic.comm.modulation import modulateGray
from optic.comm.metrics import bert
from optic.dsp.core import firFilter, pulseShape, upsample, anorm
from optic.models.devices import mzm, photodiode
from optic.models.channels import linearFiberChannel
from optic.utils import parameters, dBm2W

# 10 Gb/s NRZ-OOK over 100 km of fiber with direct detection
SpS, Rs = 16, 10e9  # samples per symbol, symbol rate
Fs = SpS * Rs       # sampling frequency

paramBits = parameters()
paramBits.nBits, paramBits.seed = 100_000, 123

paramPulse = parameters()
paramPulse.pulseType, paramPulse.SpS = "nrz", SpS

paramMZM = parameters()
paramMZM.Vpi, paramMZM.Vb = 2, -1

paramCh = parameters()
paramCh.L, paramCh.alpha, paramCh.D = 100, 0.2, 16  # km, dB/km, ps/nm/km
paramCh.Fc, paramCh.Fs = 193.1e12, Fs

paramPD = parameters()
paramPD.ideal, paramPD.B, paramPD.Fs, paramPD.seed = False, Rs, Fs, 456

# transmitter: bits -> 2-PAM symbols -> NRZ pulses -> MZM
bitsTx = bitSource(paramBits)
symbTx = modulateGray(bitsTx, 2, "pam")
sigTx = anorm(firFilter(pulseShape(paramPulse), upsample(symbTx, SpS)))
sigTxo = mzm(np.sqrt(dBm2W(3)), sigTx, paramMZM)  # 3 dBm laser

# fiber channel (loss + chromatic dispersion) and noisy photodiode
sigRx = photodiode(linearFiberChannel(sigTxo, paramCh), paramPD)

# BER and Q-factor from the samples at the center of each symbol
BER, Q = bert(sigRx[0::SpS])
print(f"BER = {BER:.2e}, Q-factor = {Q:.2f}")

The getting started notebook walks through this example step by step and extends it to BER versus received power curves.

Examples

The examples folder contains Jupyter notebooks covering the main features of the package. Most of them can be run directly in the browser with Google Colab, through the Open in Colab button at their top.

Documentation

The full documentation, with the API reference of every module and rendered example notebooks, is available at opticommpy.readthedocs.io.

To build the documentation locally, install OptiCommPy with the documentation dependencies and run Sphinx from the root of the repository:

pip install .[docs]
sphinx-build -b html docs/source docs/build/html

Contributing

Contributions are welcome, from bug reports and documentation improvements to new models and algorithms.

1. Open an issue to report a bug or to discuss the feature you want to implement.
2. Fork the repository and create a new branch from the latest version of main.
3. Follow the conventions adopted in the code (naming, NumPy-style docstrings, etc.).
4. Add tests for your changes and make sure the test suite passes (pip install pytest, then pytest tests).
5. Include an example of usage for new features, ideally as a notebook in the examples folder.
6. Open a pull request.

For suggestions or questions about OptiCommPy, get in touch by e-mail (edsonporto88@gmail.com).

If OptiCommPy is useful for your work, consider supporting its development:

Citing OptiCommPy

If you use OptiCommPy in your research, please cite the paper:

Edson Porto da Silva, Adolfo Fernandes Herbster. "OptiCommPy: Open-source Simulation of Fiber Optic Communications with Python", Journal of Open Source Software, 9(98), 6600, (2024). https://doi.org/10.21105/joss.06600

@article{daSilva2024OptiCommPy,
  author  = {da Silva, Edson Porto and Herbster, Adolfo Fernandes},
  title   = {{OptiCommPy}: Open-source Simulation of Fiber Optic Communications with {Python}},
  journal = {Journal of Open Source Software},
  year    = {2024},
  volume  = {9},
  number  = {98},
  pages   = {6600},
  doi     = {10.21105/joss.06600}
}

License

OptiCommPy is distributed under the GNU General Public License v3.0.