# nmrsim package¶

## nmrsim.discrete module¶

Non-quantum mechanical solutions for specific second-order patterns.

These are adapted from the routines from WINDNMR [1] by Hans Reich, U. Wisconsin, and equations from Pople, Schneider and Bernstein [2]. Note that many of the names for arguments, etc. are non-Pythonic but chosen to match the WINDNMR interface and source code (for now).

The partials module provides the following functions:

• AB: simulates an AB quartet.
• AB2: simulates an AB2 system.
• ABX: simulates an ABX system.
• ABX3: simulates an ABX3 system.
• AAXX: simulates an AA’XX’ system.
• AABB: simulates an AA’BB’ system.

References

 [2] Pople, J.A.; Schneider, W.G.; Bernstein, H.J. High-Resolution Nuclear Magnetic Resonance. New York: McGraw-Hill, 1959.
nmrsim.discrete.AABB(Vab, Jaa, Jbb, Jab, Jab_prime, Vcentr, normalize=True, **kwargs)[source]

A wrapper for a second-order AA’BB’ calculation, but using the same arguments as WINDNMR.

Parameters: Vab (float) – the difference in frequency (Hz) between Ha and Hb in the absence of coupling. A positive number indicates vb > va. Jbb, Jab, Jab_prime (Jaa,) – Jaa is the JAA’ coupling constant; Jxx the JXX’; Jax the JAX; and JAX_prime the JAX’. Vcentr (float) – the frequency for the center of the signal. normalize (bool) – whether the signal intensity should be normalized. a list of (frequency, intensity) tuples. [(float, float)..]
nmrsim.discrete.AAXX(Jaa, Jxx, Jax, Jax_prime, Vcentr, normalize=True)[source]

Simulates one half (‘A’ part) of an AA’XX’ spin system.

All frequencies are in Hz.

Parameters: Jax, Jax, Jax_prime (Jaa,) – Jaa is the JAA’ coupling constant; Jxx the JXX’; Jax the JAX; and JAX_prime the JAX’. Vcentr (float) – the frequency for the center of the signal. normalize (bool) – whether the signal intensity should be normalized (to 2). a list of (frequency, intensity) tuples. [(float, float)..]
nmrsim.discrete.AB(Jab, Vab, Vcentr, normalize=True)[source]

Calculates the signal frequencies and intensities for two strongly coupled protons (Ha and Hb).

Parameters: Jab (float) – The coupling constant (Hz) between Ha and Hb Vab (float) – The chemical shift difference (Hz) between Ha and Hb in the absence of coupling. Vcentr (float) – The frequency (Hz) for the center of the AB quartet. normalize (bool) – Whether the signal intensity should be normalized. A list of four (frequency, intensity) tuples. [(float, float)..]
nmrsim.discrete.AB2(Jab, Vab, Vcentr, normalize=True)[source]

Calculates signal frequencies and intensities for an AB2 spin system.

Parameters: Jab (float) – the Ha-Hb coupling constant (Hz). Vab (float) – the difference in the frequencies (Hz). A positive value means vb > va; negative means va > vb. Vcentr (float) – the frequency (Hz) for the center of the AB2 signal. normalize (bool) – whether the signal intensity should be normalized. a list of (frequency, intensity) tuples. [(float, float)..]
nmrsim.discrete.ABX(Jab, Jax, Jbx, Vab, Vcentr, vx, normalize=True)[source]

Non-QM approximation for an ABX spin system. The approximation assumes that Hx is very far away in chemical shift from Ha/Hb.

Parameters: Jab (float) – The Ha-Hb coupling constant (Hz). Jax (float) – The Ha-Hx coupling constant (Hz). Jbx (float) – The Hb-Hx coupling constant (Hz). Vab (float) – The difference in the frequencies (in the absence of coupling) of Ha and Hb (Hz). Vcentr (float) – The frequency (Hz) for the center of the AB signal. vx (float) – The frequency (Hz) for Hx in the absence of coupling. normalize (bool (optional)) – whether the signal intensity should be normalized. If false, the total signal intensity happens to be ~12. a list of (frequency, intensity) tuples. [(float, float)..]
nmrsim.discrete.ABX3(Jab, Jax, Jbx, Vab, Vcentr)[source]

Simulation of the AB part of an ABX3 spin system.

Parameters: Jab (float) – the Ha-Hb coupling constant (Hz). Jax (float) – the Ha-Hb coupling constant (Hz). Jbx (float) – the Ha-Hb coupling constant (Hz). Vab (float) – the difference in the frequencies (Hz) of Ha and Hb in the absence of coupling. Positive when vb > va. Vcentr (float) – the frequency (Hz) for the center of the AB signal. a list of (frequency, intensity) tuples. [(float, float)..]

## nmrsim.dnmr module¶

The dnmr module provides functions for calculating DNMR line shapes, and classes to describe DNMR systems.

The dnmr module provides the following classes:

• DnmrTwoSinglets: a sumulation of the lineshape for two uncoupled nuclei undergoing exchange.
• DnmrAB: a simulation of the lineshape for two coupled nuclei undergoing exchange (i.e. an AB (or AX) pattern at the slow exchange limit).

The dnmr module provides the following functions:

• dnmr_two_singlets: for simulating the lineshape for two uncoupled nuclei undergoing exchange [3].
• dnmr_AB : for simulating the lineshape for two coupled nuclei undergoing exchange (i.e. an AB (or AX) pattern at the slow exchange limit) [4].

References

 [3] Sandström, J. Dynamic NMR Spectroscopy; Academic Press: New York, 1982.
 [4] Brown, K.C.; Tyson, R.L.; Weil, J.A. J. Chem. Educ. 1998, 75, 1632. an important math correction to the previous reference: TODO: add reference to correction
class nmrsim.dnmr.DnmrAB(va=165.0, vb=135.0, J=12.0, k=12.0, w=0.5, limits=None, points=800)[source]

Bases: object

Simulate the DNMR lineshape for two coupled nuclei undergoing exchange (AB or AX pattern at the slow-exchange limit).

Parameters: vb (va,) – frequencies of a and b nuclei (at the slow exchange limit, in the absence of coupling) J (int or float) – the coupling constant between the two nuclei. k (int or float) – rate constant for state A–> state B w (int or float) – peak widths at half height (at the slow-exchange limit). limits ((int or float, int or float), optional) – The minimum and maximum frequencies (in any order) for the simulation. points (int) – The length of the returned arrays (i.e. the number of points plotted).

DnmrAB
A class representation for this simulation.

References

See the documentation for the nmrsim.dnmr module.

J

The coupling constant (Hz) between the two nuclei.

Returns: int or float
k

The rate constant (Hz) for state A–> state B (must be >0).

Returns: int or float
limits

Give minimum and maximum frequencies for the simulated lineshape.

Returns: (int or float, int or float)
lineshape()[source]

Return the x, y lineshape data for the simulation.

Returns: x, y – Arrays for the x (frequency) and y (intensity) lineshape data points. numpy.array, numpy.array
points

Give the length of the returned arrays (i.e. the number of points plotted).

Returns: int
va

The frequency of nucleus “a” (Hz) at the slow-exchange limit, in the absence of coupling.

Returns: int or float
vb

The frequency of nucleus “b” (Hz) at the slow-exchange limit, in the absence of coupling.

Returns: int or float
w

The peak width (Hz) at half height (at the slow-exchange limit).

Returns: int or float
class nmrsim.dnmr.DnmrTwoSinglets(va=1, vb=0, k=0.01, wa=0.5, wb=0.5, pa=0.5, limits=None, points=800)[source]

Bases: object

A DNMR simulation for two uncoupled nuclei undergoing exchange.

Parameters: vb (va,) – The frequencies (Hz) of nuclei ‘a’ and ‘b’ at the slow exchange limit. k (int or float) – The rate constant (Hz) for state a–> state b wb (wa,) – The peak widths at half height for the ‘a’ and ‘b’ singlets at the slow-exchange limit. pa (float (0 <= pa <= 1)) – The fraction of the population in state a limits ((int or float, int or float), optional) – The minimum and maximum frequencies (in any order) for the simulation. points (int) – The length of the returned arrays (i.e. the number of points plotted).

DnmrTwoSinglets
A class representation for this simulation
k

The rate constant (Hz) for state A–> state B (must be >0).

Returns: int or float
limits

The minimum and maximum frequencies for the simulated lineshape.

Returns: (int or float, int or float)
lineshape()[source]

Calculate and return the lineshape for the DNMR spectrum.

Returns: x, y – Arrays for the x (frequency) and y (intensity) lineshape data points. numpy.array, numpy.array
pa

The fraction of the population in state a. Must be >=0 and <=1.

Returns: float
points

The length of the returned arrays (i.e. the number of points plotted).

Returns: int
va

The frequency of nucleus “a” (Hz) at the slow-exchange limit.

Returns: int or float
vb

The frequency of nucleus “b” (Hz) at the slow-exchange limit.

Returns: int or float
wa

The peak width at half height (Hz) for the ‘a’ singlet at the slow-exchange limit.

Returns: int or float
wb

The peak width at half height (Hz) for the ‘b’ singlet at the slow-exchange limit.

Returns: int or float
nmrsim.dnmr.dnmr_AB(va, vb, J, k, w, limits=None, points=800)[source]

Simulate the DNMR lineshape for two coupled nuclei undergoing exchange (AB or AX pattern at the slow-exchange limit).

Parameters: vb (va,) – frequencies of a and b nuclei (at the slow exchange limit, in the absence of coupling) J (float) – the coupling constant between the two nuclei. k (float) – rate constant for state A–> state B w (float) – peak widths at half height (at the slow-exchange limit). limits ((int or float, int or float), optional) – The minimum and maximum frequencies (in any order) for the simulation. points (int) – The length of the returned arrays (i.e. the number of points plotted). x, y – Arrays for the x (frequency) and y (intensity) lineshape data points. numpy.array, numpy.array

DnmrAB()
A class representation for this simulation.

References

See the documentation for the nmrsim.dnmr module.

nmrsim.dnmr.dnmr_two_singlets(va, vb, ka, wa, wb, pa, limits=None, points=800)[source]

Create a the lineshape for a DNMR spectrum of two uncoupled spin-half nuclei.

Parameters: vb (va,) – The frequencies (Hz) of nuclei ‘a’ and ‘b’ at the slow exchange limit. ka (int or float) – The rate constant (Hz) for state a–> state b wb (wa,) – The peak widths at half height for the ‘a’ and ‘b’ singlets at the slow-exchange limit. pa (float (0 <= pa <= 1)) – The fraction of the population in state a limits ((int or float, int or float), optional) – The minimum and maximum frequencies (in any order) for the simulation. points (int) – The length of the returned arrays (i.e. the number of points plotted). x, y – Arrays for the x (frequency) and y (intensity) lineshape data points. numpy.array, numpy.array

DnmrTwoSinglets()
A class representation for this simulation.

References

See the documentation for the nmrsim.dnmr module.

## nmrsim.firstorder module¶

“Functions for calculating first-order spectra.

The nmrsim.firstorder module provides the following functions:

• multiplet: performs first-order splitting of a signal into multiple signals.
• first_order_spin_system: provides a peaklist for several nuclei, using the
same v/J parameters that are used for second-order spin systems. See nmrsim.qm for details on these parameters.
nmrsim.firstorder.first_order_spin_system(v, J)[source]

Create a first-order peaklist of several multiplets from the same v/J arguments used for qm calculations.

This allows a user to model several multiplets at once, rather than creating each multiplet individually. It also provides a “toggle” where the user, or a higher-level function/class (such as nmrsim.SpinSystem) can decide whether a spin system is modeled as first order or second order.

Parameters: v (array-like [float...]) – an array of frequencies J (2D array-like (square)) – a matrix of J coupling constants a combined peaklist of signals for all the multiplets in the spin system. [(float, float)..]
nmrsim.firstorder.multiplet(signal, couplings)[source]

Splits a set of signals into first-order multiplets.

Parameters: signal ((float, float)) – a (frequency (Hz), intensity) tuple; couplings ([(float, int)..]) – A list of (J, # of nuclei) tuples. The order of the tuples in couplings does not matter. e.g. to split a signal into a dt, J = 8, 5 Hz, use: couplings = [(8, 2), (5, 3)] a sorted peaklist for the multiplet that results from splitting the signal by each J. [(float, float)..]

## nmrsim.math module¶

A collection of functions for processing simulated NMR spectra.

Terms used: signal: a pair (e.g. tuple) of frequency, intensity values peaklist: a list (or 1D-array-like) of signals.

Provides the following functions:

• add_peaks: combines a list of signals into one signal of average frequency and summed intensity.
• reduce_peaks: processes a peaklist so that signals within a frequency tolerance are added together.
• normalize_peaklist: scales a peaklist so that intensities add to a specific value.
• lorentz: given a frequency, a signal and a linewidth, calculates an intensity. Used to calculate Lorentzian lineshapes for signals.
• get_intensity: given a lineshape and a frequency, find the intensity at the datapoint closest to that frequency.
nmrsim.math.add_lorentzians(linspace, peaklist, w)[source]

Given a numpy linspace, a peaklist of (frequency, intensity) tuples, and a linewidth, returns an array of y coordinates for the total line shape.

Parameters: linspace (array-like) – Normally a numpy.linspace of x coordinates corresponding to frequency in Hz. peaklist ([(float, float)..]) – A list of (frequency, intensity) tuples. w (float) – Peak width at half maximum intensity. an array of y coordinates corresponding to intensity. [float…]
nmrsim.math.add_peaks(plist)[source]

Reduces a list of (frequency, intensity) tuples to an (average frequency, total intensity) tuple.

Parameters: plist ([(float, float)..]) – a list of (frequency, intensity) tuples a tuple of (average frequency, total intensity) (float, float)
nmrsim.math.get_intensity(lineshape, x)[source]

A crude method to find the intensity of data point closest to frequency x. Better: interpolate between two data points if match isn’t exact (TODO?)

Parameters: lineshape (tuple of (x, y) arrays for frequency, intensity data) – x (frequency lookup) – float the intensity at that frequency
nmrsim.math.get_maxima(lineshape)[source]

Crude function that returns maxima in the lineshape.

Parameters: lineshape (tuple of frequency, intensity arrays) – a list of (frequency, intensity) tuples for individual maxima.
nmrsim.math.lorentz(v, v0, I, w)[source]

A lorentz function that takes linewidth at half intensity (w) as a parameter.

When v = v0, and w = 0.5 (Hz), the function returns intensity I.

Parameters: v (float) – The frequency (x coordinate) in Hz at which to evaluate intensity (y coordinate). v0 (float) – The center of the distribution. I (float) – the relative intensity of the signal w (float) – the peak width at half maximum intensity the intensity (y coordinate) for the Lorentzian distribution evaluated at frequency v. float
nmrsim.math.normalize_peaklist(peaklist, n=1)[source]

Normalize the intensities in a peaklist so that total intensity equals value n (nominally the number of nuclei giving rise to the signal).

Parameters: peaklist ([(float, float)..]) – a list of (frequency, intensity) tuples. n (int or float (optional)) – total intensity to normalize to (default = 1).
nmrsim.math.reduce_peaks(plist_, tolerance=0)[source]

Takes a list of (x, y) tuples and adds together tuples whose values are within a certain tolerance limit.

Parameters: plist ([(float, float)..]) – A list of (x, y) tuples tolerance (float) – tuples that differ in x by <= tolerance are combined using add_peaks a list of (x, y) tuples where all x values differ by > tolerance [(float, float)..]

## nmrsim.plt module¶

The plt module provides convenience functions for creating matplotlib plots, plus applying Lorentzian distributions about signals.

The plt module provides the following functions:

• add_lorentzians: Creates lineshape data from a provided linspace (array of x coordinates) and peaklist).
• mplplot: Creates a lineshape plot from a peaklist and returns the x, y plot data.
• mplplot_stick: Creates a “stick” (matplotlib “stem” plot) plot from a peaklist and returns the x, y plot data.
• mplplot_lineshape: Creates a lineshape plot from provided x, y lineshape data and returns the x, y plot data.
nmrsim.plt.mplplot(peaklist, w=1, y_min=-0.01, y_max=1, points=800, limits=None)[source]

A matplotlib plot of the simulated lineshape for a peaklist.

Parameters: peaklist ([(float, float)..]) – A list of (frequency, intensity) tuples. w (float) – Peak width at half height y_min (float or int) – Minimum intensity for the plot. y_max (float or int) – Maximum intensity for the plot. points (int) – Number of data points. limits ((float, float)) – Frequency limits for the plot. x, y – Arrays for frequency (x) and intensity (y) for the simulated lineshape. numpy.array
nmrsim.plt.mplplot_lineshape(x, y, y_min=None, y_max=None, limits=None)[source]

A matplotlib plot that accepts arrays of x and y coordinates.

Parameters: x (array-like) – The list of x coordinates. y (array-like) – The list of y coordinates. y_min (float or int) – Minimum intensity for the plot. Default is -10% max y. y_max (float or int) – Maximum intensity for the plot. Default is 110% max y. limits ((float, float)) – Frequency limits for the plot. x, y The original x, y arguments.
nmrsim.plt.mplplot_stick(peaklist, y_min=-0.01, y_max=1, limits=None)[source]

A matplotlib plot of a spectrum in “stick” (stem) style.

Parameters: peaklist ([(float, float)..]) – A list of (frequency, intensity) tuples. y_min (float or int) – Minimum intensity for the plot. y_max (float or int) – Maximum intensity for the plot. limits ((float, float)) – Frequency limits for the plot. The arrays of x and y coordinates used for the plot. numpy.array, numpy.array

## nmrsim.qm module¶

qm contains functions for the quantum-mechanical (second-order) calculation of NMR spectra.

The qm module provides the following attributes:

• CACHE : bool (default True)
Whether saving to disk of partial solutions is allowed.
• SPARSE : bool (default True)
Whether the sparse library can be used.

The qm module provides the following functions:

• qm_spinsystem: The high-level function for computing a second-order simulation from frequency and J-coupling data.
• hamiltonian_dense: Calculate a spin Hamiltonian using dense arrays (slower).
• hamiltonian_sparse: Calculate a spin Hamiltonian using cached sparse arrays (faster).
• solve_hamiltonian: Calculate a peaklist from a spin Hamiltonian.
• secondorder_dense: Calculate a peaklist for a second-order spin system, using dense arrays (slower).
• secondorder_sparse: Calculate a peaklist for a second-order spin system, using cached sparse arrays (faster).

Notes

Because numpy.matrix is marked as deprecated, starting with Version 0.2.0 the qm code was refactored to a) accommodate this deprecation and b) speed up the calculations. The fastest calculations rely on:

1. the pydata/sparse library. SciPy’s sparse depends on numpy.matrix, and they currently recommend that pydata/sparse be used for now.

2. Caching partial solutions for spin operators and transition matrices as .npz files.

If the pydata/sparse package is no longer available, and/or if distributing the library with .npz files via PyPI is problematic, then a backup is required. The qm module for now provides two sets of functions for calculating second-order spectra: one using pydata/sparse and caching, and the other using neither.

nmrsim.qm.hamiltonian_dense(v, J)[source]

Calculate the spin Hamiltonian as a dense array.

Parameters: v (array-like) – list of frequencies in Hz (in the absence of splitting) for each nucleus. J (2D array-like) – matrix of coupling constants. J[m, n] is the coupling constant between v[m] and v[n]. H – a sparse spin Hamiltonian. numpy.ndarray
nmrsim.qm.hamiltonian_sparse(v, J)[source]

Calculate the spin Hamiltonian as a sparse array.

Parameters: v (array-like) – list of frequencies in Hz (in the absence of splitting) for each nucleus. J (2D array-like) – matrix of coupling constants. J[m, n] is the coupling constant between v[m] and v[n]. H – a sparse spin Hamiltonian. sparse.COO
nmrsim.qm.qm_spinsystem(*args, cache=True, sparse=True, **kwargs)[source]

Calculates second-order spectral data (frequency and intensity of signals) for n spin-half nuclei.

Currently, n is capped at 11 spins.

Parameters: Returns: freqs ([float...]) – a list of n nuclei frequencies in Hz. couplings (array-like) – An n, n array of couplings in Hz. The order of nuclei in the list corresponds to the column and row order in the matrix, e.g. couplings[0][1] and [1]0] are the J coupling between the nuclei of freqs[0] and freqs[1]. normalize (bool (optional keyword argument; default = True)) – True if the intensities should be normalized so that total intensity equals the total number of nuclei. peaklist – of [frequency, intensity] pairs. [[float, float]..] numpy 2D array cache (bool (default = nmrsim.qm.CACHE)) – Whether caching of partial solutions (for acceleration) is allowed. Currently CACHE = True, but this provides a hook to modify nmrsim for platforms such as Raspberry Pi where storage space is a concern. sparse (bool (default = nmrsim.qm.SPARSE)) – Whether the pydata sparse library for sparse matrices is available. Currently SPARSE = True, but this provides a hook to modify nmrsim should the sparse library become unavailable (see notes). cutoff (float) – The intensity cutoff for reporting signals (default is 0.001).

Notes

With numpy.matrix marked for deprecation, the scipy sparse array functionality is on shaky ground, and the current recommendation is to use the pydata sparse library. In case a problem arises in the numpy/scipy/ sparse ecosystem, SPARSE provides a hook to use a non-sparse-dependent alternative.

nmrsim.qm.secondorder_dense(freqs, couplings, normalize=True, **kwargs)[source]

Calculates second-order spectral data (freqency and intensity of signals) for n spin-half nuclei.

Parameters: Returns: freqs ([float...]) – a list of n nuclei frequencies in Hz couplings (array-like) – an n, n array of couplings in Hz. The order of nuclei in the list corresponds to the column and row order in the matrix, e.g. couplings[0][1] and [1]0] are the J coupling between the nuclei of freqs[0] and freqs[1]. normalize (bool) – True if the intensities should be normalized so that total intensity equals the total number of nuclei. peaklist – numpy 2D array of [frequency, intensity] pairs. [[float, float]..] cutoff (float) – The intensity cutoff for reporting signals (default is 0.001).
nmrsim.qm.secondorder_sparse(freqs, couplings, normalize=True, **kwargs)[source]

Calculates second-order spectral data (frequency and intensity of signals) for n spin-half nuclei.

Parameters: Returns: freqs ([float...]) – a list of n nuclei frequencies in Hz couplings (array-like) – an n, n array of couplings in Hz. The order of nuclei in the list corresponds to the column and row order in the matrix, e.g. couplings[0][1] and [1]0] are the J coupling between the nuclei of freqs[0] and freqs[1]. normalize (bool) – True if the intensities should be normalized so that total intensity equals the total number of nuclei. peaklist – of [frequency, intensity] pairs. [[float, float]..] numpy 2D array cutoff (float) – The intensity cutoff for reporting signals (default is 0.001).
nmrsim.qm.solve_hamiltonian(H, nspins, **kwargs)[source]

Calculates frequencies and intensities of signals from a spin Hamiltonian and number of spins.

Parameters: Returns: H (numpy.ndarray (2D)) – The spin Hamiltonian nspins (int) – The number of spins in the system [[float, float]..] numpy 2D array of frequency, intensity pairs. cutoff (float) – The intensity cutoff for reporting signals (default is 0.001).

## Module contents¶

### nmrsim¶

The nmrsim package provides tools for simulating nuclear magnetic resonance (NMR) spectra.

The API is still in flux. Currently, it includes the following modules:

• dnmr: for modeling Dynamic NMR systems
• firstorder: for modeling first-order spectra
• math: core math routines for handling NMR data
• partial: uses non-quantum-mechanical solutions for common second-order NMR patterns
• plt: convenience plotting routines for NMR results
• qm: quantum-mechanical second-order simulation of spin systems (currently capped at 11 nuclei)

Currently, only spin-1/2 nuclei are accommodated.

The top-level nmrsim namespace provides the following classes:

• Multiplet: a representation of a first-order multiplet (e.g. quartet; doublet of triplets).
• SpinSystem: a representation of a set of coupled nuclei (modeled as either first-order or second-order).
• Spectrum: a collection of components such as Multiplets or SpinSystems that contribute to a total NMR spectrum simulation.

#### Definitions of Terms Used¶

In naming classes, functions, methods, data types etc. certain phrases, taken from NMR nomenclature, have the following interpretations:

• multiplet (e.g. the nmrsim.Multiplet class): a first-order simulation for one signal (i.e. one or more chemical shift-equivalent nuclei). Examples: doublet, triplet, doublet of triplets, but not an AB quartet (which is a second-order pattern for two nuclei).
• spin system (e.g. the SpinSystem class): a simulation of a set of coupled nuclei.
• spectrum (e.g. the Spectrum class): a complete collection of first- and/or second-order components for simulating a total NMR spectrum. ‘Spectrum’ can also refer in general to the simulation results for the system, e.g a peaklist or lineshape (see below).
• peak: a pair of frequency (Hz), intensity values corresponding to a resonance in an NMR spectrum. For example, a 1H triplet centered at 100 Hz with J = 10 Hz would have the following peaks: (110, 0.25), (100, 0.5), (90, 0.25).
• peaklist: a list of peaks (e.g. [(110, 0.25), (100, 0.5), (90, 0.25)] for the above triplet).
• lineshape: a pair of [x coordinates…], [y coordinates] arrays for plotting the lineshape of a spectrum.

The following idioms are used for arguments: * v for a frequency or list of frequencies (similar to the Greek lowercase “nu” character). * I for a signal intensity (despite being a PEP8 naming violation) * J for coupling constant data (exact format depends on the implementation).