keyword stringclasses 7 values | repo_name stringlengths 8 98 | file_path stringlengths 4 244 | file_extension stringclasses 29 values | file_size int64 0 84.1M | line_count int64 0 1.6M | content stringlengths 1 84.1M ⌀ | language stringclasses 14 values |
|---|---|---|---|---|---|---|---|
2D | dean0x7d/pybinding | pybinding/pltutils.py | .py | 14,833 | 517 | """Collection of utility functions for matplotlib"""
import warnings
from contextlib import contextmanager, suppress
import numpy as np
import matplotlib as mpl
import matplotlib.style as mpl_style
import matplotlib.pyplot as plt
from .utils import with_defaults
__all__ = ['cm2inch', 'colorbar', 'despine', 'despine_all', 'get_palette', 'legend', 'respine',
'set_palette', 'use_style']
def _set_smart_bounds(spine, value):
"""Hold on to the deprecated `set_smart_bounds()` for a little while longer
`set_smart_bounds()` was deprecated in matplotlib 3.2 and will be removed in the future.
This compatibility function ensures that we can keep using the function (while it's still
there) without any deprecation warnings. And when it is removed, suppress `AttributeError`
to make it a no-op. It's purely aesthetic change to the plots, but it's nice to keep it
while it's there.
"""
with warnings.catch_warnings(), suppress(AttributeError):
warnings.simplefilter("ignore", mpl.MatplotlibDeprecationWarning)
spine.set_smart_bounds(value)
@contextmanager
def axes(ax):
"""A context manager that sets the active Axes instance to `ax`
Parameters
----------
ax : plt.Axes
Examples
--------
>>> f, (ax1, ax2) = plt.subplots(1, 2)
>>> ax2 == plt.gca()
True
>>> with axes(ax1):
... ax1 == plt.gca()
True
>>> ax2 == plt.gca()
True
"""
previous_ax = plt.gca()
plt.sca(ax)
yield
plt.sca(previous_ax)
@contextmanager
def backend(new_backend):
"""Change the backend within this context
Parameters
----------
new_backend : str
Name of a matplotlib backend.
"""
old_backend = mpl.get_backend()
plt.switch_backend(new_backend)
try:
yield
finally:
plt.switch_backend(old_backend)
def despine(trim=False):
"""Remove the top and right spines
Parameters
----------
trim : bool
Trim spines so that they don't extend beyond the last major ticks.
"""
ax = plt.gca()
if ax.name == '3d':
return
for side in ["top", "right"]:
ax.spines[side].set_visible(False)
ax.xaxis.tick_bottom()
ax.yaxis.tick_left()
if trim:
ax.xaxis.set_major_locator(plt.MaxNLocator(nbins="auto", steps=[1, 2, 5, 10]))
ax.yaxis.set_major_locator(plt.MaxNLocator(nbins="auto", steps=[1, 2, 5, 10]))
for v, side in [('x', 'bottom'), ('y', 'left')]:
_set_smart_bounds(ax.spines[side], True)
ticks = getattr(ax, "get_{}ticks".format(v))()
vmin, vmax = getattr(ax, "get_{}lim".format(v))()
ticks = ticks[(ticks >= vmin) & (ticks <= vmax)]
getattr(ax, "set_{}ticks".format(v))(ticks)
def despine_all():
"""Remove all spines, axes labels and ticks"""
ax = plt.gca()
if ax.name == '3d':
return
for side in ['top', 'right', 'bottom', 'left']:
ax.spines[side].set_visible(False)
ax.xaxis.set_ticks_position('none')
ax.yaxis.set_ticks_position('none')
ax.set_xlabel('')
ax.set_ylabel('')
ax.set_xticks([])
ax.set_yticks([])
def respine():
"""Redraw all spines, opposite of :func:`despine`"""
ax = plt.gca()
for side in ['top', 'right', 'bottom', 'left']:
ax.spines[side].set_visible(True)
_set_smart_bounds(ax.spines[side], False)
ax.xaxis.set_ticks_position('both')
ax.yaxis.set_ticks_position('both')
def set_min_axis_length(length, axis='xy'):
"""Set minimum axis length
Parameters
----------
length : float
Minimum range in data coordinates
axis : {'x', 'y', 'xy'}
Apply to a single axis ('x', 'y') or both ('xy').
"""
ax = plt.gca()
for a in axis:
_min, _max = getattr(ax, "get_{}lim".format(a))()
if abs(_max - _min) < length:
center = (_max + _min) / 2
_min = center - length / 2
_max = center + length / 2
getattr(ax, "set_{}lim".format(a))(_min, _max, auto=None)
def set_min_axis_ratio(ratio):
"""Set minimum ratio between axes limits
Parameters
----------
ratio : float
"""
xmin, xmax = plt.xlim()
ymin, ymax = plt.ylim()
x = (xmax - xmin) / 2
y = (ymax - ymin) / 2
if y != 0 and x / y < ratio:
center = (xmax + xmin) / 2
lim = ratio * y
plt.xlim(center - lim, center + lim)
elif y / x < ratio:
center = (ymax + ymin) / 2
lim = ratio * x
plt.ylim(center - lim, center + lim)
def add_margin(margin=0.08, axis='xy'):
"""Adjust the axis length to include a margin (after autoscale)
Parameters
----------
margin : float
Fraction of the original length.
axis : {'x', 'y', 'xy'}
Apply to a single axis ('x', 'y') or both ('xy').
"""
ax = plt.gca()
for a in axis:
_min, _max = getattr(ax, "get_{}lim".format(a))()
set_min_axis_length(abs(_max - _min) * (1 + margin), axis=a)
def blend_colors(color, bg, factor):
"""Blend color with background
Parameters
----------
color
Color that will be blended.
bg
Background color.
factor : float
Blend factor: 0 to 1.
"""
from matplotlib.colors import colorConverter
color, bg = (np.array(colorConverter.to_rgb(c)) for c in (color, bg))
return (1 - factor) * bg + factor * color
def colorbar(mappable=None, cax=None, ax=None, label="", powerlimits=(0, 0), **kwargs):
"""Custom colorbar with modified style and optional label
Changes default `pad` and `aspect` argument values and turns on rasterization for a
nicer looking colorbar with smaller size in vector formats (pdf, svg).
Parameters
----------
label : str
Color data label.
powerlimits : Tuple[int, int]
Sets size thresholds for scientific notation.
mappable, cax, ax, **kwargs
Forwarded to :func:`matplotlib.pyplot.colorbar`.
"""
cbar = plt.colorbar(mappable, cax, ax, **with_defaults(kwargs, pad=0.02, aspect=28))
cbar.solids.set_edgecolor("face") # remove white gaps between segments
cbar.solids.set_rasterized(True) # and reduce pdf and svg output size
if powerlimits and hasattr(cbar.formatter, 'set_powerlimits'):
cbar.formatter.set_powerlimits(powerlimits)
cbar.update_ticks()
if label:
if cbar.formatter.get_offset() or cbar.orientation != 'vertical':
cbar.set_label(label)
else:
cbar.ax.set_xlabel(label)
cbar.ax.xaxis.set_label_position('top')
return cbar
def annotate_box(s, xy, fontcolor='black', **kwargs):
"""Annotate with a box around the text
Parameters
----------
s : str
Text string.
xy : Tuple[float, float]
Text position.
fontcolor : color
Setting 'white' will make the background black.
**kwargs
Forwarded to `plt.annotate()`.
"""
kwargs['bbox'] = with_defaults(
kwargs.get('bbox', {}),
boxstyle="round,pad=0.2", alpha=0.5, lw=0.3,
fc='white' if fontcolor != 'white' else 'black'
)
if all(key in kwargs for key in ['arrowprops', 'xytext']):
kwargs['arrowprops'] = with_defaults(
kwargs['arrowprops'], dict(arrowstyle="->", color=fontcolor)
)
plt.annotate(s, xy, **with_defaults(kwargs, color=fontcolor, horizontalalignment='center',
verticalalignment='center'))
def cm2inch(*values):
"""Convert from centimeter to inch
Parameters
----------
*values
Returns
-------
tuple
Examples
--------
>>> cm2inch(2.54, 5.08)
(1.0, 2.0)
"""
return tuple(v / 2.54 for v in values)
def legend(*args, reverse=False, facecolor='0.98', lw=0, **kwargs):
"""Custom legend with modified style and option to reverse label order
Parameters
----------
reverse : bool
Reverse the label order.
facecolor : color
Legend background color.
lw : float
Frame width.
*args, **kwargs
Forwarded to :func:`matplotlib.pyplot.legend`.
"""
handles, labels = plt.gca().get_legend_handles_labels()
if not any([handles, args, kwargs]):
return None
if not reverse or not handles:
ret = plt.legend(*args, **kwargs)
else:
ret = plt.legend(handles[::-1], labels[::-1], *args, **kwargs)
frame = ret.get_frame()
frame.set_facecolor(facecolor)
frame.set_linewidth(lw)
return ret
def get_palette(name=None, num_colors=8, start=0):
"""Get a color palette from matplotlib's colormap database
Parameters
----------
name : str, optional
Name of the palette to get. If `None`, get the active palette.
num_colors : int
Number of colors to retrieve.
start : int
Staring from this color number.
Returns
-------
List[color]
"""
if not name:
return [x['color'] for x in mpl.rcParams["axes.prop_cycle"]]
brewer = dict(Set1=9, Set2=8, Set3=12, Pastel1=9, Pastel2=8, Accent=8, Dark2=8, Paired=12)
if name in brewer:
total = brewer[name]
take = min(num_colors, total)
bins = np.linspace(0, 1, total)[:take]
else:
bins = np.linspace(0, 1, num_colors + 2)[1:-1]
cmap = plt.get_cmap(name)
palette = cmap(bins)[:, :3]
from itertools import cycle, islice
palette = list(islice(cycle(palette), start, start + num_colors))
return [list(color) for color in palette]
def set_palette(name=None, num_colors=8, start=0):
"""Set the active color palette
Parameters
----------
name : str, optional
Name of the palette. If `None`, modify the active palette.
num_colors : int
Number of colors to retrieve.
start : int
Staring from this color number.
"""
palette = get_palette(name, num_colors, start)
mpl.rcParams["axes.prop_cycle"] = plt.cycler('color', palette)
mpl.rcParams["patch.facecolor"] = palette[0]
plt.gca().set_prop_cycle(mpl.rcParams["axes.prop_cycle"])
def direct_cmap_norm(data, colors, blend=1):
"""Colormap with direct mapping: data[i] -> colors[i]
Parameters
----------
data : array_like
The data for which the colormap will be created.
colors : color or tuple of colors
Colors to map to unique data values.
blend : float
Like `alpha` but always blend with white.
Returns
-------
Tuple[ListedColormap, BoundaryNorm]
"""
if not isinstance(colors, (list, tuple)):
colors = [colors]
if blend < 1:
colors = [blend_colors(c, 'white', blend) for c in colors]
# colormap with an boundary norm to match the unique data points
from matplotlib.colors import ListedColormap, BoundaryNorm
cmap = ListedColormap(colors)
data = np.asarray(data)
if data.dtype.kind == "i":
boundaries = np.append(np.arange(data.max() + 1), np.inf)
else:
boundaries = np.append(np.unique(data), np.inf)
norm = BoundaryNorm(boundaries, len(boundaries) - 1)
return cmap, norm
def align(x, y):
"""Return text alignment based on (x, y) numbers
Parameters
----------
x, y : int
Negative is left/bottom, positive is right/top, zero is center/center.
Examples
--------
>>> align(1, -1)
('right', 'bottom')
>>> align(0, 1)
('center', 'top')
>>> align(-1, 0)
('left', 'center')
"""
if np.isclose(x, 0):
ha = 'center'
elif x > 0:
ha = 'right'
else:
ha = 'left'
if np.isclose(y, 0):
va = 'center'
elif y > 0:
va = 'top'
else:
va = 'bottom'
return ha, va
def _make_style():
nearly_black = '0.15'
linewidth = 0.6
dpi = 160
palette = list(get_palette('Set1'))
palette[5] = list(get_palette('Set2'))[5]
style = {
'lines.linewidth': 1.2, # [1.5]
'lines.solid_capstyle': 'round', # [projecting] butt|round|projecting
'font.size': 7.0, # [10.0]
'text.color': nearly_black, # [black]
'mathtext.default': 'regular', # [it] the default font to use for math.
'axes.edgecolor': nearly_black, # [black] axes edge color
'axes.linewidth': linewidth, # [0.8] edge linewidth
'axes.labelcolor': nearly_black, # [black]
'axes.unicode_minus': False, # [True] use unicode for the minus symbol
'axes.prop_cycle': plt.cycler('color', palette), # ['bgrcmyk']
'axes.autolimit_mode': 'round_numbers', # ['data']
'axes.xmargin': 0, # [0.05]
'axes.ymargin': 0, # [0.05]
'patch.facecolor': palette[1], # [b]
'xtick.major.size': 2.5, # [3.5] major tick size in points
'xtick.minor.size': 1.0, # [2] minor tick size in points
'xtick.major.width': linewidth, # [0.8] major tick width in points
'xtick.color': nearly_black, # [black] color of the tick labels
'xtick.direction': "in", # [out] in, out, or inout
'ytick.major.size': 2.5, # [3.5] major tick size in points
'ytick.minor.size': 1.0, # [2] minor tick size in points
'ytick.major.width': linewidth, # [0.8] major tick width in points
'ytick.color': nearly_black, # [black] color of the tick labels
'ytick.direction': "in", # [out] in, out, or inout
'grid.linestyle': ":", # [-]
'grid.linewidth': 0.5, # [0.8]
'grid.alpha': 0.6, # [1.0]
'figure.figsize': (3.4, 2.92), # [(6.4, 4.8) inch] (3.4, 2.92) inch == (8.6, 7.4) cm
'figure.dpi': dpi, # [100] figure dots per inch
'savefig.bbox': 'tight', # ['standard']
'savefig.pad_inches': 0.04, # [0.1] padding to be used when bbox is set to 'tight'
}
return style
pb_style = _make_style()
def _is_jupyter_notebook():
try:
# noinspection PyUnresolvedReferences
get_ipython()
return True
except NameError:
return False
def _is_notebook_inline_backend():
return _is_jupyter_notebook() and 'backend_inline' in mpl.get_backend()
def _reset_notebook_inline_backend():
with suppress(NameError):
# noinspection PyUnresolvedReferences
get_ipython().run_line_magic('matplotlib', 'inline')
def use_style(style=pb_style):
"""use_style(style=pb_style)
Shortcut for :func:`matplotlib.style.use` with pybinding style applied by default
Parameters
----------
style : dict
A matplotlib style specification.
"""
mpl_style.use(style)
# the style shouldn't override inline backend settings
if _is_notebook_inline_backend():
_reset_notebook_inline_backend()
| Python |
2D | dean0x7d/pybinding | pybinding/chebyshev.py | .py | 22,251 | 583 | """Computations based on Chebyshev polynomial expansion
The kernel polynomial method (KPM) can be used to approximate various functions by expanding them
in a series of Chebyshev polynomials.
"""
import warnings
import numpy as np
import scipy
from . import _cpp
from . import results
from .model import Model
from .system import System
from .utils.time import timed
from .support.deprecated import LoudDeprecationWarning
__all__ = ['KPM', 'kpm', 'kpm_cuda', 'SpatialLDOS',
'jackson_kernel', 'lorentz_kernel', 'dirichlet_kernel']
class SpatialLDOS:
"""Holds the results of :meth:`KPM.calc_spatial_ldos`
It behaves like a product of a :class:`.Series` and a :class:`.StructureMap`.
"""
def __init__(self, data, energy, structure):
self.data = data
self.energy = energy
self.structure = structure
def structure_map(self, energy):
"""Return a :class:`.StructureMap` of the spatial LDOS at the given energy
Parameters
----------
energy : float
Produce a structure map for LDOS data closest to this energy value.
Returns
-------
:class:`.StructureMap`
"""
idx = np.argmin(abs(self.energy - energy))
return self.structure.with_data(self.data[idx])
def ldos(self, position, sublattice=""):
"""Return the LDOS as a function of energy at a specific position
Parameters
----------
position : array_like
sublattice : Optional[str]
Returns
-------
:class:`.Series`
"""
idx = self.structure.find_nearest(position, sublattice)
return results.Series(self.energy, self.data[:, idx],
labels=dict(variable="E (eV)", data="LDOS", columns="orbitals"))
class KPM:
"""The common interface for various KPM implementations
It should not be created directly but via specific functions
like :func:`kpm` or :func:`kpm_cuda`.
All implementations are based on: https://doi.org/10.1103/RevModPhys.78.275
"""
def __init__(self, impl):
if isinstance(impl, Model):
raise TypeError("You're probably looking for `pb.kpm()` (lowercase).")
self.impl = impl
@property
def model(self) -> Model:
"""The tight-binding model holding the Hamiltonian"""
return self.impl.model
@model.setter
def model(self, model):
self.impl.model = model
@property
def system(self) -> System:
"""The tight-binding system (shortcut for `KPM.model.system`)"""
return System(self.impl.system, self.model.lattice)
@property
def scaling_factors(self) -> tuple:
"""A tuple of KPM scaling factors `a` and `b`"""
return self.impl.scaling_factors
@property
def kernel(self):
"""The damping kernel"""
return self.impl.kernel
def report(self, shortform=False):
"""Return a report of the last computation
Parameters
----------
shortform : bool, optional
Return a short one line version of the report
"""
return self.impl.report(shortform)
def __call__(self, *args, **kwargs):
warnings.warn("Use .calc_greens() instead", LoudDeprecationWarning)
return self.calc_greens(*args, **kwargs)
def moments(self, num_moments, alpha, beta=None, op=None):
r"""Calculate KPM moments in the form of expectation values
The result is an array of moments where each value is equal to:
.. math::
\mu_n = <\beta|op \cdot T_n(H)|\alpha>
Parameters
----------
num_moments : int
The number of moments to calculate.
alpha : array_like
The starting state vector of the KPM iteration.
beta : Optional[array_like]
If not given, defaults to :math:`\beta = \alpha`.
op : Optional[csr_matrix]
Operator in the form of a sparse matrix. If omitted, an identity matrix
is assumed: :math:`\mu_n = <\beta|T_n(H)|\alpha>`.
Returns
-------
ndarray
"""
from scipy.sparse import csr_matrix
if beta is None:
beta = []
if op is None:
op = csr_matrix([])
else:
op = op.tocsr()
return self.impl.moments(num_moments, alpha, beta, op)
def calc_greens(self, i, j, energy, broadening):
"""Calculate Green's function of a single Hamiltonian element
Parameters
----------
i, j : int
Hamiltonian indices.
energy : ndarray
Energy value array.
broadening : float
Width, in energy, of the smallest detail which can be resolved.
Lower values result in longer calculation time.
Returns
-------
ndarray
Array of the same size as the input `energy`.
"""
return self.impl.calc_greens(i, j, energy, broadening)
def calc_ldos(self, energy, broadening, position, sublattice="", reduce=True):
"""Calculate the local density of states as a function of energy
Parameters
----------
energy : ndarray
Values for which the LDOS is calculated.
broadening : float
Width, in energy, of the smallest detail which can be resolved.
Lower values result in longer calculation time.
position : array_like
Cartesian position of the lattice site for which the LDOS is calculated.
Doesn't need to be exact: the method will find the actual site which is
closest to the given position.
sublattice : str
Only look for sites of a specific sublattice, closest to `position`.
The default value considers any sublattice.
reduce : bool
This option is only relevant for multi-orbital models. If true, the
resulting LDOS will summed over all the orbitals at the target site
and the result will be a 1D array. If false, the individual orbital
results will be preserved and the result will be a 2D array with
`shape == (energy.size, num_orbitals)`.
Returns
-------
:class:`~pybinding.Series`
"""
ldos = self.impl.calc_ldos(energy, broadening, position, sublattice, reduce)
return results.Series(energy, ldos.squeeze(), labels=dict(variable="E (eV)", data="LDOS",
columns="orbitals"))
def calc_spatial_ldos(self, energy, broadening, shape, sublattice=""):
"""Calculate the LDOS as a function of energy and space (in the area of the given shape)
Parameters
----------
energy : ndarray
Values for which the LDOS is calculated.
broadening : float
Width, in energy, of the smallest detail which can be resolved.
Lower values result in longer calculation time.
shape : Shape
Determines the site positions at which to do the calculation.
sublattice : str
Only look for sites of a specific sublattice, within the `shape`.
The default value considers any sublattice.
Returns
-------
:class:`SpatialLDOS`
"""
ldos = self.impl.calc_spatial_ldos(energy, broadening, shape, sublattice)
smap = self.system[shape.contains(*self.system.positions)]
if sublattice:
smap = smap[smap.sub == sublattice]
return SpatialLDOS(ldos, energy, smap)
def calc_dos(self, energy, broadening, num_random=1):
"""Calculate the density of states as a function of energy
Parameters
----------
energy : ndarray
Values for which the DOS is calculated.
broadening : float
Width, in energy, of the smallest detail which can be resolved.
Lower values result in longer calculation time.
num_random : int
The number of random vectors to use for the stochastic calculation of KPM moments.
Larger numbers improve the quality of the result but also increase calculation time
linearly. Fortunately, result quality also improves with system size, so the DOS of
very large systems can be calculated accurately with only a small number of random
vectors.
Returns
-------
:class:`~pybinding.Series`
"""
dos = self.impl.calc_dos(energy, broadening, num_random)
return results.Series(energy, dos, labels=dict(variable="E (eV)", data="DOS"))
def deferred_ldos(self, energy, broadening, position, sublattice=""):
"""Same as :meth:`calc_ldos` but for parallel computation: see the :mod:`.parallel` module
Parameters
----------
energy : ndarray
Values for which the LDOS is calculated.
broadening : float
Width, in energy, of the smallest detail which can be resolved.
Lower values result in longer calculation time.
position : array_like
Cartesian position of the lattice site for which the LDOS is calculated.
Doesn't need to be exact: the method will find the actual site which is
closest to the given position.
sublattice : str
Only look for sites of a specific sublattice, closest to `position`.
The default value considers any sublattice.
Returns
-------
Deferred
"""
return self.impl.deferred_ldos(energy, broadening, position, sublattice)
def calc_conductivity(self, chemical_potential, broadening, temperature,
direction="xx", volume=1.0, num_random=1, num_points=1000):
"""Calculate Kubo-Bastin electrical conductivity as a function of chemical potential
The return value is in units of the conductance quantum (e^2 / hbar) not taking into
account spin or any other degeneracy.
The calculation is based on: https://doi.org/10.1103/PhysRevLett.114.116602.
Parameters
----------
chemical_potential : array_like
Values (in eV) for which the conductivity is calculated.
broadening : float
Width (in eV) of the smallest detail which can be resolved in the chemical potential.
Lower values result in longer calculation time.
temperature : float
Value of temperature for the Fermi-Dirac distribution.
direction : Optional[str]
Direction in which the conductivity is calculated. E.g., "xx", "xy", "zz", etc.
volume : Optional[float]
The volume of the system.
num_random : int
The number of random vectors to use for the stochastic calculation of KPM moments.
Larger numbers improve the quality of the result but also increase calculation time
linearly. Fortunately, result quality also improves with system size, so the DOS of
very large systems can be calculated accurately with only a small number of random
vectors.
num_points : Optional[int]
Number of points for integration.
Returns
-------
:class:`~pybinding.Series`
"""
data = self.impl.calc_conductivity(chemical_potential, broadening, temperature,
direction, num_random, num_points)
if volume != 1.0:
data /= volume
return results.Series(chemical_potential, data,
labels=dict(variable=r"$\mu$ (eV)", data="$\sigma (e^2/h)$"))
class _ComputeProgressReporter:
def __init__(self):
from .utils.progressbar import ProgressBar
self.pbar = ProgressBar(0)
def __call__(self, delta, total):
if total == 1:
return # Skip reporting for short jobs
if delta < 0:
print("Computing KPM moments...")
self.pbar.size = total
self.pbar.start()
elif delta == total:
self.pbar.finish()
else:
self.pbar += delta
def kpm(model, energy_range=None, kernel="default", num_threads="auto", silent=False, **kwargs):
"""The default CPU implementation of the Kernel Polynomial Method
This implementation works on any system and is well optimized.
Parameters
----------
model : Model
Model which will provide the Hamiltonian matrix.
energy_range : Optional[Tuple[float, float]]
KPM needs to know the lowest and highest eigenvalue of the Hamiltonian, before
computing the expansion moments. By default, this is determined automatically
using a quick Lanczos procedure. To override the automatic boundaries pass a
`(min_value, max_value)` tuple here. The values can be overestimated, but note
that performance drops as the energy range becomes wider. On the other hand,
underestimating the range will produce `NaN` values in the results.
kernel : Kernel
The kernel in the *Kernel* Polynomial Method. Used to improve the quality of
the function reconstructed from the Chebyshev series. Possible values are
:func:`jackson_kernel` or :func:`lorentz_kernel`. The Jackson kernel is used
by default.
num_threads : int
The number of CPU threads to use for calculations. This is automatically set
to the number of logical cores available on the current machine.
silent : bool
Don't show any progress messages.
Returns
-------
:class:`~pybinding.chebyshev.KPM`
"""
if kernel != "default":
kwargs["kernel"] = kernel
if num_threads != "auto":
kwargs["num_threads"] = num_threads
if "progress_callback" not in kwargs:
kwargs["progress_callback"] = _ComputeProgressReporter()
if silent:
del kwargs["progress_callback"]
return KPM(_cpp.kpm(model, energy_range or (0, 0), **kwargs))
def kpm_cuda(model, energy_range=None, kernel="default", **kwargs):
"""Same as :func:`kpm` except that it's executed on the GPU using CUDA (if supported)
See :func:`kpm` for detailed parameter documentation.
This method is only available if the C++ extension module was compiled with CUDA.
Parameters
----------
model : Model
energy_range : Optional[Tuple[float, float]]
kernel : Kernel
Returns
-------
:class:`~pybinding.chebyshev.KPM`
"""
try:
if kernel != "default":
kwargs["kernel"] = kernel
# noinspection PyUnresolvedReferences
return KPM(_cpp.kpm_cuda(model, energy_range or (0, 0), **kwargs))
except AttributeError:
raise Exception("The module was compiled without CUDA support.\n"
"Use a different KPM implementation or recompile the module with CUDA.")
def jackson_kernel():
"""The Jackson kernel -- a good general-purpose kernel, appropriate for most applications
Imposes Gaussian broadening `sigma = pi / N` where `N` is the number of moments. The
broadening value is user-defined for each function calculation (LDOS, Green's, etc.).
The number of moments is then determined based on the broadening -- it's not directly
set by the user.
"""
return _cpp.jackson_kernel()
def lorentz_kernel(lambda_value=4.0):
"""The Lorentz kernel -- best for Green's function
This kernel is most appropriate for the expansion of the Green’s function because it most
closely mimics the divergences near the true eigenvalues of the Hamiltonian. The Lorentzian
broadening is given by `epsilon = lambda / N` where `N` is the number of moments.
Parameters
----------
lambda_value : float
May be used to fine-tune the smoothness of the convergence. Usual values are
between 3 and 5. Lower values will speed up the calculation at the cost of
accuracy. If in doubt, leave it at the default value of 4.
"""
return _cpp.lorentz_kernel(lambda_value)
def dirichlet_kernel():
"""The Dirichlet kernel -- returns raw moments, least favorable choice
This kernel doesn't modify the moments at all. The resulting moments represent just
a truncated series which results in lots of oscillation in the reconstructed function.
Therefore, this kernel should almost never be used. It's only here in case the raw
moment values are needed for some other purpose. Note that `required_num_moments()`
returns `N = pi / sigma` for compatibility with the Jackson kernel, but there is
no actual broadening associated with the Dirichlet kernel.
"""
return _cpp.dirichlet_kernel()
class _PythonImpl:
"""Basic Python/SciPy implementation of KPM"""
def __init__(self, model, energy_range, kernel, **_):
self.model = model
self.energy_range = energy_range
self.kernel = kernel
self._stats = {}
@property
def stats(self):
class AttrDict(dict):
"""Allows dict items to be retrieved as attributes: d["item"] == d.item"""
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.__dict__ = self
s = AttrDict(self._stats)
s.update({k: v.elapsed for k, v in s.items() if "_time" in k})
s["eps"] = s["nnz"] / s["moments_time"]
return s
def _scaling_factors(self):
"""Compute the energy bounds of the model and return the appropriate KPM scaling factors"""
def find_bounds():
if self.energy_range[0] != self.energy_range[1]:
return self.energy_range
from scipy.sparse.linalg import eigsh
h = self.model.hamiltonian
self.energy_range = [eigsh(h, which=x, k=1, tol=2e-3, return_eigenvectors=False)[0]
for x in ("SA", "LA")]
return self.energy_range
with timed() as self._stats["bounds_time"]:
emin, emax = find_bounds()
self._stats["energy_min"] = emin
self._stats["energy_max"] = emax
tolerance = 0.01
a = 0.5 * (emax - emin) * (1 + tolerance)
b = 0.5 * (emax + emin)
return a, b
def _rescale_hamiltonian(self, h, a, b):
size = h.shape[0]
with timed() as self._stats["rescale_time"]:
return (h - b * scipy.sparse.eye(size)) * (2 / a)
def _compute_diagonal_moments(self, num_moments, starter, h2):
"""Procedure for computing KPM moments when the two vectors are identical"""
r0 = starter.copy()
r1 = h2.dot(r0) * 0.5
moments = np.zeros(num_moments, dtype=h2.dtype)
moments[0] = np.vdot(r0, r0) * 0.5
moments[1] = np.vdot(r1, r0)
for n in range(1, num_moments // 2):
r0 = h2.dot(r1) - r0
r0, r1 = r1, r0
moments[2 * n] = 2 * (np.vdot(r0, r0) - moments[0])
moments[2 * n + 1] = 2 * np.vdot(r1, r0) - moments[1]
self._stats["num_moments"] = num_moments
self._stats["nnz"] = h2.nnz * num_moments / 2
self._stats["vector_memory"] = r0.nbytes + r1.nbytes
self._stats["matrix_memory"] = (h2.data.nbytes + h2.indices.nbytes + h2.indptr.nbytes
if isinstance(h2, scipy.sparse.csr_matrix) else 0)
return moments
@staticmethod
def _exval_starter(h2, index):
"""Initial vector for the expectation value procedure"""
r0 = np.zeros(h2.shape[0], dtype=h2.dtype)
r0[index] = 1
return r0
@staticmethod
def _reconstruct_real(moments, energy, a, b):
"""Reconstruct a real function from KPM moments"""
scaled_energy = (energy - b) / a
ns = np.arange(moments.size)
k = 2 / (a * np.pi)
return np.array([k / np.sqrt(1 - w**2) * np.sum(moments.real * np.cos(ns * np.arccos(w)))
for w in scaled_energy])
def _ldos(self, index, energy, broadening):
"""Calculate the LDOS at the given Hamiltonian index"""
a, b = self._scaling_factors()
num_moments = self.kernel.required_num_moments(broadening / a)
h2 = self._rescale_hamiltonian(self.model.hamiltonian, a, b)
starter = self._exval_starter(h2, index)
with timed() as self._stats["moments_time"]:
moments = self._compute_diagonal_moments(num_moments, starter, h2)
with timed() as self._stats["reconstruct_time"]:
moments *= self.kernel.damping_coefficients(num_moments)
return self._reconstruct_real(moments, energy, a, b)
def calc_ldos(self, energy, broadening, position, sublattice="", reduce=True):
"""Calculate the LDOS at the given position/sublattice"""
with timed() as self._stats["total_time"]:
system_index = self.model.system.find_nearest(position, sublattice)
ham_idx = self.model.system.to_hamiltonian_indices(system_index)
result_data = np.array([self._ldos(i, energy, broadening) for i in ham_idx]).T
if reduce:
return np.sum(result_data, axis=1)
else:
return result_data
def report(self, *_):
from .utils import with_suffix, pretty_duration
stats = self.stats.copy()
stats.update({k: with_suffix(stats[k]) for k in ("num_moments", "eps")})
stats.update({k: pretty_duration(v) for k, v in stats.items() if "_time" in k})
fmt = " ".join([
"{energy_min:.2f}, {energy_max:.2f} [{bounds_time}]",
"[{rescale_time}]",
"{num_moments} @ {eps}eps [{moments_time}]",
"[{reconstruct_time}]",
"| {total_time}"
])
return fmt.format_map(stats)
def _kpm_python(model, energy_range=None, kernel="default", **kwargs):
"""Basic Python/SciPy implementation of KPM"""
if kernel == "default":
kernel = jackson_kernel()
return KPM(_PythonImpl(model, energy_range or (0, 0), kernel, **kwargs))
| Python |
2D | dean0x7d/pybinding | pybinding/modifier.py | .py | 18,397 | 538 | """Modifier function decorators
Used to create functions which express some feature of a tight-binding model,
such as various fields, defects or geometric deformations.
"""
import inspect
import functools
import warnings
import numpy as np
from . import _cpp
from .system import Sites
from .support.inspect import get_call_signature
from .support.alias import AliasIndex, SplitName
from .support.deprecated import LoudDeprecationWarning
from .utils.misc import decorator_decorator
__all__ = ['constant_potential', 'force_double_precision', 'force_complex_numbers',
'hopping_energy_modifier', 'hopping_generator', 'onsite_energy_modifier',
'site_generator', 'site_position_modifier', 'site_state_modifier']
def _process_modifier_args(args, keywords, requested_argnames):
"""Return only the requested modifier arguments
Also process any special args like 'sub_id', 'hop_id' and 'sites'.
"""
prime_arg = args[0]
if isinstance(prime_arg, np.ndarray):
if prime_arg.ndim > 1:
# Move axis so that sites are first -- makes a nicer modifier interface
norb1, norb2, nsites = prime_arg.shape
prime_arg = np.moveaxis(prime_arg, 2, 0)
args = [prime_arg] + list(args[1:])
shape = nsites, 1, 1
orbs = norb1, norb2
else:
shape = prime_arg.shape
orbs = 1, 1
def process(obj):
if isinstance(obj, str):
return AliasIndex(SplitName(obj), shape, orbs)
elif isinstance(obj, np.ndarray) and obj.size == shape[0]:
obj.shape = shape
return obj
else:
return obj
kwargs = dict(zip(keywords, args))
requested_kwargs = {k: process(v) for k, v in kwargs.items()
if k in requested_argnames}
if "sites" in requested_argnames and "sites" not in kwargs:
requested_kwargs["sites"] = Sites((kwargs[k] for k in ("x", "y", "z")), kwargs["sub_id"])
if "system" in keywords:
requested_kwargs.update({p: getattr(kwargs["system"], p) for p in "xyz"
if p in requested_argnames})
return requested_kwargs
def _check_modifier_spec(func, keywords, has_sites=False):
"""Make sure the arguments are specified correctly
Parameters
----------
func : callable
The function which is to become a modifier.
keywords : list
Used to check that `func` arguments are correct.
has_sites : bool
Check for 'site' argument.
"""
argnames = inspect.signature(func).parameters.keys()
if has_sites:
keywords += ["sites"]
unexpected = ", ".join([name for name in argnames if name not in keywords])
if unexpected:
expected = ", ".join(keywords)
raise RuntimeError("Unexpected argument(s) in modifier: {unexpected}\n"
"Arguments must be any of: {expected}".format(**locals()))
def _sanitize_modifier_result(result, args, expected_num_return, can_be_complex):
"""Make sure the modifier returns ndarrays with type and shape matching the input `args`"""
result = result if isinstance(result, tuple) else (result,)
prime_arg = args[0]
if any(not isinstance(r, np.ndarray) for r in result):
raise TypeError("Modifiers must return ndarray(s)")
if len(result) != expected_num_return:
raise TypeError("Modifier expected to return {} ndarray(s), "
"but got {}".format(expected_num_return, len(result)))
if any(r.size != prime_arg.size for r in result):
raise TypeError("Modifier must return the same size ndarray as the arguments")
def cast(r):
"""Cast the result back to the same data type as the arguments"""
try:
return r.astype(prime_arg.dtype, casting="same_kind", copy=False)
except TypeError:
if np.iscomplexobj(r) and can_be_complex:
return r # fine, the model will be upgraded to complex for certain modifiers
else:
raise TypeError("Modifier result is '{}', but expected same kind as '{}'"
" (precision is flexible)".format(r.dtype, prime_arg.dtype))
def moveaxis(r):
"""If the result is a new contiguous array, the axis needs to be moved back"""
if r.ndim == 3 and r.flags["OWNDATA"] and r.flags["C_CONTIGUOUS"]:
return np.moveaxis(r, 0, 2).copy()
else:
return r
result = tuple(map(cast, result))
result = tuple(map(moveaxis, result))
return result[0] if expected_num_return == 1 else result
def _make_modifier(func, kind, init, keywords, has_sites=True, num_return=1, can_be_complex=False):
"""Turn a regular function into a modifier of the desired kind
Parameters
----------
func : callable
The function which is to become a modifier.
kind : object
Modifier base class.
init : dict
Initializer kwargs for the Modifier base class.
keywords : str
String of comma separated names: the expected arguments of a modifier function.
has_sites : bool
Arguments may include the :class:`Sites` helper.
num_return : int
Expected number of return values.
can_be_complex : bool
The modifier may return a complex result even if the input is real.
Returns
-------
Modifier
"""
keywords = [word.strip() for word in keywords.split(",")]
_check_modifier_spec(func, keywords, has_sites)
requested_argnames = tuple(inspect.signature(func).parameters.keys())
def apply_func(*args):
requested_kwargs = _process_modifier_args(args, keywords, requested_argnames)
result = func(**requested_kwargs)
return _sanitize_modifier_result(result, args, num_return, can_be_complex)
class Modifier(kind):
callsig = getattr(func, 'callsig', None)
if not callsig:
callsig = get_call_signature()
callsig.function = func
def __init__(self):
# noinspection PyArgumentList
super().__init__(apply_func, **init)
self.apply = apply_func
def __str__(self):
return str(self.callsig)
def __repr__(self):
return repr(self.callsig)
def __call__(self, *args, **kwargs):
return func(*args, **kwargs)
return Modifier()
@decorator_decorator
def site_state_modifier(min_neighbors=0):
"""Modify the state (valid or invalid) of lattice sites, e.g.\ to create vacancies
Parameters
----------
min_neighbors : int
After modification, remove dangling sites with less than this number of neighbors.
Notes
-----
The function parameters must be a combination of any number of the following:
state : ndarray of bool
Indicates if a lattice site is valid. Invalid sites will be removed from
the model after all modifiers have been applied.
x, y, z : ndarray
Lattice site position.
sub_id : ndarray
Sublattice identifier: Can be checked for equality with sublattice names
specified in :class:`.Lattice`. For example, `state[sub_id == 'A'] = False`
will invalidate only sites on sublattice A.
sites : :class:`.Sites`
Helper object. Can be used instead of `x, y, z, sub_id`. See :class:`.Sites`.
The function must return:
ndarray
A modified `state` argument or an `ndarray` of the same dtype and shape.
Examples
--------
::
def vacancy(position, radius):
@pb.site_state_modifier
def f(state, x, y):
x0, y0 = position
state[(x-x0)**2 + (y-y0)**2 < radius**2] = False
return state
return f
model = pb.Model(
... # lattice, shape, etc.
vacancy(position=[0, 0], radius=0.1)
)
"""
return functools.partial(_make_modifier, kind=_cpp.SiteStateModifier,
init=dict(min_neighbors=min_neighbors),
keywords="state, x, y, z, sub_id")
@decorator_decorator
def site_position_modifier(*_):
"""site_position_modifier()
Modify the position of lattice sites, e.g.\ to apply geometric deformations
Notes
-----
The function parameters must be a combination of any number of the following:
x, y, z : ndarray
Lattice site position.
sub_id : ndarray of int
Sublattice identifier: can be checked for equality with sublattice names
specified in :class:`.Lattice`. For example, `x[sub_id == 'A'] += 0.1` will
only displace sites on sublattice A.
sites : :class:`.Sites`
Helper object. Can be used instead of `x, y, z, sub_id`. See :class:`.Sites`.
The function must return:
tuple of ndarray
Modified 'x, y, z' arguments or 3 `ndarray` objects of the same dtype and shape.
Examples
--------
::
def triaxial_displacement(c):
@pb.site_position_modifier
def displacement(x, y, z):
ux = 2*c * x*y
uy = c * (x**2 - y**2)
return x + ux, y + uy, z
return displacement
model = pb.Model(
... # lattice, shape, etc.
triaxial_displacement(c=0.15)
)
"""
return functools.partial(_make_modifier, kind=_cpp.PositionModifier, init={},
keywords="x, y, z, sub_id", num_return=3)
@decorator_decorator
def onsite_energy_modifier(is_double=False, **kwargs):
"""Modify the onsite energy, e.g.\ to apply an electric field
Parameters
----------
is_double : bool
Requires the model to use double precision floating point values.
Defaults to single precision otherwise.
Notes
-----
The function parameters must be a combination of any number of the following:
energy : ndarray
The onsite energy.
x, y, z : ndarray
Lattice site position.
sub_id : ndarray of int
Sublattice identifier: can be checked for equality with sublattice names
specified in :class:`.Lattice`. For example, `energy[sub_id == 'A'] = 0`
will set the onsite energy only for sublattice A sites.
sites : :class:`.Sites`
Helper object. Can be used instead of `x, y, z, sub_id`. See :class:`.Sites`.
The function must return:
ndarray
A modified `potential` argument or an `ndarray` of the same dtype and shape.
Examples
--------
::
def wavy(a, b):
@pb.onsite_energy_modifier
def f(x, y):
return np.sin(a * x)**2 + np.cos(b * y)**2
return f
model = pb.Model(
... # lattice, shape, etc.
wavy(a=0.6, b=0.9)
)
"""
if "double" in kwargs:
warnings.warn("Use `is_double` parameter name instead of `double`", LoudDeprecationWarning)
is_double = kwargs["double"]
return functools.partial(_make_modifier, kind=_cpp.OnsiteModifier,
init=dict(is_double=is_double), can_be_complex=True,
keywords="energy, x, y, z, sub_id")
@decorator_decorator
def hopping_energy_modifier(is_double=False, is_complex=False, **kwargs):
"""Modify the hopping energy, e.g.\ to apply a magnetic field
Parameters
----------
is_double : bool
Requires the model to use double precision floating point values.
Defaults to single precision otherwise.
is_complex : bool
Requires the model to use complex numbers. Even if this is set to `False`,
the model will automatically switch to complex numbers if it finds that a
modifier has returned complex numbers for real input. Manually setting this
argument to `True` will speed up model build time slightly, but it's not
necessary for correct operation.
Notes
-----
The function parameters must be a combination of any number of the following:
energy : ndarray
The hopping energy between two sites.
x1, y1, z1, x2, y2, z2 : ndarray
Positions of the two lattice sites connected by the hopping parameter.
hop_id : ndarray of int
Hopping identifier: can be checked for equality with hopping names specified
in :class:`.Lattice`. For example, `energy[hop_id == 't_nn'] *= 1.1` will only
modify the energy of the hopping family named `t_nn`.
The function must return:
ndarray
A modified `hopping` argument or an `ndarray` of the same dtype and shape.
Examples
--------
::
def constant_magnetic_field(B):
@pb.hopping_energy_modifier
def f(energy, x1, y1, x2, y2):
y = 0.5 * (y1 + y2) * 1e-9
peierls = B * y * (x1 - x2) * 1e-9
return energy * np.exp(1j * 2*pi/phi0 * peierls)
return f
model = pb.Model(
... # lattice, shape, etc.
constant_magnetic_field(B=10)
)
"""
if "double" in kwargs:
warnings.warn("Use `is_double` parameter name instead of `double`", LoudDeprecationWarning)
is_double = kwargs["double"]
return functools.partial(_make_modifier, kind=_cpp.HoppingModifier,
init=dict(is_double=is_double, is_complex=is_complex),
can_be_complex=True, has_sites=False,
keywords="energy, x1, y1, z1, x2, y2, z2, hop_id")
def constant_potential(magnitude):
"""Apply a constant onsite energy to every lattice site
Parameters
----------
magnitude : float
In units of eV.
"""
@onsite_energy_modifier
def f(energy, sub_id):
return energy + sub_id.eye * magnitude
return f
def force_double_precision():
"""Forces the model to use double precision even if that's not require by any modifier"""
@onsite_energy_modifier(is_double=True)
def f(energy):
return energy
return f
def force_complex_numbers():
"""Forces the model to use complex numbers even if that's not require by any modifier"""
@hopping_energy_modifier(is_complex=True)
def f(energy):
return energy
return f
def _make_generator(func, kind, name, energy, keywords, process_result=lambda x, *_: x):
"""Turn a regular function into a generator of the desired kind
Parameters
----------
func : callable
The function which is to become a modifier.
kind : object
Modifier base class.
keywords : str
String of comma separated names: the expected arguments of a modifier function.
process_result : Callable
Apply additional processing on the generator result
"""
keywords = [word.strip() for word in keywords.split(",")]
_check_modifier_spec(func, keywords)
requested_argnames = tuple(inspect.signature(func).parameters.keys())
def generator_func(*args):
requested_kwargs = _process_modifier_args(args, keywords, requested_argnames)
result = func(**requested_kwargs)
return process_result(result, *args)
class Generator(kind):
callsig = getattr(func, 'callsig', None)
if not callsig:
callsig = get_call_signature()
callsig.function = func
def __init__(self):
# noinspection PyArgumentList
super().__init__(name, energy, generator_func)
def __str__(self):
return str(self.callsig)
def __repr__(self):
return repr(self.callsig)
def __call__(self, *args, **kwargs):
return func(*args, **kwargs)
return Generator()
@decorator_decorator
def site_generator(name, energy):
"""Introduce a new site family (with a new `sub_id`) via a list of site positions
This can be used to create new sites independent of the main :class:`Lattice` definition.
It's especially useful for creating disorder or terminating system edges with atoms of
a different element.
Parameters
----------
name : string
Friendly identifier for the new site family.
energy : Union[float, complex, array_like]
Base hopping energy value -- scalar or matrix.
Notes
-----
The function parameters must be a combination of any number of the following:
x, y, z : np.ndarray
Lattice site position.
system : :class:`.System`
Structural data of the model constructed so far. See :class:`.System` for details.
The function must return:
Tuple[np.ndarray, np.ndarray, np.ndarray]
Tuple of (x, y, z) arrays which indicate the positions of the new sites.
"""
return functools.partial(_make_generator, kind=_cpp.SiteGenerator,
name=name, energy=energy, keywords="system, x, y, z")
@decorator_decorator
def hopping_generator(name, energy):
"""Introduce a new hopping family (with a new `hop_id`) via a list of index pairs
This can be used to create new hoppings independent of the main :class:`Lattice` definition.
It's especially useful for creating additional local hoppings, e.g. to model defects.
Parameters
----------
name : string
Friendly identifier for the new hopping family.
energy : Union[float, complex]
Base hopping energy value.
Notes
-----
The function parameters must be a combination of any number of the following:
x, y, z : np.ndarray
Lattice site position.
system : :class:`.System`
Structural data of the model constructed so far. See :class:`.System` for details.
The function must return:
Tuple[np.ndarray, np.ndarray]
A pair of arrays of indices which form the new hoppings.
"""
def process_result(result, system):
def process(v):
v = np.asarray(v)
if v.dtype == np.bool_ and v.size == system.num_sites:
return np.flatnonzero(v)
else:
return v
return tuple(process(v) for v in result)
return functools.partial(_make_generator, kind=_cpp.HoppingGenerator, name=name, energy=energy,
process_result=process_result, keywords="system, x, y, z")
| Python |
2D | dean0x7d/pybinding | pybinding/model.py | .py | 5,858 | 163 | """Main model definition interface"""
import numpy as np
from scipy.sparse import csr_matrix
from . import _cpp
from . import results
from .system import System, decorate_structure_plot
from .lattice import Lattice
from .leads import Leads
__all__ = ['Model']
class Model(_cpp.Model):
"""Builds a Hamiltonian from lattice, shape, symmetry and modifier parameters
The most important attributes are :attr:`.system` and :attr:`.hamiltonian` which are
constructed based on the input parameters. The :class:`.System` contains structural
data like site positions. The tight-binding Hamiltonian is a sparse matrix in the
:class:`.scipy.sparse.csr_matrix` format.
Parameters
----------
lattice : :class:`~pybinding.Lattice`
The lattice specification.
*args
Can be any of: shape, symmetry or various modifiers. Note that:
* There can be at most one shape and at most one symmetry. Shape and symmetry
can be composed as desired, but physically impossible scenarios will result
in an empty system.
* Any number of modifiers can be added. Adding the same modifier more than once
is allowed: this will usually multiply the modifier's effect.
"""
def __init__(self, lattice, *args):
super().__init__(lattice.impl)
self._lattice = lattice
self._shape = None
self.add(*args)
def add(self, *args):
"""Add parameter(s) to the model
Parameters
----------
*args
Any of: shape, symmetry, modifiers. Tuples and lists of parameters are expanded
automatically, so `M.add(p0, [p1, p2])` is equivalent to `M.add(p0, p1, p2)`.
"""
for arg in args:
if arg is None:
raise RuntimeError("`None` was passed to Model: check that all "
"modifier functions have return values")
try:
self.add(*arg)
except TypeError:
super().add(arg)
if isinstance(arg, _cpp.Shape):
self._shape = arg
def attach_lead(self, direction, contact):
"""Attach a lead to the main system
Not valid for 1D lattices.
Parameters
----------
direction : int
Lattice vector direction of the lead. Must be one of: 1, 2, 3, -1, -2, -3.
For example, `direction=2` would create a lead which intersects the main system
in the :math:`a_2` lattice vector direction. Setting `direction=-2` would create
a lead on the opposite side of the system, but along the same lattice vector.
contact : :class:`~_pybinding.Shape`
The place where the lead should contact the main system. For a 2D lattice it's
just a :func:`.line` describing the intersection of the lead and the system.
For a 3D lattice it's the area described by a 2D :class:`.FreeformShape`.
"""
super().attach_lead(direction, contact)
def structure_map(self, data):
"""Return a :class:`.StructureMap` of the model system mapped to the specified `data`
Parameters
----------
data : Optional[array_like]
Data array to map to site positions.
Returns
-------
:class:`~pybinding.results.StructureMap`
"""
return self.system.with_data(data)
def tokwant(self):
"""Convert this model into `kwant <http://kwant-project.org/>`_ format (finalized)
This is intended for compatibility with the kwant package: http://kwant-project.org/.
Returns
-------
kwant.system.System
Finalized system which can be used with kwant compute functions.
"""
from .support.kwant import tokwant
return tokwant(self)
@property
def system(self) -> System:
"""Structural data like site positions and hoppings, see :class:`.System` for details"""
return System(super().system, self.lattice)
@property
def hamiltonian(self) -> csr_matrix:
"""Hamiltonian sparse matrix in the :class:`.scipy.sparse.csr_matrix` format"""
return super().hamiltonian
@property
def lattice(self) -> Lattice:
""":class:`.Lattice` specification"""
return self._lattice
@property
def leads(self):
"""List of :class:`.Lead` objects"""
return Leads(super().leads, self.lattice)
@property
def shape(self):
""":class:`.Polygon` or :class:`.FreeformShape` object"""
return self._shape
@property
def modifiers(self) -> list:
"""List of all modifiers applied to this model"""
return (self.state_modifiers + self.position_modifiers +
self.onsite_modifiers + self.hopping_modifiers)
@property
def onsite_map(self) -> results.StructureMap:
""":class:`.StructureMap` of the onsite energy"""
return self.structure_map(np.real(self.hamiltonian.diagonal()))
def plot(self, num_periods=1, lead_length=6, axes='xy', **kwargs):
"""Plot the structure of the model: sites, hoppings, boundaries and leads
Parameters
----------
num_periods : int
Number of times to repeat the periodic boundaries.
lead_length : int
Number of times to repeat the lead structure.
axes : str
The spatial axes to plot. E.g. 'xy', 'yz', etc.
**kwargs
Additional plot arguments as specified in :func:`.structure_plot_properties`.
"""
kwargs['add_margin'] = False
self.system.plot(num_periods, axes=axes, **kwargs)
for lead in self.leads:
lead.plot(lead_length, axes=axes, **kwargs)
decorate_structure_plot(axes=axes)
| Python |
2D | dean0x7d/pybinding | pybinding/shape.py | .py | 10,808 | 345 | """System shape and symmetry"""
import numpy as np
import matplotlib.pyplot as plt
from . import _cpp
from . import pltutils
from .utils import with_defaults
__all__ = ['FreeformShape', 'Polygon', 'CompositeShape',
'circle', 'line', 'primitive', 'rectangle', 'regular_polygon',
'translational_symmetry']
def _plot_freeform_shape(vertices, contains, resolution=(1000, 1000), **kwargs):
"""Plot the area where `contains(x, y, z)` is True within the polygon given by `vertices`
Parameters
----------
resolution : Tuple[int, int]
The (x, y) pixel resolution of the generated image.
**kwargs
Forwarded to :func:`matplotlib.pyplot.imshow`.
"""
if any(z != 0 for _, _, z in vertices):
raise RuntimeError("This method only works for 2D shapes.")
x, y, *_ = zip(*vertices)
xx, yy = np.meshgrid(np.linspace(min(x), max(x), resolution[0], dtype=np.float32),
np.linspace(min(y), max(y), resolution[1], dtype=np.float32))
area = contains(xx.flat, yy.flat, np.zeros_like(xx.flat))
area.shape = xx.shape
area = np.ma.masked_array(area, np.logical_not(area))
area = np.flipud(area)
if "color" in kwargs:
kwargs["cmap"], kwargs["norm"] = pltutils.direct_cmap_norm([1], [kwargs.pop("color")])
im = plt.imshow(area, extent=(min(x), max(x), min(y), max(y)),
**with_defaults(kwargs, cmap="gray", alpha=0.15, interpolation="bicubic"))
plt.axis("scaled")
plt.xlabel("x (nm)")
plt.ylabel("y (nm)")
pltutils.despine(trim=True)
pltutils.add_margin()
return im
class _CompositionMixin:
"""Provides logical and arithmetic operators to form composite shapes"""
def __and__(self, other):
return CompositeShape(self, other, np.logical_and)
def __or__(self, other):
return CompositeShape(self, other, np.logical_or)
def __xor__(self, other):
return CompositeShape(self, other, np.logical_xor)
def __add__(self, other):
return self.__or__(other)
def __sub__(self, other):
return CompositeShape(self, other, lambda a, b: np.logical_and(a, np.logical_not(b)))
class Line(_cpp.Line):
"""Shape defined by two points
This is intended for 1D lattices or for specifying leads for 2D lattices
Attributes
----------
a, b : Union[float, array_like]
Start and end points.
"""
def __init__(self, a, b):
a, b = map(np.array, (a, b))
a.resize(2)
b.resize(2)
super().__init__(a, b)
self.a = a
self.b = b
def with_offset(self, vector):
"""Return a copy that's offset by the given vector"""
return Line(self.a + vector[0], self.b + vector[1])
def plot(self, **kwargs):
"""Show the line
Parameters
----------
**kwargs
Forwarded to :func:`matplotlib.pyplot.plot`.
"""
plt.plot(*zip(self.a, self.b), **with_defaults(kwargs, color='black', lw=1.6))
class Polygon(_cpp.Polygon, _CompositionMixin):
"""Shape defined by a list of vertices in a 2D plane
Attributes
----------
vertices : List[array_like]
Must be defined in clockwise or counterclockwise order.
"""
def __init__(self, vertices):
if len(vertices) < 3:
raise RuntimeError("A polygon must have at least 3 sides")
super().__init__(vertices)
def with_offset(self, vector):
"""Return a copy that's offset by the given vector"""
v = np.zeros(3)
v[:len(vector)] = vector
return Polygon([v0 + v for v0 in self.vertices])
def plot(self, **kwargs):
"""Line plot of the polygon
Parameters
----------
**kwargs
Forwarded to :func:`matplotlib.pyplot.plot`.
"""
x, y, _ = zip(*self.vertices)
plt.plot(np.append(x, x[0]), np.append(y, y[0]), **with_defaults(kwargs, color='black'))
plt.axis("scaled")
plt.xlabel("x (nm)")
plt.ylabel("y (nm)")
pltutils.despine(trim=True)
pltutils.add_margin()
class FreeformShape(_cpp.FreeformShape, _CompositionMixin):
"""Shape in 1 to 3 dimensions, defined by a function and a bounding box
Note that this class can describe 3D shapes, but the :meth:`.plot` method can currently
only draw in 2D. Nevertheless, a :class:`.Model` will accept 3D shapes without a problem.
Parameters
----------
contains : callable
The function which selects if a point is contained within the shape.
width : array_like
Width up to 3 dimensions which specifies the size of the bounding box.
center : array_like
The position of the center of the bounding box.
"""
def __init__(self, contains, width, center=(0, 0, 0)):
super().__init__(contains, width, center)
self.width = np.atleast_1d(width)
self.center = np.atleast_1d(center)
def with_offset(self, vector):
"""Return a copy that's offset by the given vector"""
def contains(x, y, z):
r0 = [x, y, z]
r = [v0 - v for v0, v in zip(r0, vector)] + r0[len(vector):]
return self.contains(*r)
return FreeformShape(contains, self.width, self.center[:len(vector)] + vector)
def plot(self, resolution=(1000, 1000), **kwargs):
"""Plot a lightly shaded silhouette of the freeform shape
This method only works for 2D shapes.
Parameters
----------
resolution : Tuple[int, int]
The (x, y) pixel resolution of the generated shape image.
**kwargs
Forwarded to :func:`matplotlib.pyplot.imshow`.
"""
return _plot_freeform_shape(self.vertices, self.contains, resolution, **kwargs)
class CompositeShape(_cpp.Shape, _CompositionMixin):
"""A composition of 2 shapes using some operator (and, or, xor...)
This shape is usually not created directly but present the result of
applying logical or arithmetic operators on other shapes.
Parameters
----------
shape1, shape2 : _cpp.Shape
The shapes which shall be composed.
op : Callable
A logical operator (and, or, xor...) to use for the composition.
"""
def __init__(self, shape1, shape2, op):
from scipy.spatial import ConvexHull
# The bounding vertices are always taken as the convex hull of the combined vertices.
# This is a wasteful in some situations (e.g. intersections) but its always safe and
# quick to code using scipy's implementation. Performance isn't an issue here for now
# but revisit this if it becomes a concern.
hull = ConvexHull(np.array(shape1.vertices + shape2.vertices)[:, :2])
vertices = hull.points[hull.vertices]
super().__init__(vertices, lambda x, y, z: op(shape1.contains(x, y, z),
shape2.contains(x, y, z)))
def with_offset(self, vector):
"""Return a copy that's offset by the given vector"""
def contains(x, y, z):
r0 = [x, y, z]
r = [v0 - v for v0, v in zip(r0, vector)] + r0[len(vector):]
return self.contains(*r)
shape = CompositeShape.__new__(CompositeShape)
v = np.zeros(3)
v[:len(vector)] = vector
vertices = [v0 + v for v0 in self.vertices]
super(CompositeShape, shape).__init__(vertices, contains)
return shape
def plot(self, resolution=(1000, 1000), **kwargs):
"""Plot a lightly shaded silhouette of the composite shape
Parameters
----------
resolution : Tuple[int, int]
The (x, y) pixel resolution of the generated image.
**kwargs
Forwarded to :func:`matplotlib.pyplot.imshow`.
"""
return _plot_freeform_shape(self.vertices, self.contains, resolution, **kwargs)
def primitive(a1=1, a2=1, a3=1):
"""Follow the primitive lattice shape -- just repeat the unit cell a number of times
Parameters
----------
a1, a2, a3 : int or float
Number of times to repeat the unit cell in the respective lattice vector directions.
Returns
-------
:class:`~_pybinding.Primitive`
"""
return _cpp.Primitive(a1, a2, a3)
def line(a, b):
"""A line shape intended for 1D lattices or to specify leads for 2D lattices
Parameters
----------
a, b : Union[float, array_like]
Start and end points.
Returns
-------
:class:`~pybinding.shape.Line`
"""
return Line(a, b)
def rectangle(x, y=None):
"""A rectangle in the xy plane
Parameters
----------
x : float
Width of the rectangle.
y : float, optional
Height of the rectangle. If not given, assumed equal to `x`.
Returns
-------
:class:`~pybinding.Polygon`
"""
y = y or x
x0, y0 = x / 2, y / 2
return Polygon([[x0, y0], [x0, -y0], [-x0, -y0], [-x0, y0]])
def regular_polygon(num_sides, radius, angle=0):
"""A polygon shape where all sides have equal length
Parameters
----------
num_sides : int
Number of sides.
radius : float
Radius of the circle which connects all the vertices of the polygon.
angle : float
Rotate the polygon.
Returns
-------
:class:`~pybinding.Polygon`
"""
from math import pi, sin, cos
angles = [angle + 2 * n * pi / num_sides for n in range(num_sides)]
return Polygon([(radius * sin(a), radius * cos(a)) for a in angles])
def circle(radius, center=(0, 0)):
"""A circle in the xy plane
Parameters
----------
radius : float
center : array_like
Returns
-------
:class:`~pybinding.FreeformShape`
"""
def contains(x, y, z):
x0, y0 = center
return np.sqrt((x - x0)**2 + (y - y0)**2) < radius
return FreeformShape(contains, [2 * radius] * 2, center)
def translational_symmetry(a1=True, a2=True, a3=True):
"""Simple translational symmetry
Parameters
----------
a1, a2, a3 : bool or float
Control translation in the 'a1, a2, a3' lattice vector directions.
Possible values:
* False -> No translational symmetry in this direction.
* True -> Translation length is automatically set to the unit cell length.
* float value -> Manually set the translation length in nanometers.
"""
def to_cpp_params(value):
if value is False:
return -1 # disabled
elif value is True:
return 0 # automatic length
else:
return value # manual length
lengths = tuple(to_cpp_params(a) for a in (a1, a2, a3))
return _cpp.TranslationalSymmetry(*lengths)
| Python |
2D | dean0x7d/pybinding | pybinding/results.py | .py | 36,387 | 1,051 | """Processing and presentation of computed data
Result objects hold computed data and offer postprocessing and plotting functions
which are specifically adapted to the nature of the stored data.
"""
from copy import copy
import numpy as np
import matplotlib.pyplot as plt
from . import pltutils
from .utils import with_defaults, x_pi
from .support.pickle import pickleable, save, load
from .support.structure import Positions, AbstractSites, Sites, Hoppings
__all__ = ['Bands', 'Eigenvalues', 'NDSweep', 'Series', 'SpatialMap', 'StructureMap',
'Sweep', 'make_path', 'save', 'load']
def _make_crop_indices(obj, limits):
"""Return the indices into `obj` which retain only the data within the given limits"""
idx = np.ones(obj.num_sites, dtype=np.bool)
for name, limit in limits.items():
v = getattr(obj, name)
idx = np.logical_and(idx, v >= limit[0])
idx = np.logical_and(idx, v < limit[1])
return idx
class Path(np.ndarray):
"""An ndarray which represents a path connecting certain points
Attributes
----------
point_indices : List[int]
Indices of the significant points along the path. Minimum 2: start and end.
"""
def __new__(cls, array, point_indices):
obj = np.asarray(array).view(cls)
assert len(point_indices) >= 2
obj.point_indices = point_indices
return obj
def __array_finalize__(self, obj):
if obj is None:
return
default_indices = [0, obj.shape[0] - 1] if len(obj.shape) >= 1 else []
self.point_indices = getattr(obj, 'point_indices', default_indices)
def __reduce__(self):
r = super().__reduce__()
state = r[2] + (self.point_indices,)
return r[0], r[1], state
# noinspection PyMethodOverriding,PyArgumentList
def __setstate__(self, state):
self.point_indices = state[-1]
super().__setstate__(state[:-1])
@property
def points(self):
"""Significant points along the path, including start and end"""
return self[self.point_indices]
@property
def is_simple(self):
"""Is it just a simple path between two points?"""
return len(self.point_indices) == 2
def as_1d(self):
"""Return a 1D representation of the path -- useful for plotting
For simple paths (2 points) the closest 1D path with real positions is returned.
Otherwise, an `np.arange(size)` is returned, where `size` matches the path. This doesn't
have any real meaning, but it's something that can be used as the x-axis in a line plot.
Examples
--------
>>> np.allclose(make_path(-2, 1, step=1).as_1d().T, [-2, -1, 0, 1])
True
>>> np.allclose(make_path([0, -2], [0, 1], step=1).as_1d().T, [-2, -1, 0, 1])
True
>>> np.allclose(make_path(1, -1, 4, step=1).as_1d().T, [0, 1, 2, 3, 4, 5, 6, 7])
True
"""
if self.is_simple:
if len(self.shape) == 1:
return self
else: # return the first axis with non-zero length
return self[:, np.flatnonzero(np.diff(self.points, axis=0))[0]]
else:
return np.arange(self.shape[0])
def plot(self, point_labels=None, **kwargs):
"""Quiver plot of the path
Parameters
----------
point_labels : List[str]
Labels for the :attr:`.Path.points`.
**kwargs
Forwarded to :func:`~matplotlib.pyplot.quiver`.
"""
ax = plt.gca()
ax.set_aspect('equal')
default_color = pltutils.get_palette('Set1')[1]
kwargs = with_defaults(kwargs, scale_units='xy', angles='xy', scale=1, zorder=2,
lw=1.5, color=default_color, edgecolor=default_color)
x, y = map(np.array, zip(*self.points))
plt.quiver(x[:-1], y[:-1], np.diff(x), np.diff(y), **kwargs)
ax.autoscale_view()
pltutils.add_margin(0.5)
pltutils.despine(trim=True)
if point_labels:
for k_point, label in zip(self.points, point_labels):
ha, va = pltutils.align(*(-k_point))
pltutils.annotate_box(label, k_point * 1.05, fontsize='large',
ha=ha, va=va, bbox=dict(lw=0))
def make_path(k0, k1, *ks, step=0.1):
"""Create a path which connects the given k points
Parameters
----------
k0, k1, *ks
Points in k-space to connect.
step : float
Length in k-space between two samples. Smaller step -> finer detail.
Examples
--------
>>> np.allclose(make_path(0, 3, -1, step=1).T, [0, 1, 2, 3, 2, 1, 0, -1])
True
>>> np.allclose(make_path([0, 0], [2, 3], [-1, 4], step=1.4),
... [[0, 0], [1, 1.5], [2, 3], [0.5, 3.5], [-1, 4]])
True
"""
k_points = [np.atleast_1d(k) for k in (k0, k1) + ks]
if not all(k.shape == k_points[0].shape for k in k_points[:1]):
raise RuntimeError("All k-points must have the same shape")
k_paths = []
point_indices = [0]
for k_start, k_end in zip(k_points[:-1], k_points[1:]):
num_steps = int(np.linalg.norm(k_end - k_start) // step)
# k_path.shape == num_steps, k_space_dimensions
k_path = np.array([np.linspace(s, e, num_steps, endpoint=False)
for s, e in zip(k_start, k_end)]).T
k_paths.append(k_path)
point_indices.append(point_indices[-1] + num_steps)
k_paths.append(k_points[-1])
return Path(np.vstack(k_paths), point_indices)
@pickleable
class Series:
"""A series of data points determined by a common relation, i.e. :math:`y = f(x)`
Attributes
----------
variable : array_like
Independent variable for which the data was computed.
data : array_like
An array of values which were computed as a function of `variable`.
It can be 1D or 2D. In the latter case each column represents the result
of a different function applied to the same `variable` input.
labels : dict
Plot labels: 'variable', 'data', 'title' and 'columns'.
"""
def __init__(self, variable, data, labels=None):
self.variable = np.atleast_1d(variable)
self.data = np.atleast_1d(data)
self.labels = with_defaults(labels, variable="x", data="y", columns="")
def with_data(self, data):
"""Return a copy of this result object with different data"""
result = copy(self)
result.data = data
return result
def reduced(self):
"""Return a copy where the data is summed over the columns
Only applies to results which may have multiple columns of data, e.g.
results for multiple orbitals for LDOS calculation.
"""
return self.with_data(self.data.sum(axis=1))
def plot(self, **kwargs):
"""Labeled line plot
Parameters
----------
**kwargs
Forwarded to `plt.plot()`.
"""
plt.plot(self.variable, self.data, **kwargs)
plt.xlim(self.variable.min(), self.variable.max())
plt.xlabel(self.labels["variable"])
plt.ylabel(self.labels["data"])
if "title" in self.labels:
plt.title(self.labels["title"])
pltutils.despine()
if self.data.ndim > 1:
labels = [str(i) for i in range(self.data.shape[-1])]
pltutils.legend(labels=labels, title=self.labels["columns"])
@pickleable
class SpatialMap:
"""Represents some spatially dependent property: data mapped to site positions"""
def __init__(self, data, positions, sublattices=None):
self._data = np.atleast_1d(data)
if sublattices is None and isinstance(positions, AbstractSites):
self._sites = positions
else:
self._sites = Sites(positions, sublattices)
if self.num_sites != data.size:
raise RuntimeError("Data size doesn't match number of sites")
@property
def num_sites(self) -> int:
"""Total number of lattice sites"""
return self._sites.size
@property
def data(self) -> np.ndarray:
"""1D array of values for each site, i.e. maps directly to x, y, z site coordinates"""
return self._data
@data.setter
def data(self, value):
self._data = value
@property
def positions(self) -> Positions:
"""Lattice site positions. Named tuple with x, y, z fields, each a 1D array."""
return self._sites.positions
@property
def xyz(self) -> np.ndarray:
"""Return a new array with shape=(N, 3). Convenient, but slow for big systems."""
return np.array(self.positions).T
@property
def x(self) -> np.ndarray:
"""1D array of coordinates, short for :attr:`.positions.x <.SpatialMap.positions.x>`"""
return self._sites.x
@property
def y(self) -> np.ndarray:
"""1D array of coordinates, short for :attr:`.positions.y <.SpatialMap.positions.y>`"""
return self._sites.y
@property
def z(self) -> np.ndarray:
"""1D array of coordinates, short for :attr:`.positions.z <.SpatialMap.positions.z>`"""
return self._sites.z
@property
def sublattices(self) -> np.ndarray:
"""1D array of sublattices IDs"""
return self._sites.ids
@property
def sub(self) -> np.ndarray:
"""1D array of sublattices IDs, short for :attr:`.sublattices <.SpatialMap.sublattices>`"""
return self._sites.ids
def with_data(self, data) -> "SpatialMap":
"""Return a copy of this object with different data mapped to the sites"""
result = copy(self)
result._data = data
return result
def save_txt(self, filename):
with open(filename + '.dat', 'w') as file:
file.write('# {:12}{:13}{:13}\n'.format('x(nm)', 'y(nm)', 'data'))
for x, y, d in zip(self.x, self.y, self.data):
file.write(("{:13.5e}" * 3 + '\n').format(x, y, d))
def __getitem__(self, idx):
"""Same rules as numpy indexing"""
if hasattr(idx, "contains"):
idx = idx.contains(*self.positions) # got a Shape object -> evaluate it
return self.__class__(self._data[idx], self._sites[idx])
def cropped(self, **limits):
"""Return a copy which retains only the sites within the given limits
Parameters
----------
**limits
Attribute names and corresponding limits. See example.
Examples
--------
Leave only the data where -10 <= x < 10 and 2 <= y < 4::
new = original.cropped(x=[-10, 10], y=[2, 4])
"""
return self[_make_crop_indices(self, limits)]
def clipped(self, v_min, v_max):
"""Clip (limit) the values in the `data` array, see :func:`~numpy.clip`"""
return self.with_data(np.clip(self.data, v_min, v_max))
def convolve(self, sigma=0.25):
# TODO: slow and only works in the xy-plane
x, y, _ = self.positions
r = np.sqrt(x**2 + y**2)
data = np.empty_like(self.data)
for i in range(len(data)):
idx = np.abs(r - r[i]) < sigma
data[i] = np.sum(self.data[idx] * np.exp(-0.5 * ((r[i] - r[idx]) / sigma)**2))
data[i] /= np.sum(np.exp(-0.5 * ((r[i] - r[idx]) / sigma)**2))
self._data = data
@staticmethod
def _decorate_plot():
ax = plt.gca()
ax.set_aspect('equal')
ax.set_xlabel('x (nm)')
ax.set_ylabel('y (nm)')
pltutils.despine(trim=True)
def plot_pcolor(self, **kwargs):
"""Color plot of the xy plane
Parameters
----------
**kwargs
Forwarded to :func:`~matplotlib.pyplot.tripcolor`.
"""
x, y, _ = self.positions
kwargs = with_defaults(kwargs, shading='gouraud', rasterized=True)
pcolor = plt.tripcolor(x, y, self.data, **kwargs)
self._decorate_plot()
return pcolor
def plot_contourf(self, num_levels=50, **kwargs):
"""Filled contour plot of the xy plane
Parameters
----------
num_levels : int
Number of contour levels.
**kwargs
Forwarded to :func:`~matplotlib.pyplot.tricontourf`.
"""
levels = np.linspace(self.data.min(), self.data.max(), num=num_levels)
x, y, _ = self.positions
kwargs = with_defaults(kwargs, levels=levels)
contourf = plt.tricontourf(x, y, self.data, **kwargs)
# Each collection has to be rasterized, `tricontourf()` does not accept `rasterized=True`
for collection in contourf.collections:
collection.set_rasterized(True)
self._decorate_plot()
return contourf
def plot_contour(self, **kwargs):
"""Contour plot of the xy plane
Parameters
----------
**kwargs
Forwarded to :func:`~matplotlib.pyplot.tricontour`.
"""
x, y, _ = self.positions
contour = plt.tricontour(x, y, self.data, **kwargs)
self._decorate_plot()
return contour
@pickleable
class StructureMap(SpatialMap):
"""A subclass of :class:`.SpatialMap` that also includes hoppings between sites"""
def __init__(self, data, sites, hoppings, boundaries=()):
super().__init__(data, sites)
self._hoppings = hoppings
self._boundaries = boundaries
@property
def spatial_map(self) -> SpatialMap:
"""Just the :class:`SpatialMap` subset without hoppings"""
return SpatialMap(self._data, self._sites)
@property
def hoppings(self) -> Hoppings:
"""Sparse matrix of hopping IDs"""
return self._hoppings
@property
def boundaries(self) -> list:
"""Boundary hoppings between different translation units (only for infinite systems)"""
return self._boundaries
def __getitem__(self, idx):
"""Same rules as numpy indexing"""
if hasattr(idx, "contains"):
idx = idx.contains(*self.positions) # got a Shape object -> evaluate it
return self.__class__(self.data[idx], self._sites[idx], self._hoppings[idx],
[b[idx] for b in self._boundaries])
def with_data(self, data) -> "StructureMap":
"""Return a copy of this object with different data mapped to the sites"""
result = copy(self)
result._data = data
return result
def plot(self, cmap='YlGnBu', site_radius=(0.03, 0.05), num_periods=1, **kwargs):
"""Plot the spatial structure with a colormap of :attr:`data` at the lattice sites
Both the site size and color are used to display the data.
Parameters
----------
cmap : str
Matplotlib colormap to be used for the data.
site_radius : Tuple[float, float]
Min and max radius of lattice sites. This range will be used to visually
represent the magnitude of the data.
num_periods : int
Number of times to repeat periodic boundaries.
**kwargs
Additional plot arguments as specified in :func:`.structure_plot_properties`.
"""
from .system import (plot_sites, plot_hoppings, plot_periodic_boundaries,
structure_plot_properties, decorate_structure_plot)
def to_radii(data):
if not isinstance(site_radius, (tuple, list)):
return site_radius
positive_data = data - data.min()
maximum = positive_data.max()
if not np.allclose(maximum, 0):
delta = site_radius[1] - site_radius[0]
return site_radius[0] + delta * positive_data / maximum
else:
return site_radius[1]
props = structure_plot_properties(**kwargs)
props['site'] = with_defaults(props['site'], radius=to_radii(self.data), cmap=cmap)
collection = plot_sites(self.positions, self.data, **props['site'])
hop = self.hoppings.tocoo()
props['hopping'] = with_defaults(props['hopping'], color='#bbbbbb')
plot_hoppings(self.positions, hop, **props['hopping'])
props['site']['alpha'] = props['hopping']['alpha'] = 0.5
plot_periodic_boundaries(self.positions, hop, self.boundaries, self.data,
num_periods, **props)
decorate_structure_plot(**props)
if collection:
plt.sci(collection)
return collection
@pickleable
class Structure:
"""Holds and plots the structure of a tight-binding system
Similar to :class:`StructureMap`, but only holds the structure without
mapping to any actual data.
"""
def __init__(self, sites, hoppings, boundaries=()):
self._sites = sites
self._hoppings = hoppings
self._boundaries = boundaries
@property
def num_sites(self) -> int:
"""Total number of lattice sites"""
return self._sites.size
@property
def positions(self) -> Positions:
"""Lattice site positions. Named tuple with x, y, z fields, each a 1D array."""
return self._sites.positions
@property
def xyz(self) -> np.ndarray:
"""Return a new array with shape=(N, 3). Convenient, but slow for big systems."""
return np.array(self.positions).T
@property
def x(self) -> np.ndarray:
"""1D array of coordinates, short for :attr:`.positions.x <.SpatialMap.positions.x>`"""
return self._sites.x
@property
def y(self) -> np.ndarray:
"""1D array of coordinates, short for :attr:`.positions.y <.SpatialMap.positions.y>`"""
return self._sites.y
@property
def z(self) -> np.ndarray:
"""1D array of coordinates, short for :attr:`.positions.z <.SpatialMap.positions.z>`"""
return self._sites.z
@property
def sublattices(self) -> np.ndarray:
"""1D array of sublattices IDs"""
return self._sites.ids
@property
def sub(self) -> np.ndarray:
"""1D array of sublattices IDs, short for :attr:`.sublattices <.SpatialMap.sublattices>`"""
return self._sites.ids
@property
def hoppings(self) -> Hoppings:
"""Sparse matrix of hopping IDs"""
return self._hoppings
@property
def boundaries(self) -> list:
"""Boundary hoppings between different translation units (only for infinite systems)"""
return self._boundaries
def __getitem__(self, idx):
"""Same rules as numpy indexing"""
if hasattr(idx, "contains"):
idx = idx.contains(*self.positions) # got a Shape object -> evaluate it
sliced = Structure(self._sites[idx], self._hoppings[idx],
[b[idx] for b in self._boundaries])
if hasattr(self, "lattice"):
sliced.lattice = self.lattice
return sliced
def find_nearest(self, position, sublattice=""):
"""Find the index of the atom closest to the given position
Parameters
----------
position : array_like
Where to look.
sublattice : Optional[str]
Look for a specific sublattice site. By default any will do.
Returns
-------
int
"""
return self._sites.find_nearest(position, sublattice)
def cropped(self, **limits):
"""Return a copy which retains only the sites within the given limits
Parameters
----------
**limits
Attribute names and corresponding limits. See example.
Examples
--------
Leave only the data where -10 <= x < 10 and 2 <= y < 4::
new = original.cropped(x=[-10, 10], y=[2, 4])
"""
return self[_make_crop_indices(self, limits)]
def with_data(self, data) -> StructureMap:
"""Map some data to this structure"""
return StructureMap(data, self._sites, self._hoppings, self._boundaries)
def plot(self, num_periods=1, **kwargs):
"""Plot the structure: sites, hoppings and periodic boundaries (if any)
Parameters
----------
num_periods : int
Number of times to repeat the periodic boundaries.
**kwargs
Additional plot arguments as specified in :func:`.structure_plot_properties`.
"""
from .system import (plot_sites, plot_hoppings, plot_periodic_boundaries,
structure_plot_properties, decorate_structure_plot)
props = structure_plot_properties(**kwargs)
if hasattr(self, "lattice"):
props["site"].setdefault("radius", self.lattice.site_radius_for_plot())
plot_hoppings(self.positions, self._hoppings, **props['hopping'])
plot_sites(self.positions, self.sublattices, **props['site'])
plot_periodic_boundaries(self.positions, self._hoppings, self._boundaries,
self.sublattices, num_periods, **props)
decorate_structure_plot(**props)
@pickleable
class Eigenvalues:
"""Hamiltonian eigenvalues with optional probability map
Attributes
----------
values : np.ndarray
probability : np.ndarray
"""
def __init__(self, eigenvalues, probability=None):
self.values = np.atleast_1d(eigenvalues)
self.probability = np.atleast_1d(probability)
@property
def indices(self):
return np.arange(0, self.values.size)
def _decorate_plot(self, mark_degenerate, number_states, margin=0.1):
"""Common elements for the two eigenvalue plots"""
if mark_degenerate:
# draw lines between degenerate states
from .solver import Solver
from matplotlib.collections import LineCollection
pairs = ((s[0], s[-1]) for s in Solver.find_degenerate_states(self.values))
lines = [[(i, self.values[i]) for i in pair] for pair in pairs]
plt.gca().add_collection(LineCollection(lines, color='black', alpha=0.5))
if number_states:
# draw a number next to each state
for index, energy in enumerate(self.values):
pltutils.annotate_box(index, (index, energy), fontsize='x-small',
xytext=(0, -10), textcoords='offset points')
margin = 0.25
plt.xlabel('state')
plt.ylabel('E (eV)')
plt.xlim(-1, len(self.values))
pltutils.despine(trim=True)
pltutils.add_margin(margin, axis="y")
def plot(self, mark_degenerate=True, show_indices=False, **kwargs):
"""Standard eigenvalues scatter plot
Parameters
----------
mark_degenerate : bool
Plot a line which connects degenerate states.
show_indices : bool
Plot index number next to all states.
**kwargs
Forwarded to plt.scatter().
"""
plt.scatter(self.indices, self.values, **with_defaults(kwargs, c='#377ec8', s=15, lw=0.1))
self._decorate_plot(mark_degenerate, show_indices)
def plot_heatmap(self, size=(7, 77), mark_degenerate=True, show_indices=False, **kwargs):
"""Eigenvalues scatter plot with a heatmap indicating probability density
Parameters
----------
size : Tuple[int, int]
Min and max scatter dot size.
mark_degenerate : bool
Plot a line which connects degenerate states.
show_indices : bool
Plot index number next to all states.
**kwargs
Forwarded to plt.scatter().
"""
if not np.any(self.probability):
return self.plot(mark_degenerate, show_indices, **kwargs)
# higher probability states should be drawn above lower ones
idx = np.argsort(self.probability)
indices, energy, probability = (v[idx] for v in
(self.indices, self.values, self.probability))
scatter_point_sizes = size[0] + size[1] * probability / probability.max()
plt.scatter(indices, energy, **with_defaults(kwargs, cmap='YlOrRd', lw=0.2, alpha=0.85,
c=probability, s=scatter_point_sizes,
edgecolor="k"))
self._decorate_plot(mark_degenerate, show_indices)
return self.probability.max()
@pickleable
class Bands:
"""Band structure along a path in k-space
Attributes
----------
k_path : :class:`Path`
The path in reciprocal space along which the bands were calculated.
E.g. constructed using :func:`make_path`.
energy : array_like
Energy values for the bands along the path in k-space.
"""
def __init__(self, k_path, energy):
self.k_path = np.atleast_1d(k_path).view(Path)
self.energy = np.atleast_1d(energy)
@staticmethod
def _point_names(k_points):
names = []
for k_point in k_points:
k_point = np.atleast_1d(k_point)
values = map(x_pi, k_point)
fmt = "[{}]" if len(k_point) > 1 else "{}"
names.append(fmt.format(', '.join(values)))
return names
@property
def num_bands(self):
return self.energy.shape[1]
def plot(self, point_labels=None, **kwargs):
"""Line plot of the band structure
Parameters
----------
point_labels : List[str]
Labels for the `k_points`.
**kwargs
Forwarded to `plt.plot()`.
"""
default_color = pltutils.get_palette('Set1')[1]
default_linewidth = np.clip(5 / self.num_bands, 1.1, 1.6)
kwargs = with_defaults(kwargs, color=default_color, lw=default_linewidth)
k_space = self.k_path.as_1d()
plt.plot(k_space, self.energy, **kwargs)
plt.xlim(k_space.min(), k_space.max())
plt.xlabel('k-space')
plt.ylabel('E (eV)')
pltutils.add_margin()
pltutils.despine(trim=True)
point_labels = point_labels or self._point_names(self.k_path.points)
plt.xticks(k_space[self.k_path.point_indices], point_labels)
# Draw vertical lines at significant points. Because of the `transLimits.transform`,
# this must be the done last, after all other plot elements are positioned.
for idx in self.k_path.point_indices:
ymax = plt.gca().transLimits.transform([0, max(self.energy[idx])])[1]
plt.axvline(k_space[idx], ymax=ymax, color="0.4", lw=0.8, ls=":", zorder=-1)
def plot_kpath(self, point_labels=None, **kwargs):
"""Quiver plot of the k-path along which the bands were computed
Combine with :meth:`.Lattice.plot_brillouin_zone` to see the path in context.
Parameters
----------
point_labels : List[str]
Labels for the k-points.
**kwargs
Forwarded to :func:`~matplotlib.pyplot.quiver`.
"""
self.k_path.plot(point_labels, **kwargs)
@pickleable
class Sweep:
"""2D parameter sweep with `x` and `y` 1D array parameters and `data` 2D array result
Attributes
----------
x : array_like
1D array with x-axis values -- usually the primary parameter being swept.
y : array_like
1D array with y-axis values -- usually the secondary parameter.
data : array_like
2D array with `shape == (x.size, y.size)` containing the main result data.
labels : dict
Plot labels: 'title', 'x', 'y' and 'data'.
tags : dict
Any additional user defined variables.
"""
def __init__(self, x, y, data, labels=None, tags=None):
self.x = np.atleast_1d(x)
self.y = np.atleast_1d(y)
self.data = np.atleast_2d(data)
self.labels = with_defaults(labels, title="", x="x", y="y", data="data")
self.tags = tags
def __getitem__(self, item):
"""Same rules as numpy indexing"""
if isinstance(item, tuple):
idx_x, idx_y = item
else:
idx_x = item
idx_y = slice(None)
return self._with_data(self.x[idx_x], self.y[idx_y], self.data[idx_x, idx_y])
def _with_data(self, x, y, data):
return self.__class__(x, y, data, self.labels, self.tags)
@property
def _plain_labels(self):
"""Labels with latex symbols stripped out"""
trans = str.maketrans('', '', '$\\')
return {k: v.translate(trans) for k, v in self.labels.items()}
def _xy_grids(self):
"""Expand x and y into 2D arrays matching data."""
xgrid = np.column_stack([self.x] * self.y.size)
ygrid = np.row_stack([self.y] * self.x.size)
return xgrid, ygrid
def save_txt(self, filename):
"""Save text file with 3 columns: x, y, data.
Parameters
----------
filename : str
"""
with open(filename, 'w') as file:
file.write("#{x:>11} {y:>12} {data:>12}\n".format(**self._plain_labels))
xgrid, ygrid = self._xy_grids()
for row in zip(xgrid.flat, ygrid.flat, self.data.flat):
values = ("{:12.5e}".format(v) for v in row)
file.write(" ".join(values) + "\n")
def cropped(self, x=None, y=None):
"""Return a copy with data cropped to the limits in the x and/or y axes
A call with x=[-1, 2] will leave data only where -1 <= x <= 2.
Parameters
----------
x, y : Tuple[float, float]
Min and max data limit.
Returns
-------
:class:`~pybinding.Sweep`
"""
idx_x = np.logical_and(x[0] <= self.x, self.x <= x[1]) if x else np.arange(self.x.size)
idx_y = np.logical_and(y[0] <= self.y, self.y <= y[1]) if y else np.arange(self.y.size)
return self._with_data(self.x[idx_x], self.y[idx_y], self.data[np.ix_(idx_x, idx_y)])
def mirrored(self, axis='x'):
"""Return a copy with data mirrored in around specified axis
Only makes sense if the axis starts at 0.
Parameters
----------
axis : 'x' or 'y'
Returns
-------
:class:`~pybinding.Sweep`
"""
if axis == 'x':
x = np.concatenate((-self.x[::-1], self.x[1:]))
data = np.vstack((self.data[::-1], self.data[1:]))
return self._with_data(x, self.y, data)
elif axis == 'y':
y = np.concatenate((-self.y[::-1], self.y[1:]))
data = np.hstack((self.data[:, ::-1], self.data[:, 1:]))
return self._with_data(self.x, y, data)
else:
RuntimeError("Invalid axis")
def interpolated(self, mul=None, size=None, kind='linear'):
"""Return a copy with interpolate data using :class:`scipy.interpolate.interp1d`
Call with `mul=2` to double the size of the x-axis and interpolate data to match.
To interpolate in both axes pass a tuple, e.g. `mul=(4, 2)`.
Parameters
----------
mul : Union[int, Tuple[int, int]]
Number of times the size of the axes should be multiplied.
size : Union[int, Tuple[int, int]]
New size of the axes. Zero will leave size unchanged.
kind
Forwarded to :class:`scipy.interpolate.interp1d`.
Returns
-------
:class:`~pybinding.Sweep`
"""
if not mul and not size:
return self
from scipy.interpolate import interp1d
x, y, data = self.x, self.y, self.data
if mul:
try:
mul_x, mul_y = mul
except TypeError:
mul_x, mul_y = mul, 1
size_x = x.size * mul_x
size_y = y.size * mul_y
else:
try:
size_x, size_y = size
except TypeError:
size_x, size_y = size, 0
if size_x > 0 and size_x != x.size:
interpolate = interp1d(x, data, axis=0, kind=kind)
x = np.linspace(x.min(), x.max(), size_x, dtype=x.dtype)
data = interpolate(x)
if size_y > 0 and size_y != y.size:
interpolate = interp1d(y, data, kind=kind)
y = np.linspace(y.min(), y.max(), size_y, dtype=y.dtype)
data = interpolate(y)
return self._with_data(x, y, data)
def _convolved(self, sigma, axis='x'):
"""Return a copy where the data is convolved with a Gaussian function
Parameters
----------
sigma : float
Gaussian broadening.
axis : 'x' or 'y'
Returns
-------
:class:`~pybinding.Sweep`
"""
def convolve(v, data0):
v0 = v[v.size // 2]
gaussian = np.exp(-0.5 * ((v - v0) / sigma)**2)
gaussian /= gaussian.sum()
extend = 10 # TODO: rethink this
data1 = np.concatenate((data0[extend::-1], data0, data0[:-extend:-1]))
data1 = np.convolve(data1, gaussian, 'same')
return data1[extend:-extend]
x, y, data = self.x, self.y, self.data.copy()
if 'x' in axis:
for i in range(y.size):
data[:, i] = convolve(x, data[:, i])
if 'y' in axis:
for i in range(x.size):
data[i, :] = convolve(y, data[i, :])
return self._with_data(x, y, data)
def plot(self, **kwargs):
"""Plot a 2D colormap of :attr:`Sweep.data`
Parameters
----------
**kwargs
Forwarded to :func:`matplotlib.pyplot.pcolormesh`.
"""
mesh = plt.pcolormesh(self.x, self.y, self.data.T,
**with_defaults(kwargs, cmap='RdYlBu_r', rasterized=True))
plt.xlim(self.x.min(), self.x.max())
plt.ylim(self.y.min(), self.y.max())
plt.title(self.labels['title'])
plt.xlabel(self.labels['x'])
plt.ylabel(self.labels['y'])
return mesh
def colorbar(self, **kwargs):
"""Draw a colorbar with the label of :attr:`Sweep.data`"""
return pltutils.colorbar(**with_defaults(kwargs, label=self.labels['data']))
def _plot_slice(self, axis, x, y, value, **kwargs):
plt.plot(x, y, **kwargs)
split = self.labels[axis].split(' ', 1)
label = split[0]
unit = '' if len(split) == 1 else split[1].strip('()')
plt.title('{}, {} = {:.2g} {}'.format(self.labels['title'], label, value, unit))
plt.xlim(x.min(), x.max())
plt.xlabel(self.labels['x' if axis == 'y' else 'y'])
plt.ylabel(self.labels['data'])
pltutils.despine()
def _slice_x(self, x):
"""Return a slice of data nearest to x and the found values of x.
Parameters
----------
x : float
"""
idx = np.abs(self.x - x).argmin()
return self.data[idx, :], self.x[idx]
def _slice_y(self, y):
"""Return a slice of data nearest to y and the found values of y.
Parameters
----------
y : float
"""
idx = np.abs(self.y - y).argmin()
return self.data[:, idx], self.y[idx]
def plot_slice_x(self, x, **kwargs):
z, value = self._slice_x(x)
self._plot_slice('x', self.y, z, value, **kwargs)
def plot_slice_y(self, y, **kwargs):
z, value = self._slice_y(y)
self._plot_slice('y', self.x, z, value, **kwargs)
@pickleable
class NDSweep:
"""ND parameter sweep
Attributes
----------
variables : tuple of array_like
The parameters being swept.
data : np.ndarray
Main result array with `shape == [len(v) for v in variables]`.
labels : dict
Plot labels: 'title', 'x', 'y' and 'data'.
tags : dict
Any additional user defined variables.
"""
def __init__(self, variables, data, labels=None, tags=None):
self.variables = variables
self.data = np.reshape(data, [len(v) for v in variables])
self.labels = with_defaults(labels, title="", axes=[], data="data")
# alias the first 3 axes to x, y, z for compatibility with Sweep labels
for axis, label in zip('xyz', self.labels['axes']):
self.labels[axis] = label
self.tags = tags
| Python |
2D | dean0x7d/pybinding | pybinding/__init__.py | .py | 3,159 | 79 | from .__about__ import (__author__, __copyright__, __doc__, __email__, __license__, __summary__,
__title__, __url__, __version__)
import os
import sys
if sys.platform.startswith("linux"):
# When the _pybinding C++ extension is compiled with MKL, it requires specific
# dlopen flags on Linux: RTLD_GLOBAL. This will not play nice with some scipy
# modules, i.e. it will produce segfaults. As a workaround, specific modules
# are imported first with default dlopenflags.
# After that, RTLD_GLOBAL must be set for MKL to load properly. It's not possible
# to set RTLD_GLOBAL, import _pybinding and then reset to default flags. This is
# fundamentally an MKL issue which makes it difficult to resolve. This workaround
# is the best solution at the moment.
import scipy.sparse.linalg
import scipy.spatial
sys.setdlopenflags(sys.getdlopenflags() | os.RTLD_GLOBAL)
try:
import _pybinding as _cpp
except ImportError as e:
if "GLIBCXX" in str(e):
msg = ("The version of libstdc++.so found in this environment is older than "
"the GCC which was used to compile pybinding. If you're using conda, "
"its internal libstdc++ may be masking the system library. Switching "
"to the conda-forge channel and removing the outdated library should "
"fix the issue. You can use the following commands: \n"
" conda config --add channels conda-forge \n"
" conda update --all \n"
" conda uninstall libgcc ")
raise ImportError(msg).with_traceback(e.__traceback__)
else:
raise
from .model import *
from .lattice import *
from .shape import *
from .modifier import *
from .results import *
from .chebyshev import *
from .parallel import parallel_for, parallelize
from . import (constants, greens, parallel, pltutils, results, solver, system, utils)
def tests(options=None, plugins=None):
"""Run the tests
Parameters
----------
options : list or str
Command line options for pytest (excluding target file_or_dir).
plugins : list
Plugin objects to be auto-registered during initialization.
"""
import pytest
import pathlib
import matplotlib as mpl
from .utils.misc import cd
args = options or []
if isinstance(args, str):
args = args.split()
module_path = pathlib.Path(__file__).parent
if (module_path / 'tests').exists():
# tests are inside installed package -> use read-only mode
args.append('--failpath=' + os.getcwd() + '/failed')
with cd(module_path), pltutils.backend('Agg'):
args += ['-c', str(module_path / 'tests/local.cfg'), str(module_path)]
error_code = pytest.main(args, plugins)
else:
# tests are in dev environment -> use development mode
with cd(module_path.parent), pltutils.backend('Agg'):
error_code = pytest.main(args, plugins)
return error_code or None
| Python |
2D | dean0x7d/pybinding | pybinding/solver.py | .py | 17,892 | 489 | """Eigensolvers with a few extra computation methods
The :class:`.Solver` class is the main interface for dealing with eigenvalue problems. It
is made to work specifically with pybinding's :class:`.Model` objects, but it may use any
eigensolver algorithm under the hood.
A few different algorithms are provided out of the box: the :func:`.lapack`, :func:`.arpack`
and :func:`.feast` functions return concrete :class:`.Solver` implementation using the LAPACK,
ARPACK and FEAST algorithms, respectively.
The :class:`.Solver` may easily be extended with new eigensolver algorithms. All that is
required is a function which takes a Hamiltonian matrix and returns the computed
eigenvalues and eigenvectors. See :class:`._SolverPythonImpl` for example.
"""
import time
import math
import numpy as np
from . import _cpp
from . import results
from .model import Model
from .system import System
__all__ = ['Solver', 'arpack', 'feast', 'lapack']
class Solver:
"""Computes the eigenvalues and eigenvectors of a Hamiltonian matrix
This the common interface for various eigensolver implementations. It should not
be created directly, but via the specific functions: :func:`.lapack`, :func:`.arpack`
and :func:`.feast`. Those functions will set up their specific solver strategy and
return a properly configured :class:`.Solver` object.
"""
def __init__(self, impl: _cpp.Solver):
self.impl = impl
@property
def model(self) -> Model:
"""The tight-binding model attached to this solver"""
return self.impl.model
@model.setter
def model(self, model):
self.impl.model = model
@property
def system(self) -> System:
"""The tight-binding system attached to this solver (shortcut for Solver.model.system)"""
return System(self.impl.system, self.model.lattice)
@property
def eigenvalues(self) -> np.ndarray:
"""1D array of computed energy states"""
return self.impl.eigenvalues
@property
def eigenvectors(self) -> np.ndarray:
"""2D array where each column represents a wave function
eigenvectors.shape == (system.num_sites, eigenvalues.size)
"""
return self.impl.eigenvectors
def solve(self):
"""Explicitly solve the eigenvalue problem right now
This method is usually not needed because the main result properties,
:attr:`.eigenvalues` and :attr:`.eigenvectors`, will call this implicitly
the first time they are accessed. However, since the :meth:`solve()` routine
may be computationally expensive, it is useful to have the ability to call it
ahead of time as needed.
"""
self.impl.solve()
def clear(self):
"""Clear the computed results and start over"""
self.impl.clear()
def report(self, shortform=False) -> str:
"""Return a report of the last :meth:`solve()` computation
Parameters
----------
shortform : bool, optional
Return a short one line version of the report
"""
return self.impl.report(shortform)
def set_wave_vector(self, k):
"""Set the wave vector for periodic models
Parameters
----------
k : array_like
Wave vector in reciprocal space.
"""
self.clear()
self.model.set_wave_vector(k)
def calc_eigenvalues(self, map_probability_at=None):
"""Return an :class:`.Eigenvalues` result object with an optional probability colormap
While the :attr:`.eigenvalues` property returns the raw values array, this
method returns a result object with more data. In addition to the energy
states, this result may show a colormap of the probability density for each
state at a single position.
Parameters
----------
map_probability_at : array_like, optional
Cartesian position where the probability density of each energy state
should be calculated.
Returns
-------
:class:`~pybinding.Eigenvalues`
"""
if not map_probability_at:
return results.Eigenvalues(self.eigenvalues)
else:
site_idx = self.system.find_nearest(position=map_probability_at)
probability = abs(self.eigenvectors[site_idx, :])**2
# sum probabilities of degenerate states
for idx in self.find_degenerate_states(self.eigenvalues):
probability[idx] = np.sum(probability[idx]) / len(idx)
return results.Eigenvalues(self.eigenvalues, probability)
def calc_probability(self, n, reduce=1e-5):
r"""Calculate the spatial probability density
.. math::
\text{P}(r) = |\Psi_n(r)|^2
for each position :math:`r` in `system.positions` where :math:`\Psi_n(r)`
is `eigenvectors[:, n]`.
Parameters
----------
n : int or array_like
Index of the desired eigenstate. If an array of indices is given, the
probability will be calculated at each one and a sum will be returned.
reduce : float, optional
Reduce degenerate states by summing their probabilities. Neighboring
states are considered degenerate if their energy is difference is lower
than the value of `reduce`. This is disabled by passing `reduce=0`.
Returns
-------
:class:`~pybinding.StructureMap`
"""
if reduce and np.isscalar(n):
n = np.flatnonzero(abs(self.eigenvalues[n] - self.eigenvalues) < reduce)
probability = abs(self.eigenvectors[:, n]) ** 2
if probability.ndim > 1:
probability = np.sum(probability, axis=1)
return self.system.with_data(probability)
def calc_dos(self, energies, broadening):
r"""Calculate the density of states as a function of energy
.. math::
\text{DOS}(E) = \frac{1}{c \sqrt{2\pi}}
\sum_n{e^{-\frac{(E_n - E)^2}{2 c^2}}}
for each :math:`E` in `energies`, where :math:`c` is `broadening` and
:math:`E_n` is `eigenvalues[n]`.
Parameters
----------
energies : array_like
Values for which the DOS is calculated.
broadening : float
Controls the width of the Gaussian broadening applied to the DOS.
Returns
-------
:class:`~pybinding.Series`
"""
if hasattr(self.impl, 'calc_dos'):
dos = self.impl.calc_dos(energies, broadening)
else:
scale = 1 / (broadening * math.sqrt(2 * math.pi))
delta = self.eigenvalues[:, np.newaxis] - energies
dos = scale * np.sum(np.exp(-0.5 * delta**2 / broadening**2), axis=0)
return results.Series(energies, dos, labels=dict(variable="E (eV)", data="DOS"))
def calc_ldos(self, energies, broadening, position, sublattice="", reduce=True):
r"""Calculate the local density of states as a function of energy at the given position
.. math::
\text{LDOS}(E) = \frac{1}{c \sqrt{2\pi}}
\sum_n{|\Psi_n(r)|^2 e^{-\frac{(E_n - E)^2}{2 c^2}}}
for each :math:`E` in `energies`, where :math:`c` is `broadening`,
:math:`E_n` is `eigenvalues[n]` and :math:`r` is a single site position
determined by the arguments `position` and `sublattice`.
Parameters
----------
energies : array_like
Values for which the DOS is calculated.
broadening : float
Controls the width of the Gaussian broadening applied to the DOS.
position : array_like
Cartesian position of the lattice site for which the LDOS is calculated.
Doesn't need to be exact: the method will find the actual site which is
closest to the given position.
sublattice : str
Only look for sites of a specific sublattice, closest to `position`.
The default value considers any sublattice.
reduce : bool
This option is only relevant for multi-orbital models. If true, the
resulting LDOS will summed over all the orbitals at the target site
and the result will be a 1D array. If false, the individual orbital
results will be preserved and the result will be a 2D array with
`shape == (energy.size, num_orbitals)`.
Returns
-------
:class:`~pybinding.Series`
"""
if hasattr(self.impl, 'calc_ldos'):
ldos = self.impl.calc_ldos(energies, broadening, position, sublattice)
else:
delta = self.eigenvalues[:, np.newaxis] - energies
gaussian = np.exp(-0.5 * delta**2 / broadening**2)
scale = 1 / (broadening * math.sqrt(2 * math.pi))
sys_idx = self.system.find_nearest(position, sublattice)
ham_idx = self.system.to_hamiltonian_indices(sys_idx)
def calc_single(index):
psi2 = np.abs(self.eigenvectors[index])**2
return scale * np.sum(psi2[:, np.newaxis] * gaussian, axis=0)
ldos = np.array([calc_single(i) for i in ham_idx]).T
if reduce:
ldos = np.sum(ldos, axis=1)
return results.Series(energies, ldos.squeeze(), labels=dict(variable="E (eV)", data="LDOS",
columns="orbitals"))
def calc_spatial_ldos(self, energy, broadening):
r"""Calculate the spatial local density of states at the given energy
.. math::
\text{LDOS}(r) = \frac{1}{c \sqrt{2\pi}}
\sum_n{|\Psi_n(r)|^2 e^{-\frac{(E_n - E)^2}{2 c^2}}}
for each position :math:`r` in `system.positions`, where :math:`E` is `energy`,
:math:`c` is `broadening`, :math:`E_n` is `eigenvalues[n]` and :math:`\Psi_n(r)`
is `eigenvectors[:, n]`.
Parameters
----------
energy : float
The energy value for which the spatial LDOS is calculated.
broadening : float
Controls the width of the Gaussian broadening applied to the DOS.
Returns
-------
:class:`~pybinding.StructureMap`
"""
if hasattr(self.impl, 'calc_spatial_ldos'):
ldos = self.impl.calc_spatial_ldos(energy, broadening)
else:
scale = 1 / (broadening * math.sqrt(2 * math.pi))
gaussian = np.exp(-0.5 * (self.eigenvalues - energy)**2 / broadening**2)
psi2 = np.abs(self.eigenvectors)**2
ldos = scale * np.sum(psi2 * gaussian, axis=1)
return self.system.with_data(ldos)
def calc_bands(self, k0, k1, *ks, step=0.1):
"""Calculate the band structure on a path in reciprocal space
Parameters
----------
k0, k1, *ks : array_like
Points in reciprocal space which form the path for the band calculation.
At least two points are required.
step : float, optional
Calculation step length in reciprocal space units. Lower `step` values
will return more detailed results.
Returns
-------
:class:`~pybinding.Bands`
"""
k_points = [np.atleast_1d(k) for k in (k0, k1) + ks]
k_path = results.make_path(*k_points, step=step)
bands = []
for k in k_path:
self.set_wave_vector(k)
bands.append(self.eigenvalues)
return results.Bands(k_path, np.vstack(bands))
@staticmethod
def find_degenerate_states(energies, abs_tolerance=1e-5):
"""Return groups of indices which belong to degenerate states
Parameters
----------
energies : array_like
abs_tolerance : float, optional
Examples
--------
>>> energies = np.array([0.1, 0.1, 0.2, 0.5, 0.5, 0.5, 0.7, 0.8, 0.8])
>>> Solver.find_degenerate_states(energies)
[[0, 1], [3, 4, 5], [7, 8]]
>>> energies = np.array([0.1, 0.2, 0.5, 0.7])
>>> Solver.find_degenerate_states(energies)
[]
"""
# when: energy == [0.1, 0.1, 0.2, 0.5, 0.5, 0.5, 0.7, 0.8, 0.8]
# ... idx == [0, 3, 4, 7]
idx = np.flatnonzero(abs(np.diff(energies)) < abs_tolerance)
if idx.size == 0:
return []
groups = np.split(idx, np.flatnonzero(np.diff(idx) != 1) + 1)
# ... groups == [[0], [3, 4], [7]]
# return: [[0, 1], [3, 4, 5], [7, 8]]
return [list(g) + [g[-1] + 1] for g in groups]
class _SolverPythonImpl:
"""Python eigensolver implementation
This is intended to make use of scipy's LAPACK and ARPACK solvers.
"""
def __init__(self, solve_func, model, **kwargs):
self.solve_func = solve_func
self._model = model
self.kwargs = kwargs
self.vals = np.empty(0)
self.vecs = np.empty(0)
self.compute_time = .0
def clear(self):
self.vals = np.empty(0)
self.vecs = np.empty(0)
self.compute_time = .0
@property
def model(self):
return self._model
@model.setter
def model(self, model):
self.clear()
self._model = model
@property
def system(self):
return self.model.system.impl
@property
def eigenvalues(self) -> np.ndarray:
self.solve()
return self.vals
@property
def eigenvectors(self) -> np.ndarray:
self.solve()
return self.vecs
def solve(self):
if len(self.vals):
return
start_time = time.time()
self.vals, self.vecs = self.solve_func(self.model.hamiltonian, **self.kwargs)
idx = self.vals.argsort()
self.vals = self.vals[idx]
self.vecs = self.vecs[:, idx]
self.compute_time = time.time() - start_time
def report(self, _=False):
from .utils.time import pretty_duration
return "Converged in " + pretty_duration(self.compute_time)
def lapack(model, **kwargs):
"""LAPACK :class:`.Solver` implementation for dense matrices
This solver is intended for small models which are best represented by
dense matrices. Always solves for all the eigenvalues and eigenvectors.
Internally this solver uses the :func:`scipy.linalg.eigh` function for
dense Hermitian matrices.
Parameters
----------
model : Model
Model which will provide the Hamiltonian matrix.
**kwargs
Advanced arguments: forwarded to :func:`scipy.linalg.eigh`.
Returns
-------
:class:`~pybinding.solver.Solver`
"""
def solver_func(hamiltonian, **kw):
from scipy.linalg import eigh
return eigh(hamiltonian.toarray(), **kw)
return Solver(_SolverPythonImpl(solver_func, model, **kwargs))
def arpack(model, k, sigma=0, **kwargs):
"""ARPACK :class:`.Solver` implementation for sparse matrices
This solver is intended for large models with sparse Hamiltonian matrices.
It only computes a small targeted subset of eigenvalues and eigenvectors.
Internally this solver uses the :func:`scipy.sparse.linalg.eigsh` function
for sparse Hermitian matrices.
Parameters
----------
model : Model
Model which will provide the Hamiltonian matrix.
k : int
The desired number of eigenvalues and eigenvectors. This number must be smaller
than the size of the matrix, preferably much smaller for optimal performance.
The computed eigenvalues are the ones closest to `sigma`.
sigma : float, optional
Look for eigenvalues near `sigma`.
**kwargs
Advanced arguments: forwarded to :func:`scipy.sparse.linalg.eigsh`.
Returns
-------
:class:`~pybinding.solver.Solver`
"""
from scipy.sparse.linalg import eigsh
if sigma == 0:
# eigsh can cause problems when sigma is exactly zero
sigma = np.finfo(model.hamiltonian.dtype).eps
return Solver(_SolverPythonImpl(eigsh, model, k=k, sigma=sigma, **kwargs))
def feast(model, energy_range, initial_size_guess, recycle_subspace=False, is_verbose=False):
"""FEAST :class:`.Solver` implementation for sparse matrices
This solver is only available if the C++ extension module was compiled with FEAST.
Parameters
----------
model : Model
Model which will provide the Hamiltonian matrix.
energy_range : tuple of float
The lowest and highest eigenvalue between which to compute the solutions.
initial_size_guess : int
Initial user guess for number of eigenvalues which will be found in the given
`energy_range`. This value may be completely wrong - the solver will auto-correct
as needed. However, for optimal performance the estimate should be as close to
1.5 * actual_size as possible.
recycle_subspace : bool, optional
Reuse previously computed values as a starting point for the next computation.
This improves performance when subsequent computations differ only slightly, as
is the case for the band structure of periodic systems where the results change
gradually as a function of the wave vector. It may hurt performance otherwise.
is_verbose : bool, optional
Show the raw output from the FEAST routine.
Returns
-------
:class:`~pybinding.solver.Solver`
"""
try:
# noinspection PyUnresolvedReferences
return Solver(_cpp.FEAST(model, energy_range, initial_size_guess,
recycle_subspace, is_verbose))
except AttributeError:
raise Exception("The module was compiled without the FEAST solver.\n"
"Use a different solver or recompile the module with FEAST.")
| Python |
2D | dean0x7d/pybinding | pybinding/constants.py | .py | 749 | 28 | """A few useful physical constants
Note that energy is expressed in units of eV.
"""
from math import pi
import numpy as np
c = 299792458 #: [m/s] speed of light
e = 1.602 * 10**-19 #: [C] electron charge
epsilon0 = 8.854 * 10**-12 #: [F/m] vacuum permittivity
hbar = 6.58211899 * 10**-16 #: [eV*s] reduced Plank constant
phi0 = 2 * pi * hbar #: [V*s] magnetic quantum
class Pauli:
x = np.array([[0, 1],
[1, 0]])
y = np.array([[0, -1j],
[1j, 0]])
z = np.array([[1, 0],
[0, -1]])
def __repr__(self):
return "x: [[0, 1], [1, 0]], y: [[0, -1j], [1j, 0]], z: [[1, 0], [0, -1]]"
pauli = Pauli() #: Pauli matrices -- use the ``.x``, ``.y`` and ``.z`` attributes
| Python |
2D | dean0x7d/pybinding | pybinding/lattice.py | .py | 20,663 | 559 | """Crystal lattice specification"""
import itertools
import warnings
from copy import deepcopy
from math import pi, atan2, sqrt
import numpy as np
import matplotlib.pyplot as plt
from . import _cpp
from . import pltutils
from .utils import x_pi, with_defaults, rotate_axes
from .support.deprecated import LoudDeprecationWarning
__all__ = ['Lattice']
class Lattice:
"""Unit cell of a Bravais lattice, the basic building block of a tight-binding model
This class describes the primitive vectors, positions of sublattice sites and hopping
parameters which connect those sites. All of this structural information is used to
build up a larger system by translation.
A few prebuilt lattices are available in the :doc:`/materials/index`.
Parameters
----------
a1, a2, a3 : array_like
Primitive vectors of a Bravais lattice. A valid lattice must have at least
one primitive vector (`a1`), thus forming a simple 1-dimensional lattice.
If `a2` is also specified, a 2D lattice is created. Passing values for all
three vectors will create a 3D lattice.
"""
def __init__(self, a1, a2=None, a3=None):
vectors = (v for v in (a1, a2, a3) if v is not None)
self.impl = _cpp.Lattice(*vectors)
@classmethod
def from_impl(cls, impl: _cpp.Lattice) -> 'Lattice':
lat = cls.__new__(cls)
lat.impl = impl
return lat
@property
def ndim(self) -> int:
"""The dimensionality of the lattice: number of primitive vectors"""
return self.impl.ndim
@property
def nsub(self) -> int:
"""Number of sublattices"""
return self.impl.nsub
@property
def nhop(self) -> int:
"""Number of hopping families"""
return self.impl.nhop
@property
def vectors(self) -> list:
"""Primitive lattice vectors"""
return self.impl.vectors
@property
def sublattices(self) -> dict:
"""Dict of names and :class:`~_pybinding.Sublattice`"""
return self.impl.sublattices
@property
def hoppings(self) -> dict:
"""Dict of names and :class:`~_pybinding.HoppingFamily`"""
return self.impl.hoppings
@property
def offset(self):
"""Global lattice offset: sublattice offsets are defined relative to this
It must be within half the length of a primitive lattice vector."""
return self.impl.offset
@offset.setter
def offset(self, value):
self.impl.offset = value
@property
def min_neighbors(self):
"""Minimum number of neighbours required at each lattice site
When constructing a finite-sized system, lattice sites with less neighbors
than this minimum will be considered as "dangling" and they will be removed."""
return self.impl.min_neighbors
@min_neighbors.setter
def min_neighbors(self, value):
self.impl.min_neighbors = value
def __getitem__(self, name):
warnings.warn("Use the sublattice name directly instead",
LoudDeprecationWarning, stacklevel=2)
return name
def __call__(self, name):
warnings.warn("Use the hopping name directly instead",
LoudDeprecationWarning, stacklevel=2)
return name
def register_hopping_energies(self, mapping):
"""Register a mapping of user-friendly names to hopping energies
Parameters
----------
mapping : dict
Keys are user-friendly hopping names and values are the numeric values
of the hopping energy.
"""
for name, energy in sorted(mapping.items(), key=lambda item: item[0]):
self.impl.register_hopping_energy(name, energy)
def add_one_sublattice(self, name, position, onsite_energy=0.0, alias=""):
"""Add a new sublattice
Parameters
----------
name : str
User-friendly identifier. The unique sublattice ID can later be accessed
via this sublattice name as `lattice[sublattice_name]`.
position : array_like
Cartesian position with respect to the origin.
onsite_energy : float
Onsite energy to be applied only to sites of this sublattice.
alias : str
Deprecated: Use :meth:`add_one_alias` instead.
"""
if alias:
warnings.warn("Use Lattice.add_aliases() instead",
LoudDeprecationWarning, stacklevel=2)
self.add_one_alias(name, alias, position)
else:
self.impl.add_sublattice(name, position, np.asarray(onsite_energy))
def add_sublattices(self, *sublattices):
"""Add multiple new sublattices
Parameters
----------
*sublattices
Each element should be a tuple containing the arguments for
a `add_one_sublattice()` method call. See example.
Examples
--------
These three calls::
lattice.add_one_sublattice('a', [0, 0], 0.5)
lattice.add_one_sublattice('b', [0, 1], 0.0)
lattice.add_one_sublattice('c', [1, 0], 0.3)
Can be replaced with a single call to::
lattice.add_sublattices(
('a', [0, 0], 0.5),
('b', [0, 1], 0.0),
('c', [1, 0], 0.3)
)
"""
for sub in sublattices:
self.add_one_sublattice(*sub)
def add_one_alias(self, name, original, position):
"""Add a sublattice alias - useful for creating supercells
Create a new sublattice called `name` with the same properties as `original`
(same onsite energy) but with at a different `position`. The new `name` is
only used during lattice construction and the `original` will be used for the
final system and Hamiltonian. This is useful when defining a supercell which
contains multiple sites of one sublattice family at different positions.
Parameters
----------
name : str
User-friendly identifier of the alias.
original : str
Name of the original sublattice. It must already exist.
position : array_like
Cartesian position with respect to the origin. Usually different than the original.
"""
self.impl.add_alias(name, original, position)
def add_aliases(self, *aliases):
"""Add multiple new aliases
Parameters
----------
*aliases
Each element should be a tuple containing the arguments for
:meth:`add_one_alias`. Works just like :meth:`add_sublattices`.
"""
for alias in aliases:
self.add_one_alias(*alias)
def add_one_hopping(self, relative_index, from_sub, to_sub, hop_name_or_energy):
"""Add a new hopping
For each new hopping, its Hermitian conjugate is added automatically. Doing so
manually, i.e. adding a hopping which is the Hermitian conjugate of an existing
one, will result in an exception being raised.
Parameters
----------
relative_index : array_like of int
Difference of the indices of the source and destination unit cells.
from_sub : str
Name of the sublattice in the source unit cell.
to_sub : str
Name of the sublattice in the destination unit cell.
hop_name_or_energy : float or str
The numeric value of the hopping energy or the name of a previously
registered hopping.
"""
self.impl.add_hopping(relative_index, from_sub, to_sub, hop_name_or_energy)
def add_hoppings(self, *hoppings):
"""Add multiple new hoppings
Parameters
----------
*hoppings
Each element should be a tuple containing the arguments for
a `add_one_hopping()` method call. See example.
Examples
--------
These three calls::
lattice.add_one_hopping([0, 0], 'a', 'b', 0.8)
lattice.add_one_hopping([0, 1], 'a', 'a', 0.3)
lattice.add_one_hopping([1, 1], 'a', 'b', 0.8)
Can be replaced with a single call to::
lattice.add_hoppings(
([0, 0], 'a', 'b', 0.8),
([0, 1], 'a', 'a', 0.3),
([1, 1], 'a', 'b', 0.8),
)
"""
for hop in hoppings:
self.add_one_hopping(*hop)
def with_offset(self, position):
"""Return a copy of this lattice with a different offset
It must be within half the length of a primitive lattice vector
Parameters
----------
position : array_like
Cartesian offset in the same length unit as the lattice vectors.
Returns
-------
:class:`Lattice`
"""
cp = deepcopy(self)
cp.offset = position
return cp
def with_min_neighbors(self, number):
"""Return a copy of this lattice with a different minimum neighbor count
Parameters
----------
number : int
The minimum number of neighbors.
Returns
-------
:class:`Lattice`
"""
cp = deepcopy(self)
cp.min_neighbors = number
return cp
def reciprocal_vectors(self):
"""Calculate the reciprocal space lattice vectors
Returns
-------
list
Examples
--------
>>> lat = Lattice(a1=[0, 1], a2=[0.5, 0.5])
>>> np.allclose(lat.reciprocal_vectors(), [[-2*pi, 2*pi, 0], [4*pi, 0, 0]])
True
"""
n = self.ndim
mat = np.column_stack(self.vectors)[:n]
mat = 2 * pi * np.linalg.inv(mat).T
mat = np.vstack([mat, np.zeros(shape=(3 - n, n))])
return [v.squeeze() for v in np.hsplit(mat, n)]
def brillouin_zone(self):
"""Return a list of vertices which form the Brillouin zone (1D and 2D only)
Returns
-------
List[array_like]
Examples
--------
>>> lat_1d = Lattice(a1=1)
>>> np.allclose(lat_1d.brillouin_zone(), [-pi, pi])
True
>>> lat_2d = Lattice(a1=[0, 1], a2=[0.5, 0.5])
>>> np.allclose(lat_2d.brillouin_zone(), [[0, -2*pi], [2*pi, 0], [0, 2*pi], [-2*pi, 0]])
True
"""
from scipy.spatial import Voronoi
if self.ndim == 1:
v1, = self.reciprocal_vectors()
l = np.linalg.norm(v1)
return [-l/2, l/2]
elif self.ndim == 2:
# The closest reciprocal lattice points are combinations of the primitive vectors
vectors = self.reciprocal_vectors()
points = [sum(n * v for n, v in zip(ns, vectors))
for ns in itertools.product([-1, 0, 1], repeat=self.ndim)]
# Voronoi doesn't like trailing zeros in coordinates
vor = Voronoi([p[:self.ndim] for p in points])
# See scipy's Voronoi documentation for details (-1 indicates infinity)
finite_regions = [r for r in vor.regions if len(r) != 0 and -1 not in r]
assert len(finite_regions) == 1
bz_vertices = [vor.vertices[i] for i in finite_regions[0]]
# sort counter-clockwise
return sorted(bz_vertices, key=lambda v: atan2(v[1], v[0]))
else:
raise RuntimeError("3D Brillouin zones are not currently supported")
@staticmethod
def _plot_vectors(vectors, position=(0, 0), name="a", scale=1.0,
head_width=0.08, head_length=0.2):
vnorm = np.average([np.linalg.norm(v) for v in vectors]) * scale
for i, vector in enumerate(vectors):
v2d = np.array(vector[:2]) * scale
if np.allclose(v2d, [0, 0]):
continue # nonzero only in z dimension, but the plot is 2D
plt.arrow(position[0], position[1], *v2d, color='black', length_includes_head=True,
head_width=vnorm * head_width, head_length=vnorm * head_length)
pltutils.annotate_box(r"${}_{}$".format(name, i+1), position[:2] + v2d / 2,
fontsize='large', bbox=dict(lw=0, alpha=0.6))
pltutils.despine(trim=True)
pltutils.add_margin()
def plot_vectors(self, position, scale=1.0):
"""Plot lattice vectors in the xy plane
Parameters
----------
position : array_like
Cartesian position to be used as the origin for the vectors.
scale : float
Multiply the length of the vectors by this number.
"""
self._plot_vectors(self.vectors, position, scale=scale)
def _visible_sublattices(self, axes):
"""Return the sublattices which are visible when viewed top-down in the `axes` plane"""
idx = list(rotate_axes([0, 1, 2], axes))
xy_idx, z_idx = idx[:2], idx[2]
sorted_subs = sorted(self.sublattices.items(), reverse=True,
key=lambda pair: pair[1].position[z_idx])
result = dict()
seen_positions = set()
for name, sub in sorted_subs:
p = tuple(sub.position[xy_idx])
if p not in seen_positions:
seen_positions.add(p)
result[name] = sub
return result
def site_radius_for_plot(self, max_fraction=0.33):
"""Return a good estimate for the lattice site radius for plotting
Calculated heuristically base on the length (1D) or area (2D) of the unit cell.
In order to prevent overlap between sites, if the computed radius is too large,
it will be clamped to a fraction of the shortest inter-atomic spacing.
Parameters
----------
max_fraction : float
Set the upper limit of the calculated radius as this fraction of the
shortest inter-atomic spacing in the lattice unit cell. Should be less
than 0.5 to avoid overlap between neighboring lattice sites.
Returns
-------
float
"""
def heuristic_radius(lattice):
"""The `magic` numbers were picked base on what looks nice in figures"""
if lattice.ndim == 1:
magic = 0.12
return magic * np.linalg.norm(lattice.vectors[0])
elif lattice.ndim == 2:
v1, v2 = lattice.vectors
unit_cell_area = np.linalg.norm(np.cross(v1, v2))
num_visible = len(self._visible_sublattices("xy"))
site_area = unit_cell_area / num_visible
if (lattice.ndim / num_visible).is_integer():
magic = 0.35 # single layer or nicely stacked layers
else:
magic = 0.42 # staggered layers
return magic * sqrt(site_area / pi)
else:
magic = 0.18
average_vec_length = sum(np.linalg.norm(v) for v in lattice.vectors) / 3
return magic * average_vec_length
def shortest_site_spacing(lattice):
from scipy.spatial.distance import pdist
distances = pdist([s.position for s in lattice.sublattices.values()])
distances = distances[distances > 0]
if np.any(distances):
return np.min(distances)
else:
vector_lengths = [np.linalg.norm(v) for v in lattice.vectors]
return np.min(vector_lengths)
r1 = heuristic_radius(self)
r2 = max_fraction * shortest_site_spacing(self)
return min(r1, r2)
def plot(self, axes="xy", vector_position="center", **kwargs):
"""Illustrate the lattice by plotting the primitive cell and its nearest neighbors
Parameters
----------
axes : str
The spatial axes to plot. E.g. 'xy', 'yz', etc.
vector_position : array_like or 'center'
Cartesian position to be used as the origin for the lattice vectors.
By default the origin is placed in the center of the primitive cell.
**kwargs
Forwarded to `System.plot()`.
"""
from .model import Model
from .shape import translational_symmetry
# reuse model plotting code (kind of meta)
model = Model(self, translational_symmetry())
model.system.plot(**with_defaults(kwargs, hopping=dict(color='#777777', width=1),
axes=axes))
# by default, plot the lattice vectors from the center of the unit cell
vectors = [np.array(rotate_axes(v, axes)) for v in self.vectors]
sub_center = sum(s.position for s in self.sublattices.values()) / self.nsub
sub_center = rotate_axes(sub_center, axes)
if vector_position is not None:
vector_position = sub_center if vector_position == "center" else vector_position
self._plot_vectors(vectors, vector_position)
# annotate sublattice names
for name, sub in self._visible_sublattices(axes).items():
pltutils.annotate_box(name, xy=rotate_axes(sub.position, axes)[:2],
bbox=dict(boxstyle="circle,pad=0.3", alpha=0.2, lw=0))
# collect relative indices where annotations should be drawn
relative_indices = []
for hopping_family in self.hoppings.values():
for term in hopping_family.terms:
if tuple(term.relative_index[:2]) == (0, 0):
continue # skip the original cell
relative_indices.append(term.relative_index)
relative_indices.append(-term.relative_index)
# 3D distance (in length units) of the neighboring cell from the original
offsets = [sum(r * v for r, v in zip(ri, self.vectors)) for ri in relative_indices]
offsets = [np.array(rotate_axes(p, axes)) for p in offsets]
# annotate neighboring cell indices
for relative_index, offset in zip(relative_indices, offsets):
text = "[" + ", ".join(map(str, relative_index[:self.ndim])) + "]"
# align the text so that it goes away from the original cell
ha, va = pltutils.align(*(-offset[:2]))
pltutils.annotate_box(text, xy=(sub_center[:2] + offset[:2]) * 1.05,
ha=ha, va=va, clip_on=True, bbox=dict(lw=0))
# ensure there is some padding around the lattice
offsets += [(0, 0, 0)]
points = [n * v + o for n in (-0.5, 0.5) for v in vectors for o in offsets]
x, y, _ = zip(*points)
pltutils.set_min_axis_length(abs(max(x) - min(x)), 'x')
pltutils.set_min_axis_length(abs(max(y) - min(y)), 'y')
pltutils.add_margin()
def plot_brillouin_zone(self, decorate=True, **kwargs):
"""Plot the Brillouin zone and reciprocal lattice vectors
Parameters
----------
decorate : bool
Label the vertices of the Brillouin zone and show the reciprocal vectors
**kwargs
Forwarded to `plt.plot()`.
"""
ax = plt.gca()
ax.set_aspect('equal')
ax.set_xlabel(r"$k_x (nm^{-1})$")
vertices = self.brillouin_zone()
default_color = pltutils.get_palette("Set1")[0]
if self.ndim == 1:
x1, x2 = vertices
y = x2 / 10
plt.plot([x1, x2], [y, y], **with_defaults(kwargs, color=default_color))
ticks = [x1, 0, x2]
plt.xticks(ticks, [x_pi(t) for t in ticks])
plt.ylim(0, 2 * y)
plt.yticks([])
ax.spines['left'].set_visible(False)
else:
ax.add_patch(plt.Polygon(
vertices, **with_defaults(kwargs, fill=False, color=default_color)
))
if decorate:
self._plot_vectors(self.reciprocal_vectors(), name="b",
head_width=0.05, head_length=0.12)
for vertex in vertices:
text = "[" + ", ".join(map(x_pi, vertex)) + "]"
# align the text so that it goes away from the origin
ha, va = pltutils.align(*(-vertex))
pltutils.annotate_box(text, vertex * 1.05, ha=ha, va=va, bbox=dict(lw=0))
x, y = zip(*vertices)
pltutils.set_min_axis_length(abs(max(x) - min(x)) * 2, 'x')
pltutils.set_min_axis_length(abs(max(y) - min(y)) * 2, 'y')
ax.set_ylabel(r"$k_y (nm^{-1})$")
pltutils.despine(trim=True)
| Python |
2D | dean0x7d/pybinding | pybinding/system.py | .py | 19,487 | 526 | """Structural information and utilities"""
import functools
import itertools
import numpy as np
import matplotlib.pyplot as plt
from matplotlib.collections import LineCollection
from . import _cpp
from . import pltutils
from .lattice import Lattice
from .utils import with_defaults, rotate_axes
from .support.alias import AliasArray
from .support.fuzzy_set import FuzzySet
from .support.structure import AbstractSites, Sites
from .results import Structure, StructureMap
__all__ = ['Sites', 'System', 'plot_hoppings', 'plot_periodic_boundaries', 'plot_sites',
'structure_plot_properties']
class _CppSites(AbstractSites):
"""Tailored to the internal C++ compressed sublattice representation"""
def __init__(self, impl: _cpp.System):
self._positions = impl.positions
self._cs = impl.compressed_sublattices
self._registry = impl.site_registry
@property
def x(self):
return self._positions.x
@property
def y(self):
return self._positions.y
@property
def z(self):
return self._positions.z
@property
def ids(self):
return AliasArray(self._cs.decompressed(), self._registry.name_map)
def __getitem__(self, item):
return Sites([v[item] for v in self.positions], self.ids[item])
class System(Structure):
"""Structural data of a tight-binding model
Stores positions, sublattice and hopping IDs for all lattice sites.
"""
def __init__(self, impl: _cpp.System, lattice=None):
super().__init__(_CppSites(impl), impl.hopping_blocks, impl.boundaries)
self.impl = impl
self.lattice = lattice
def __getstate__(self):
return self.__dict__
def __setstate__(self, state):
if isinstance(state, dict):
self.__init__(state["impl"], state["lattice"])
else:
self.__init__(state)
@property
def expanded_positions(self):
"""`positions` expanded to `hamiltonian_size` by replicating for each orbital"""
return self.impl.expanded_positions
@property
def hamiltonian_size(self) -> int:
"""The size of the Hamiltonian matrix constructed from this system
Takes into account the number of orbitals/spins at each lattice site
which makes `hamiltonian_size` >= `num_sites`.
"""
return self.impl.hamiltonian_size
def with_data(self, data) -> StructureMap:
"""Map some data to this system"""
data = self.reduce_orbitals(data)
return StructureMap(data, self._sites, self._hoppings, self._boundaries)
def find_nearest(self, position, sublattice=""):
"""Find the index of the atom closest to the given position
Parameters
----------
position : array_like
Where to look.
sublattice : Optional[str]
Look for a specific sublattice site. By default any will do.
Returns
-------
int
"""
return self.impl.find_nearest(position, sublattice)
def count_neighbors(self):
"""Return the number of neighbors for each site"""
return self.impl.hopping_blocks.count_neighbors()
def to_hamiltonian_indices(self, system_idx):
"""Translate the given system index into its corresponding Hamiltonian indices
System indices are always scalars and index a single (x, y, z) site position.
For single-orbital models there is a 1:1 correspondence between system and
Hamiltonian indices. However, for multi-orbital models the Hamiltonian indices
are 1D arrays with a size corresponding to the number of orbitals on the target
site.
Parameters
----------
system_idx : int
Returns
-------
array_like
"""
return self.impl.to_hamiltonian_indices(system_idx)
def reduce_orbitals(self, data):
"""Sum up the contributions of individual orbitals in the given data
Takes a 1D array of `hamiltonian_size` and returns a 1D array of `num_sites` size
where the multiple orbital data has been reduced per site.
Parameters
----------
data : array_like
Must be 1D and the equal to the size of the Hamiltonian matrix
Returns
-------
array_like
"""
data = np.atleast_1d(data)
if data.size == self.num_sites:
return data
if data.ndim != 1 or data.size != self.hamiltonian_size:
raise RuntimeError("The given data does not match the Hamiltonian size")
start = 0
reduced_data = []
cs = self.impl.compressed_sublattices
for nsites, norb in zip(cs.site_counts, cs.orbital_counts):
end = start + nsites * norb
reduced_data.append(data[start:end].reshape((-1, norb)).sum(axis=1))
start = end
return np.concatenate(reduced_data)
def structure_plot_properties(axes='xyz', site=None, hopping=None, boundary=None, **kwargs):
"""Process structure plot properties
Parameters
----------
axes : str
The spatial axes to plot. E.g. 'xy' for the default view,
or 'yz', 'xz' and similar to plot a rotated view.
site : dict
Arguments forwarded to :func:`plot_sites`.
hopping : dict
Arguments forwarded to :func:`plot_hoppings`.
boundary : dict
Arguments forwarded to :func:`plot_periodic_boundaries`.
**kwargs
Additional args are reserved for internal implementation.
Returns
-------
dict
"""
# Also accept the plural form (`sites` and `hoppings`) since
# this is a common mistake and source of frustration.
site = kwargs.pop("sites", site)
hopping = kwargs.pop("hoppings", hopping)
invalid_args = kwargs.keys() - {'add_margin'}
if invalid_args:
raise RuntimeError("Invalid arguments: {}".format(','.join(invalid_args)))
props = {'axes': axes, 'add_margin': kwargs.get('add_margin', True),
'site': with_defaults(site, axes=axes),
'hopping': with_defaults(hopping, axes=axes)}
props['boundary'] = with_defaults(boundary, props['hopping'], color='#f40a0c')
return props
def decorate_structure_plot(axes='xy', add_margin=True, **_):
plt.gca().set_aspect('equal')
plt.gca().autoscale_view()
plt.xlabel("{} (nm)".format(axes[0]))
plt.ylabel("{} (nm)".format(axes[1]))
if add_margin:
pltutils.set_min_axis_length(0.5)
pltutils.set_min_axis_ratio(0.4)
pltutils.despine(trim=True)
pltutils.add_margin()
else:
pltutils.despine()
def _data_units_to_points(ax, value):
"""Convert a value from data units to points"""
fig = ax.get_figure()
length = fig.bbox_inches.width * ax.get_position().width
length *= 72 # convert to points
data_range = np.diff(ax.get_xlim())
return value * (length / data_range)
def plot_sites(positions, data, radius=0.025, offset=(0, 0, 0), blend=1.0,
cmap='auto', axes='xyz', **kwargs):
"""Plot circles at lattice site `positions` with colors based on `data`
Parameters
----------
positions : Tuple[array_like, array_like, array_like]
Site coordinates in the form of an (x, y, z) tuple of 1D arrays.
data : array_like
Color data at each site. Should be a 1D array of the same size as `positions`.
If the data is discrete with few unique values, the discrete `colors` parameter
should be used. For continuous data, setting a `cmap` (colormap) is preferred.
radius : Union[float, array_like]
Radius (in data units) of the plotted circles representing lattice sites.
Should be a scalar value or an array with the same size as `positions`.
offset : Tuple[float, float, float]
Offset all positions by a constant value.
blend : float
Blend all colors to white (fake alpha blending): expected values between 0 and 1.
cmap : Union[str, List[str]]
Either a regular matplotlib colormap or a list of discrete colors to apply to the
drawn circles. In the latter case, it is assumed that `data` is discrete with only
a few unique values. For example, sublattice data for graphene will only contain two
unique values for the A and B sublattices which will be assigned the first two colors
from the `cmap` list. For continuous data, a regular matplotlib colormap should be
used instead.
axes : str
The spatial axes to plot. E.g. 'xy', 'yz', etc.
**kwargs
Forwarded to :class:`matplotlib.collections.CircleCollection`.
Returns
-------
:class:`matplotlib.collections.CircleCollection`
"""
if np.all(radius == 0):
return
kwargs = with_defaults(kwargs, alpha=0.97, lw=0.2, edgecolor=str(1-blend))
if cmap == 'auto':
cmap = ['#377ec8', '#ff7f00', '#41ae76', '#e41a1c',
'#984ea3', '#ffff00', '#a65628', '#f781bf']
elif cmap == 'pairs':
cmap = ['#a6cee3', '#1f78b4', '#b2df8a', '#33a02c', '#fb9a99', '#e31a1c',
'#fdbf6f', '#ff7f00', '#cab2d6', '#6a3d9a']
# create colormap from discrete colors
if isinstance(cmap, (list, tuple)):
kwargs['cmap'], kwargs['norm'] = pltutils.direct_cmap_norm(data, cmap, blend)
else:
kwargs['cmap'] = cmap
rotate = functools.partial(rotate_axes, axes=axes)
positions, offset = map(rotate, (positions, offset))
# create array of (x, y) points
points = np.array(positions[:2]).T + offset[:2]
ax = plt.gca()
if ax.name != '3d':
# sort based on z position to get proper 2D z-order
z = positions[2]
if len(np.unique(z)) > 1:
idx = z.argsort()
if not np.isscalar(radius):
radius = radius[idx]
points, data = points[idx], data[idx]
from pybinding.support.collections import CircleCollection
col = CircleCollection(radius, offsets=points, transOffset=ax.transData, **kwargs)
col.set_array(data)
ax.add_collection(col)
def dynamic_scale(active_ax):
"""Rescale the circumference line width and radius based on data units"""
scale = _data_units_to_points(active_ax, 0.005) # [nm] reference for 1 screen point
line_scale = np.clip(scale, 0.2, 1.1) # don't make the line too thin or thick
col.set_linewidth(line_scale * kwargs['lw'])
if np.isscalar(radius):
scale = _data_units_to_points(active_ax, 0.01) # [nm]
radius_scale = np.clip(2 - scale, 0.85, 1.3)
col.radius = radius_scale * np.atleast_1d(radius)
dynamic_scale(ax)
ax.callbacks.connect('xlim_changed', dynamic_scale)
ax.callbacks.connect('ylim_changed', dynamic_scale)
else:
from pybinding.support.collections import Circle3DCollection
col = Circle3DCollection(radius/8, offsets=points, transOffset=ax.transData, **kwargs)
col.set_array(data)
z = positions[2] + offset[2]
col.set_3d_properties(z, 'z')
had_data = ax.has_data()
ax.add_collection(col)
minmax = tuple((v.min(), v.max()) for v in positions)
ax.auto_scale_xyz(*minmax, had_data=had_data)
return col
def plot_hoppings(positions, hoppings, width=1.0, offset=(0, 0, 0), blend=1.0, color='#666666',
axes='xyz', boundary=(), draw_only=(), **kwargs):
"""Plot lines between lattice sites at `positions` based on the `hoppings` matrix
Parameters
----------
positions : Tuple[array_like, array_like, array_like]
Site coordinates in the form of an (x, y, z) tuple of 1D arrays.
hoppings : :class:`~scipy.sparse.coo_matrix`
Sparse matrix with the hopping data, usually :attr:`System.hoppings`.
The `row` and `col` indices of the sparse matrix are used to draw lines between
lattice sites, while `data` determines the color.
width : float
Width of the hopping plot lines.
offset : Tuple[float, float, float]
Offset all positions by a constant value.
blend : float
Blend all colors to white (fake alpha blending): expected values between 0 and 1.
axes : str
The spatial axes to plot. E.g. 'xy', 'yz', etc.
color : str
Set the same color for all hopping lines. To assign a different color for each
hopping ID, use the `cmap` parameter.
boundary : Tuple[int, array_like]
If given, apply the boundary (sign, shift).
draw_only : Iterable[str]
Only draw lines for the hoppings named in this list.
**kwargs
Forwarded to :class:`matplotlib.collections.LineCollection`.
Returns
-------
:class:`matplotlib.collections.LineCollection`
"""
hoppings = hoppings.tocoo()
if width == 0 or hoppings.data.size == 0:
return
kwargs = with_defaults(kwargs, zorder=-1)
num_unique_hoppings = hoppings.data.max() + 1
if "cmap" in kwargs:
cmap = kwargs["cmap"]
if cmap == 'auto':
cmap = ['#666666', '#1b9e77', '#e6ab02', '#7570b3', '#e7298a', '#66a61e', '#a6761d']
# create colormap from discrete colors
if isinstance(cmap, (list, tuple)):
unique_hop_ids = np.arange(num_unique_hoppings)
kwargs['cmap'], kwargs['norm'] = pltutils.direct_cmap_norm(unique_hop_ids, cmap, blend)
else:
kwargs['cmap'] = cmap
else:
color = pltutils.blend_colors(color, "white", blend)
rotate = functools.partial(rotate_axes, axes=axes)
positions, offset = map(rotate, (positions, offset))
# leave only the desired hoppings
if draw_only:
keep = np.zeros_like(hoppings.data, dtype=np.bool)
for hop_id in draw_only:
keep = np.logical_or(keep, hoppings.data == hop_id)
hoppings.data = hoppings.data[keep]
hoppings.col = hoppings.col[keep]
hoppings.row = hoppings.row[keep]
ax = plt.gca()
ndims = 3 if ax.name == '3d' else 2
pos = np.array(positions[:ndims]).T + np.array(offset[:ndims])
if not boundary:
lines = np.stack([pos[hoppings.row], pos[hoppings.col]], axis=1)
else:
sign, shift = boundary
shift = rotate(shift)[:ndims]
if sign > 0:
lines = np.stack([pos[hoppings.row] + shift, pos[hoppings.col]], axis=1)
else:
lines = np.stack([pos[hoppings.row], pos[hoppings.col] - shift], axis=1)
if ndims == 2:
col = LineCollection(lines, colors=color, **kwargs)
if "cmap" in kwargs:
col.set_array(hoppings.data)
ax.add_collection(col)
def dynamic_scale(active_ax):
"""Rescale the line width based on data units"""
scale = _data_units_to_points(active_ax, 0.005) # [nm] reference for 1 screen point
scale = np.clip(scale, 0.6, 1.2) # don't make the line too thin or thick
col.set_linewidth(scale * width)
dynamic_scale(ax)
ax.callbacks.connect('xlim_changed', dynamic_scale)
ax.callbacks.connect('ylim_changed', dynamic_scale)
else:
from mpl_toolkits.mplot3d.art3d import Line3DCollection
had_data = ax.has_data()
col = Line3DCollection(lines, colors=color, lw=width, **kwargs)
if "cmap" in kwargs:
col.set_array(hoppings.data)
ax.add_collection3d(col)
ax.set_zmargin(0.5)
minmax = np.vstack((pos.min(axis=0), pos.max(axis=0))).T
ax.auto_scale_xyz(*minmax, had_data=had_data)
return col
def _make_shift_set(boundaries, level):
"""Return a set of boundary shift combinations for the given repetition level"""
if level == 0:
return FuzzySet([np.zeros(3)])
base_shifts = [b.shift for b in boundaries] + [-b.shift for b in boundaries]
all_shifts = (sum(c) for c in itertools.combinations_with_replacement(base_shifts, level))
blacklist = sum(_make_shift_set(boundaries, l) for l in range(level))
exclusive_shifts = (s for s in all_shifts if s not in blacklist)
return FuzzySet(exclusive_shifts)
def plot_periodic_boundaries(positions, hoppings, boundaries, data, num_periods=1, **kwargs):
"""Plot the periodic boundaries of a system
Parameters
----------
positions : Tuple[array_like, array_like, array_like]
Site coordinates in the form of an (x, y, z) tuple of 1D arrays.
hoppings : :class:`~scipy.sparse.coo_matrix`
Sparse matrix with the hopping data, usually :meth:`System.hoppings`.
The `row` and `col` indices of the sparse matrix are used to draw lines between
lattice sites, while `data` determines the color.
boundaries : List[Boundary]
Periodic boundaries of a :class:`System`.
data : array_like
Color data at each site. Should be a 1D array of the same size as `positions`.
num_periods : int
Number of times to repeat the periodic boundaries.
**kwargs
Additional plot arguments as specified in :func:`.structure_plot_properties`.
"""
props = structure_plot_properties(**kwargs)
# the periodic parts will fade out gradually at each level of repetition
blend_gradient = np.linspace(0.5, 0.15, num_periods)
# periodic unit cells
for level, blend in enumerate(blend_gradient, start=1):
shift_set = _make_shift_set(boundaries, level)
for s in shift_set:
plot_sites(positions, data, offset=s, **{"blend": blend, **props["site"]})
plot_hoppings(positions, hoppings, offset=s, **{"blend": blend, **props["hopping"]})
# periodic boundary hoppings
for level, blend in enumerate(blend_gradient, start=1):
shift_set = _make_shift_set(boundaries, level)
prev_shift_set = _make_shift_set(boundaries, level - 1)
boundary_set = itertools.product(shift_set + prev_shift_set, (1, -1), boundaries)
for shift, sign, boundary in boundary_set:
if (shift + sign * boundary.shift) not in prev_shift_set:
continue # skip existing
plot_hoppings(positions, boundary.hoppings.tocoo(), offset=shift,
boundary=(sign, boundary.shift), **{"blend": blend, **props["boundary"]})
def plot_site_indices(system):
"""Show the Hamiltonian index next to each atom (mainly for debugging)
Parameters
----------
system : System
"""
for i, xy in enumerate(zip(system.x, system.y)):
pltutils.annotate_box(i, xy)
def plot_hopping_values(system):
"""Show the hopping energy over each hopping line (mainly for debugging)
Parameters
----------
system : System
"""
pos = system.xyz[:, :2]
def get_energy(hopping_id):
inv_name_map = {hop.family_id: name for name, hop in system.lattice.hoppings.items()}
return inv_name_map[hopping_id]
coo = system.hoppings.tocoo()
for i, j, k in zip(coo.row, coo.col, coo.data):
pltutils.annotate_box(get_energy(k), (pos[i] + pos[j]) / 2)
for boundary in system.boundaries:
coo = boundary.hoppings.tocoo()
for i, j, k in zip(coo.row, coo.col, coo.data):
pltutils.annotate_box(get_energy(k), (pos[i] + pos[j] + boundary.shift[:2]) / 2)
pltutils.annotate_box(get_energy(k), (pos[i] + pos[j] - boundary.shift[:2]) / 2)
| Python |
2D | dean0x7d/pybinding | pybinding/greens.py | .py | 577 | 22 | """Green's function computation and related methods
Deprecated: use the chebyshev module instead
"""
import warnings
from . import chebyshev
from .support.deprecated import LoudDeprecationWarning
__all__ = ['Greens', 'kpm', 'kpm_cuda']
Greens = chebyshev.KPM
def kpm(*args, **kwargs):
warnings.warn("Use pb.kpm() instead", LoudDeprecationWarning, stacklevel=2)
return chebyshev.kpm(*args, **kwargs)
def kpm_cuda(*args, **kwargs):
warnings.warn("Use pb.kpm_cuda() instead", LoudDeprecationWarning, stacklevel=2)
return chebyshev.kpm_cuda(*args, **kwargs)
| Python |
2D | dean0x7d/pybinding | pybinding/leads.py | .py | 7,279 | 198 | """Lead interface for scattering models
The only way to create leads is using the :meth:`.Model.attach_lead` method.
The classes represented here are the final product of that process, listed
in :attr:`.Model.leads`.
"""
import numpy as np
import matplotlib.pyplot as plt
from math import pi
from scipy.sparse import csr_matrix
from . import _cpp
from . import pltutils, results
from .system import (System, plot_sites, plot_hoppings, structure_plot_properties,
decorate_structure_plot)
__all__ = ['Lead']
def _center(pos, shift):
"""Return the 2D center position of `pos + shift`"""
x = np.concatenate((pos[0], pos[0] + shift[0]))
y = np.concatenate((pos[1], pos[1] + shift[1]))
return (x.max() + x.min()) / 2, (y.max() + y.min()) / 2
class Lead:
"""Describes a single lead connected to a :class:`.Model`
Leads can only be created using :meth:`.Model.attach_lead`
and accessed using :attr:`.Model.leads`.
"""
def __init__(self, impl: _cpp.Lead, index, lattice):
self.impl = impl
self.index = index
self.lattice = lattice
@property
def indices(self) -> np.ndarray:
"""Main system indices (1d array) to which this lead is connected"""
return self.impl.indices
@property
def system(self) -> System:
"""Structural information, see :class:`.System`"""
return System(self.impl.system, self.lattice)
@property
def h0(self) -> csr_matrix:
"""Unit cell Hamiltonian as :class:`~scipy.sparse.csr_matrix`"""
return self.impl.h0
@property
def h1(self) -> csr_matrix:
"""Hamiltonian which connects who unit cells, :class:`~scipy.sparse.csr_matrix`"""
return self.impl.h1
def calc_bands(self, start=-pi, end=pi, step=0.05):
"""Calculate the band structure of an infinite lead
Parameters
----------
start, end : float
Points in reciprocal space which form the path for the band calculation.
step : float
Calculation step length in reciprocal space units. Lower `step` values
will return more detailed results.
Returns
-------
:class:`~pybinding.results.Bands`
"""
from scipy.linalg import eigh
h0 = self.h0.todense()
h1 = self.h1.todense()
h1t = np.conj(h1.T)
def eigenvalues(k):
h = h0 + h1 * np.exp(1j * k) + h1t * np.exp(-1j * k)
return eigh(h, eigvals_only=True)
k_path = results.make_path(start, end, step=step).flatten()
bands = [eigenvalues(k) for k in k_path]
return results.Bands(k_path, np.vstack(bands))
def plot(self, lead_length=6, **kwargs):
"""Plot the sites, hoppings and periodic boundaries of the lead
Parameters
----------
lead_length : int
Number of times to repeat the lead's periodic boundaries.
**kwargs
Additional plot arguments as specified in :func:`.structure_plot_properties`.
"""
pos = self.system.positions
sub = self.system.sublattices
inner_hoppings = self.system.hoppings.tocoo()
boundary = self.system.boundaries[0]
outer_hoppings = boundary.hoppings.tocoo()
props = structure_plot_properties(**kwargs)
props['site'].setdefault('radius', self.system.lattice.site_radius_for_plot())
blend_gradient = np.linspace(0.5, 0.1, lead_length)
for i, blend in enumerate(blend_gradient):
offset = i * boundary.shift
plot_sites(pos, sub, offset=offset, blend=blend, **props['site'])
plot_hoppings(pos, inner_hoppings, offset=offset, blend=blend, **props['hopping'])
plot_hoppings(pos, outer_hoppings, offset=offset - boundary.shift, blend=blend,
boundary=(1, boundary.shift), **props['boundary'])
label_pos = _center(pos, lead_length * boundary.shift * 1.5)
pltutils.annotate_box("lead {}".format(self.index), label_pos, bbox=dict(alpha=0.7))
decorate_structure_plot(**props)
def plot_contact(self, line_width=1.6, arrow_length=0.5,
shade_width=0.3, shade_color='#d40a0c'):
"""Plot the shape and direction of the lead contact region
Parameters
----------
line_width : float
Width of the line representing the lead contact.
arrow_length : float
Size of the direction arrow as a fraction of the contact line length.
shade_width : float
Width of the shaded area as a fraction of the arrow length.
shade_color : str
Color of the shaded area.
"""
lead_spec = self.impl.spec
vectors = self.lattice.vectors
if len(lead_spec.shape.vertices) != 2 or len(vectors) != 2:
raise RuntimeError("This only works for 2D systems")
# contact line vertices
a, b = (v[:2] for v in lead_spec.shape.vertices)
def plot_contact_line():
# Not using plt.plot() because it would reset axis limits
plt.gca().add_patch(plt.Polygon([a, b], color='black', lw=line_width))
def rescale_lattice_vector(vec):
line_length = np.linalg.norm(a - b)
scale = arrow_length * line_length / np.linalg.norm(vec)
return vec[:2] * scale
def plot_arrow(xy, vec, spec, head_width=0.08, head_length=0.2):
vnorm = np.linalg.norm(vec)
plt.arrow(xy[0], xy[1], *vec, color='black', alpha=0.9, length_includes_head=True,
head_width=vnorm * head_width, head_length=vnorm * head_length)
label = r"${}a_{}$".format("-" if spec.sign < 0 else "", spec.axis + 1)
pltutils.annotate_box(label, xy + vec / 5, fontsize='large',
bbox=dict(lw=0, alpha=0.6))
def plot_polygon(w):
plt.gca().add_patch(plt.Polygon([a - w, a + w, b + w, b - w],
color=shade_color, alpha=0.25, lw=0))
plot_contact_line()
v = rescale_lattice_vector(vectors[lead_spec.axis] * lead_spec.sign)
plot_arrow(xy=(a + b) / 2, vec=v, spec=lead_spec)
plot_polygon(w=shade_width * v)
pltutils.despine(trim=True)
pltutils.add_margin()
def plot_bands(self, start=-pi, end=pi, step=0.05, **kwargs):
"""Plot the band structure of an infinite lead
Parameters
----------
start, end : float
Points in reciprocal space which form the path for the band calculation.
step : float
Calculation step length in reciprocal space units. Lower `step` values
will return more detailed results.
**kwargs
Forwarded to :meth:`.Bands.plot`.
"""
bands = self.calc_bands(start, end, step)
bands.plot(**kwargs)
plt.title("lead {}".format(self.index))
class Leads:
def __init__(self, impl: _cpp.Leads, lattice):
self.impl = impl
self.lattice = lattice
def __getitem__(self, index):
return Lead(self.impl[index], index, self.lattice)
def __len__(self):
return len(self.impl)
| Python |
2D | dean0x7d/pybinding | pybinding/parallel.py | .py | 13,695 | 428 | """Multi-threaded functions for parameter sweeps"""
import sys
import inspect
import itertools
from copy import copy
from functools import partial
import numpy as np
import matplotlib.pyplot as plt
from pybinding.support.inspect import get_call_signature
from . import _cpp
from .utils import cpuinfo, progressbar, decorator_decorator
from .results import Sweep, NDSweep
__all__ = ['num_cores', 'parallel_for', 'parallelize', 'sweep', 'ndsweep']
num_cores = cpuinfo.physical_core_count()
def _sequential_for(sequence, produce, retire):
"""Simple single-threaded for loop"""
for idx, var in enumerate(sequence):
deferred = produce(var)
deferred.compute()
retire(deferred, idx)
def _parallel_for(sequence, produce, retire, num_threads=num_cores, queue_size=num_cores):
"""Multi-threaded for loop
See the implementation of `_sequential_for` to get the basic idea. This parallel
version is functionally identical but executes on multiple threads simultaniously
thanks to C++. The `produce` function must return a Deferred compute object which
has a `compute()` method and a `result` field.
Everything is implemented in C++. This is just a wrapper which sets the default
values of `num_threads` and `queue_size` to the number of physical cores.
Parameters
----------
sequence : array_like
The for loop will iterate over this.
produce : callable
Takes a value from `sequence` and returns a `Deferred` compute object.
retire : callable
Takes the computed `Deferred` object and 'idx' which indicates the index
of the value in `sequence` which was just computed.
num_threads : int
Number of thread that will run in parallel.
queue_size : int
Number of `Deferred` jobs to be queued up for consumption by the worker
threads. The maximum number of jobs that will be kept in memory at any
one time will be `queue_size` + `num_threads`.
Examples
--------
::
def produce(var):
model = pb.Model(...) # something that depends on var
greens = pb.greens.kpm(model)
return greens.deferred_ldos(...) # may also depend on var
def retire(deferred, idx):
print(deferred.result)
_parallel_for(np.linspace(0, 1, 50), produce, retire)
"""
_cpp.parallel_for(sequence, produce, retire, num_threads, queue_size)
class Hooks:
"""Holds functions which hook into `ParallelFor`
Attributes
----------
first : list of callable
Called only once after the first `Deferred` is produced.
status : list of callable
Called every time a `Deferred` job is computed. As arguments it takes
a `report` string, `idx` of the original value and `count` the number
of job that have been computed so far.
plot : list of callable
Called once in a while with a `result` argument to be plotted.
"""
def __init__(self):
self.first = []
self.status = []
self.plot = []
class Config:
"""Configuration variables for `ParallelFor`
Attributes
----------
callsig : CallSignature
Signature of the function call which made the parallel `Factory`.
Used for automatic configuration.
filename : str
The name of the file (without an extension) for various files which will be
produced. The computed data will be saved with the '.pbz' extension, plots
with '.png', progress log with '.log', etc.
num_threads, queue_size : int
Forwarded to `_parallel_for`.
save_every : float
A 0 to 100 percentage points interval to save and plot the data.
pbar_fd : {sys.stdout, sys.stderr, None}
Output stream. The progress bar is always the last line of output.
"""
def __init__(self, callsig, num_threads, queue_size):
self.callsig = callsig
self.num_threads = num_threads
self.queue_size = queue_size
self.filename = self.make_filename(callsig)
self.save_every = 10.0
self.pbar_fd = sys.stdout
def make_save_set(self, total):
save_at = {int(total * p) for p in np.arange(0, 1, self.save_every / 100)}
save_at.remove(0)
save_at.add(total) # make sure progress is saved on the last iteration
return save_at
@staticmethod
def make_filename(callsig):
invalid_chars = " /.,"
filename = "".join("{:.1s}{}".format(k, v) for k, v in callsig.named_args.items())
if not filename:
filename = "data"
return "".join(c for c in filename if c not in invalid_chars)
class DefaultStatus:
"""Default status reporter"""
def __init__(self, params, sequence):
self.params = params
self.sequence = sequence
size = len(sequence)
count_width = len(str(size))
vars_width = max(len(self._vars(idx)) for idx in range(size))
self.template = "{{count:{}}}| {{vars:{}}} | {{report}}".format(count_width, vars_width)
def _vars(self, idx):
return ", ".join("{} = {:.2g}".format(k, v)
for k, v in zip(self.params, self.sequence[idx]))
def __call__(self, deferred, idx, count):
report = deferred.solver.report(shortform=True)
print(self.template.format(vars=self._vars(idx), **locals()))
class Factory:
"""Produces `Deferred` jobs for `ParallelFor`
Attributes
----------
variables : tuple of array_like
Parameters which change while iterating.
fixtures : dict
Constant parameters.
sequence : list
Product of `variables`. The loop will iterate over its values.
produce : callable
Takes a value from `sequence` and returns a `Deferred` compute object.
config : Config
hooks : Hooks
"""
def __init__(self, variables, fixtures, produce, config):
self.variables = variables
self.fixtures = fixtures
self.produce = produce
self.config = config
self.sequence = list(itertools.product(*variables))
self.hooks = Hooks()
self.hooks.status.append(DefaultStatus(
inspect.signature(self.produce).parameters, self.sequence
))
class ParallelFor:
"""Keep track of progress while running `_parallel_for`
Parameters
----------
factory : Factory
Produces Deferred compute kernels.
make_result : callable
Creates the final result from raw data. See `_make_result` prototype.
"""
def __init__(self, factory, make_result=None):
self.factory = factory
self.hooks = factory.hooks
self.config = factory.config
if make_result:
self._make_result = make_result
size = len(factory.sequence)
self.save_at = self.config.make_save_set(size)
logname = self.config.filename + ".log" if self.config.filename else ""
self.pbar = progressbar.ProgressBar(size, stream=self.config.pbar_fd, filename=logname)
if self.config.num_threads == 1:
self.loop = _sequential_for
else:
self.loop = partial(_parallel_for, num_threads=self.config.num_threads,
queue_size=self.config.queue_size)
self.called_first = False
self.result = None
self.data = [None] * size
@staticmethod
def _make_result(data):
return data
def _produce(self, var):
deferred = self.factory.produce(*var, **self.factory.fixtures)
if not self.called_first:
self._first(deferred)
self.called_first = True
self.pbar.refresh()
return deferred
def _first(self, deferred):
for f in self.hooks.first:
f(deferred)
def _retire(self, deferred, idx):
self.data[idx] = copy(deferred.result)
count = self.pbar.value + 1
self._status(deferred, idx, count)
self.pbar += 1 # also refreshes output stream
if count in self.save_at:
result = self._make_result(self.data)
self.result = copy(result) # _plot() may modify the local
self._save(result)
self._plot(result)
def _status(self, deferred, idx, count):
for f in self.hooks.status:
f(deferred, idx, count)
def _save(self, result):
if not self.config.filename:
return
from .support.pickle import save
save(result, self.config.filename)
def _plot(self, result):
if not self.config.filename:
return
try:
if self.hooks.plot:
for f in self.hooks.plot:
f(result)
plt.savefig(self.config.filename + ".png")
plt.close()
except Exception as err:
print(err)
def __call__(self):
self.called_first = False
with self.pbar:
self.loop(self.factory.sequence, self._produce, self._retire)
return self.result
def parallel_for(factory, make_result=None):
"""Multi-threaded loop feed by the `factory` function
Parameters
----------
factory : :func:`Factory <parallelize>`
Factory function created with the :func:`parallelize` decorator.
make_result : callable, optional
Creates the final result from raw data. This result is also the
final return value of :func:`parallel_for`.
Returns
-------
array_like
A result for each loop iteration.
Examples
--------
::
@parallelize(x=np.linspace(0, 1, 10))
def factory(x):
pb.Model(...) # depends on `x`
greens = pb.greens.kpm(model)
return greens.deferred_ldos(...) # may also depend on `x`
results = parallel_for(factory)
"""
return ParallelFor(factory, make_result)()
@decorator_decorator
def parallelize(num_threads=num_cores, queue_size=num_cores, **kwargs):
"""parallelize(num_threads=num_cores, queue_size=num_cores, **kwargs)
A decorator which creates factory functions for :func:`parallel_for`
The decorated function must return a `Deferred` compute kernel.
Parameters
----------
num_threads : int
Number of threads that will run in parallel. Defaults to the number of
cores in the current machine.
queue_size : int
Number of `Deferred` jobs to be queued up for consumption by the worker
threads. The maximum number of jobs that will be kept in memory at any
one time will be `queue_size` + `num_threads`.
**kwargs
Variables which will be iterated over in :func:`parallel_for`
and passed to the decorated function. See example.
Examples
--------
::
@parallelize(a=np.linspace(0, 1, 10), b=np.linspace(-2, 2, 10))
def factory(a, b):
pb.Model(...) # depends on `a` and `b`
greens = pb.greens.kpm(model)
return greens.deferred_ldos(...) # may also depend on `a` and `b`
results = parallel_for(factory)
"""
callsig = kwargs.pop('callsig', None)
if not callsig:
callsig = get_call_signature(up=2)
def decorator(produce_func):
params = inspect.signature(produce_func).parameters
variables = tuple(kwargs[k] for k in params if k in kwargs)
fixtures = {k: v.default for k, v in params.items() if k not in kwargs}
return Factory(variables, fixtures, produce_func,
Config(callsig, num_threads, queue_size))
return decorator
def sweep(factory, plot=lambda r: r.plot(), labels=None, tags=None, silent=False):
"""Do a multi-threaded parameter sweep
Parameters
----------
factory : :func:`Factory <parallelize>`
Factory function created with the :func:`parallelize` decorator.
plot : callable
Plotting functions which takes a :class:`.Sweep` result as its only argument.
labels, tags : dict
Forwarded to :class:`.Sweep` object.
silent : bool
Don't print status messages.
Returns
-------
:class:`~pybinding.Sweep`
"""
x = factory.variables[0]
energy = factory.fixtures['energy']
zero = np.zeros_like(energy, np.float32)
def make_result(data):
sweep_data = np.vstack([v.squeeze() if v is not None else zero for v in data])
return Sweep(x, energy, sweep_data, labels, tags)
if silent:
factory.hooks.status.clear()
if plot:
factory.hooks.plot.append(plot)
return parallel_for(factory, make_result)
def ndsweep(factory, plot=None, labels=None, tags=None, silent=False):
"""Do a multi-threaded n-dimensional parameter sweep
Parameters
----------
factory : :func:`Factory <parallelize>`
Factory function created with the :func:`parallelize` decorator.
plot : callable
Plotting functions which takes a :class:`.NDSweep` result as its only argument.
labels, tags : dict
Forwarded to :class:`.NDSweep` object.
silent : bool
Don't print status messages.
Returns
-------
:class:`~pybinding.NDSweep`
"""
energy = factory.fixtures['energy']
variables = factory.variables + (energy,)
zero = np.zeros_like(energy, np.float32)
def make_result(data):
sweep_data = np.vstack([v.squeeze() if v is not None else zero for v in data])
return NDSweep(variables, sweep_data, labels, tags)
if silent:
factory.hooks.status.clear()
if plot:
factory.hooks.plot.append(plot)
return parallel_for(factory, make_result)
| Python |
2D | dean0x7d/pybinding | pybinding/repository/__init__.py | .py | 0 | 0 | null | Python |
2D | dean0x7d/pybinding | pybinding/repository/group6_tmd.py | .py | 4,432 | 112 | """Tight-binding models for group 6 transition metal dichalcogenides (TMD)."""
import re
import math
import pybinding as pb
_default_3band_params = { # from https://doi.org/10.1103/PhysRevB.88.085433
# -> a, eps1, eps2, t0, t1, t2, t11, t12, t22
"MoS2": [0.3190, 1.046, 2.104, -0.184, 0.401, 0.507, 0.218, 0.338, 0.057],
"WS2": [0.3191, 1.130, 2.275, -0.206, 0.567, 0.536, 0.286, 0.384, -0.061],
"MoSe2": [0.3326, 0.919, 2.065, -0.188, 0.317, 0.456, 0.211, 0.290, 0.130],
"WSe2": [0.3325, 0.943, 2.179, -0.207, 0.457, 0.486, 0.263, 0.329, 0.034],
"MoTe2": [0.3557, 0.605, 1.972, -0.169, 0.228, 0.390, 0.207, 0.239, 0.252],
"WTe2": [0.3560, 0.606, 2.102, -0.175, 0.342, 0.410, 0.233, 0.270, 0.190],
}
def monolayer_3band(name, override_params=None):
r"""Monolayer of a group 6 TMD using the nearest-neighbor 3-band model
Parameters
----------
name : str
Name of the TMD to model. The available options are: MoS2, WS2, MoSe2,
WSe2, MoTe2, WTe2. The relevant tight-binding parameters for these
materials are given by https://doi.org/10.1103/PhysRevB.88.085433.
override_params : Optional[dict]
Replace or add new material parameters. The dictionary entries must
be in the format `"name": [a, eps1, eps2, t0, t1, t2, t11, t12, t22]`.
Examples
--------
.. plot::
:context: reset
:alt: Molybdenum disulfide: unit cell for the nearest-neighbor 3-band model
from pybinding.repository import group6_tmd
group6_tmd.monolayer_3band("MoS2").plot()
.. plot::
:context: close-figs
:alt: Molybdenum disulfide: 3-band model band structure
model = pb.Model(group6_tmd.monolayer_3band("MoS2"), pb.translational_symmetry())
solver = pb.solver.lapack(model)
k_points = model.lattice.brillouin_zone()
gamma = [0, 0]
k = k_points[0]
m = (k_points[0] + k_points[1]) / 2
plt.figure(figsize=(6.7, 2.3))
plt.subplot(121, title="MoS2 3-band model band structure")
bands = solver.calc_bands(gamma, k, m, gamma)
bands.plot(point_labels=[r"$\Gamma$", "K", "M", r"$\Gamma$"])
plt.subplot(122, title="Band structure path in reciprocal space")
model.lattice.plot_brillouin_zone(decorate=False)
bands.plot_kpath(point_labels=[r"$\Gamma$", "K", "M", r"$\Gamma$"])
.. plot::
:context: close-figs
:alt: Band structure of various group 6 TMDs: MoS2, WS2, MoSe2, WSe2, MoTe2, WTe2
grid = plt.GridSpec(3, 2, hspace=0.4)
plt.figure(figsize=(6.7, 8))
for square, name in zip(grid, ["MoS2", "WS2", "MoSe2", "WSe2", "MoTe2", "WTe2"]):
model = pb.Model(group6_tmd.monolayer_3band(name), pb.translational_symmetry())
solver = pb.solver.lapack(model)
k_points = model.lattice.brillouin_zone()
gamma = [0, 0]
k = k_points[0]
m = (k_points[0] + k_points[1]) / 2
plt.subplot(square, title=name)
bands = solver.calc_bands(gamma, k, m, gamma)
bands.plot(point_labels=[r"$\Gamma$", "K", "M", r"$\Gamma$"], lw=1.5)
"""
params = _default_3band_params.copy()
if override_params:
params.update(override_params)
a, eps1, eps2, t0, t1, t2, t11, t12, t22 = params[name]
rt3 = math.sqrt(3) # convenient constant
lat = pb.Lattice(a1=[a, 0], a2=[1/2 * a, rt3/2 * a])
metal_name, chalcogenide_name = re.findall("[A-Z][a-z]*", name)
lat.add_one_sublattice(metal_name, [0, 0], [eps1, eps2, eps2])
h1 = [[ t0, -t1, t2],
[ t1, t11, -t12],
[ t2, t12, t22]]
h2 = [[ t0, 1/2 * t1 + rt3/2 * t2, rt3/2 * t1 - 1/2 * t2],
[-1/2 * t1 + rt3/2 * t2, 1/4 * t11 + 3/4 * t22, rt3/4 * (t11 - t22) - t12],
[-rt3/2 * t1 - 1/2 * t2, rt3/4 * (t11 - t22) + t12, 3/4 * t11 + 1/4 * t22]]
h3 = [[ t0, -1/2 * t1 - rt3/2 * t2, rt3/2 * t1 - 1/2 * t2],
[ 1/2 * t1 - rt3/2 * t2, 1/4 * t11 + 3/4 * t22, rt3/4 * (t22 - t11) + t12],
[-rt3/2 * t1 - 1/2 * t2, rt3/4 * (t22 - t11) - t12, 3/4 * t11 + 1/4 * t22]]
m = metal_name
lat.add_hoppings(([1, 0], m, m, h1),
([0, -1], m, m, h2),
([1, -1], m, m, h3))
return lat
| Python |
2D | dean0x7d/pybinding | pybinding/repository/phosphorene.py | .py | 2,298 | 64 | """A single layer of black phosphorus"""
from math import pi, sin, cos
import pybinding as pb
def monolayer_4band(num_hoppings=5):
"""Monolayer phosphorene lattice using the four-band model
Parameters
----------
num_hoppings : int
Number of hopping terms to consider: from t2 to t5.
"""
a = 0.222 # nm
ax = 0.438 # nm
ay = 0.332 # nm
theta = 96.79 * (pi / 180)
phi = 103.69 * (pi / 180)
lat = pb.Lattice(a1=[ax, 0], a2=[0, ay])
h = a * sin(phi - pi / 2)
s = 0.5 * ax - a * cos(theta / 2)
lat.add_sublattices(('A', [-s/2, -ay/2, h], 0),
('B', [ s/2, -ay/2, 0], 0),
('C', [-s/2 + ax/2, 0, 0], 0),
('D', [ s/2 + ax/2, 0, h], 0))
lat.register_hopping_energies({'t1': -1.22, 't2': 3.665, 't3': -0.205,
't4': -0.105, 't5': -0.055})
if num_hoppings < 2:
raise RuntimeError("t1 and t2 must be included")
elif num_hoppings > 5:
raise RuntimeError("t5 is the last one")
if num_hoppings >= 2:
lat.add_hoppings(([-1, 0], 'A', 'D', 't1'),
([-1, -1], 'A', 'D', 't1'),
([ 0, 0], 'B', 'C', 't1'),
([ 0, -1], 'B', 'C', 't1'))
lat.add_hoppings(([ 0, 0], 'A', 'B', 't2'),
([ 0, 0], 'C', 'D', 't2'))
if num_hoppings >= 3:
lat.add_hoppings(([ 0, 0], 'A', 'D', 't3'),
([ 0, -1], 'A', 'D', 't3'),
([ 1, 1], 'C', 'B', 't3'),
([ 1, 0], 'C', 'B', 't3'))
if num_hoppings >= 4:
lat.add_hoppings(([ 0, 0], 'A', 'C', 't4'),
([ 0, -1], 'A', 'C', 't4'),
([-1, 0], 'A', 'C', 't4'),
([-1, -1], 'A', 'C', 't4'),
([ 0, 0], 'B', 'D', 't4'),
([ 0, -1], 'B', 'D', 't4'),
([-1, 0], 'B', 'D', 't4'),
([-1, -1], 'B', 'D', 't4'))
if num_hoppings >= 5:
lat.add_hoppings(([-1, 0], 'A', 'B', 't5'),
([-1, 0], 'C', 'D', 't5'))
lat.min_neighbors = 2
return lat
| Python |
2D | dean0x7d/pybinding | pybinding/repository/examples.py | .py | 1,000 | 50 | """Example components: lattices, shapes and modifiers
Components which aren't very useful for simulations,
but great for examples and testing.
"""
import pybinding as pb
def chain_lattice(a=1, t=-1, v=0):
"""1D lattice
Parameters
----------
a : float
Unit cell length.
t : float
Hopping energy.
v : float
Onsite energy.
"""
lat = pb.Lattice(a)
lat.add_one_sublattice('A', [0, 0], onsite_energy=v)
lat.add_one_hopping(1, 'A', 'A', t)
return lat
def square_lattice(d=0.2, t=-1):
"""A simple square lattice
Parameters
----------
d : float
Length of the unit cell.
t : float
Hopping energy.
Returns
-------
pb.Lattice
"""
lat = pb.Lattice(a1=[d, 0], a2=[0, d])
lat.add_one_sublattice('A', [0, 0])
lat.add_hoppings(
([0, 1], 'A', 'A', t),
([1, 0], 'A', 'A', t),
([1, 1], 'A', 'A', t),
([1, -1], 'A', 'A', t),
)
return lat
| Python |
2D | dean0x7d/pybinding | pybinding/repository/graphene/shape.py | .py | 1,168 | 32 | import math
import pybinding as pb
from .constants import a, a_cc
__all__ = ['hexagon_ac']
def hexagon_ac(side_width, lattice_offset=(-a/2, 0)):
"""A graphene-specific shape which guaranties armchair edges on all sides
Parameters
----------
side_width : float
Hexagon side width. It may be adjusted slightly to ensure armchair edges.
lattice_offset : array_like
Offset the lattice so a carbon hexagon is at the center of the shape.
The default value is specific for :func:`.monolayer()` and :func:`.bilayer()`
lattices from this material repository.
"""
# expected number of atoms on an armchair edge
side_atoms = math.ceil((side_width / a_cc + 1) * 2/3)
side_atoms += (side_atoms % 2) # it must be an even number
# set a better width value based on the calculated number of atoms
side_width = (3/2 * side_atoms - 1) * a_cc - a_cc / 2
x0 = side_width * math.sqrt(3) / 2
y0 = side_width
hexagon = pb.Polygon([(0, y0), ( x0, y0/2), ( x0, -y0/2),
(0, -y0), (-x0, -y0/2), (-x0, y0/2)])
hexagon.lattice_offset = lattice_offset
return hexagon
| Python |
2D | dean0x7d/pybinding | pybinding/repository/graphene/__init__.py | .py | 178 | 7 | """A one-atom thick layer of carbon in a honeycomb structure"""
from . import utils
from .constants import *
from .lattice import *
from .modifiers import *
from .shape import *
| Python |
2D | dean0x7d/pybinding | pybinding/repository/graphene/constants.py | .py | 319 | 9 | from pybinding.constants import hbar
a = 0.24595 #: [nm] unit cell length
a_cc = 0.142 #: [nm] carbon-carbon distance
t = -2.8 #: [eV] nearest neighbor hopping
t_nn = 0.1 #: [eV] next-nearest neighbor hopping
vf = 3 / (2 * hbar) * abs(t) * a_cc #: [nm/s] Fermi velocity
beta = 3.37 #: strain hopping modulation
| Python |
2D | dean0x7d/pybinding | pybinding/repository/graphene/lattice.py | .py | 5,652 | 196 | import pybinding as pb
__all__ = ['monolayer', 'monolayer_alt', 'monolayer_4atom', 'bilayer']
def monolayer(nearest_neighbors=1, onsite=(0, 0), **kwargs):
"""Monolayer graphene lattice up to `nearest_neighbors` hoppings
Parameters
----------
nearest_neighbors : int
Number of nearest neighbors to consider.
onsite : Tuple[float, float]
Onsite energy for sublattices A and B.
**kwargs
Specify the hopping parameters `t`, `t_nn` and `t_nnn`.
If not given, the default values from :mod:`.graphene.constants` will be used.
"""
from math import sqrt
from .constants import a_cc, a, t, t_nn
lat = pb.Lattice(a1=[a, 0], a2=[a/2, a/2 * sqrt(3)])
# The next-nearest hoppings shift the Dirac point away from zero energy.
# This will push it back to zero for consistency with the first-nearest model.
onsite_offset = 0 if nearest_neighbors < 2 else 3 * kwargs.get('t_nn', t_nn)
lat.add_sublattices(
('A', [0, -a_cc/2], onsite[0] + onsite_offset),
('B', [0, a_cc/2], onsite[1] + onsite_offset)
)
lat.register_hopping_energies({
't': kwargs.get('t', t),
't_nn': kwargs.get('t_nn', t_nn),
't_nnn': kwargs.get('t_nnn', 0.05),
})
lat.add_hoppings(
([0, 0], 'A', 'B', 't'),
([1, -1], 'A', 'B', 't'),
([0, -1], 'A', 'B', 't')
)
if nearest_neighbors >= 2:
lat.add_hoppings(
([0, -1], 'A', 'A', 't_nn'),
([0, -1], 'B', 'B', 't_nn'),
([1, -1], 'A', 'A', 't_nn'),
([1, -1], 'B', 'B', 't_nn'),
([1, 0], 'A', 'A', 't_nn'),
([1, 0], 'B', 'B', 't_nn'),
)
if nearest_neighbors >= 3:
lat.add_hoppings(
[( 1, -2), 'A', 'B', 't_nnn'],
[( 1, 0), 'A', 'B', 't_nnn'],
[(-1, 0), 'A', 'B', 't_nnn'],
)
if nearest_neighbors >= 4:
raise RuntimeError("No more")
lat.min_neighbors = 2
return lat
def monolayer_alt(onsite=(0, 0)):
"""Nearest-neighbor lattice with alternative lattice vectors
Parameters
----------
onsite : Tuple[float, float]
Onsite energy for sublattices A and B.
"""
from math import sqrt
from .constants import a_cc, a, t
lat = pb.Lattice(a1=[a/2, a/2 * sqrt(3)],
a2=[a/2, -a/2 * sqrt(3)])
lat.add_sublattices(('A', [0, 0], onsite[0]),
('B', [0, a_cc], onsite[1]))
lat.add_hoppings(([ 0, 0], 'A', 'B', t),
([ 0, 1], 'A', 'B', t),
([-1, 0], 'A', 'B', t))
lat.min_neighbors = 2
return lat
def monolayer_4atom(onsite=(0, 0)):
"""Nearest-neighbor with 4 atoms per unit cell: square lattice instead of oblique
Parameters
----------
onsite : Tuple[float, float]
Onsite energy for sublattices A and B.
"""
from .constants import a_cc, a, t
lat = pb.Lattice(a1=[a, 0], a2=[0, 3*a_cc])
lat.add_sublattices(('A', [ 0, -a_cc/2], onsite[0]),
('B', [ 0, a_cc/2], onsite[1]))
lat.add_aliases(('A2', 'A', [a / 2, a_cc]),
('B2', 'B', [a / 2, 2 * a_cc]))
lat.add_hoppings(
# inside the unit sell
([0, 0], 'A', 'B', t),
([0, 0], 'B', 'A2', t),
([0, 0], 'A2', 'B2', t),
# between neighbouring unit cells
([-1, -1], 'A', 'B2', t),
([ 0, -1], 'A', 'B2', t),
([-1, 0], 'B', 'A2', t),
)
lat.min_neighbors = 2
return lat
def bilayer(gamma3=False, gamma4=False, onsite=(0, 0, 0, 0)):
r"""Bilayer lattice in the AB-stacked form (Bernal-stacked)
* :math:`\gamma_0` is the single-layer hopping within the top layer (A1/B1)
and bottom layer (A2/B2)
* :math:`\gamma_1` is the inter-layer hopping between B1 and A2
(where atom B1 lies directly over A2)
* Hoppings :math:`\gamma_3` and :math:`\gamma_4` are optional (see parameters)
Parameters
----------
gamma3, gamma4 : bool
Enable :math:`\gamma_3` and/or :math:`\gamma_4` hoppings.
By default, only :math:`\gamma_0` and :math:`\gamma_1` are active.
onsite : Tuple[float, float, float, float]
Onsite energy for A1, B1, A2, B2
"""
from math import sqrt
from .constants import a_cc, a, t
lat = pb.Lattice(
a1=[ a/2, a/2 * sqrt(3)],
a2=[-a/2, a/2 * sqrt(3)]
)
c0 = 0.335 # [nm] interlayer spacing
lat.add_sublattices(
('A1', [0, -a_cc/2, 0], onsite[0]),
('B1', [0, a_cc/2, 0], onsite[1]),
('A2', [0, a_cc/2, -c0], onsite[2]),
('B2', [0, 3*a_cc/2, -c0], onsite[3])
)
lat.register_hopping_energies({
'gamma0': t,
'gamma1': -0.4,
'gamma3': -0.3,
'gamma4': -0.04
})
lat.add_hoppings(
# layer 1
([ 0, 0], 'A1', 'B1', 'gamma0'),
([ 0, -1], 'A1', 'B1', 'gamma0'),
([-1, 0], 'A1', 'B1', 'gamma0'),
# layer 2
([ 0, 0], 'A2', 'B2', 'gamma0'),
([ 0, -1], 'A2', 'B2', 'gamma0'),
([-1, 0], 'A2', 'B2', 'gamma0'),
# interlayer
([ 0, 0], 'B1', 'A2', 'gamma1')
)
if gamma3:
lat.add_hoppings(
([0, 1], 'B2', 'A1', 'gamma3'),
([1, 0], 'B2', 'A1', 'gamma3'),
([1, 1], 'B2', 'A1', 'gamma3')
)
if gamma4:
lat.add_hoppings(
([0, 0], 'A2', 'A1', 'gamma4'),
([0, 1], 'A2', 'A1', 'gamma4'),
([1, 0], 'A2', 'A1', 'gamma4')
)
lat.min_neighbors = 2
return lat
| Python |
2D | dean0x7d/pybinding | pybinding/repository/graphene/utils.py | .py | 273 | 9 | from math import sqrt
from .constants import hbar, vf
def landau_level(magnetic_field: float, n: int):
""" Calculate the energy of Landau level n in the given magnetic field. """
lb = sqrt(hbar / magnetic_field)
return hbar * (vf * 10**-9) / lb * sqrt(2 * n)
| Python |
2D | dean0x7d/pybinding | pybinding/repository/graphene/modifiers.py | .py | 3,680 | 138 | import numpy as np
import pybinding as pb
from pybinding.constants import pi, phi0, hbar
__all__ = ['mass_term', 'coulomb_potential', 'constant_magnetic_field',
'triaxial_strain', 'gaussian_bump']
def mass_term(delta):
"""Break sublattice symmetry, make massive Dirac electrons, open a band gap
Only for monolayer graphene.
Parameters
----------
delta : float
Onsite energy +delta is added to sublattice 'A' and -delta to 'B'.
"""
@pb.onsite_energy_modifier
def onsite(energy, sub_id):
energy[sub_id == "A"] += delta
energy[sub_id == "B"] -= delta
return energy
return onsite
def coulomb_potential(beta, cutoff_radius=.0, offset=(0, 0, 0)):
"""A Coulomb potential created by an impurity in graphene
Parameters
----------
beta : float
Charge of the impurity [unitless].
cutoff_radius : float
Cut off the potential below this radius [nm].
offset: array_like
Position of the charge.
"""
from .constants import vf
# beta is dimensionless -> multiply hbar*vF makes it [eV * nm]
scaled_beta = beta * hbar * vf
@pb.onsite_energy_modifier
def potential(energy, x, y, z):
x0, y0, z0 = offset
r = np.sqrt((x - x0)**2 + (y - y0)**2 + (z - z0)**2)
r[r < cutoff_radius] = cutoff_radius
return energy - scaled_beta / r
return potential
def constant_magnetic_field(magnitude):
"""Constant magnetic field in the z-direction, perpendicular to the graphene plane
Parameters
----------
magnitude : float
In units of Tesla.
"""
scale = 1e-18 # both the vector potential and coordinates are in [nm] -> scale to [m]
const = scale * 2 * pi / phi0
@pb.hopping_energy_modifier(is_complex=True)
def func(energy, x1, y1, x2, y2):
# vector potential along the x-axis
vp_x = 0.5 * magnitude * (y1 + y2)
# integral of (A * dl) from position 1 to position 2
peierls = vp_x * (x1 - x2)
return energy * np.exp(1j * const * peierls)
return func
@pb.hopping_energy_modifier
def strained_hopping(energy, x1, y1, z1, x2, y2, z2):
from .constants import a_cc, beta
l = np.sqrt((x1 - x2)**2 + (y1 - y2)**2 + (z1 - z2)**2)
w = l / a_cc - 1
return energy * np.exp(-beta * w)
def triaxial_strain(magnetic_field):
"""Triaxial strain corresponding to a homogeneous pseudo-magnetic field
Parameters
----------
magnetic_field : float
Intensity of the pseudo-magnetic field to induce.
"""
from .constants import a_cc, beta
def field_to_strain(field):
return field * a_cc / (4 * hbar * beta) * 10**-18
c = field_to_strain(magnetic_field)
zigzag_direction = False
@pb.site_position_modifier
def displacement(x, y, z):
if not zigzag_direction:
ux = 2*c * x*y
uy = c * (x**2 - y**2)
else:
ux = c * (y**2 - x**2)
uy = 2*c * x*y
x += ux
y += uy
return x, y, z
return displacement, strained_hopping
def gaussian_bump(height, sigma, center=(0, 0)):
"""Gaussian bump deformation
Parameters
----------
height : float
Height of the bump [nm].
sigma : float
Gaussian sigma parameter: controls the width of the bump [nm].
center : array_like
Position of the center of the bump.
"""
@pb.site_position_modifier
def displacement(x, y):
x0, y0 = center
r2 = (x - x0)**2 + (y - y0)**2
z = height * np.exp(-r2 / sigma**2)
return x, y, z
return displacement, strained_hopping
| Python |
2D | dean0x7d/pybinding | pybinding/utils/misc.py | .py | 3,785 | 151 | import os
from functools import wraps
from contextlib import contextmanager
import numpy as np
from ..support.inspect import get_call_signature
def to_tuple(o):
try:
return tuple(o)
except TypeError:
return (o,) if o is not None else ()
def to_list(o):
try:
return list(o)
except TypeError:
return [o] if o is not None else []
def with_defaults(options: dict, defaults_dict: dict=None, **defaults_kwargs):
"""Return a dict where missing keys are filled in by defaults
>>> options = dict(hello=0)
>>> with_defaults(options, hello=4, world=5) == dict(hello=0, world=5)
True
>>> defaults = dict(hello=4, world=5)
>>> with_defaults(options, defaults) == dict(hello=0, world=5)
True
>>> with_defaults(options, defaults, world=7, yes=3) == dict(hello=0, world=5, yes=3)
True
"""
options = options if options else {}
if defaults_dict:
options = dict(defaults_dict, **options)
return dict(defaults_kwargs, **options)
def x_pi(value):
"""Return str of value in 'multiples of pi' latex representation
>>> x_pi(6.28) == r"2$\pi$"
True
>>> x_pi(3) == r"0.95$\pi$"
True
>>> x_pi(-np.pi) == r"-$\pi$"
True
>>> x_pi(0) == "0"
True
"""
n = value / np.pi
if np.isclose(n, 0):
return "0"
elif np.isclose(abs(n), 1):
return r"$\pi$" if n > 0 else r"-$\pi$"
else:
return r"{:.2g}$\pi$".format(n)
def decorator_decorator(decorator_wrapper):
"""A decorator decorator which allows it to be used with or without arguments
Parameters
----------
decorator_wrapper : Callable[[Any], Callable]
Examples
--------
>>> @decorator_decorator
... def decorator_wrapper(optional="default"):
... def actual_decorator(func):
... return lambda x: func(x, optional)
... return actual_decorator
>>> @decorator_wrapper("hello")
... def foo(x, y):
... print(x, y)
>>> foo(1)
1 hello
>>> @decorator_wrapper
... def bar(x, y):
... print(x, y)
>>> bar(2)
2 default
"""
@wraps(decorator_wrapper)
def new_wrapper(*args, **kwargs):
try:
callsig = get_call_signature(up=1)
except IndexError:
callsig = None
if len(args) == 1 and not kwargs and (isinstance(args[0], type) or callable(args[0])):
args[0].callsig = callsig
return decorator_wrapper()(args[0])
else:
def deferred(cls_or_func):
cls_or_func.callsig = callsig
return decorator_wrapper(*args, **kwargs)(cls_or_func)
return deferred
return new_wrapper
@contextmanager
def cd(directory):
"""Change directory within this context
Parameters
----------
directory : str or path
"""
previous_dir = os.getcwd()
os.chdir(os.path.expanduser(str(directory)))
try:
yield
finally:
os.chdir(previous_dir)
def with_suffix(number, base=1000):
"""Convert number to string with SI suffix, e.g.: 14226 -> 14.2k, 5395984 -> 5.39M"""
mapping = {base**3: "G", base**2: "M", base: "k"}
for bucket, suffix in mapping.items():
if number > 0.999 * bucket:
return "{:.3g}{}".format(number / bucket, suffix)
return "{:.3g}".format(number)
def rotate_axes(position, axes):
"""Rotate axes in position
Examples
--------
>>> rotate_axes([1, 2, 3], "xy")
(1, 2, 3)
>>> rotate_axes([1, 2, 3], "yz")
(2, 3, 1)
"""
missing_axes = set('xyz') - set(axes)
for a in missing_axes:
axes += a
assert len(axes) == 3
mapping = dict(x=0, y=1, z=2)
return tuple(position[mapping[a]] for a in axes)
| Python |
2D | dean0x7d/pybinding | pybinding/utils/progressbar.py | .py | 5,796 | 224 | import datetime
import io
import os
import sys
def percentage(template="{:3.0%}"):
def widget(pbar):
return template.format(pbar.percent)
return widget
def bar(marker='/', left='[', right=']', fill=' '):
def widget(pbar, width):
width -= len(left) + len(right)
marked = marker * int(pbar.percent * width)
return "{}{}{}".format(left, marked.ljust(width, fill), right)
return widget
def elapsed(template="Elapsed: {}"):
def widget(pbar):
return template.format(datetime.timedelta(seconds=int(pbar.elapsed_seconds)))
return widget
def eta(template="ETA: {}"):
def widget(pbar):
if pbar.value == 0:
return template.format("--:--:--")
else:
remaining = pbar.elapsed_seconds * (1 / pbar.percent - 1)
return template.format(datetime.timedelta(seconds=int(remaining)))
return widget
class StdCapture:
def __init__(self, stream_name='stdout'):
self.stream_name = stream_name
self._old_stream = getattr(sys, stream_name)
def start(self):
self._old_stream = getattr(sys, self.stream_name)
setattr(sys, self.stream_name, io.StringIO())
def get(self):
output = getattr(sys, self.stream_name).getvalue()
setattr(sys, self.stream_name, io.StringIO())
return output
def stop(self):
setattr(sys, self.stream_name, self._old_stream)
class StreamOutput:
def __init__(self, stream):
self.stream = stream
self.width = 80
def start(self, width):
self.width = width
def clear_pbar(self):
self.stream.write("\r" + " " * self.width + "\r")
def write(self, line):
self.stream.write(line)
self.stream.flush()
def write_pbar(self, line):
self.stream.write('\r' + line)
self.stream.flush()
def stop(self):
self.stream.write("\n")
class FileOutput:
def __init__(self, filename):
self.file = open(filename, 'w')
def start(self, width):
self.file.seek(0, 0)
self.file.write(' ' * width + '\n')
self.file.flush()
self.file.seek(0, os.SEEK_END)
def clear_pbar(self):
pass
def write(self, line):
self.file.write(line)
def write_pbar(self, line):
self.file.seek(0, 0)
self.file.write(line + '\n')
self.file.flush()
self.file.seek(0, os.SEEK_END)
def stop(self):
self.file.close()
class ProgressBar:
def __init__(self, size, widgets=None, width=80, stream=sys.stdout, filename=""):
self.size = size
if widgets:
self.widgets = widgets
else:
self.widgets = self.default_widgets()
self.width = width
self.outputs = []
if stream:
self.outputs.append(StreamOutput(stream))
if filename:
self.outputs.append(FileOutput(filename))
self.captures = [StdCapture('stdout'), StdCapture('stderr')]
self.value = 0
self.running = False
self.start_time = datetime.datetime.now()
self.last_update_time = self.start_time
@staticmethod
def default_widgets():
return ['Progress ', percentage(), ' ', bar(), ' ', elapsed(), ' / ', eta()]
@property
def percent(self):
return self.value / self.size
@property
def elapsed_seconds(self):
return (self.last_update_time - self.start_time).total_seconds()
def __enter__(self):
return self.start()
def __exit__(self, *_):
self.stop()
def __iadd__(self, value):
self.update(self.value + value)
return self
def _make_line(self):
def format_fixed_size(widget):
try:
return widget(self)
except TypeError:
return widget
semi_formatted_widgets = [format_fixed_size(w) for w in self.widgets]
num_remaining = sum(callable(w) for w in semi_formatted_widgets)
width_formatted = sum(len(w) if not callable(w) else 0 for w in semi_formatted_widgets)
width_remaining = self.width - width_formatted
def format_variable_size(widget):
if callable(widget):
return widget(self, int(width_remaining / num_remaining))
else:
return widget
formatted_widgets = (format_variable_size(w) for w in semi_formatted_widgets)
return "".join(formatted_widgets).ljust(self.width)
def start(self):
self.running = True
self.value = 0
for capture in self.captures:
capture.start()
for output in self.outputs:
output.start(self.width)
self.start_time = datetime.datetime.now()
self.last_update_time = self.start_time
self.refresh()
def update(self, value):
if not self.running:
self.start()
if self.value == value:
return
self.value = value
self.last_update_time = datetime.datetime.now()
self.refresh()
def refresh(self):
for output in self.outputs:
output.clear_pbar()
lines = [c.get() for c in self.captures]
for output in self.outputs:
for line in lines:
output.write(line)
for output in self.outputs:
output.write_pbar(self._make_line())
def stop(self):
if not self.running:
return
self.refresh()
for capture in self.captures:
capture.stop()
for output in self.outputs:
output.stop()
self.running = False
def finish(self):
if not self.running:
return
self.update(self.size)
self.stop()
| Python |
2D | dean0x7d/pybinding | pybinding/utils/__init__.py | .py | 75 | 4 | from . import cpuinfo, progressbar
from .misc import *
from .time import *
| Python |
2D | dean0x7d/pybinding | pybinding/utils/cpuinfo.py | .py | 1,702 | 65 | import os
from .. import _cpp
_cached_info = None
def cpu_info():
"""Forwarded from `cpuinfo.get_cpu_info()`"""
global _cached_info
if not _cached_info:
try:
from cpuinfo import get_cpu_info
except ImportError:
def get_cpu_info():
return {}
_cached_info = get_cpu_info()
return _cached_info
def physical_core_count():
"""Try to return the number of physical cores
An accurate number of physical cores will only be returned if the extension
module was compiled with MKL. Otherwise, this will return the same number
as `virtual_core_count()`.
Examples
--------
>>> physical_core_count() <= virtual_core_count()
True
"""
try:
# noinspection PyUnresolvedReferences
return _cpp.physical_core_count
except AttributeError:
return os.cpu_count()
def virtual_core_count():
"""Return the number of threads the CPU can process simultaniously"""
return os.cpu_count()
def summary():
"""Return a short description of the host CPU
The returned SIMD instruction set is the one that the extension module was
compiled with, not the highest one supported by the CPU.
"""
info = cpu_info()
if not info:
return "py-cpuinfo is not installed"
info = info.copy()
hz_raw, scale = info['hz_advertised_raw']
info['ghz'] = hz_raw * 10**(scale - 9)
info['physical'] = physical_core_count()
info['virtual'] = virtual_core_count()
info['simd'] = _cpp.simd_info()
return "{brand}\n{physical}/{virtual} cores @ {ghz:.2g} GHz with {simd}".format_map(info)
if __name__ == '__main__':
print(summary())
| Python |
2D | dean0x7d/pybinding | pybinding/utils/time.py | .py | 2,669 | 116 | import time
__all__ = ['tic', 'toc', 'timed', 'pretty_duration']
_tic_times = []
def tic():
"""Set a start time"""
global _tic_times
_tic_times.append(time.time())
def toc(message=""):
"""Print the elapsed time from the last :func:`.tic`
Parameters
----------
message : str
Print this in front of the elapsed time.
"""
if not _tic_times:
raise RuntimeError("Called toc() without a tic()")
if message:
print(message, end=" ")
print(pretty_duration(time.time() - _tic_times.pop()))
class _Timed:
def __init__(self, message=""):
self.message = message
def __enter__(self):
self._enter_time = time.time()
return self
def __exit__(self, *_):
self.elapsed = time.time() - self._enter_time
if self.message:
print(self.message, self)
def __str__(self):
return pretty_duration(self.elapsed)
def timed(message=""):
"""Context manager which times its code block
Parameters
----------
message : str
Message to print on block exit, followed by the elapsed time.
"""
return _Timed(message)
def pretty_duration(seconds):
"""Return a pretty duration string
Parameters
----------
seconds : float
Duration in seconds
Examples
--------
>>> pretty_duration(2.1e-6)
'0.00ms'
>>> pretty_duration(2.1e-5)
'0.02ms'
>>> pretty_duration(2.1e-4)
'0.21ms'
>>> pretty_duration(2.1e-3)
'2.1ms'
>>> pretty_duration(2.1e-2)
'21ms'
>>> pretty_duration(2.1e-1)
'0.21s'
>>> pretty_duration(2.1)
'2.10s'
>>> pretty_duration(12.1)
'12.1s'
>>> pretty_duration(22.1)
'22s'
>>> pretty_duration(62.1)
'1:02'
>>> pretty_duration(621.1)
'10:21'
>>> pretty_duration(6217.1)
'1:43:37'
"""
miliseconds = seconds * 1000
if miliseconds < 1:
return "{:.2f}ms".format(miliseconds)
elif miliseconds < 10:
return "{:.1f}ms".format(miliseconds)
elif miliseconds < 100:
return "{:.0f}ms".format(miliseconds)
elif seconds < 10:
return "{:.2f}s".format(seconds)
elif seconds < 20:
return "{:.1f}s".format(seconds)
elif seconds < 60:
return "{:.0f}s".format(seconds)
else:
minutes = seconds // 60
seconds = int(seconds - minutes * 60)
if minutes < 60:
return "{minutes:.0f}:{seconds:02}".format(**locals())
else:
hours = minutes // 60
minutes = int(minutes - hours * 60)
return "{hours:.0f}:{minutes:02}:{seconds:02}".format(**locals())
| Python |
2D | dean0x7d/pybinding | pybinding/support/kwant.py | .py | 3,368 | 105 | """Kwant compatibility layer"""
import warnings
import numpy as np
try:
from kwant.system import FiniteSystem, InfiniteSystem
kwant_installed = True
except ImportError:
FiniteSystem = InfiniteSystem = object
kwant_installed = False
def _warn_if_not_empty(args, params):
if args or params:
warnings.warn(
"Additional `args/params` are ignored because pybinding's Hamiltonian is immutable. "
"Complete the model with all parameters before calling the `tokwant()` conversion.",
stacklevel=3
)
class Graph:
"""Mock `kwant.graph.CGraph`
Only the `num_nodes` attribute seems to be required, at least for `smatrix`.
"""
def __init__(self, num_nodes):
self.num_nodes = num_nodes
class KwantFiniteSystem(FiniteSystem):
"""Mock 'kwant.system.FiniteSystem`
Mostly complete, some features of `hamiltonian_submatrix` are not supported,
however it seems to work well for `smatrix`.
"""
def __init__(self, pb_model):
self.pb_model = pb_model
self.graph = Graph(pb_model.system.num_sites)
self._pos = np.array(pb_model.system.positions[:pb_model.lattice.ndim]).T
self.leads = [KwantInfiniteSystem(l) for l in pb_model.leads]
self.lead_interfaces = [l.indices for l in pb_model.leads]
def pos(self, index):
return self._pos[index]
def hamiltonian(self, i, j, *args, params=None):
_warn_if_not_empty(args, params)
return self.pb_model.hamiltonian[i, j]
def hamiltonian_submatrix(self, args=(), to_sites=None, from_sites=None,
sparse=False, return_norb=False, *, params=None):
if to_sites is not None or from_sites is not None:
raise RuntimeError("The `to_sites` and `from_sites` arguments are not supported")
_warn_if_not_empty(args, params)
ham = self.pb_model.hamiltonian
matrix = ham.tocoo() if sparse else ham.todense()
if not return_norb:
return matrix
else:
subs = self.pb_model.system.sublattices
norb = self.pb_model.system.impl.compressed_sublattices.orbital_counts
to_norb = norb[subs]
from_norb = to_norb
return matrix, to_norb, from_norb
class KwantInfiniteSystem(InfiniteSystem):
"""Mock 'kwant.system.InfiniteSystem`
Should completely reproduce all features.
"""
def __init__(self, pb_lead):
self.h0 = pb_lead.h0
self.h1 = pb_lead.h1
def hamiltonian(self, i, j, *args, params=None):
_warn_if_not_empty(args, params)
return self.h0[i, j]
def cell_hamiltonian(self, args=(), sparse=False, *, params=None):
_warn_if_not_empty(args, params)
return self.h0.tocoo() if sparse else self.h0.todense()
def inter_cell_hopping(self, args=(), sparse=False, *, params=None):
_warn_if_not_empty(args, params)
return self.h1.tocoo() if sparse else self.h1.todense()
def tokwant(model):
"""Return a finalized kwant system constructed from a pybinding Model
Parameters
----------
model : Model
Returns
-------
kwant.system.FiniteSystem
"""
if not kwant_installed:
raise ImportError("Can't convert to kwant format if kwant isn't installed")
return KwantFiniteSystem(model)
| Python |
2D | dean0x7d/pybinding | pybinding/support/pickle.py | .py | 2,912 | 110 | """Utility functions for getting data to/from files"""
import gzip
import os
import pathlib
import pickle
from ..utils import decorator_decorator
__all__ = ['pickleable', 'save', 'load']
def _normalize(file):
"""Convenience function to support path objects."""
if 'Path' in type(file).__name__:
return str(file)
else:
return file
def _add_extension(file):
"""Append '.pbz' if the file has no extension
Examples
--------
>>> _add_extension("plain")
'plain.pbz'
>>> _add_extension("has_one.ext")
'has_one.ext'
"""
if not isinstance(file, str):
return file
path = pathlib.Path(file)
if not path.suffix:
return str(path.with_suffix(".pbz"))
else:
return file
def save(obj, file):
"""Save an object to a compressed file
Essentially, this is just a wrapper for :func:`pickle.dump()` with a few conveniences,
like default pickle protocol 4 and gzip compression. The '.pbz' extension will be added
if file has none.
Parameters
----------
obj : Any
Object to be saved.
file : Union[str, pathlib.Path]
May be a `str`, a `pathlib` object or a file object created with `open()`.
"""
file = _add_extension(_normalize(file))
with gzip.open(file, 'wb') as f:
pickle.dump(obj, f, protocol=4)
def load(file):
"""Load an object from a compressed file
Wraps :func:`pickle.load()` with the same conveniences as :func:`pb.save() <save>`.
Parameters
----------
file : Union[str, pathlib.Path]
May be a `str`, a `pathlib` object or a file object created with `open()`.
"""
file = _normalize(file)
file_ext = _add_extension(file)
if isinstance(file, str) and not os.path.exists(file) and os.path.exists(file_ext):
file = file_ext
with gzip.open(file, 'rb') as f:
return pickle.load(f)
@decorator_decorator
def pickleable(props="", version: int=0):
props = props.split()
def getstate(self):
state = dict(version=version, dict=self.__dict__)
if props:
state["props"] = {name: getattr(self, name) for name in props}
return state
def setstate(self, state):
if "version" not in state:
self.__dict__.update(state)
return
if state["version"] != version:
raise RuntimeError("Can't create class {} v{} from incompatible data v{}".format(
type(self), version, state["version"]
))
self.__dict__.update(state["dict"])
props_state = {name: value for name, value in state.get("props", {})
if name in props}
for name, value in props_state:
setattr(self, name, value)
def decorator(cls):
cls.__getstate__ = getstate
cls.__setstate__ = setstate
return cls
return decorator
| Python |
2D | dean0x7d/pybinding | pybinding/support/fuzzy_set.py | .py | 1,002 | 45 | import copy
import numpy as np
__all__ = ['FuzzySet']
class FuzzySet:
def __init__(self, iterable=None, rtol=1.e-3, atol=1.e-5):
self.data = []
self.rtol = rtol
self.atol = atol
if iterable:
for item in iterable:
self.add(item)
def __getitem__(self, index):
return self.data[index]
def __len__(self):
return len(self.data)
def __contains__(self, item):
return any(np.allclose(item, x, rtol=self.rtol, atol=self.atol) for x in self.data)
def __iadd__(self, other):
for item in other:
self.add(item)
return self
def __add__(self, other):
if isinstance(other, FuzzySet):
ret = copy.copy(self)
ret += other
return ret
else:
return copy.copy(self)
def __radd__(self, other):
return self + other
def add(self, item):
if item not in self:
self.data.append(item)
| Python |
2D | dean0x7d/pybinding | pybinding/support/deprecated.py | .py | 112 | 5 |
class LoudDeprecationWarning(UserWarning):
"""Python's DeprecationWarning is silent by default"""
pass
| Python |
2D | dean0x7d/pybinding | pybinding/support/__init__.py | .py | 0 | 0 | null | Python |
2D | dean0x7d/pybinding | pybinding/support/inspect.py | .py | 4,158 | 123 | import inspect
from collections import OrderedDict
__all__ = ['CallSignature', 'get_call_signature']
class CallSignature:
"""Holds a function and the arguments it was called with"""
def __init__(self, function: callable, positional: OrderedDict,
args: tuple, keyword_only: OrderedDict, kwargs: dict):
self.positional = positional
self.args = args
self.keyword_only = keyword_only
self.kwargs = kwargs
self.function = function
@property
def named_args(self):
"""All arguments except *args"""
ordered = OrderedDict()
for x in self.positional, self.keyword_only, self.kwargs:
ordered.update(x)
return ordered
def _format_args(self, func):
"""Apply `func` to each argument value and return the formatted string"""
if self.args:
positional = [func(v) for k, v in self.positional.items()]
else:
positional = ["{}={}".format(k, func(v)) for k, v in self.positional.items()]
args = [func(v) for v in self.args]
keywords_only = ["{}={}".format(k, func(v)) for k, v in self.keyword_only.items()]
kwargs = ["{}={}".format(k, func(v)) for k, v in self.kwargs.items()]
return ", ".join(positional + args + keywords_only + kwargs)
def __str__(self):
return "{}({})".format(self.function.__name__, self._format_args(str))
def __repr__(self):
return "{}({})".format(self.function.__qualname__, self._format_args(repr))
def _find_callable(name, frame):
"""Find the callable which matches the name and frame code"""
func = frame.f_globals.get(name)
if func and inspect.isfunction(func) and func.__code__ is frame.f_code:
return func
if frame.f_back:
func = frame.f_back.f_locals.get(name)
if func and inspect.isfunction(func) and func.__code__ is frame.f_code:
return func
import gc # try brute force
for obj in gc.get_objects():
if inspect.isfunction(obj) and obj.__code__ is frame.f_code:
return obj
raise RuntimeError("Can't find callable '{}()'".format(name))
def get_call_signature(up=0):
"""Return a CallSignature of the function currently being executed or `up` a few frames
Parameters
----------
up : int, optional
Selects which call frame to inspect: number of frames up from the current one.
Examples
--------
>>> # noinspection PyUnusedLocal
... def hello(a, b=8, *args, target=1, **kwargs):
... # noinspection PyUnusedLocal
... def world(x=1):
... return get_call_signature(target)
... return world()
>>> hello(7)
hello(a=7, b=8, target=1)
>>> hello(7, 8, d=2)
hello(a=7, b=8, target=1, d=2)
>>> hello(7, 8, 9, d=2)
hello(7, 8, 9, target=1, d=2)
>>> hello(7, target=0)
hello.<locals>.world(x=1)
>>> str(hello(7, target=0))
'world(x=1)'
>>> def outer(x):
... # noinspection PyUnusedLocal
... def inner(y=x):
... return get_call_signature(0)
... return inner
>>> outer(2)()
outer.<locals>.inner(y=2)
"""
stack = inspect.stack()
try:
frame, _, _, func_name, *_ = stack[up + 1]
except:
raise IndexError("Stack frame out of range")
if func_name == '<module>':
raise IndexError("Can't inspect a module")
_, args_name, kwargs_name, frame_locals = inspect.getargvalues(frame)
function = _find_callable(func_name, frame)
params = inspect.signature(function).parameters
positional = OrderedDict([(name, frame_locals[name])
for name, param in params.items()
if param.kind == param.POSITIONAL_OR_KEYWORD])
args = frame_locals.get(args_name, ())
keyword_only = OrderedDict([(name, frame_locals[name])
for name, param in params.items()
if param.kind == param.KEYWORD_ONLY])
kwargs = frame_locals.get(kwargs_name, {})
return CallSignature(function, positional, args, keyword_only, kwargs)
| Python |
2D | dean0x7d/pybinding | pybinding/support/collections.py | .py | 3,143 | 85 | import numpy as np
from matplotlib.collections import Collection
from matplotlib.artist import allow_rasterization
# noinspection PyAbstractClass
class CircleCollection(Collection):
"""Custom circle collection
The default matplotlib `CircleCollection` creates circles based on their
area in screen units. This class uses the radius in data units. It behaves
like a much faster version of a `PatchCollection` of `Circle`.
The implementation is similar to `EllipseCollection`.
"""
def __init__(self, radius, **kwargs):
super().__init__(**kwargs)
from matplotlib import path, transforms
self.radius = np.atleast_1d(radius)
self._paths = [path.Path.unit_circle()]
self.set_transform(transforms.IdentityTransform())
self._transforms = np.empty((0, 3, 3))
def _set_transforms(self):
ax = self.axes
self._transforms = np.zeros((self.radius.size, 3, 3))
self._transforms[:, 0, 0] = self.radius * ax.bbox.width / ax.viewLim.width
self._transforms[:, 1, 1] = self.radius * ax.bbox.height / ax.viewLim.height
self._transforms[:, 2, 2] = 1
@allow_rasterization
def draw(self, renderer):
self._set_transforms()
super().draw(renderer)
class Circle3DCollection(CircleCollection):
def __init__(self, radius, zs=0, zdir='z', depthshade=True, **kwargs):
super().__init__(radius, **kwargs)
self._depthshade = depthshade
self.set_3d_properties(zs, zdir)
self._A0 = self._A
def set_array(self, array):
self._A0 = array
super().set_array(array)
def set_3d_properties(self, zs, zdir):
# Force the collection to initialize the face and edgecolors
# just in case it is a scalarmappable with a colormap.
self.update_scalarmappable()
offsets = self.get_offsets()
if len(offsets) > 0:
xs, ys = list(zip(*offsets))
else:
xs = []
ys = []
from mpl_toolkits.mplot3d.art3d import juggle_axes
self._offsets3d = juggle_axes(xs, ys, np.atleast_1d(zs), zdir)
self._facecolor3d = self.get_facecolor()
self._edgecolor3d = self.get_edgecolor()
def do_3d_projection(self, renderer):
from mpl_toolkits.mplot3d import proj3d
from mpl_toolkits.mplot3d.art3d import zalpha
from matplotlib import colors as mcolors
# transform and sort in z direction
v = np.array(proj3d.proj_transform_clip(*self._offsets3d, M=renderer.M)[:3])
idx = v[2].argsort()[::-1]
vzs = v[2, idx]
self.set_offsets(v[:2, idx].transpose())
super().set_array(self._A0[idx])
fcs = zalpha(self._facecolor3d, vzs) if self._depthshade else self._facecolor3d
fcs = mcolors.colorConverter.to_rgba_array(fcs, self._alpha)
self.set_facecolors(fcs)
ecs = zalpha(self._edgecolor3d, vzs) if self._depthshade else self._edgecolor3d
ecs = mcolors.colorConverter.to_rgba_array(ecs, self._alpha)
self.set_edgecolors(ecs)
return min(vzs) if vzs.size > 0 else np.nan
| Python |
2D | dean0x7d/pybinding | pybinding/support/structure.py | .py | 6,913 | 244 | from abc import ABCMeta, abstractmethod
from collections import namedtuple
import numpy as np
from numpy import ma
from scipy.sparse import csr_matrix, coo_matrix
def _slice_csr_matrix(csr, idx):
"""Return a slice of a CSR matrix matching the given indices (applied to both rows and cols"""
from copy import copy
m = copy(csr) # shallow copy
m.data = m.data.copy()
m.data += 1 # increment by 1 to preserve zeroes when slicing to preserve all data, even zeros
m = m[idx][:, idx]
m.data -= 1
return m
Positions = namedtuple("Positions", "x y z")
Positions.__doc__ = """
Named tuple of arrays
Attributes
----------
x, y, z : array_like
1D arrays of Cartesian coordinates
"""
class AbstractSites(metaclass=ABCMeta):
"""Abstract interface for site position and family ID storage"""
@property
@abstractmethod
def x(self) -> np.ndarray:
"""1D array of coordinates"""
@property
@abstractmethod
def y(self) -> np.ndarray:
"""1D array of coordinates"""
@property
@abstractmethod
def z(self) -> np.ndarray:
"""1D array of coordinates"""
@property
@abstractmethod
def ids(self) -> np.ndarray:
"""Site family identifies. Multiple sites can share the same ID,
e.g. sites which belong to the same sublattice."""
@abstractmethod
def __getitem__(self, item):
"""Matches numpy indexing behavior and applies it to all attributes"""
def __len__(self):
"""Total number of sites"""
return self.x.size
@property
def size(self) -> int:
"""Total number of sites"""
return self.x.size
@property
def positions(self) -> Positions:
"""Named tuple of x, y, z positions"""
return Positions(self.x, self.y, self.z)
@property
def xyz(self) -> np.ndarray:
"""Return a new array with shape=(N, 3). Convenient, but slow for big systems."""
return np.array(self.positions).T
def distances(self, target_position):
"""Return the distances of all sites from the target position
Parameters
----------
target_position : array_like
Examples
--------
>>> sites = Sites(([0, 1, 1.1], [0, 0, 0], [0, 0, 0]), [0, 1, 0])
>>> np.allclose(sites.distances([1, 0, 0]), [1, 0, 0.1])
True
"""
target_position = np.atleast_1d(target_position)
ndim = len(target_position)
positions = np.stack(self.positions[:ndim], axis=1)
return np.linalg.norm(positions - target_position, axis=1)
def find_nearest(self, target_position, target_site_family=""):
"""Return the index of the position nearest the target
Parameters
----------
target_position : array_like
target_site_family : Optional[str]
Look for a specific sublattice site. By default any will do.
Returns
-------
int
Examples
--------
>>> sites = Sites(([0, 1, 1.1], [0, 0, 0], [0, 0, 0]), [0, 1, 0])
>>> sites.find_nearest([1, 0, 0])
1
>>> sites.find_nearest([1, 0, 0], target_site_family=0)
2
"""
distances = self.distances(target_position)
if target_site_family == "":
return np.argmin(distances)
else:
return ma.argmin(ma.array(distances, mask=(self.ids != target_site_family)))
def argsort_nearest(self, target_position, target_site_family=None):
"""Return an ndarray of site indices, sorted by distance from the target
Parameters
----------
target_position : array_like
target_site_family : int
Look for a specific sublattice site. By default any will do.
Returns
-------
np.ndarray
Examples
--------
>>> sites = Sites(([0, 1, 1.1], [0, 0, 0], [0, 0, 0]), [0, 1, 0])
>>> np.all(sites.argsort_nearest([1, 0, 0]) == [1, 2, 0])
True
>>> np.all(sites.argsort_nearest([1, 0, 0], target_site_family=0) == [2, 0, 1])
True
"""
distances = self.distances(target_position)
if target_site_family is None:
return np.argsort(distances)
else:
return ma.argsort(ma.array(distances, mask=(self.ids != target_site_family)))
class Sites(AbstractSites):
"""Reference implementation of :class:`AbstractSites`"""
def __init__(self, positions, ids=None):
self._x, self._y, self._z = np.atleast_1d(tuple(positions))
if ids is not None:
self._ids = np.atleast_1d(ids)
@property
def x(self):
return self._x
@property
def y(self):
return self._y
@property
def z(self):
return self._z
@property
def ids(self):
return getattr(self, "_ids", np.zeros_like(self._x, dtype=np.int8))
def __getitem__(self, item):
return self.__class__([v[item] for v in self.positions], self._ids[item])
class AbstractHoppings(metaclass=ABCMeta):
"""Abstract hopping storage with conversion and slicing functionality"""
def __len__(self):
"""Total number of hoppings"""
return self.nnz
@property
@abstractmethod
def nnz(self):
"""Total number of hoppings"""
@abstractmethod
def tocsr(self) -> csr_matrix:
"""Return hoppings as :class:`~scipy.sparse.csr_matrix`"""
@abstractmethod
def tocoo(self) -> coo_matrix:
"""Return hoppings as :class:`~scipy.sparse.coo_matrix`"""
@abstractmethod
def __getitem__(self, item):
"""Matches numpy indexing behavior and applies it to hoppings"""
class Hoppings(AbstractHoppings):
"""Reference implementation which stores a CSR matrix internally"""
def __init__(self, hoppings):
self._csr = hoppings.tocsr()
@property
def nnz(self):
return self._csr.nnz
def tocsr(self) -> csr_matrix:
return self._csr
def tocoo(self) -> coo_matrix:
return self._csr.tocoo()
def __getitem__(self, idx):
return self.__class__(_slice_csr_matrix(self._csr, idx))
class Boundary:
"""Describes a boundary between translation units of an infinite periodic system"""
def __init__(self, shift, hoppings):
self._shift = shift
self._hoppings = hoppings
@property
def shift(self) -> np.ndarray:
"""The coordinate difference between the destination translation unit and the original"""
return self._shift
@property
def hoppings(self) -> AbstractHoppings:
"""Hopping between the destination translation unit and the original"""
return self._hoppings
def __getitem__(self, item):
"""Matches numpy indexing behavior and applies it to hoppings"""
return self.__class__(self.shift, self.hoppings[item])
| Python |
2D | dean0x7d/pybinding | pybinding/support/alias.py | .py | 6,352 | 233 | import numpy as np
from scipy.sparse import csr_matrix
class AliasArray(np.ndarray):
"""An ndarray with a mapping of values to user-friendly names -- see example
This ndarray subclass enables comparing sub_id and hop_id arrays directly with
their friendly string identifiers. The mapping parameter translates sublattice
or hopping names into their number IDs.
Only the `==` and `!=` operators are overloaded to handle the aliases.
Examples
--------
>>> a = AliasArray([0, 1, 0], mapping={"A": 0, "B": 1})
>>> list(a == 0)
[True, False, True]
>>> list(a == "A")
[True, False, True]
>>> list(a != "A")
[False, True, False]
>>> a = AliasArray([0, 1, 0, 2], mapping={"A|1": 0, "B": 1, "A|2": 2})
>>> list(a == "A")
[True, False, True, True]
>>> list(a != "A")
[False, True, False, False]
>>> import pickle
>>> s = pickle.dumps(a)
>>> a2 = pickle.loads(s)
>>> list(a2 == "A")
[True, False, True, True]
"""
def __new__(cls, array, mapping):
obj = np.asarray(array).view(cls)
obj.mapping = {SplitName(k): v for k, v in mapping.items()}
return obj
def __array_finalize__(self, obj):
if obj is None:
return
self.mapping = getattr(obj, "mapping", None)
def _mapped_eq(self, other):
if other in self.mapping:
return super().__eq__(self.mapping[other])
else:
result = np.zeros(len(self), dtype=np.bool)
for k, v in self.mapping.items():
if k == other:
result = np.logical_or(result, super().__eq__(v))
return result
def __eq__(self, other):
if isinstance(other, str):
return self._mapped_eq(other)
else:
return super().__eq__(other)
def __ne__(self, other):
if isinstance(other, str):
return np.logical_not(self._mapped_eq(other))
else:
return super().__ne__(other)
def __reduce__(self):
r = super().__reduce__()
state = r[2] + (self.mapping,)
return r[0], r[1], state
def __setstate__(self, state):
self.mapping = state[-1]
super().__setstate__(state[:-1])
# noinspection PyAbstractClass
class AliasCSRMatrix(csr_matrix):
"""Same as :class:`AliasArray` but for a CSR matrix
Examples
--------
>>> from scipy.sparse import spdiags
>>> m = AliasCSRMatrix(spdiags([1, 2, 1], [0], 3, 3), mapping={'A': 1, 'B': 2})
>>> list(m.data == 'A')
[True, False, True]
>>> list(m.tocoo().data == 'A')
[True, False, True]
>>> list(m[:2].data == 'A')
[True, False]
>>> import pickle
>>> s = pickle.dumps(m)
>>> m2 = pickle.loads(s)
>>> list(m2.data == 'A')
[True, False, True]
"""
def __init__(self, *args, **kwargs):
mapping = kwargs.pop('mapping', {})
if not mapping:
mapping = getattr(args[0], 'mapping', {})
super().__init__(*args, **kwargs)
self.data = AliasArray(self.data, mapping)
@property
def format(self):
return 'csr'
@format.setter
def format(self, _):
pass
@property
def mapping(self):
return self.data.mapping
def tocoo(self, *args, **kwargs):
coo = super().tocoo(*args, **kwargs)
coo.data = AliasArray(coo.data, mapping=self.mapping)
return coo
def __getitem__(self, item):
result = super().__getitem__(item)
if getattr(result, 'format', '') == 'csr':
return AliasCSRMatrix(result, mapping=self.mapping)
else:
return result
class AliasIndex:
"""An all-or-nothing array index based on equality with a specific value
The `==` and `!=` operators are overloaded to return a lazy array which is either
all `True` or all `False`. See the examples below. This is useful for modifiers
where the each call gets arrays with the same sub_id/hop_id for all elements.
Instead of passing an `AliasArray` with `.size` identical element, `AliasIndex`
does the same all-or-nothing indexing.
Examples
--------
>>> l = np.array([1, 2, 3])
>>> ai = AliasIndex("A", len(l))
>>> list(l[ai == "A"])
[1, 2, 3]
>>> list(l[ai == "B"])
[]
>>> list(l[ai != "A"])
[]
>>> list(l[ai != "B"])
[1, 2, 3]
>>> np.logical_and([True, False, True], ai == "A")
array([ True, False, True])
>>> np.logical_and([True, False, True], ai != "A")
array([False, False, False])
>>> bool(ai == "A")
True
>>> bool(ai != "A")
False
>>> str(ai)
'A'
>>> hash(ai) == hash("A")
True
>>> int(ai.eye)
1
>>> np.allclose(AliasIndex("A", 1, (2, 2)).eye, np.eye(2))
True
"""
class LazyArray:
def __init__(self, value, shape):
self.value = value
self.shape = shape
def __bool__(self):
return bool(self.value)
def __array__(self):
return np.full(self.shape, self.value)
def __init__(self, name, shape, orbs=(1, 1)):
self.name = name
self.shape = shape
self.orbs = orbs
def __str__(self):
return self.name
def __eq__(self, other):
return self.LazyArray(self.name == other, self.shape)
def __ne__(self, other):
return self.LazyArray(self.name != other, self.shape)
def __hash__(self):
return hash(self.name)
@property
def eye(self):
return np.eye(*self.orbs)
class SplitName(str):
"""String subclass with special support for strings of the form "first|second"
Operators `==` and `!=` are overloaded to return `True` even if only the first part matches.
Examples
--------
>>> s = SplitName("first|second")
>>> s == "first|second"
True
>>> s != "first|second"
False
>>> s == "first"
True
>>> s != "first"
False
>>> s == "second"
False
>>> s != "second"
True
"""
@property
def first(self):
return self.split("|")[0]
def __eq__(self, other):
return super().__eq__(other) or self.first == other
def __ne__(self, other):
return super().__ne__(other) and self.first != other
def __hash__(self):
return super().__hash__()
| Python |
2D | dean0x7d/pybinding | docs/test_examples.py | .py | 710 | 24 | import pytest
import pathlib
import warnings
docs = pathlib.Path(__file__).parent
examples = list(docs.glob("tutorial/**/*.py")) + list(docs.glob("examples/**/*.py"))
assert len(examples) != 0
@pytest.fixture(scope='module', ids=[e.stem for e in examples], params=examples)
def example_file(request):
"""An example file from the documentation directory"""
return request.param
def test_docs(example_file):
"""Make sure all example files execute without error"""
filename = str(example_file)
with open(filename, "rb") as file:
with warnings.catch_warnings():
warnings.simplefilter("ignore", UserWarning)
exec(compile(file.read(), filename, "exec"), {})
| Python |
2D | dean0x7d/pybinding | docs/conf.py | .py | 12,076 | 361 | #!/usr/bin/env python
# -*- coding: utf-8 -*-
import sys
import os
import shutil
import filecmp
import sphinx_rtd_theme
from recommonmark.parser import CommonMarkParser
# If extensions (or modules to document with autodoc) are in another directory,
# add these directories to sys.path here. If the directory is relative to the
# documentation root, use os.path.abspath to make it absolute, like shown here.
sys.path.insert(0, os.path.abspath('./_ext'))
sys.path.insert(0, os.path.abspath('..'))
import pybinding as pb
# -- General configuration ------------------------------------------------
# If your documentation needs a minimal Sphinx version, state it here.
needs_sphinx = '1.3'
# Add any Sphinx extension module names here, as strings. They can be
# extensions coming with Sphinx (named 'sphinx.ext.*') or your custom
# ones.
extensions = [
'sphinx.ext.autodoc',
'sphinx.ext.autosummary',
'sphinx.ext.mathjax',
'sphinx.ext.todo',
'sphinx.ext.intersphinx',
'numpydoc',
'matplotlib.sphinxext.plot_directive',
'nbexport',
'generate'
]
autodoc_member_order = 'groupwise'
autodoc_default_options = {
'members': None,
'special-members': None,
'inherited-members': None
}
autodoc_allowed_special_members = ['__call__', '__getitem__']
generate_from_files = ['api.rst']
mathjax_path = ("https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.1/MathJax.js?"
"config=TeX-AMS-MML_HTMLorMML")
intersphinx_mapping = {'python': ('https://docs.python.org/3', None),
'numpy': ('https://docs.scipy.org/doc/numpy/', None),
'scipy': ('https://docs.scipy.org/doc/scipy/reference/', None),
'matplotlib': ('http://matplotlib.org/', None)}
numpydoc_class_members_toctree = False
numpydoc_show_class_members = False
plot_include_source = True
plot_html_show_source_link = False
plot_formats = [('png', 120), 'pdf']
plot_html_show_formats = False
plot_pre_code = """
import pybinding as pb
import numpy as np
import matplotlib.pyplot as plt
"""
plot_rcparams = pb.pltutils.pb_style
plot_apply_rcparams = True
nbexport_pre_code = plot_pre_code + """
pb.pltutils.use_style()
%matplotlib inline
"""
nbexport_baseurl = "http://docs.pybinding.site/page/"
nbexport_execute = False
# Add any paths that contain templates here, relative to this directory.
templates_path = ['_templates']
# The encoding of source files.
# source_encoding = 'utf-8-sig'
# The master toctree document.
master_doc = 'index'
# General information about the project.
project = pb.__title__
copyright = pb.__copyright__
author = pb.__author__
# The version info for the project you're documenting, acts as replacement for
# |version| and |release|, also used in various other places throughout the
# built documents.
#
# The short X.Y version.
version = '.'.join(pb.__version__.split('.')[:2])
# The full version, including alpha/beta/rc tags.
release = pb.__version__
# The language for content autogenerated by Sphinx. Refer to documentation
# for a list of supported languages.
#
# This is also used if you do content translation via gettext catalogs.
# Usually you set "language" from the command line for these cases.
language = None
# There are two options for replacing |today|: either, you set today to some
# non-false value, then it is used:
# today = ''
# Else, today_fmt is used as the format for a strftime call.
# today_fmt = '%B %d, %Y'
# List of patterns, relative to source directory, that match files and
# directories to ignore when looking for source files.
exclude_patterns = ['_build', 'readme.md']
# The reST default role (used for this markup: `text`) to use for all
# documents.
default_role = 'samp'
# If true, '()' will be appended to :func: etc. cross-reference text.
# add_function_parentheses = True
# If true, the current module name will be prepended to all description
# unit titles (such as .. function::).
add_module_names = False
# If true, sectionauthor and moduleauthor directives will be shown in the
# output. They are ignored by default.
# show_authors = False
# The name of the Pygments (syntax highlighting) style to use.
pygments_style = 'default'
# A list of ignored prefixes for module index sorting.
# modindex_common_prefix = []
# If true, keep warnings as "system message" paragraphs in the built documents.
# keep_warnings = False
# If true, `todo` and `todoList` produce output, else they produce nothing.
todo_include_todos = True
# -- Options for HTML output ----------------------------------------------
# The theme to use for HTML and HTML Help pages. See the documentation for
# a list of builtin themes.
html_theme = 'sphinx_rtd_theme'
# Theme options are theme-specific and customize the look and feel of a theme
# further. For a list of options available for each theme, see the
# documentation.
# html_theme_options = {}
# Add any paths that contain custom themes here, relative to this directory.
html_theme_path = [sphinx_rtd_theme.get_html_theme_path()]
# The name for this set of Sphinx documents. If None, it defaults to
# "<project> v<release> documentation".
html_title = project
# A shorter title for the navigation bar. Default is the same as html_title.
# html_short_title = None
# The name of an image file (relative to this directory) to place at the top
# of the sidebar.
# html_logo = None
# The name of an image file (within the static path) to use as favicon of the
# docs. This file should be a Windows icon file (.ico) being 16x16 or 32x32
# pixels large.
# html_favicon = None
# Add any paths that contain custom static files (such as style sheets) here,
# relative to this directory. They are copied after the builtin static files,
# so a file named "default.css" will overwrite the builtin "default.css".
html_static_path = ['_static']
html_context = {'extra_css_files': ['_static/extra.css']}
# Add any extra paths that contain custom files (such as robots.txt or
# .htaccess) here, relative to this directory. These files are copied
# directly to the root of the documentation.
# html_extra_path = []
# If not '', a 'Last updated on:' timestamp is inserted at every page bottom,
# using the given strftime format.
# html_last_updated_fmt = '%b %d, %Y'
# If true, SmartyPants will be used to convert quotes and dashes to
# typographically correct entities.
# html_use_smartypants = True
# Custom sidebar templates, maps document names to template names.
# html_sidebars = {}
# Additional templates that should be rendered to pages, maps page names to
# template names.
# html_additional_pages = {}
# If false, no module index is generated.
# html_domain_indices = True
# If false, no index is generated.
# html_use_index = True
# If true, the index is split into individual pages for each letter.
# html_split_index = False
# If true, links to the reST sources are added to the pages.
# html_show_sourcelink = True
# If true, "Created using Sphinx" is shown in the HTML footer. Default is True.
# html_show_sphinx = True
# If true, "(C) Copyright ..." is shown in the HTML footer. Default is True.
# html_show_copyright = True
# If true, an OpenSearch description file will be output, and all pages will
# contain a <link> tag referring to it. The value of this option must be the
# base URL from which the finished HTML is served.
# html_use_opensearch = ''
# This is the file name suffix for HTML files (e.g. ".xhtml").
# html_file_suffix = None
# Language to be used for generating the HTML full-text search index.
# Sphinx supports the following languages:
# 'da', 'de', 'en', 'es', 'fi', 'fr', 'h', 'it', 'ja'
# 'nl', 'no', 'pt', 'ro', 'r', 'sv', 'tr'
# html_search_language = 'en'
# A dictionary with options for the search language support, empty by default.
# Now only 'ja' uses this config value
# html_search_options = {'type': 'default'}
# The name of a javascript file (relative to the configuration directory) that
# implements a search results scorer. If empty, the default will be used.
# html_search_scorer = 'scorer.js'
# Output file base name for HTML help builder.
htmlhelp_basename = project + 'doc'
# -- Options for LaTeX output ---------------------------------------------
latex_elements = {
# The paper size ('letterpaper' or 'a4paper').
'papersize': 'a4paper',
# The font size ('10pt', '11pt' or '12pt').
# 'pointsize': '10pt',
# Additional stuff for the LaTeX preamble.
'preamble': r"\definecolor{VerbatimBorderColor}{rgb}{1,1,1}",
# Latex figure (float) alignment
# 'figure_align': 'htbp',
}
# Grouping the document tree into LaTeX files. List of tuples
# (source start file, target name, title,
# author, documentclass [howto, manual, or own class]).
latex_documents = [
(master_doc, project + '.tex', project.capitalize() + ' User Guide', author, 'manual'),
]
# The name of an image file (relative to this directory) to place at the top of
# the title page.
# latex_logo = None
# For "manual" documents, if this is true, then toplevel headings are parts,
# not chapters.
# latex_use_parts = False
# If true, show page references after internal links.
# latex_show_pagerefs = False
# If true, show URL addresses after external links.
# latex_show_urls = False
# Documents to append as an appendix to all manuals.
# latex_appendices = []
# If false, no module index is generated.
latex_domain_indices = False
# -- Options for manual page output ---------------------------------------
# One entry per manual page. List of tuples
# (source start file, name, description, authors, manual section).
man_pages = [
(master_doc, project, project.capitalize() + ' Documentation', [author], 1)
]
# If true, show URL addresses after external links.
# man_show_urls = False
# -- Options for Texinfo output -------------------------------------------
# Grouping the document tree into Texinfo files. List of tuples
# (source start file, target name, title, author,
# dir menu entry, description, category)
texinfo_documents = [
(master_doc, project, project.capitalize() + ' Documentation',
author, project, pb.__summary__, 'Miscellaneous'),
]
# Documents to append as an appendix to all manuals.
# texinfo_appendices = []
# If false, no module index is generated.
# texinfo_domain_indices = True
# How to display URL addresses: 'footnote', 'no', or 'inline'.
# texinfo_show_urls = 'footnote'
# If true, do not generate a @detailmenu in the "Top" node's menu.
# texinfo_no_detailmenu = False
# -- Quick extensions -----------------------------------------------------
def copy_changelog(app):
"""Make the changelog available to sphinx"""
src = os.path.join(app.env.srcdir, "../changelog.md")
dst = os.path.join(app.env.srcdir, "changelog.md")
if not os.path.exists(dst) or not filecmp.cmp(src, dst, shallow=False):
shutil.copy(src, dst)
# noinspection PyUnusedLocal
def autodoc_skip_member(app, what, name, obj, skip, options):
"""Skip special members which aren't on the allowed list"""
if skip:
return True
elif name.startswith('__'):
skip = name not in autodoc_allowed_special_members
return skip
# noinspection PyUnusedLocal
def autodoc_process_signature(app, what, name, obj, options, signature, return_annotation):
"""Remove 'self' and return type annotation from C++ methods"""
if what == 'method' and "self:" in signature:
s = signature.strip("()").split(",")[1:]
return "({})".format(",".join(s)), ""
class WorkaroundCommonMarkParser(CommonMarkParser):
"""Workaround recommonmark issue https://github.com/readthedocs/recommonmark/issues/177"""
def visit_document(self, _):
pass
def setup(app):
app.connect('builder-inited', copy_changelog)
app.connect('autodoc-skip-member', autodoc_skip_member)
app.connect('autodoc-process-signature', autodoc_process_signature)
app.add_config_value('autodoc_allowed_special_members', [], 'env')
app.add_source_suffix('.md', 'markdown')
app.add_source_parser(WorkaroundCommonMarkParser)
| Python |
2D | dean0x7d/pybinding | docs/benchmarks/system_build.py | .py | 6,109 | 173 | #! /usr/bin/env python3
"""Tight-binding system construction benchmark
Usage: Make sure you have all the requirements and then run this script using python3.
The considered system sizes can be changed in the `__name__ == '__main__'` section at
the bottom.
Requires Python >= 3.6 and the following packages which can be installed using pip:
- memory_profiler
- psutil (memory_profiler will be slow without it)
The benchmark compares the following packages. See the websites for install instructions:
- pybinding : http://pybinding.site/
- kwant : http://kwant-project.org/
The benchmark constructs a circular graphene flake with a pn-junction and a constant
magnetic field. The system build time is measured from the start of the definition
to the point where the Hamiltonian matrix is fully constructed.
"""
import math
import cmath
import numpy as np
import matplotlib.pyplot as plt
from memory_profiler import memory_usage
import kwant
import pybinding as pb
from pybinding.repository import graphene
pb.pltutils.use_style()
pb.pltutils.set_palette("Set1", start=3)
def calc_radius(num_sites, lattice=graphene.monolayer()):
"""The approximate radius of a circle which can contain the given number of lattice sites"""
unit_area = np.linalg.norm(np.cross(*lattice.vectors)) / len(lattice.sublattices)
return math.sqrt(num_sites * unit_area / math.pi)
def measure_pybinding(num_sites, warmup=False, plot=False):
def circular_pn_junction(v0, radius):
@pb.onsite_energy_modifier
def function(energy, x, y):
energy[(x**2 + y**2) < (radius / 2)**2] = v0
return energy
return function
def make_model(radius, potential=0.2, magnetic_field=3):
return pb.Model(
graphene.monolayer().with_min_neighbors(2),
pb.circle(radius),
circular_pn_junction(potential, radius),
graphene.constant_magnetic_field(magnetic_field)
)
with pb.utils.timed() as time:
model = make_model(radius=calc_radius(num_sites))
h = model.hamiltonian
if not warmup:
print(" {:7} <-> atoms = {}, non-zeros = {}".format(str(time), h.shape[0], h.nnz))
if plot:
model.plot()
plt.show()
return time.elapsed
def measure_kwant(num_sites, warmup=False, plot=False):
def make_system(radius, potential=0.2, magnetic_field=3):
def circle(pos):
x, y = pos
return x**2 + y**2 < radius**2
def onsite(site):
x, y = site.pos
if x**2 + y**2 < (radius / 2)**2:
return potential
else:
return 0
def hopping(site_i, site_j):
xi, yi = site_i.pos
xj, yj = site_j.pos
phi_ij = 0.5 * magnetic_field * (xi + xj) * (yi - yj)
const = 1.519e-3 # 2*pi*e/h*[nm^2]
return -2.8 * cmath.exp(1j * phi_ij * const)
a_cc = 0.142
a = a_cc * math.sqrt(3)
graphene_lattice = kwant.lattice.general([(a, 0), (a/2, a/2 * math.sqrt(3))],
[(0, -a_cc/2), (0, a_cc/2)])
builder = kwant.Builder()
builder[graphene_lattice.shape(circle, (0, 0))] = onsite
builder[graphene_lattice.neighbors()] = hopping
builder.eradicate_dangling()
return builder.finalized()
with pb.utils.timed() as time:
system = make_system(radius=calc_radius(num_sites))
h = system.hamiltonian_submatrix(sparse=True)
if not warmup:
print(" {:7} <-> atoms = {}, non-zeros = {}".format(str(time), h.shape[0], h.nnz))
if plot:
kwant.plot(system)
return time.elapsed
def plot_time(sizes, times, label):
plt.plot(sizes, times, label=label, marker='o', markersize=5, lw=2, zorder=10)
plt.grid(True, which='major', color='gray', ls=':', alpha=0.5)
plt.loglog()
plt.title("system build time")
plt.xlabel("system size (number of atoms)")
plt.ylabel("build time (seconds)")
plt.xlim(0.7 * min(sizes), 1.2 * max(sizes))
pb.pltutils.despine()
pb.pltutils.legend(loc='upper left', reverse=True)
def plot_memory(memory_profile, label):
progress = np.linspace(0, 100, len(memory_profile))
units = "MiB"
if max(memory_profile) > 1024:
memory_profile = np.array(memory_profile) / 1024
units = "GiB"
plt.plot(progress, memory_profile, lw=2, label=label, zorder=10)
plt.grid(True, which='major', color='gray', ls=':', alpha=0.5)
plt.title("RAM usage over time")
plt.xlabel("build progress (%)")
plt.ylabel("memory ({})".format(units))
pb.pltutils.despine()
pb.pltutils.legend(loc='upper left', reverse=True)
def measure_and_plot(sizes, interval=0.02):
"""Measure build time and memory usage
The list of `sizes` specifies the number atoms in the constructed systems.
The `interval` is the memory usage sampling rate -- see `memory_profiler` package.
The measurements are preceded by a short warmup run with a small system size. This
takes care of submodule initialization so that it's not part of the measurement.
"""
print("pybinding:")
measure_pybinding(1e3, warmup=True)
pb_memory, pb_times = memory_usage(lambda: [measure_pybinding(n) for n in sizes],
interval, retval=True)
print("\nkwant:")
measure_kwant(1e3, warmup=True)
kwant_memory, kwant_times = memory_usage(lambda: [measure_kwant(n) for n in sizes],
interval, retval=True)
plt.figure(figsize=(6, 2.4))
plt.subplots_adjust(wspace=0.3)
plt.subplot(121)
plot_time(sizes, pb_times, label="pybinding")
plot_time(sizes, kwant_times, label="kwant")
plt.subplot(122)
plot_memory(pb_memory, label="pybinding")
plot_memory(kwant_memory, label="kwant")
filename = "system_build_results.png"
plt.savefig(filename)
print("\nDone! Results saved to file: {}".format(filename))
if __name__ == '__main__':
measure_and_plot(sizes=[1e3, 1e4, 1e5, 1e6])
| Python |
2D | dean0x7d/pybinding | docs/tutorial/strain_example.py | .py | 1,268 | 49 | """Strain a triangular system by pulling on its vertices"""
import pybinding as pb
import numpy as np
import matplotlib.pyplot as plt
from pybinding.repository import graphene
from math import pi
pb.pltutils.use_style()
def triaxial_strain(c):
"""Strain-induced displacement and hopping energy modification"""
@pb.site_position_modifier
def displacement(x, y, z):
ux = 2*c * x*y
uy = c * (x**2 - y**2)
return x + ux, y + uy, z
@pb.hopping_energy_modifier
def strained_hopping(energy, x1, y1, z1, x2, y2, z2):
l = np.sqrt((x1-x2)**2 + (y1-y2)**2 + (z1-z2)**2)
w = l / graphene.a_cc - 1
return energy * np.exp(-3.37 * w)
return displacement, strained_hopping
model = pb.Model(
graphene.monolayer(),
pb.regular_polygon(num_sides=3, radius=2, angle=pi),
triaxial_strain(c=0.1)
)
model.plot()
plt.show()
plt.figure(figsize=(7, 2.5))
grid = plt.GridSpec(nrows=1, ncols=2)
for block, energy in zip(grid, [0, 0.25]):
plt.subplot(block)
plt.title("E = {} eV".format(energy))
solver = pb.solver.arpack(model, k=30, sigma=energy)
ldos_map = solver.calc_spatial_ldos(energy=energy, broadening=0.03)
ldos_map.plot()
pb.pltutils.colorbar(label="LDOS")
plt.show()
| Python |
2D | dean0x7d/pybinding | docs/tutorial/fields_example.py | .py | 1,518 | 58 | """PN junction and broken sublattice symmetry in a graphene nanoribbon"""
import pybinding as pb
import matplotlib.pyplot as plt
from pybinding.repository import graphene
from math import pi, sqrt
pb.pltutils.use_style()
def mass_term(delta):
"""Break sublattice symmetry with opposite A and B onsite energy"""
@pb.onsite_energy_modifier
def potential(energy, sub_id):
energy[sub_id == 'A'] += delta
energy[sub_id == 'B'] -= delta
return energy
return potential
def pn_juction(y0, v1, v2):
"""PN junction potential
The `y0` argument is the position of the junction, while `v1` and `v2`
are the values of the potential (in eV) before and after the junction.
"""
@pb.onsite_energy_modifier
def potential(energy, y):
energy[y < y0] += v1
energy[y >= y0] += v2
return energy
return potential
model = pb.Model(
graphene.monolayer(),
pb.rectangle(1.2), # width in nanometers
pb.translational_symmetry(a1=True, a2=False),
mass_term(delta=2.5), # eV
pn_juction(y0=0, v1=-2.5, v2=2.5) # y0 in [nm] and v1, v2 in [eV]
)
model.plot()
plt.show()
# plot the potential: note that pn_junction cancels out delta on some sites
model.onsite_map.plot(cmap="coolwarm", site_radius=0.04)
pb.pltutils.colorbar(label="U (eV)")
plt.show()
# compute the bands
solver = pb.solver.lapack(model)
a = graphene.a_cc * sqrt(3) # nanoribbon unit cell length
bands = solver.calc_bands(-pi/a, pi/a)
bands.plot()
plt.show()
| Python |
2D | dean0x7d/pybinding | docs/tutorial/shape_symmetry_example.py | .py | 1,480 | 55 | """Model an infinite nanoribbon consisting of graphene rings"""
import pybinding as pb
import numpy as np
import matplotlib.pyplot as plt
from pybinding.repository import graphene
from math import pi
pb.pltutils.use_style()
def ring(inner_radius, outer_radius):
"""A simple ring shape"""
def contains(x, y, z):
r = np.sqrt(x**2 + y**2)
return np.logical_and(inner_radius < r, r < outer_radius)
return pb.FreeformShape(contains, width=[2 * outer_radius, 2 * outer_radius])
model = pb.Model(
graphene.monolayer_4atom(),
ring(inner_radius=1.4, outer_radius=2), # length in nanometers
pb.translational_symmetry(a1=3.8, a2=False) # period in nanometers
)
plt.figure(figsize=pb.pltutils.cm2inch(20, 7))
model.plot()
plt.show()
# only solve for the 10 lowest energy eigenvalues
solver = pb.solver.arpack(model, k=10)
a = 3.8 # [nm] unit cell length
bands = solver.calc_bands(-pi/a, pi/a)
bands.plot(point_labels=[r'$-\pi / a$', r'$\pi / a$'])
plt.show()
solver.set_wave_vector(k=0)
ldos = solver.calc_spatial_ldos(energy=0, broadening=0.01) # LDOS around 0 eV
plt.figure(figsize=pb.pltutils.cm2inch(20, 7))
ldos.plot(site_radius=(0.03, 0.12))
pb.pltutils.colorbar(label="LDOS")
plt.show()
solver.set_wave_vector(k=pi/a)
ldos = solver.calc_spatial_ldos(energy=0, broadening=0.01) # LDOS around 0 eV
plt.figure(figsize=pb.pltutils.cm2inch(20, 7))
ldos.plot(site_radius=(0.03, 0.12))
pb.pltutils.colorbar(label="LDOS")
plt.show()
| Python |
2D | dean0x7d/pybinding | docs/tutorial/twisted_heterostructures.py | .py | 6,393 | 192 | """Construct a circular flake of twisted bilayer graphene (arbitrary angle)"""
import numpy as np
import matplotlib.pyplot as plt
import math
import pybinding as pb
from scipy.spatial import cKDTree
from pybinding.repository import graphene
c0 = 0.335 # [nm] graphene interlayer spacing
def two_graphene_monolayers():
"""Two individual AB stacked layers of monolayer graphene without any interlayer hopping,"""
from pybinding.repository.graphene.constants import a_cc, a, t
lat = pb.Lattice(a1=[a/2, a/2 * math.sqrt(3)], a2=[-a/2, a/2 * math.sqrt(3)])
lat.add_sublattices(('A1', [0, a_cc, 0]),
('B1', [0, 0, 0]),
('A2', [0, 0, -c0]),
('B2', [0, -a_cc, -c0]))
lat.register_hopping_energies({'gamma0': t})
lat.add_hoppings(
# layer 1
([0, 0], 'A1', 'B1', 'gamma0'),
([0, 1], 'A1', 'B1', 'gamma0'),
([1, 0], 'A1', 'B1', 'gamma0'),
# layer 2
([0, 0], 'A2', 'B2', 'gamma0'),
([0, 1], 'A2', 'B2', 'gamma0'),
([1, 0], 'A2', 'B2', 'gamma0'),
# not interlayer hopping
)
lat.min_neighbors = 2
return lat
def twist_layers(theta):
"""Rotate one layer and then a generate hopping between the rotated layers,
reference is AB stacked"""
theta = theta / 180 * math.pi # from degrees to radians
@pb.site_position_modifier
def rotate(x, y, z):
"""Rotate layer 2 by the given angle `theta`"""
layer2 = (z < 0)
x0 = x[layer2]
y0 = y[layer2]
x[layer2] = x0 * math.cos(theta) - y0 * math.sin(theta)
y[layer2] = y0 * math.cos(theta) + x0 * math.sin(theta)
return x, y, z
@pb.hopping_generator('interlayer', energy=0.1) # eV
def interlayer_generator(x, y, z):
"""Generate hoppings for site pairs which have distance `d_min < d < d_max`"""
positions = np.stack([x, y, z], axis=1)
layer1 = (z == 0)
layer2 = (z != 0)
d_min = c0 * 0.98
d_max = c0 * 1.1
kdtree1 = cKDTree(positions[layer1])
kdtree2 = cKDTree(positions[layer2])
coo = kdtree1.sparse_distance_matrix(kdtree2, d_max, output_type='coo_matrix')
idx = coo.data > d_min
abs_idx1 = np.flatnonzero(layer1)
abs_idx2 = np.flatnonzero(layer2)
row, col = abs_idx1[coo.row[idx]], abs_idx2[coo.col[idx]]
return row, col # lists of site indices to connect
@pb.hopping_energy_modifier
def interlayer_hopping_value(energy, x1, y1, z1, x2, y2, z2, hop_id):
"""Set the value of the newly generated hoppings as a function of distance"""
d = np.sqrt((x1-x2)**2 + (y1-y2)**2 + (z1-z2)**2)
interlayer = (hop_id == 'interlayer')
energy[interlayer] = 0.4 * c0 / d[interlayer]
return energy
return rotate, interlayer_generator, interlayer_hopping_value
def hbn_layer(shape):
"""Generate hBN layer defined by the shape with intralayer hopping terms"""
from pybinding.repository.graphene.constants import a_cc, t
a_bn = 56 / 55 * a_cc # ratio of lattice constants is 56/55
vn = -1.4 # [eV] nitrogen onsite potential
vb = 3.34 # [eV] boron onsite potential
def hbn_monolayer():
"""Create a lattice of monolayer hBN """
a = math.sqrt(3) * a_bn
lat = pb.Lattice(a1=[a/2, a/2 * math.sqrt(3)], a2=[-a/2, a/2 * math.sqrt(3)])
lat.add_sublattices(('Br', [0, -a_bn, -c0], vb),
('N', [0, 0, -c0], vn))
lat.min_neighbors = 2 # no need for hoppings lattice is used only to generate coordinates
return lat
model = pb.Model(
hbn_monolayer(),
shape
)
subs = model.system.sublattices
idx_b = np.flatnonzero(subs == model.lattice.sublattices["Br"].alias_id)
idx_n = np.flatnonzero(subs == model.lattice.sublattices["N"].alias_id)
positions_boron = model.system[idx_b].positions
positions_nitrogen = model.system[idx_n].positions
@pb.site_generator(name='Br', energy=vb) # onsite energy [eV]
def add_boron():
"""Add positions of newly generated boron sites"""
return positions_boron
@pb.site_generator(name='N', energy=vn) # onsite energy [eV]
def add_nitrogen():
"""Add positions of newly generated nitrogen sites"""
return positions_nitrogen
@pb.hopping_generator('intralayer_bn', energy=t)
def intralayer_generator(x, y, z):
"""Generate nearest-neighbor hoppings between B and N sites"""
positions = np.stack([x, y, z], axis=1)
layer_bn = (z != 0)
d_min = a_bn * 0.98
d_max = a_bn * 1.1
kdtree1 = cKDTree(positions[layer_bn])
kdtree2 = cKDTree(positions[layer_bn])
coo = kdtree1.sparse_distance_matrix(kdtree2, d_max, output_type='coo_matrix')
idx = coo.data > d_min
abs_idx = np.flatnonzero(layer_bn)
row, col = abs_idx[coo.row[idx]], abs_idx[coo.col[idx]]
return row, col # lists of site indices to connect
@pb.hopping_energy_modifier
def intralayer_hopping_value(energy, x1, y1, z1, x2, y2, z2, hop_id):
"""Set the value of the newly generated hoppings as a function of distance"""
d = np.sqrt((x1-x2)**2 + (y1-y2)**2 + (z1-z2)**2)
intralayer = (hop_id == 'intralayer_bn')
energy[intralayer] = 0.1 * t * a_bn / d[intralayer]
return energy
return add_boron, add_nitrogen, intralayer_generator, intralayer_hopping_value
model = pb.Model(
two_graphene_monolayers(),
pb.circle(radius=1.5),
twist_layers(theta=21.798)
)
plt.figure(figsize=(6.5, 6.5))
model.plot()
plt.title(r"$\theta$ = 21.798 $\degree$")
plt.show()
model = pb.Model(
two_graphene_monolayers(),
pb.circle(radius=1.5),
twist_layers(theta=12.95)
)
plt.figure(figsize=(6.5, 6.5))
model.plot()
plt.title(r"$\theta$ = 12.95 $\degree$")
plt.show()
shape = pb.circle(radius=2),
model = pb.Model(
graphene.monolayer_alt(), # reference stacking is AB (theta=0)
shape,
hbn_layer(shape=shape),
twist_layers(21.787),
)
plt.figure(figsize=(6.8, 7.5))
s = model.system
plt.subplot(2, 2, 1, title="graphene")
s[s.z == 0].plot()
plt.subplot(2, 2, 2, title="hBN")
s[s.z < 0].plot()
plt.subplot(2, 2, (3, 4), title="graphene/hBN")
s.plot()
plt.show()
| Python |
2D | dean0x7d/pybinding | docs/tutorial/bands_example.py | .py | 835 | 27 | """Calculate and plot the band structure of monolayer graphene"""
import pybinding as pb
import matplotlib.pyplot as plt
from math import sqrt, pi
from pybinding.repository import graphene
pb.pltutils.use_style()
model = pb.Model(
graphene.monolayer(), # predefined lattice from the material repository
pb.translational_symmetry() # creates an infinite sheet of graphene
)
solver = pb.solver.lapack(model) # eigensolver from the LAPACK library
# significant points in graphene's Brillouin zone
a_cc = graphene.a_cc # carbon-carbon distance
Gamma = [0, 0]
K1 = [-4*pi / (3*sqrt(3)*a_cc), 0]
M = [0, 2*pi / (3*a_cc)]
K2 = [2*pi / (3*sqrt(3)*a_cc), 2*pi / (3*a_cc)]
# plot the bands through the desired points
bands = solver.calc_bands(K1, Gamma, M, K2)
bands.plot(point_labels=['K', r'$\Gamma$', 'M', 'K'])
plt.show()
| Python |
2D | dean0x7d/pybinding | docs/tutorial/finite_example.py | .py | 892 | 34 | """Model a graphene ring structure and calculate the local density of states"""
import pybinding as pb
import numpy as np
import matplotlib.pyplot as plt
from pybinding.repository import graphene
pb.pltutils.use_style()
def ring(inner_radius, outer_radius):
"""A simple ring shape"""
def contains(x, y, z):
r = np.sqrt(x**2 + y**2)
return np.logical_and(inner_radius < r, r < outer_radius)
return pb.FreeformShape(contains, width=[2 * outer_radius, 2 * outer_radius])
model = pb.Model(
graphene.monolayer(),
ring(inner_radius=1.4, outer_radius=2) # length in nanometers
)
model.plot()
plt.show()
# only solve for the 20 lowest energy eigenvalues
solver = pb.solver.arpack(model, k=20)
ldos = solver.calc_spatial_ldos(energy=0, broadening=0.05) # LDOS around 0 eV
ldos.plot(site_radius=(0.03, 0.12))
pb.pltutils.colorbar(label="LDOS")
plt.show()
| Python |
2D | dean0x7d/pybinding | docs/tutorial/lattice_example.py | .py | 965 | 44 | """Create and plot a monolayer graphene lattice and it's Brillouin zone"""
import pybinding as pb
import matplotlib.pyplot as plt
from math import sqrt
pb.pltutils.use_style()
def monolayer_graphene():
"""Return the lattice specification for monolayer graphene"""
a = 0.24595 # [nm] unit cell length
a_cc = 0.142 # [nm] carbon-carbon distance
t = -2.8 # [eV] nearest neighbour hopping
# create a lattice with 2 primitive vectors
lat = pb.Lattice(
a1=[a, 0],
a2=[a/2, a/2 * sqrt(3)]
)
lat.add_sublattices(
# name and position
('A', [0, -a_cc/2]),
('B', [0, a_cc/2])
)
lat.add_hoppings(
# inside the main cell
([0, 0], 'A', 'B', t),
# between neighboring cells
([1, -1], 'A', 'B', t),
([0, -1], 'A', 'B', t)
)
return lat
lattice = monolayer_graphene()
lattice.plot()
plt.show()
lattice.plot_brillouin_zone()
plt.show()
| Python |
2D | dean0x7d/pybinding | docs/examples/ribbons/bilayer_graphene.py | .py | 1,484 | 48 | """Bilayer graphene nanoribbon with zigzag edges"""
import pybinding as pb
import matplotlib.pyplot as plt
from pybinding.repository import graphene
from math import pi, sqrt
pb.pltutils.use_style()
def bilayer_graphene():
"""Bilayer lattice in the AB-stacked form (Bernal-stacked)"""
lat = pb.Lattice(a1=[graphene.a, 0], a2=[0.5*graphene.a, 0.5*sqrt(3)*graphene.a])
c0 = 0.335 # [nm] interlayer spacing
lat.add_sublattices(('A1', [0, -graphene.a_cc/2, 0]),
('B1', [0, graphene.a_cc/2, 0]),
('A2', [0, graphene.a_cc/2, -c0]),
('B2', [0, 3*graphene.a_cc/2, -c0]))
lat.register_hopping_energies({'t': graphene.t, 't_layer': -0.4})
lat.add_hoppings(
# layer 1
([ 0, 0], 'A1', 'B1', 't'),
([ 1, -1], 'A1', 'B1', 't'),
([ 0, -1], 'A1', 'B1', 't'),
# layer 2
([ 0, 0], 'A2', 'B2', 't'),
([ 1, -1], 'A2', 'B2', 't'),
([ 0, -1], 'A2', 'B2', 't'),
# interlayer
([ 0, 0], 'B1', 'A2', 't_layer')
)
lat.min_neighbors = 2
return lat
model = pb.Model(
bilayer_graphene(),
pb.rectangle(1.3), # nm
pb.translational_symmetry(a1=True, a2=False)
)
model.plot()
model.lattice.plot_vectors(position=[-0.6, 0.3]) # nm
plt.show()
solver = pb.solver.lapack(model)
bands = solver.calc_bands(-pi/graphene.a, pi/graphene.a)
bands.plot(point_labels=[r"$-\pi / a$", r"$\pi / a$"])
plt.show()
| Python |
2D | dean0x7d/pybinding | docs/examples/lattice/monolayer_graphene_soc.py | .py | 2,087 | 71 | """Calculate the band structure of graphene with Rashba spin-orbit coupling"""
import pybinding as pb
import numpy as np
import matplotlib.pyplot as plt
from math import pi, sqrt
def monolayer_graphene_soc():
"""Return the lattice specification for monolayer graphene with Rashba SOC,
see http://doi.org/10.1103/PhysRevB.95.165415 for reference"""
from pybinding.constants import pauli
from pybinding.repository.graphene import a_cc, a, t
onsite = 0.05 # [eV] onsite energy
rashba = 0.1 # [eV] strength of Rashba SOC
rashba_so = 1j * 2/3 * rashba
# create a lattice with 2 primitive vectors
a1 = np.array([a / 2 * sqrt(3), a / 2])
a2 = np.array([a / 2 * sqrt(3), -a / 2])
lat = pb.Lattice(
a1=a1, a2=a2
)
pos_a = np.array([-a_cc / 2, 0])
pos_b = np.array([+a_cc / 2, 0])
lat.add_sublattices(
('A', pos_a, [[ onsite, 0], [0, onsite]]),
('B', pos_b, [[-onsite, 0], [0, -onsite]]))
# nearest neighbor vectors
d1 = (pos_b - pos_a) / a_cc # [ 0, 0]
d2 = (pos_b - pos_a - a1) / a_cc # [-1, 0]
d3 = (pos_b - pos_a - a2) / a_cc # [ 0, -1]
nn_hopp = np.array([[t, 0], [0, t]]) # nn hopping, same spin
t1 = nn_hopp + rashba_so * (pauli.x * d1[1] - pauli.y * d1[0]) # cross([sx , sy], [dx, dy])
t2 = nn_hopp + rashba_so * (pauli.x * d2[1] - pauli.y * d2[0])
t3 = nn_hopp + rashba_so * (pauli.x * d3[1] - pauli.y * d3[0])
# name and position
lat.add_hoppings(
([0, 0], 'A', 'B', t1),
([-1, 0], 'A', 'B', t2),
([0, -1], 'A', 'B', t3)
)
return lat
lattice = monolayer_graphene_soc()
lattice.plot()
plt.show()
lattice.plot_brillouin_zone()
plt.show()
model = pb.Model(lattice, pb.translational_symmetry())
solver = pb.solver.lapack(model)
k_points = model.lattice.brillouin_zone()
Gamma = [0, 0]
K1 = k_points[0]
K2 = k_points[2]
M = (k_points[0] + k_points[1]) / 2
bands = solver.calc_bands(K1, Gamma, M, K2)
bands.plot(point_labels=['K', r'$\Gamma$', 'M', 'K'])
plt.show()
| Python |
2D | dean0x7d/pybinding | docs/examples/lattice/trestle.py | .py | 737 | 38 | """One dimensional lattice with complex hoppings"""
import pybinding as pb
import matplotlib.pyplot as plt
pb.pltutils.use_style()
def trestle(d=0.2, t1=0.8 + 0.6j, t2=2):
lat = pb.Lattice(a1=1.3*d)
lat.add_sublattices(
('A', [0, 0], 0),
('B', [d/2, d], 0)
)
lat.add_hoppings(
(0, 'A', 'B', t1),
(1, 'A', 'B', t1.conjugate()),
(1, 'A', 'A', t2),
(1, 'B', 'B', t2)
)
return lat
lattice = trestle()
lattice.plot()
plt.show()
lattice.plot_brillouin_zone()
plt.show()
model = pb.Model(trestle(), pb.translational_symmetry())
solver = pb.solver.lapack(model)
start, end = lattice.brillouin_zone()
bands = solver.calc_bands(start, end)
bands.plot()
plt.show()
| Python |
2D | dean0x7d/pybinding | docs/examples/lattice/monolayer_graphene.py | .py | 1,445 | 61 | """Create and plot a monolayer graphene lattice, its Brillouin zone and band structure"""
import pybinding as pb
import matplotlib.pyplot as plt
from math import sqrt, pi
pb.pltutils.use_style()
def monolayer_graphene():
"""Return the lattice specification for monolayer graphene"""
a = 0.24595 # [nm] unit cell length
a_cc = 0.142 # [nm] carbon-carbon distance
t = -2.8 # [eV] nearest neighbour hopping
# create a lattice with 2 primitive vectors
lat = pb.Lattice(
a1=[a, 0],
a2=[a/2, a/2 * sqrt(3)]
)
lat.add_sublattices(
# name and position
('A', [0, -a_cc/2]),
('B', [0, a_cc/2])
)
lat.add_hoppings(
# inside the main cell
([0, 0], 'A', 'B', t),
# between neighboring cells
([1, -1], 'A', 'B', t),
([0, -1], 'A', 'B', t)
)
return lat
lattice = monolayer_graphene()
lattice.plot()
plt.show()
lattice.plot_brillouin_zone()
plt.show()
model = pb.Model(monolayer_graphene(), pb.translational_symmetry())
solver = pb.solver.lapack(model)
a_cc = 0.142
Gamma = [0, 0]
K1 = [-4*pi / (3*sqrt(3)*a_cc), 0]
M = [0, 2*pi / (3*a_cc)]
K2 = [2*pi / (3*sqrt(3)*a_cc), 2*pi / (3*a_cc)]
bands = solver.calc_bands(K1, Gamma, M, K2)
bands.plot(point_labels=['K', r'$\Gamma$', 'M', 'K'])
plt.show()
model.lattice.plot_brillouin_zone(decorate=False)
bands.plot_kpath(point_labels=['K', r'$\Gamma$', 'M', 'K'])
| Python |
2D | dean0x7d/pybinding | docs/examples/lattice/phosphorene.py | .py | 2,236 | 91 | """Create and plot a phosphorene lattice, its Brillouin zone and band structure"""
import pybinding as pb
import matplotlib.pyplot as plt
from math import pi, sin, cos
pb.pltutils.use_style()
def phosphorene_4band():
"""Monolayer phosphorene lattice using the four-band model"""
a = 0.222
ax = 0.438
ay = 0.332
theta = 96.79 * (pi / 180)
phi = 103.69 * (pi / 180)
lat = pb.Lattice(a1=[ax, 0], a2=[0, ay])
h = a * sin(phi - pi / 2)
s = 0.5 * ax - a * cos(theta / 2)
lat.add_sublattices(
('A', [-s/2, -ay/2, h], 0),
('B', [ s/2, -ay/2, 0], 0),
('C', [-s/2 + ax/2, 0, 0], 0),
('D', [ s/2 + ax/2, 0, h], 0)
)
lat.register_hopping_energies({
't1': -1.22,
't2': 3.665,
't3': -0.205,
't4': -0.105,
't5': -0.055
})
lat.add_hoppings(
# t1
([-1, 0], 'A', 'D', 't1'),
([-1, -1], 'A', 'D', 't1'),
([ 0, 0], 'B', 'C', 't1'),
([ 0, -1], 'B', 'C', 't1'),
# t2
([ 0, 0], 'A', 'B', 't2'),
([ 0, 0], 'C', 'D', 't2'),
# t3
([ 0, 0], 'A', 'D', 't3'),
([ 0, -1], 'A', 'D', 't3'),
([ 1, 1], 'C', 'B', 't3'),
([ 1, 0], 'C', 'B', 't3'),
# t4
([ 0, 0], 'A', 'C', 't4'),
([ 0, -1], 'A', 'C', 't4'),
([-1, 0], 'A', 'C', 't4'),
([-1, -1], 'A', 'C', 't4'),
([ 0, 0], 'B', 'D', 't4'),
([ 0, -1], 'B', 'D', 't4'),
([-1, 0], 'B', 'D', 't4'),
([-1, -1], 'B', 'D', 't4'),
# t5
([-1, 0], 'A', 'B', 't5'),
([-1, 0], 'C', 'D', 't5')
)
return lat
plt.figure(figsize=(6, 6))
lattice = phosphorene_4band()
lattice.plot()
plt.show()
lattice.plot_brillouin_zone()
plt.show()
model = pb.Model(phosphorene_4band(), pb.translational_symmetry())
solver = pb.solver.lapack(model)
ax = 0.438
ay = 0.332
kx = pi / ax
ky = pi / ay
bands = solver.calc_bands([kx, ky], [kx, 0], [0, 0], [0, ky], [kx, ky])
bands.plot(point_labels=["S", "Y", r"$\Gamma$", "X", "S"])
plt.show()
model.lattice.plot_brillouin_zone(decorate=False)
bands.plot_kpath(point_labels=["S", "Y", r"$\Gamma$", "X", "S"])
plt.show()
| Python |
2D | dean0x7d/pybinding | docs/examples/lattice/checkerboard.py | .py | 801 | 36 | """Two dimensional checkerboard lattice with real hoppings"""
import pybinding as pb
import matplotlib.pyplot as plt
from math import pi
pb.pltutils.use_style()
def checkerboard(d=0.2, delta=1.1, t=0.6):
lat = pb.Lattice(a1=[d, 0], a2=[0, d])
lat.add_sublattices(
('A', [0, 0], -delta),
('B', [d/2, d/2], delta)
)
lat.add_hoppings(
([ 0, 0], 'A', 'B', t),
([ 0, -1], 'A', 'B', t),
([-1, 0], 'A', 'B', t),
([-1, -1], 'A', 'B', t)
)
return lat
lattice = checkerboard()
lattice.plot()
plt.show()
lattice.plot_brillouin_zone()
plt.show()
model = pb.Model(checkerboard(), pb.translational_symmetry())
solver = pb.solver.lapack(model)
bands = solver.calc_bands([0, 0], [0, 5*pi], [5*pi, 5*pi], [0, 0])
bands.plot()
plt.show()
| Python |
2D | dean0x7d/pybinding | docs/examples/lattice/bilayer_graphene.py | .py | 1,728 | 68 | """Build the simplest model of bilayer graphene and compute its band structure"""
import pybinding as pb
import matplotlib.pyplot as plt
from math import sqrt, pi
pb.pltutils.use_style()
def bilayer_graphene():
"""Bilayer lattice in the AB-stacked form (Bernal-stacked)
This is the simplest model with just a single intralayer and a single interlayer hopping.
"""
a = 0.24595 # [nm] unit cell length
a_cc = 0.142 # [nm] carbon-carbon distance
c0 = 0.335 # [nm] interlayer spacing
lat = pb.Lattice(a1=[a/2, a/2 * sqrt(3)], a2=[a/2, -a/2 * sqrt(3)])
lat.add_sublattices(
('A1', [0, -a_cc/2, 0]),
('B1', [0, a_cc/2, 0]),
('A2', [0, a_cc/2, -c0]),
('B2', [0, 3*a_cc/2, -c0])
)
lat.register_hopping_energies({
'gamma0': -2.8, # [eV] intralayer
'gamma1': -0.4, # [eV] interlayer
})
lat.add_hoppings(
# layer 1
([ 0, 0], 'A1', 'B1', 'gamma0'),
([ 0, 1], 'A1', 'B1', 'gamma0'),
([-1, 0], 'A1', 'B1', 'gamma0'),
# layer 2
([ 0, 0], 'A2', 'B2', 'gamma0'),
([ 0, 1], 'A2', 'B2', 'gamma0'),
([-1, 0], 'A2', 'B2', 'gamma0'),
# interlayer
([ 0, 0], 'B1', 'A2', 'gamma1')
)
return lat
lattice = bilayer_graphene()
lattice.plot()
plt.show()
lattice.plot_brillouin_zone()
plt.show()
model = pb.Model(bilayer_graphene(), pb.translational_symmetry())
solver = pb.solver.lapack(model)
a_cc = 0.142
Gamma = [0, 0]
K1 = [-4*pi / (3*sqrt(3)*a_cc), 0]
M = [0, 2*pi / (3*a_cc)]
K2 = [2*pi / (3*sqrt(3)*a_cc), 2*pi / (3*a_cc)]
bands = solver.calc_bands(K1, Gamma, M, K2)
bands.plot(point_labels=['K', r'$\Gamma$', 'M', 'K'])
plt.show()
| Python |
2D | dean0x7d/pybinding | docs/examples/lattice/monolayer_graphene_nn.py | .py | 1,535 | 60 | """Monolayer graphene with next-nearest hoppings"""
import pybinding as pb
import matplotlib.pyplot as plt
from math import sqrt, pi
pb.pltutils.use_style()
def monolayer_graphene_nn():
a = 0.24595 # [nm] unit cell length
a_cc = 0.142 # [nm] carbon-carbon distance
t = -2.8 # [eV] nearest neighbour hopping
t_nn = 0.25 # [eV] next-nearest neighbour hopping
lat = pb.Lattice(
a1=[a, 0],
a2=[a/2, a/2 * sqrt(3)]
)
lat.add_sublattices(
('A', [0, -a_cc/2]),
('B', [0, a_cc/2])
)
lat.add_hoppings(
# between A and B inside the main cell
([0, 0], 'A', 'B', t),
# between neighboring cells
([1, -1], 'A', 'B', t),
([0, -1], 'A', 'B', t),
# next-nearest
([1, 0], 'A', 'A', t_nn),
([1, 0], 'B', 'B', t_nn),
([0, 1], 'A', 'A', t_nn),
([0, 1], 'B', 'B', t_nn),
([1, -1], 'A', 'A', t_nn),
([1, -1], 'B', 'B', t_nn)
)
return lat
lattice = monolayer_graphene_nn()
lattice.plot()
plt.show()
lattice.plot_brillouin_zone()
plt.show()
model = pb.Model(monolayer_graphene_nn(), pb.translational_symmetry())
solver = pb.solver.lapack(model)
a_cc = 0.142
Gamma = [0, 0]
K1 = [-4*pi / (3*sqrt(3)*a_cc), 0]
M = [0, 2*pi / (3*a_cc)]
K2 = [2*pi / (3*sqrt(3)*a_cc), 2*pi / (3*a_cc)]
# Note the elector-hole asymmetry in the band structure (due to t_nn).
bands = solver.calc_bands(K1, Gamma, M, K2)
bands.plot(point_labels=['K', r'$\Gamma$', 'M', 'K'])
plt.show()
| Python |
2D | dean0x7d/pybinding | docs/examples/finite/line.py | .py | 951 | 42 | """1D lattice chains - finite dimension are imposed using builtin `pb.line` shape"""
import pybinding as pb
import matplotlib.pyplot as plt
pb.pltutils.use_style()
def simple_chain_lattice(a=1, t=-1):
"""Very simple 1D lattice"""
lat = pb.Lattice(a)
lat.add_one_sublattice('A', [0, 0])
lat.add_one_hopping(1, 'A', 'A', t)
return lat
model = pb.Model(
simple_chain_lattice(),
pb.line(-3.5, 3.5) # line start/end in nanometers
)
model.plot()
plt.show()
def trestle(a=0.2, t1=0.8 + 0.6j, t2=2):
"""A more complicated 1D lattice with 2 sublattices"""
lat = pb.Lattice(1.3 * a)
lat.add_sublattices(
('A', [0, 0], 0),
('B', [a/2, a], 0)
)
lat.add_hoppings(
(0, 'A', 'B', t1),
(1, 'A', 'B', t1),
(1, 'A', 'A', t2),
(1, 'B', 'B', t2)
)
lat.min_neighbors = 2
return lat
model = pb.Model(trestle(), pb.line(-0.7, 0.7))
model.plot()
plt.show()
| Python |
2D | dean0x7d/pybinding | docs/examples/finite/shapes.py | .py | 632 | 32 | """Several finite-sized systems created using builtin lattices and shapes"""
import pybinding as pb
from pybinding.repository import graphene
import matplotlib.pyplot as plt
from math import pi
pb.pltutils.use_style()
model = pb.Model(
graphene.monolayer(),
pb.rectangle(x=2, y=1.2)
)
model.plot()
plt.show()
model = pb.Model(
graphene.monolayer(),
pb.regular_polygon(num_sides=6, radius=1.4, angle=pi/6)
)
model.plot()
plt.show()
# A graphene-specific shape which guaranties armchair edges on all sides
model = pb.Model(
graphene.bilayer(),
graphene.hexagon_ac(side_width=1)
)
model.plot()
plt.show()
| Python |
2D | dean0x7d/pybinding | docs/_ext/generate.py | .py | 5,931 | 156 | """Adapted from sphinx.ext.autosummary.generate
Modified to only consider module members listed in `__all__` and
only class members listed in `autodoc_allowed_special_members`.
Copyright 2007-2016 by the Sphinx team, https://github.com/sphinx-doc/sphinx/blob/master/AUTHORS
License: BSD, see https://github.com/sphinx-doc/sphinx/blob/master/LICENSE for details.
"""
import os
from jinja2 import FileSystemLoader, TemplateNotFound
from jinja2.sandbox import SandboxedEnvironment
from sphinx import package_dir
from sphinx.ext.autosummary import import_by_name, get_documenter
from sphinx.jinja2glue import BuiltinTemplateLoader
from sphinx.util.osutil import ensuredir
from sphinx.util.inspect import safe_getattr
from sphinx.ext.autosummary.generate import find_autosummary_in_files
from sphinx.util import logging
logger = logging.getLogger(__name__)
def get_members(app, obj, typ, include_public=()):
__all__ = getattr(obj, '__all__', [])
skip_all = not __all__
__all__ += include_public
items = []
for name in dir(obj):
try:
documenter = get_documenter(app, safe_getattr(obj, name), obj)
except AttributeError:
continue
if documenter.objtype == typ:
items.append(name)
public = [x for x in items if x in __all__ or skip_all and not x.startswith('_')]
# only members with docstrings are considered public
public = [x for x in public if safe_getattr(obj, x).__doc__]
return public, items
def generate_autosummary_docs(sources, app, suffix='.rst', output_dir=None,
base_path=None, builder=None, template_dir=None):
showed_sources = list(sorted(sources))
if len(showed_sources) > 20:
showed_sources = showed_sources[:10] + ['...'] + showed_sources[-10:]
logger.info('[autosummary] generating autosummary for: %s' % ', '.join(showed_sources))
if output_dir:
logger.info('[autosummary] writing to %s' % output_dir)
if base_path is not None:
sources = [os.path.join(base_path, filename) for filename in sources]
# create our own templating environment
template_dirs = [os.path.join(package_dir, 'ext', 'autosummary', 'templates')]
if builder is not None:
# allow the user to override the templates
template_loader = BuiltinTemplateLoader()
template_loader.init(builder, dirs=template_dirs)
else:
if template_dir:
template_dirs.insert(0, template_dir)
template_loader = FileSystemLoader(template_dirs)
template_env = SandboxedEnvironment(loader=template_loader)
# read
items = find_autosummary_in_files(sources)
# keep track of new files
new_files = []
# write
for name, path, template_name in sorted(set(items), key=str):
if path is None:
continue # The corresponding autosummary:: directive did not have a :toctree: option
path = output_dir or os.path.abspath(path)
ensuredir(path)
try:
name, obj, parent, mod_name = import_by_name(name)
except ImportError as e:
logger.warning('[autosummary] failed to import %r: %s' % (name, e))
continue
fn = os.path.join(path, name + suffix)
# skip it if it exists
if os.path.isfile(fn):
continue
new_files.append(fn)
with open(fn, 'w') as f:
doc = get_documenter(app, obj, parent)
if template_name is not None:
template = template_env.get_template(template_name)
else:
try:
template = template_env.get_template('autosummary/%s.rst' % doc.objtype)
except TemplateNotFound:
template = template_env.get_template('autosummary/base.rst')
ns = {}
if doc.objtype == 'module':
ns['members'] = dir(obj)
ns['functions'], ns['all_functions'] = get_members(app, obj, 'function')
ns['classes'], ns['all_classes'] = get_members(app, obj, 'class')
ns['exceptions'], ns['all_exceptions'] = get_members(app, obj, 'exception')
elif doc.objtype == 'class':
ns['members'] = dir(obj)
include_public = app.config.autodoc_allowed_special_members
ns['methods'], ns['all_methods'] = get_members(app, obj, 'method', include_public)
ns['attributes'], ns['all_attributes'] = get_members(app, obj, 'attribute')
parts = name.split('.')
if doc.objtype in ('method', 'attribute'):
mod_name = '.'.join(parts[:-2])
cls_name = parts[-2]
obj_name = '.'.join(parts[-2:])
ns['class'] = cls_name
else:
mod_name, obj_name = '.'.join(parts[:-1]), parts[-1]
ns['fullname'] = name
ns['module'] = mod_name
ns['objname'] = obj_name
ns['name'] = parts[-1]
ns['objtype'] = doc.objtype
ns['underline'] = len(name) * '='
rendered = template.render(**ns)
f.write(rendered)
# descend recursively to new files
if new_files:
generate_autosummary_docs(new_files, app, suffix=suffix, output_dir=output_dir,
base_path=base_path, builder=builder, template_dir=template_dir)
def process_generate_options(app):
genfiles = app.config.generate_from_files
if not genfiles:
return
ext = '.rst'
genfiles = [genfile + (not genfile.endswith(ext) and ext or '') for genfile in genfiles]
generate_autosummary_docs(genfiles, app, suffix=ext, builder=app.builder, base_path=app.srcdir)
def setup(app):
app.connect('builder-inited', process_generate_options)
app.add_config_value('generate_from_files', [], 'env')
return {'version': "0.1"}
| Python |
2D | dean0x7d/pybinding | docs/_ext/nbexport.py | .py | 9,303 | 289 | import os
import itertools
import posixpath
from sphinx import addnodes, roles
from docutils import nodes, writers
import nbformat
from nbconvert.preprocessors import ExecutePreprocessor
from nbconvert.preprocessors.execute import CellExecutionError
def _finilize_markdown_cells(nb):
markdown_cells = (c for c in nb.cells if c.cell_type == "markdown")
for cell in markdown_cells:
cell.source = "".join(cell.source).strip()
return nb
class NBWriter(writers.Writer):
"""Jupyter notebook writer"""
def __init__(self, app, docpath):
super().__init__()
self.app = app
self.docpath = docpath
def translate(self):
visitor = NBTranslator(self.document, self.app, self.docpath)
self.document.walkabout(visitor)
nb = _finilize_markdown_cells(visitor.nb)
if self.app.config.nbexport_execute:
ep = ExecutePreprocessor(allow_errors=True)
try:
ep.preprocess(nb, {'metadata': {}})
except CellExecutionError as e:
self.app.warn(str(e))
self.output = nbformat.writes(nb)
def _split_doctest(code):
"""Split a single doctest string into multiple code block strings"""
def is_code(x):
return x.startswith(">>>") or x.startswith("...")
groups = itertools.groupby(code.splitlines(), is_code)
raw_code_blocks = (lines for is_code, lines in groups if is_code)
code_blocks = ["\n".join(line[3:].strip() for line in lines)
for lines in raw_code_blocks]
return code_blocks
# noinspection PyPep8Naming,PyUnusedLocal,PyMethodMayBeStatic
class NBTranslator(nodes.NodeVisitor):
def __init__(self, document, app, docpath):
nodes.NodeVisitor.__init__(self, document)
self.section_level = 0
self.indent = 0
self.paragraph_prefix = ""
self.app = app
self.config = app.config
self.docpath = docpath
self.nb = nbformat.from_dict({
"cells": [],
"metadata": {},
"nbformat": nbformat.current_nbformat,
"nbformat_minor": nbformat.current_nbformat_minor
})
if self.config.nbexport_pre_code:
self.write_code(self.config.nbexport_pre_code)
def write_markdown(self, text):
if self.nb.cells[-1].cell_type != "markdown":
self.nb.cells.append(nbformat.from_dict({
"cell_type": "markdown",
"metadata": {},
"source": []
}))
self.nb.cells[-1].source.append(
text.replace("\n", "\n" + " " * self.indent)
)
def rstrip_markdown(self, chars=None):
if self.nb.cells[-1].cell_type != "markdown":
return
self.nb.cells[-1].source[-1] = self.nb.cells[-1].source[-1].rstrip(chars)
def add_codecell(self, code):
self.nb.cells.append(nbformat.from_dict({
"cell_type": "code",
"execution_count": None,
"metadata": {},
"source": code.strip(),
"outputs": []
}))
def write_code(self, code):
if ">>>" in code:
for doctest in _split_doctest(code):
self.add_codecell(doctest)
else:
self.add_codecell(code)
def visit_section(self, node):
self.section_level += 1
def depart_section(self, node):
self.section_level -= 1
def visit_title(self, node):
self.write_markdown("#" * self.section_level + " ")
def depart_title(self, node):
self.write_markdown("\n\n")
def visit_Text(self, node):
self.write_markdown(node.replace("\n", " "))
def depart_Text(self, node):
pass
def visit_list_item(self, node):
self.write_markdown("* ")
self.indent += 2
def depart_list_item(self, node):
self.indent -= 2
self.rstrip_markdown(" ")
def visit_note(self, node):
self.paragraph_prefix = "> "
def depart_note(self, node):
self.paragraph_prefix = ""
def visit_paragraph(self, node):
if self.paragraph_prefix:
self.write_markdown(self.paragraph_prefix)
def depart_paragraph(self, node):
self.write_markdown("\n\n")
def visit_reference(self, node):
self.write_markdown("[")
def depart_reference(self, node):
url = node['refuri']
if node.get('internal'):
url = posixpath.join(self.config.nbexport_baseurl, self.docpath, url)
self.write_markdown("]({})".format(url))
def visit_download_reference(self, node):
if node.hasattr('filename'):
self.write_markdown("[" + node.astext())
raise nodes.SkipChildren
def depart_download_reference(self, node):
if node.hasattr('filename'):
url = posixpath.join(self.config.nbexport_baseurl, "_downloads", node['filename'])
self.write_markdown("]({})".format(url))
def visit_literal(self, node):
self.write_markdown("`")
def depart_literal(self, node):
self.write_markdown("`")
def visit_literal_block(self, node):
dont_execute = ('highlight_args' in node and
'hl_lines' in node['highlight_args'] and
0 in node['highlight_args']['hl_lines'])
if dont_execute:
self.write_markdown("```{}\n{}\n```\n\n".format(node['language'], node.astext()))
else:
self.write_code(node.astext())
raise nodes.SkipNode
def visit_doctest_block(self, node):
self.visit_literal_block(node)
def visit_math(self, node):
self.write_markdown("${}$".format(node.astext()))
raise nodes.SkipNode
def visit_math_block(self, node):
self.write_markdown("$$\n{}\n$$\n\n".format(node.astext().strip()))
raise nodes.SkipNode
def unknown_visit(self, node):
pass
def unknown_departure(self, node):
pass
def export_notebooks(app, document, docname):
""""Export the recently resolved document to a Jupyter notebook"""
if not hasattr(app.env, 'nbfiles'):
return
if docname not in app.env.nbfiles:
return
docpath = os.path.dirname(docname)
ipynb_path = app.env.nbfiles[docname]
with open(ipynb_path, 'w', encoding='utf-8') as file:
writer = NBWriter(app, docpath)
writer.write(document, file)
def cleanup_notebooks(app, _):
"""Delete cache"""
if hasattr(app.env, 'nbfiles'):
del app.env.nbfiles
def remove_notebooks_from_deps(app, _):
"""Remove notebook files from the sphinx dependency tracker
The exported notebooks always have a later timestamp than the source document,
so they would always appear as changed files. The notebooks are rebuilt anytime
a document is updated anyway, so the dependency checking is not needed.
"""
env = app.env
if not hasattr(env, 'nbfiles'):
return
for target_docname, ipynb_path in env.nbfiles.items():
for docname, deps in env.dependencies.items():
docpath = os.path.dirname(docname)
relpath = os.path.relpath(ipynb_path, os.path.join(env.srcdir, docpath))
deppath = os.path.join(docpath, relpath)
if deppath in deps:
deps.remove(deppath)
def _make_empty_file(abspath):
absdir = os.path.dirname(abspath)
if not os.path.exists(absdir):
os.makedirs(absdir)
open(abspath, 'w').close()
class NotebookExportRole(roles.XRefRole):
"""Mark a document for export and hold a reference to the exported notebook"""
def process_link(self, env, refnode, has_explicit_title, title, target):
if target == "self":
target = "/" + env.docname
target_docname, _ = env.relfn2path(target, env.docname)
ipynb_name = target_docname + ".ipynb"
if not has_explicit_title:
title = ipynb_name
build_dir = os.path.join(os.path.dirname(env.app.doctreedir), "nbexport")
ipynb_abspath = os.path.join(build_dir, ipynb_name)
_make_empty_file(ipynb_abspath) # placeholder file so the reference can be resolved
if not hasattr(env, 'nbfiles'):
env.nbfiles = {}
env.nbfiles[target_docname] = ipynb_abspath # doc to be converted -> abs path to notebook
absdocpath = os.path.dirname(os.path.join(env.srcdir, env.docname))
ipynb_relpath = os.path.relpath(ipynb_abspath, absdocpath).replace(os.path.sep, '/')
return super().process_link(env, refnode, has_explicit_title, title, ipynb_relpath)
def result_nodes(self, document, env, node, is_ref):
node.children[0]['classes'].append("download")
return super().result_nodes(document, env, node, is_ref)
def setup(app):
app.add_role('nbexport', NotebookExportRole(nodeclass=addnodes.download_reference))
app.connect('doctree-resolved', export_notebooks)
app.connect('build-finished', cleanup_notebooks)
app.connect('doctree-read', remove_notebooks_from_deps)
app.add_config_value('nbexport_pre_code', None, 'html')
app.add_config_value('nbexport_baseurl', "", 'html')
app.add_config_value('nbexport_execute', False, 'html')
return {'version': "0.1"}
| Python |
2D | dean0x7d/pybinding | docs/advanced/kwant_example.py | .py | 5,647 | 167 | #! /usr/bin/env python3
"""Transport through a barrier
The `main()` function builds identical models in pybinding and kwant and then calculates
the transmission using `kwant.smatrix`. The results are plotted to verify that they are
identical.
The `measure_and_plot()` function compares transport calculation time for various system
sizes. Modify the `__name__ == '__main__'` section at the bottom to run this benchmark.
"""
import math
import numpy as np
import matplotlib.pyplot as plt
import kwant
import pybinding as pb
from pybinding.repository import graphene
pb.pltutils.use_style()
pb.pltutils.set_palette("Set1", start=3)
def measure_pybinding(width, length, electron_energy, barrier_heights, plot=False):
def potential_barrier(v0):
@pb.onsite_energy_modifier(is_double=True)
def function(energy, x):
energy[np.logical_and(-length / 4 <= x, x <= length / 4)] = v0
return energy
return function
def make_model(v0=0):
model = pb.Model(
graphene.monolayer().with_min_neighbors(1),
pb.rectangle(length, width),
potential_barrier(v0),
)
model.attach_lead(-1, pb.line([-length/2, -width/2], [-length/2, width/2]))
model.attach_lead(+1, pb.line([ length/2, -width/2], [ length/2, width/2]))
return model
if plot:
make_model().plot()
plt.show()
transmission = []
for v in barrier_heights:
smatrix = kwant.smatrix(make_model(v).tokwant(), energy=electron_energy)
transmission.append(smatrix.transmission(1, 0))
return transmission
def measure_kwant(width, length, electron_energy, barrier_heights, plot=False):
def make_system():
t = 2.8
a_cc = 0.142
a = a_cc * math.sqrt(3)
graphene_lattice = kwant.lattice.general([(a, 0), (a / 2, a / 2 * math.sqrt(3))],
[(0, -a_cc / 2), (0, a_cc / 2)])
def shape(pos):
x, y = pos
return -length / 2 <= x <= length / 2 and -width / 2 <= y <= width / 2
def onsite(site, v0):
x, _ = site.pos
return v0 if -length / 4 <= x <= length / 4 else 0
builder = kwant.Builder()
builder[graphene_lattice.shape(shape, (0, 0))] = onsite
builder[graphene_lattice.neighbors()] = -t
def lead_shape(pos):
x, y = pos
return -width / 2 <= y <= width / 2
lead = kwant.Builder(kwant.TranslationalSymmetry(graphene_lattice.vec((-1, 0))))
lead[graphene_lattice.shape(lead_shape, (0, 0))] = 0
lead[graphene_lattice.neighbors()] = -t
builder.attach_lead(lead)
builder.attach_lead(lead.reversed())
return builder.finalized()
system = make_system()
if plot:
kwant.plot(system)
transmission = []
for v in barrier_heights:
smatrix = kwant.smatrix(system, energy=electron_energy, args=[v])
transmission.append(smatrix.transmission(1, 0))
return transmission
def main():
"""Build the same model using pybinding and kwant and verify that the results are identical"""
width, length = 15, 15
electron_energy = 0.25
barrier_heights = np.linspace(0, 0.5, 100)
with pb.utils.timed("pybinding:"):
pb_transmission = measure_pybinding(width, length, electron_energy, barrier_heights)
with pb.utils.timed("kwant:"):
kwant_transmission = measure_kwant(width, length, electron_energy, barrier_heights)
plt.plot(barrier_heights, pb_transmission, label="pybinding")
plt.plot(barrier_heights, kwant_transmission, ls="--", label="kwant")
plt.ylabel("transmission")
plt.xlabel("barrier height (eV)")
plt.axvline(electron_energy, 0, 0.5, color="gray", ls=":")
plt.annotate("electron energy\n{} eV".format(electron_energy), (electron_energy, 0.52),
xycoords=("data", "axes fraction"), ha="center")
pb.pltutils.despine()
pb.pltutils.legend()
plt.show()
def plot_time(sizes, times, label):
plt.plot(sizes, times, label=label, marker='o', markersize=5, lw=2, zorder=10)
plt.grid(True, which='major', color='gray', ls=':', alpha=0.5)
plt.title("transmission calculation time")
plt.xlabel("system size (nm)")
plt.ylabel("compute time (seconds)")
plt.xlim(0.8 * min(sizes), 1.05 * max(sizes))
pb.pltutils.despine()
pb.pltutils.legend(loc='upper left', reverse=True)
def measure_and_plot(sizes):
"""Measure transport calculation time
The list of `sizes` specifies the dimensions of the scattering region in nanometers.
"""
electron_energy = 0.25
barrier_heights = np.linspace(0, 0.5, 100)
print("pybinding:")
pb_times = []
for size in sizes:
with pb.utils.timed() as time:
measure_pybinding(size, size, electron_energy, barrier_heights)
print(" {:7} <-> size = {} nm".format(str(time), size))
pb_times.append(time.elapsed)
print("\nkwant:")
kwant_times = []
for size in sizes:
with pb.utils.timed() as time:
measure_kwant(size, size, electron_energy, barrier_heights)
print(" {:7} <-> size = {} nm".format(str(time), size))
kwant_times.append(time.elapsed)
plt.figure(figsize=(3, 2.4))
plot_time(sizes, pb_times, label="pybinding")
plot_time(sizes, kwant_times, label="kwant")
filename = "kwant_example_results.png"
plt.savefig(filename)
print("\nDone! Results saved to file: {}".format(filename))
if __name__ == '__main__':
# measure_and_plot(sizes=[5, 10, 15, 20, 25, 30])
main()
| Python |
2D | dean0x7d/pybinding | tests/test_model.py | .py | 5,050 | 155 | import pytest
import numpy as np
import pybinding as pb
from pybinding.repository import graphene
from scipy.sparse import csr_matrix
def point_to_same_memory(a, b):
"""Check if two numpy arrays point to the same data in memory"""
return a.data == b.data
@pytest.fixture(scope='module')
def model():
return pb.Model(graphene.monolayer())
def test_api():
lattice = graphene.monolayer()
shape = pb.rectangle(1)
model = pb.Model(lattice, shape)
assert model.lattice is lattice
assert model.shape is shape
# empty sequences are no-ops
model.add(())
model.add([])
with pytest.raises(RuntimeError) as excinfo:
model.add(None)
assert "None" in str(excinfo.value)
def test_report(model):
report = model.report()
assert "2 lattice sites" in report
assert "2 non-zero values" in report
def test_hamiltonian(model):
"""Must be in the correct format and point to memory allocated in C++ (no copies)"""
h = model.hamiltonian
assert isinstance(h, csr_matrix)
assert h.dtype == np.float32
assert h.shape == (2, 2)
assert pytest.fuzzy_equal(h.data, [graphene.t] * 2)
assert pytest.fuzzy_equal(h.indices, [1, 0])
assert pytest.fuzzy_equal(h.indptr, [0, 1, 2])
assert h.data.flags['OWNDATA'] is False
assert h.data.flags['WRITEABLE'] is False
with pytest.raises(ValueError) as excinfo:
h.data += 1
assert "read-only" in str(excinfo.value)
h2 = model.hamiltonian
assert h2.data is not h.data
assert point_to_same_memory(h2.data, h.data)
def test_multiorbital_hamiltonian():
"""For multi-orbital lattices the Hamiltonian size is larger than the number of sites"""
def lattice():
lat = pb.Lattice([1])
lat.add_sublattices(("A", [0], [[1, 3j],
[0, 2]]))
lat.register_hopping_energies({
"t22": [[0, 1],
[2, 3]],
"t11": 1, # incompatible hopping - it's never used so it shouldn't raise any errors
})
lat.add_hoppings(([1], "A", "A", "t22"))
return lat
model = pb.Model(lattice(), pb.primitive(3))
h = model.hamiltonian.toarray()
assert model.system.num_sites == 3
assert h.shape[0] == 6
assert pytest.fuzzy_equal(h, h.T.conjugate())
assert pytest.fuzzy_equal(h[:2, :2], h[-2:, -2:])
assert pytest.fuzzy_equal(h[:2, :2], [[ 1, 3j],
[-3j, 2]])
assert pytest.fuzzy_equal(h[:2, 2:4], [[0, 1],
[2, 3]])
@pb.onsite_energy_modifier
def onsite(energy, x, sub_id):
return 3 * energy + sub_id.eye * 0 * x
@pb.hopping_energy_modifier
def hopping(energy):
return 2 * energy
model = pb.Model(lattice(), pb.primitive(3), onsite, hopping)
h = model.hamiltonian.toarray()
assert model.system.num_sites == 3
assert h.shape[0] == 6
assert pytest.fuzzy_equal(h, h.T.conjugate())
assert pytest.fuzzy_equal(h[:2, :2], h[-2:, -2:])
assert pytest.fuzzy_equal(h[:2, :2], [[ 3, 9j],
[-9j, 6]])
assert pytest.fuzzy_equal(h[:2, 2:4], [[0, 2],
[4, 6]])
assert pytest.fuzzy_equal(h[2:4, 4:6], [[0, 2],
[4, 6]])
def lattice_with_zero_diagonal():
lat = pb.Lattice([1])
lat.add_sublattices(("A", [0], [[0, 3j],
[0, 0]]))
return lat
model = pb.Model(lattice_with_zero_diagonal(), pb.primitive(3))
h = model.hamiltonian.toarray()
assert model.system.num_sites == 3
assert h.shape[0] == 6
assert pytest.fuzzy_equal(h, h.T.conjugate())
assert pytest.fuzzy_equal(h[:2, :2], h[-2:, -2:])
assert pytest.fuzzy_equal(h[:2, :2], [[0, 3j],
[-3j, 0]])
def test_complex_multiorbital_hamiltonian():
def checkerboard_lattice(delta, t):
lat = pb.Lattice(a1=[1, 0], a2=[0, 1])
lat.add_sublattices(('A', [0, 0], -delta),
('B', [1/2, 1/2], delta))
lat.add_hoppings(
([0, 0], 'A', 'B', t),
([0, -1], 'A', 'B', t),
([-1, 0], 'A', 'B', t),
([-1, -1], 'A', 'B', t),
)
return lat
hopp_t = np.array([[2 + 2j, 3 + 3j],
[4 + 4j, 5 + 5j]]) # multi-orbital hopping
onsite_en = np.array([[1, 1j], [-1j, 1]]) # onsite energy
model = pb.Model(checkerboard_lattice(onsite_en, hopp_t),
pb.translational_symmetry(True, True))
h = model.hamiltonian.toarray()
assert model.system.num_sites == 2
assert h.shape[0] == 4
assert pytest.fuzzy_equal(h, h.T.conjugate()) # check if Hermitian
assert pytest.fuzzy_equal(h[:2, :2], -h[-2:, -2:]) # onsite energy on A and B is opposite
assert pytest.fuzzy_equal(h[:2, 2:4], 4 * hopp_t) # hopping A <-> B is 4 * hopp_t
| Python |
2D | dean0x7d/pybinding | tests/test_kpm.py | .py | 7,527 | 198 | import pytest
import numpy as np
import pybinding as pb
from pybinding.repository import graphene, group6_tmd
models = {
'graphene-pristine': [graphene.monolayer(), pb.rectangle(15)],
'graphene-pristine-oversized': [graphene.monolayer(), pb.rectangle(20)],
'graphene-const_potential': [graphene.monolayer(), pb.rectangle(15),
pb.constant_potential(0.5)],
'graphene-magnetic_field': [graphene.monolayer(), pb.rectangle(15),
graphene.constant_magnetic_field(1e3)],
}
@pytest.fixture(scope='module', ids=list(models.keys()), params=models.values())
def model(request):
return pb.Model(*request.param)
ldos_models = {**models, "mos2": [group6_tmd.monolayer_3band("MoS2"), pb.rectangle(6)]}
@pytest.mark.parametrize("params", ldos_models.values(), ids=list(ldos_models.keys()))
def test_ldos(params, baseline, plot_if_fails):
configurations = [
{'matrix_format': "CSR", 'optimal_size': False, 'interleaved': False},
{'matrix_format': "CSR", 'optimal_size': True, 'interleaved': False},
{'matrix_format': "CSR", 'optimal_size': False, 'interleaved': True},
{'matrix_format': "ELL", 'optimal_size': True, 'interleaved': True},
]
model = pb.Model(*params)
kernel = pb.lorentz_kernel()
strategies = [pb.kpm(model, kernel=kernel, silent=True, **c) for c in configurations]
energy = np.linspace(0, 2, 25)
results = [kpm.calc_ldos(energy, broadening=0.15, position=[0, 0.07], reduce=False)
for kpm in strategies]
expected = results[0].with_data(baseline(results[0].data.astype(np.float32)))
for i in range(len(results)):
plot_if_fails(results[i], expected, 'plot', label=i)
for result in results:
assert pytest.fuzzy_equal(result, expected, rtol=1e-3, atol=1e-6)
def test_moments(model, plot_if_fails):
energy = np.linspace(0, 2, 25)
broadening = 0.15
position = dict(position=[0, 0], sublattice="A")
kpm = pb.kpm(model, silent=True)
expected_ldos = kpm.calc_ldos(energy, broadening, **position)
def manual_ldos():
idx = model.system.find_nearest(**position)
alpha = np.zeros(model.hamiltonian.shape[0])
alpha[idx] = 1
a, b = kpm.scaling_factors
num_moments = kpm.kernel.required_num_moments(broadening / a)
moments = kpm.moments(num_moments, alpha)
ns = np.arange(num_moments)
scaled_energy = (energy - b) / a
k = 2 / (a * np.pi * np.sqrt(1 - scaled_energy**2))
chebyshev = np.cos(ns * np.arccos(scaled_energy[:, np.newaxis]))
return k * np.sum(moments.real * chebyshev, axis=1)
ldos = expected_ldos.with_data(manual_ldos())
plot_if_fails(ldos, expected_ldos, "plot")
assert pytest.fuzzy_equal(ldos, expected_ldos, rtol=1e-4, atol=1e-6)
with pytest.raises(RuntimeError) as excinfo:
kpm.moments(10, [1, 2, 3])
assert "Size mismatch" in str(excinfo.value)
with pytest.raises(RuntimeError) as excinfo:
kpm = pb.kpm(pb.Model(graphene.monolayer()))
kpm.moments(10, [1j, 2j])
assert "Hamiltonian is real, but the given argument 'alpha' is complex" in str(excinfo.value)
def test_kpm_multiple_indices(model):
"""KPM can take a vector of column indices and return the Green's function for all of them"""
kpm = pb.kpm(model, silent=True)
num_sites = model.system.num_sites
i, j = num_sites // 2, num_sites // 4
energy = np.linspace(-0.3, 0.3, 10)
broadening = 0.8
cols = [j, j + 1, j + 2]
gs = kpm.calc_greens(i, cols, energy, broadening)
assert len(gs) == len(cols)
g = kpm.calc_greens(j, i, energy, broadening)
assert pytest.fuzzy_equal(gs[0], g)
def test_kpm_reuse():
"""KPM should return the same result when a single object is used for multiple calculations"""
model = pb.Model(graphene.monolayer(), graphene.hexagon_ac(10))
kpm = pb.kpm(model, silent=True)
energy = np.linspace(-5, 5, 50)
broadening = 0.1
for position in [0, 0], [6, 0]:
actual = kpm.calc_ldos(energy, broadening, position)
expected = pb.kpm(model).calc_ldos(energy, broadening, position)
assert pytest.fuzzy_equal(actual, expected, rtol=1e-3, atol=1e-6)
def test_ldos_sublattice():
"""LDOS for A and B sublattices should be antisymmetric for graphene with a mass term"""
model = pb.Model(graphene.monolayer(), graphene.hexagon_ac(10), graphene.mass_term(1))
kpm = pb.kpm(model, silent=True)
a, b = (kpm.calc_ldos(np.linspace(-5, 5, 50), 0.1, [0, 0], sub) for sub in ('A', 'B'))
assert pytest.fuzzy_equal(a.data, b.data[::-1], rtol=1e-3, atol=1e-6)
def test_optimized_hamiltonian():
"""Currently available only in internal interface"""
from pybinding import _cpp
model = pb.Model(graphene.monolayer(), graphene.hexagon_ac(10))
h = model.hamiltonian
oh = _cpp.OptimizedHamiltonian(model.raw_hamiltonian, 0)
assert oh.matrix.shape == h.shape
assert oh.sizes[-1] == h.shape[0]
assert len(oh.indices) == h.shape[0]
dos_models = {
'graphene-const_potential': [graphene.monolayer(), pb.rectangle(25),
pb.constant_potential(0.5)],
'graphene-magnetic_field': [graphene.monolayer(), pb.rectangle(25),
graphene.constant_magnetic_field(1e3)],
}
@pytest.mark.parametrize("params", dos_models.values(), ids=list(dos_models.keys()))
def test_dos(params, baseline, plot_if_fails):
configurations = [
{'matrix_format': "ELL", 'optimal_size': False, 'interleaved': False},
{'matrix_format': "ELL", 'optimal_size': True, 'interleaved': True},
]
model = pb.Model(*params)
kernel = pb.lorentz_kernel()
strategies = [pb.kpm(model, kernel=kernel, silent=True, **c) for c in configurations]
energy = np.linspace(0, 2, 25)
results = [kpm.calc_dos(energy, broadening=0.15) for kpm in strategies]
expected = results[0].with_data(baseline(results[0].data.astype(np.float32)))
for i in range(len(results)):
plot_if_fails(results[i], expected, 'plot', label=i)
for result in results:
assert pytest.fuzzy_equal(result, expected, rtol=1e-3, atol=1e-6)
cond_models = {
'graphene-const_potential': [graphene.monolayer(), pb.rectangle(20),
pb.constant_potential(0.5)],
'graphene-magnetic_field': [graphene.monolayer(), pb.rectangle(20),
graphene.constant_magnetic_field(1e3)]
}
@pytest.mark.parametrize("params", cond_models.values(), ids=list(cond_models.keys()))
def test_conductivity(params, baseline, plot_if_fails):
configurations = [
{'matrix_format': "ELL", 'optimal_size': False, 'interleaved': False},
{'matrix_format': "ELL", 'optimal_size': True, 'interleaved': True},
]
model = pb.Model(*params)
kernel = pb.lorentz_kernel()
strategies = [pb.kpm(model, energy_range=[-9, 9], kernel=kernel, silent=True, **c)
for c in configurations]
energy = np.linspace(-2, 2, 25)
results = [kpm.calc_conductivity(energy, broadening=0.5, temperature=0, num_points=200)
for kpm in strategies]
expected = results[0].with_data(baseline(results[0].data.astype(np.float32)))
for i in range(len(results)):
plot_if_fails(results[i], expected, "plot", label=i)
for result in results:
assert pytest.fuzzy_equal(result, expected, rtol=1e-2, atol=1e-5)
| Python |
2D | dean0x7d/pybinding | tests/test_system.py | .py | 3,047 | 77 | import pytest
import numpy as np
import pybinding as pb
from pybinding.repository import graphene, group6_tmd
models = {
'graphene-monolayer': [graphene.monolayer(), graphene.hexagon_ac(1)],
'graphene-monolayer-alt': [graphene.monolayer_alt(), pb.rectangle(1.6, 1.4)],
'graphene-monolayer-4atom': [graphene.monolayer_4atom()],
'graphene-monolayer-nn': [graphene.monolayer(2), pb.regular_polygon(6, 0.9)],
'graphene-monolayer-periodic-1d': [graphene.monolayer(), pb.primitive(5, 5),
pb.translational_symmetry(a1=True, a2=False)],
'graphene-monolayer-periodic-1d-alt': [graphene.monolayer_4atom(), pb.rectangle(1),
pb.translational_symmetry(a1=False, a2=0.6)],
'graphene-monolayer-periodic-2d': [graphene.monolayer(), pb.primitive(a1=5, a2=5),
pb.translational_symmetry(a1=1, a2=1)],
'graphene-monolayer-4atom-periodic-2d': [graphene.monolayer_4atom(), pb.rectangle(1),
pb.translational_symmetry(a1=0.6, a2=0.6)],
'graphene-bilayer': [graphene.bilayer(), graphene.hexagon_ac(0.6)],
}
@pytest.fixture(scope='module', ids=list(models.keys()), params=models.values())
def model(request):
return pb.Model(*request.param)
def test_pickle_round_trip(model):
import pickle
unpickled = pickle.loads(pickle.dumps(model.system))
assert pytest.fuzzy_equal(model.system, unpickled)
def test_expected(model, baseline, plot_if_fails):
system = model.system
expected = baseline(system)
plot_if_fails(system, expected, "plot")
assert pytest.fuzzy_equal(system.impl, expected.impl, 1.e-4, 1.e-6)
def test_api():
model = pb.Model(graphene.monolayer(), pb.primitive(2, 2))
system = model.system
idx = system.num_sites // 2
assert idx == system.find_nearest(system.xyz[idx])
assert idx == system.find_nearest(system.xyz[idx], 'B')
assert system.find_nearest([0, 0], 'A') != system.find_nearest([0, 0], 'B')
with pytest.raises(IndexError) as excinfo:
system.find_nearest([0, 0], 'invalid_sublattice')
assert "There is no Site named" in str(excinfo.value)
assert np.allclose(system.expanded_positions.x, system.positions.x)
s = pb.Model(group6_tmd.monolayer_3band("MoS2"), pb.primitive(2, 2)).system
assert s.expanded_positions.x.size == s.positions.x.size * 3
def test_sites():
model = pb.Model(graphene.monolayer(), pb.primitive(2, 2))
system = model.system
sites = pb.system.Sites(system.positions, system.sublattices)
idx = system.num_sites // 2
assert idx == sites.find_nearest(system.xyz[idx])
assert idx == sites.find_nearest(system.xyz[idx], system.sublattices[idx])
assert sites.find_nearest([0, 0], 'A') != sites.find_nearest([0, 0], 'B')
def test_system_plot(compare_figure):
model = pb.Model(graphene.bilayer(), graphene.hexagon_ac(0.1))
with compare_figure() as chk:
model.system.plot()
assert chk.passed
| Python |
2D | dean0x7d/pybinding | tests/test_kwant.py | .py | 4,093 | 110 | import pytest
import numpy as np
import pybinding as pb
from pybinding.support.kwant import kwant_installed
from pybinding.repository import graphene, group6_tmd
if not kwant_installed:
def test_kwant_error():
"""Raise an exception if kwant isn't installed"""
model = pb.Model(graphene.monolayer())
with pytest.raises(ImportError) as excinfo:
model.tokwant()
assert "kwant isn't installed" in str(excinfo.value)
else:
import kwant
# noinspection PyUnresolvedReferences
def make_wire_with_flat_potential(width=10, lenght=2, t=1):
def onsite(_, v):
return 4 * t - v
lattice = kwant.lattice.square(a=1)
builder = kwant.Builder()
builder[(lattice(x, y) for x in range(lenght) for y in range(width))] = onsite
builder[lattice.neighbors()] = -t
lead = kwant.Builder(kwant.TranslationalSymmetry([-1, 0]))
lead[(lattice(0, y) for y in range(width))] = 4 * t
lead[lattice.neighbors()] = -t
builder.attach_lead(lead)
builder.attach_lead(lead.reversed())
return builder.finalized()
# noinspection PyUnresolvedReferences
def calc_transmission(system, energy, v=None):
params = {'v': v} if v is not None else {}
smatrix = kwant.smatrix(system, energy, params=params)
return smatrix.transmission(1, 0)
def pb_model(v=0, length=2, width=10):
def square_lattice(d, t):
lat = pb.Lattice(a1=[d, 0], a2=[0, d])
lat.add_sublattices(("A", [0, 0], 4 * t))
lat.add_hoppings(([0, 1], "A", "A", -t),
([1, 0], "A", "A", -t))
return lat
@pb.onsite_energy_modifier
def potential_well(energy, x):
energy[np.logical_and(x >= 0, x <= 1)] -= v
return energy
model = pb.Model(square_lattice(d=1, t=1), pb.rectangle(length, width), potential_well)
model.attach_lead(-1, pb.line([0, -width / 2 - 0.1], [0, width / 2]))
model.attach_lead(+1, pb.line([0, -width / 2 - 0.1], [0, width / 2]))
return model
def test_kwant():
"""Create the same model using kwant and pybinding and solve with kwant.smatrix"""
energy = 1
vs = np.linspace(-2, 0, 5)
system = make_wire_with_flat_potential()
kwant_result = np.array([calc_transmission(system, energy, v) for v in vs])
pb_result = np.array([calc_transmission(pb_model(v).tokwant(), energy) for v in vs])
assert pytest.fuzzy_equal(pb_result, kwant_result)
@pytest.mark.parametrize("lattice, norb", [
(graphene.monolayer(), 1),
(group6_tmd.monolayer_3band("MoS2"), 3),
])
def test_hamiltonian_submatrix_orbitals(lattice, norb):
"""Return the number of orbitals at each site in addition to the Hamiltonian"""
model = pb.Model(lattice, pb.rectangle(1, 1))
kwant_sys = model.tokwant()
matrix, to_norb, from_norb = kwant_sys.hamiltonian_submatrix(sparse=True, return_norb=True)
assert matrix.shape == model.hamiltonian.shape
assert to_norb.size == model.system.num_sites
assert from_norb.size == model.system.num_sites
assert np.all(to_norb == norb)
assert np.all(from_norb == norb)
def test_hamiltonian_submatrix_sites():
"""The `to_sites` and `from_sites` arguments are not supported"""
kwant_sys = pb.Model(graphene.monolayer(), pb.rectangle(1, 1)).tokwant()
with pytest.raises(RuntimeError) as excinfo:
kwant_sys.hamiltonian_submatrix(to_sites=1, from_sites=1)
assert "not supported" in str(excinfo.value)
def test_warnings():
"""Extra arguments and ignored by pybinding -- warn users"""
kwant_sys = pb.Model(graphene.monolayer(), pb.rectangle(1, 1)).tokwant()
with pytest.warns(UserWarning):
kwant_sys.hamiltonian_submatrix(sparse=True, args=(1,))
with pytest.warns(UserWarning):
kwant_sys.hamiltonian_submatrix(sparse=True, params=dict(v=1))
| Python |
2D | dean0x7d/pybinding | tests/test_parallel.py | .py | 1,675 | 53 | import pytest
import numpy as np
import pybinding as pb
from pybinding.repository import graphene
def silence_parallel_output(factory):
factory.hooks.status.clear()
factory.config.pbar_fd = None
factory.config.filename = None
def test_sweep(baseline, plot_if_fails):
@pb.parallelize(v=np.linspace(0, 0.1, 10))
def factory(v, energy=np.linspace(0, 0.1, 10)):
model = pb.Model(
graphene.monolayer(),
graphene.hexagon_ac(side_width=15),
pb.constant_potential(v)
)
kpm = pb.kpm(model, kernel=pb.lorentz_kernel())
return kpm.deferred_ldos(energy, broadening=0.15, position=[0, 0], sublattice="B")
silence_parallel_output(factory)
labels = dict(title="test sweep", x="V (eV)", y="E (eV)", data="LDOS")
result = pb.parallel.sweep(factory, labels=labels)
expected = baseline(result)
plot_if_fails(result, expected, 'plot')
assert pytest.fuzzy_equal(result, expected, rtol=1e-3, atol=1e-6)
def test_ndsweep(baseline):
@pb.parallelize(v1=np.linspace(0, 0.1, 5), v2=np.linspace(-0.2, 0.2, 4))
def factory(v1, v2, energy=np.linspace(0, 0.1, 10)):
model = pb.Model(
graphene.monolayer(),
graphene.hexagon_ac(side_width=15),
pb.constant_potential(v1),
pb.constant_potential(v2)
)
kpm = pb.kpm(model, kernel=pb.lorentz_kernel())
return kpm.deferred_ldos(energy, broadening=0.15, position=[0, 0])
silence_parallel_output(factory)
result = pb.parallel.ndsweep(factory)
expected = baseline(result)
assert pytest.fuzzy_equal(result, expected, rtol=1e-3, atol=1e-6)
| Python |
2D | dean0x7d/pybinding | tests/test_results.py | .py | 3,741 | 118 | import pytest
import pickle
import numpy as np
import pybinding as pb
from pybinding.repository import graphene
@pytest.fixture(scope='module')
def model():
return pb.Model(graphene.monolayer(), pb.rectangle(1))
def test_sweep():
x0 = np.arange(3)
y0 = np.arange(-1, 2)
data0 = np.arange(9).reshape((3, 3))
sweep = pb.results.Sweep(
x0, y0, data0, tags=dict(b=1, c=2),
labels=dict(title="test sweep", x="$\\alpha$", y=r"$\beta$ (eV)", data=r"$\gamma$")
)
assert sweep._plain_labels == dict(title="test sweep", x="alpha", y="beta (eV)", data="gamma")
xgrid, ygrid = sweep._xy_grids()
assert np.all(xgrid == [[v] * 3 for v in x0])
assert np.all(ygrid == [y0] * 3)
tmp = sweep[np.ix_([0, 1], [1, 2])]
assert np.all(tmp.x == [[0], [1]]) and np.all(tmp.y == [0, 1])
assert np.all(tmp.data == [[1, 2], [4, 5]])
tmp = sweep.cropped(x=[0, 1])
assert np.all(tmp.x == [0, 1]) and np.all(tmp.y == sweep.y)
assert np.all(tmp.data == [[0, 1, 2], [3, 4, 5]])
tmp = sweep.cropped(y=[0, 1])
assert np.all(tmp.x == sweep.x) and np.all(tmp.y == [0, 1])
assert np.all(tmp.data == [[1, 2], [4, 5], [7, 8]])
tmp = sweep.cropped(x=[0, 1], y=[0, 1])
assert np.all(tmp.x == [0, 1]) and np.all(tmp.y == [0, 1])
assert np.all(tmp.data == [[1, 2], [4, 5]])
tmp = sweep.mirrored(axis='x')
assert np.all(tmp.x == [-2, -1, 0, 1, 2])
assert np.all(tmp.data == [[6, 7, 8], [3, 4, 5], [0, 1, 2], [3, 4, 5], [6, 7, 8]])
tmp = sweep.interpolated(mul=[2, 2])
assert tmp.x.shape[0] == 6
assert tmp.y.shape[0] == 6
assert tmp.data.shape == (6, 6)
s, x = sweep._slice_x(1.2)
assert np.all(s == [3, 4, 5]) and x == 1
s, y = sweep._slice_y(0.4)
assert np.all(s == [1, 4, 7]) and y == 0
def test_spatial_map(model):
system = model.system
zeros = np.linspace(-10, 10, system.num_sites)
spatial_map = model.structure_map(zeros).spatial_map
assert system.x.data == spatial_map.x.data
assert system.y.data == spatial_map.y.data
assert system.z.data == spatial_map.z.data
assert system.sublattices.data == spatial_map.sublattices.data
tmp = spatial_map[spatial_map.sublattices == 'A']
assert len(spatial_map.x) == 2 * len(tmp.x)
tmp = spatial_map.cropped(x=(-0.1, 0.1), y=(0, 0.1))
assert len(tmp.x) == 1
tmp = spatial_map.clipped(0, 10)
assert np.all(tmp.data >= 0)
def test_structure_map(model):
system = model.system
zeros = np.zeros_like(system.x)
spatial_map = pb.results.SpatialMap(zeros, system.positions, system.sublattices)
structure_map = system.with_data(zeros)
assert pytest.fuzzy_equal(spatial_map.data, structure_map.spatial_map.data)
assert pytest.fuzzy_equal(spatial_map.positions, structure_map.spatial_map.positions)
assert pytest.fuzzy_equal(spatial_map.sublattices, structure_map.spatial_map.sublattices)
tmp = structure_map[structure_map.x < 0.05]
assert structure_map.hoppings.nnz == 41
assert tmp.hoppings.nnz == 21
assert tmp.hoppings.tocsr().data.mapping == model.system.impl.hopping_registry.name_map
def test_structure_map_plot(compare_figure):
import matplotlib.pyplot as plt
model = pb.Model(graphene.monolayer(), pb.rectangle(0.8))
structure_map = model.structure_map(model.system.x * model.system.y)
with compare_figure() as chk:
structure_map.plot(site_radius=(0.03, 0.05))
plt.gca().set_aspect("equal", "datalim")
assert chk.passed
def test_path_pickle():
k_path = pb.make_path(0, 1, 2)
s = pickle.dumps(k_path)
loaded = pickle.loads(s)
assert np.all(k_path == loaded)
assert k_path.point_indices == loaded.point_indices
| Python |
2D | dean0x7d/pybinding | tests/__init__.py | .py | 0 | 0 | null | Python |
2D | dean0x7d/pybinding | tests/test_shape.py | .py | 3,216 | 95 | import pytest
import math
import numpy as np
import pybinding as pb
from pybinding.repository import graphene, examples
polygons = {
'triangle': pb.regular_polygon(3, radius=1.1),
'triangle90': pb.regular_polygon(3, radius=1.1, angle=math.pi/2),
'diamond': pb.regular_polygon(4, radius=1),
'square': pb.regular_polygon(4, radius=1, angle=math.pi/4),
'pentagon': pb.regular_polygon(5, radius=1),
}
@pytest.fixture(scope='module', ids=list(polygons.keys()), params=polygons.values())
def polygon(request):
return request.param
def test_polygon_expected(polygon, baseline, plot_if_fails):
model = pb.Model(graphene.monolayer(), polygon)
expected = baseline(model.system)
plot_if_fails(model.system, expected, "plot")
plot_if_fails(polygon, polygon, "plot")
assert pytest.fuzzy_equal(model.system.impl, expected.impl, 1.e-4, 1.e-6)
def test_polygon_api():
with pytest.raises(RuntimeError) as excinfo:
pb.Polygon([[0, 0], [0, 1]])
assert "at least 3 sides" in str(excinfo.value)
def test_polygon_simple(polygon):
x, y, z = [[0, 100]] * 3
assert np.all(polygon.contains(x, y, z) == [True, False])
def test_freeform(baseline, plot_if_fails):
def donut(inner_radius, outer_radius):
def contains(x, y, _):
r = np.sqrt(x**2 + y**2)
return np.logical_and(inner_radius < r, r < outer_radius)
return pb.FreeformShape(contains, width=[2 * outer_radius, 2 * outer_radius])
assert pytest.fuzzy_equal(donut(0.5, 1).vertices,
[[-1, -1, 0], [1, -1, 0], [-1, 1, 0], [1, 1, 0]] * 2)
shape = donut(0.6, 1.1)
model = pb.Model(graphene.monolayer(), shape)
expected = baseline(model.system)
plot_if_fails(model.system, expected, 'plot')
plot_if_fails(shape, shape, 'plot')
assert pytest.fuzzy_equal(model.system.impl, expected.impl, 1.e-4, 1.e-6)
def test_freeform_plot():
def sphere(radius):
def contains(x, y, z):
r = np.sqrt(x**2 + y**2 + z**2)
return r < radius
return pb.FreeformShape(contains, width=[2 * radius] * 3)
with pytest.raises(RuntimeError) as excinfo:
sphere(1).plot()
assert "only works for 2D shapes" in str(excinfo.value)
def test_line():
"""1D shape with 1D lattice"""
model = pb.Model(examples.chain_lattice(a=1), pb.line(0, 4.5))
assert model.system.num_sites == 4
model = pb.Model(examples.chain_lattice(a=1), pb.line([0, -0.5], [5, 0.5]))
assert model.system.num_sites == 6
def test_primitive():
"""The primitive shape can be positioned using the lattice origin"""
model = pb.Model(graphene.monolayer(), pb.primitive(2, 2))
assert model.system.num_sites == 8
assert np.isclose(model.system.x.min(), -1.5 * graphene.a, rtol=1e-3)
assert np.isclose(model.system.y.min(), -2 * graphene.a_cc, rtol=1e-3)
model = pb.Model(
graphene.monolayer().with_offset([0.5 * graphene.a, 0.5 * graphene.a_cc]),
pb.primitive(2, 2)
)
assert model.system.num_sites == 8
assert np.isclose(model.system.x.min(), -graphene.a, rtol=1e-3)
assert np.isclose(model.system.y.min(), -1.5 * graphene.a_cc, rtol=1e-3)
| Python |
2D | dean0x7d/pybinding | tests/test_pickle.py | .py | 915 | 43 | import pytest
import pathlib
import pybinding as pb
mock_data = list(range(10))
def round_trip(obj, file):
pb.save(obj, file)
return pb.load(file) == obj
def test_path_type(tmpdir):
# str
file = str(tmpdir / 'file')
assert round_trip(mock_data, file)
# py.path.local object
file = tmpdir / 'file'
assert round_trip(mock_data, file)
# pathlib object
file = pathlib.Path(str(tmpdir)) / 'file'
assert round_trip(mock_data, file)
# file object
file = str(tmpdir / 'file')
with open(file, 'wb') as f:
pb.save(mock_data, f)
with open(file, 'rb') as f:
assert mock_data == pb.load(f)
def test_extension(tmpdir):
file = tmpdir / 'file'
pb.save(mock_data, file)
assert mock_data == pb.load(tmpdir / 'file.pbz')
file = tmpdir / 'file.ext'
pb.save(mock_data, file)
assert mock_data == pb.load(tmpdir / 'file.ext')
| Python |
2D | dean0x7d/pybinding | tests/test_wrapper.py | .py | 525 | 20 | import numpy as np
from _pybinding import wrapper_tests
def test_variant_caster():
assert wrapper_tests.variant_cast() == (5, "Hello")
assert wrapper_tests.variant_load(1) == "int"
assert wrapper_tests.variant_load("1") == "std::string"
def test_array_ref():
r = wrapper_tests.TestArrayRef()
assert r.a.shape == (2, 2, 3)
assert r.a[0, :].shape == (2, 3)
assert r.a[0].shape == (2, 3)
assert np.all(r.a[0] == [[0, 1, 2], [3, 4, 5]])
assert np.all(r.a[1] == [[6, 7, 8], [9, 10, 11]])
| Python |
2D | dean0x7d/pybinding | tests/test_modifiers.py | .py | 23,419 | 663 | import pytest
import numpy as np
import pybinding as pb
from pybinding.repository import graphene
one, zero = np.ones(1), np.zeros(1)
complex_one = np.ones(1, dtype=np.complex64)
def build_model(*params):
model = pb.Model(graphene.monolayer(), *params)
model.report()
return model
def test_modifier_function_signature():
pb.onsite_energy_modifier(lambda energy: energy)
with pytest.raises(RuntimeError) as excinfo:
pb.onsite_energy_modifier(lambda this_is_unexpected: None)
assert "Unexpected argument" in str(excinfo.value)
with pytest.raises(RuntimeError) as excinfo:
pb.onsite_energy_modifier(lambda energy, x, y, z, w: None)
assert "Unexpected argument" in str(excinfo.value)
@pb.site_state_modifier
def global_mod(state):
return np.ones_like(state)
def test_callsig():
assert "global_mod()" == str(global_mod)
assert "global_mod()" == repr(global_mod)
@pb.site_state_modifier
def local_mod(state):
return np.ones_like(state)
assert "test_callsig()" == str(local_mod)
assert "test_callsig()" == repr(local_mod)
def wrapped_mod(a, b):
@pb.site_state_modifier
def actual_mod(state):
return np.ones_like(state) * a * b
return actual_mod
assert "wrapped_mod(a=1, b=8)" == str(wrapped_mod(1, 8))
assert "test_callsig.<locals>.wrapped_mod(a=1, b=8)" == repr(wrapped_mod(1, 8))
def test_type_errors():
"""Modifier return values should be arrays and satisfy a few dtype criteria"""
build_model(pb.onsite_energy_modifier(lambda energy: energy + 1))
with pytest.raises(TypeError) as excinfo:
build_model(pb.onsite_energy_modifier(lambda: 1))
assert "Modifiers must return ndarray(s)" in str(excinfo.value)
build_model(pb.site_position_modifier(lambda x, y, z: (x, y, z)))
with pytest.raises(TypeError) as excinfo:
build_model(pb.site_position_modifier(lambda x, y, z: (x, y)))
assert "expected to return 3 ndarray(s), but got 2" in str(excinfo.value)
with pytest.raises(TypeError) as excinfo:
build_model(pb.onsite_energy_modifier(lambda: (one, one)))
assert "expected to return 1 ndarray(s), but got 2" in str(excinfo.value)
with pytest.raises(TypeError) as excinfo:
build_model(pb.onsite_energy_modifier(lambda x: np.zeros(x.size // 2)))
assert "must return the same size" in str(excinfo.value)
def complex_ones(energy):
return np.ones_like(energy, dtype=np.complex128)
build_model(pb.hopping_energy_modifier(complex_ones))
build_model(pb.onsite_energy_modifier(complex_ones))
with pytest.raises(TypeError) as excinfo:
build_model(pb.site_position_modifier(lambda x: (np.ones_like(x, dtype=np.complex128),)*3))
assert "'complex128', but expected same kind as 'float32'" in str(excinfo.value)
def test_cast():
dtypes = [np.float32, np.float64, np.complex64, np.complex128]
@pb.hopping_energy_modifier
def float32_out(energy):
return np.ones_like(energy, dtype=np.float32)
for dtype in dtypes:
assert float32_out.apply(np.ones(1, dtype=dtype), zero, zero, zero).dtype == dtype
@pb.hopping_energy_modifier
def float64_out(energy):
return np.ones_like(energy, dtype=np.float64)
for dtype in dtypes:
assert float64_out.apply(np.ones(1, dtype=dtype), zero, zero, zero).dtype == dtype
@pb.hopping_energy_modifier
def complex64_out(energy):
return np.ones_like(energy, dtype=np.complex64)
for dtype, result in zip(dtypes, [np.complex64, np.complex64, np.complex64, np.complex128]):
assert complex64_out.apply(np.ones(1, dtype=dtype), zero, zero, zero).dtype == result
@pb.hopping_energy_modifier
def complex128_out(energy):
return np.ones_like(energy, dtype=np.complex128)
for dtype, result in zip(dtypes, [np.complex128, np.complex128, np.complex64, np.complex128]):
assert complex128_out.apply(np.ones(1, dtype=dtype), zero, zero, zero).dtype == result
def test_site_state():
@pb.site_state_modifier
def mod(state):
return np.ones_like(state)
assert np.all(mod(zero))
assert np.all(mod.apply(zero, one, one, one, one))
capture = {}
@pb.site_state_modifier
def check_args(state, x, y, z, sub_id, sites):
capture[sub_id] = [v.copy() for v in (state, x, y, z)]
capture[sub_id].append(sites.argsort_nearest([0, graphene.a_cc / 2]))
return state
def assert_state(name, **kwargs):
state, x, y, z, nearest = capture[name]
assert state.shape == kwargs["shape"]
assert pytest.fuzzy_equal(state, kwargs["state"])
assert x.shape == kwargs["shape"]
assert pytest.fuzzy_equal(x, kwargs["x"])
assert pytest.fuzzy_equal(y, kwargs["y"])
assert pytest.fuzzy_equal(z, kwargs["z"])
assert np.all(nearest == kwargs["nearest"])
model = build_model(check_args, pb.primitive(1, 2))
assert model.hamiltonian.dtype == np.float32
assert_state("A", shape=(2,), state=[True] * 2, nearest=[1, 0],
x=[-graphene.a / 2, 0], y=[-2 * graphene.a_cc, -graphene.a_cc / 2], z=[0, 0])
assert_state("B", shape=(2,), state=[True] * 2, nearest=[1, 0],
x=[-graphene.a / 2, 0], y=[-graphene.a_cc, graphene.a_cc / 2], z=[0, 0])
@pb.site_state_modifier
def remove_site(state):
state[0] = False
return state
model = build_model(remove_site, pb.primitive(2, 2))
assert model.system.num_sites == 6
@pb.site_state_modifier(min_neighbors=1)
def remove_dangling(state, sub_id):
state[sub_id == "A"] = False
return state
with pytest.raises(RuntimeError) as excinfo:
build_model(remove_dangling, pb.primitive(3, 3))
assert "0 sites" in str(excinfo.value)
def test_site_position():
@pb.site_position_modifier
def mod(x, y, z):
return x + 1, y + 1, z + 1
assert (one,) * 3 == mod(zero, zero, zero)
assert (one,) * 3 == mod.apply(zero, zero, zero, one)
capture = {}
@pb.site_position_modifier
def check_args(x, y, z, sub_id, sites):
capture[sub_id] = [v.copy() for v in (x, y, z)]
capture[sub_id].append(sites.argsort_nearest([0, graphene.a_cc / 2]))
return x, y, z
def assert_positions(name, **kwargs):
x, y, z, nearest = capture[name]
assert x.shape == kwargs["shape"]
assert y.shape == kwargs["shape"]
assert z.shape == kwargs["shape"]
assert pytest.fuzzy_equal(x, kwargs["x"])
assert pytest.fuzzy_equal(y, kwargs["y"])
assert pytest.fuzzy_equal(z, kwargs["z"])
assert np.all(nearest == kwargs["nearest"])
model = build_model(check_args, pb.primitive(1, 2))
assert model.hamiltonian.dtype == np.float32
assert_positions("A", shape=(2,), nearest=[1, 0],
x=[-graphene.a / 2, 0], y=[-2 * graphene.a_cc, -graphene.a_cc / 2], z=[0, 0])
assert_positions("B", shape=(2,), nearest=[1, 0],
x=[-graphene.a / 2, 0], y=[-graphene.a_cc, graphene.a_cc / 2], z=[0, 0])
@pb.site_position_modifier
def shift(x, y, z):
return x + 1, y + 1, z + 1
model = build_model(check_args, shift)
assert pytest.fuzzy_equal(model.system.x, [1, 1])
assert pytest.fuzzy_equal(model.system.y, [1 - graphene.a_cc / 2, 1 + graphene.a_cc / 2])
assert pytest.fuzzy_equal(model.system.z, [1, 1])
def test_onsite():
@pb.onsite_energy_modifier
def mod(energy):
return energy + 2
assert np.all(2 == mod(zero))
assert np.all(2 == mod.apply(zero, zero, zero, zero, one))
capture = {}
@pb.onsite_energy_modifier
def check_args(energy, x, y, z, sub_id, sites):
capture[sub_id] = [v.copy() for v in (energy, x, y, z)]
capture[sub_id].append(sites.argsort_nearest([0, graphene.a_cc / 2]))
return energy
model = build_model(check_args)
assert model.hamiltonian.dtype == np.float32
energy, x, y, z, nearest = capture["A"]
assert np.allclose(energy, 0)
assert np.allclose(x, 0)
assert np.allclose(y, -graphene.a_cc / 2)
assert np.allclose(z, 0)
assert np.all(nearest == [0])
energy, x, y, z, nearest = capture["B"]
assert np.allclose(energy, 0)
assert np.allclose(x, 0)
assert np.isclose(y, graphene.a_cc / 2)
assert np.allclose(z, 0)
assert np.all(nearest == [0])
@pb.onsite_energy_modifier(is_double=True)
def make_double(energy):
return energy
model = build_model(make_double)
assert model.hamiltonian.dtype == np.float64
def test_hopping_energy():
@pb.hopping_energy_modifier
def mod(energy):
return energy * 2
assert np.all(2 == mod(one))
assert np.all(2 == mod.apply(one, zero, zero, zero, zero, zero, zero, zero))
capture = {}
@pb.hopping_energy_modifier
def check_args(energy, hop_id, x1, y1, z1, x2, y2, z2):
capture[hop_id] = [v.copy() for v in (energy, x1, y1, z1, x2, y2, z2)]
return energy
model = build_model(check_args)
assert model.hamiltonian.dtype == np.float32
energy, x1, y1, z1, x2, y2, z2 = capture["t"]
assert np.allclose(energy, graphene.t)
assert np.allclose(x1, 0)
assert np.allclose(y1, -graphene.a_cc / 2)
assert np.allclose(z1, 0)
assert np.allclose(x2, 0)
assert np.allclose(y2, graphene.a_cc / 2)
assert np.allclose(z2, 0)
@pb.hopping_energy_modifier(is_double=True)
def make_double(energy):
return energy
model = build_model(make_double)
assert model.hamiltonian.dtype == np.float64
@pb.hopping_energy_modifier
def make_complex(energy):
return energy * 1j
model = build_model(make_complex)
assert model.hamiltonian.dtype == np.complex64
@pb.hopping_energy_modifier(is_double=True)
def make_complex_double(energy):
return energy * 1j
model = build_model(make_complex_double)
assert model.hamiltonian.dtype == np.complex128
def test_site_generator():
"""Generated some disordered sites"""
@pb.site_generator("New", energy=0.4)
def site_gen():
x = [10, 20, 30]
y = [1, 2, 3]
z = [0, -1, -2]
return x, y, z
model = pb.Model(graphene.monolayer(), graphene.hexagon_ac(1), site_gen)
s = model.system[model.system.x >= 10]
assert s.num_sites == 3
assert pytest.fuzzy_equal(s.x, [10, 20, 30])
assert pytest.fuzzy_equal(s.y, [1, 2, 3])
assert pytest.fuzzy_equal(s.z, [0, -1, -2])
def test_hopping_generator():
"""Generated next-nearest hoppings should produce the same result as the builtin lattice"""
from scipy.spatial import cKDTree
@pb.hopping_generator("tnn_test", energy=graphene.t_nn)
def next_nearest(x, y, z):
pos = np.stack([x, y, z], axis=1)
dmin = graphene.a * 0.95
dmax = graphene.a * 1.05
kdtree = cKDTree(pos)
coo = kdtree.sparse_distance_matrix(kdtree, dmax).tocoo()
idx = coo.data > dmin
return coo.row[idx], coo.col[idx]
@pb.onsite_energy_modifier
def onsite_offset(energy):
return energy + 3 * graphene.t_nn
model = pb.Model(graphene.monolayer(), next_nearest, onsite_offset, graphene.hexagon_ac(1))
expected = pb.Model(graphene.monolayer(2), graphene.hexagon_ac(1))
assert pytest.fuzzy_equal(model.hamiltonian, expected.hamiltonian)
@pb.hopping_generator("t_new", energy=1.0)
def bad_generator():
"""Different array lengths"""
return [0, 1, 2], [0, 1]
model = pb.Model(graphene.monolayer(), pb.primitive(3, 3), bad_generator)
with pytest.raises(RuntimeError) as excinfo:
model.eval()
assert "the number of `from` and `to` indices must be equal" in str(excinfo.value)
def test_site_and_hopping_interaction():
"""Add a new row of sites and connect them just like the rest of the lattice"""
d = 1.0
v = 1.5
t = 1.0
def square_lattice():
lat = pb.Lattice(a1=[d, 0], a2=[0, d])
lat.add_sublattices(("A", [0, 0], v))
lat.add_hoppings(([0, 1], "A", "A", t),
([1, 0], "A", "A", t))
return lat
@pb.site_generator(name="B", energy=v)
def edge_sites(system):
edge_atoms = system.count_neighbors() < 4
x, y, z = (v[edge_atoms] for v in system.positions)
top_edge_only = np.isclose(y, y.max())
x, y, z = (v[top_edge_only] for v in (x, y, z))
y += d
return x, y, z
@pb.hopping_generator(name="t_edge", energy=t)
def edge_hoppings(system, y):
new_sites = system.sub == "B"
edge_atoms = np.logical_and(system.sub != "B", system.count_neighbors() < 4)
top_edge_only = np.logical_and(edge_atoms, np.isclose(y, y[edge_atoms].max()))
return new_sites, top_edge_only
@pb.hopping_generator(name="t_edge2", energy=t)
def edge_hoppings2(system):
edge_idx = np.flatnonzero(system.sub == "B")
to_idx = edge_idx[1:]
from_idx = edge_idx[:-1]
return to_idx, from_idx
model = pb.Model(square_lattice(), pb.primitive(6, 4),
edge_sites, edge_hoppings, edge_hoppings2)
expected = pb.Model(square_lattice(), pb.primitive(6, 5))
assert pytest.fuzzy_equal(model.hamiltonian, expected.hamiltonian)
def test_wrapper_return():
"""Make sure the wrapper return type conversion is working"""
@pb.hopping_energy_modifier
def mul(energy):
"""Returning a non-contiguous view will force the wrapper to create a copy"""
energy = np.concatenate([energy, energy])
energy *= 3
return energy[::2]
lattice = pb.Lattice([1, 0])
lattice.add_sublattices(("A", [0, 0]), ("B", [0, 0]))
lattice.add_one_hopping([0], "A", "B", 1.0)
model = pb.Model(lattice, mul, pb.primitive(2))
assert pytest.fuzzy_equal(model.hamiltonian.data, [3, 3, 3, 3])
def test_invalid_return():
@pb.onsite_energy_modifier
def mod_inf(energy):
return np.ones_like(energy) * np.inf
with pytest.raises(RuntimeError) as excinfo:
build_model(mod_inf)
assert "NaN or INF" in str(excinfo.value)
@pb.onsite_energy_modifier
def mod_nan(energy):
return np.ones_like(energy) * np.NaN
with pytest.raises(RuntimeError) as excinfo:
build_model(mod_nan)
assert "NaN or INF" in str(excinfo.value)
def test_mutability():
"""Only modifier return arguments should be mutable"""
@pb.onsite_energy_modifier
def mod_energy(energy):
"""The return energy is writable"""
energy += 1
return energy
assert build_model(mod_energy)
@pb.onsite_energy_modifier
def mod_x(energy, x):
"""Arguments are read-only"""
x += 1
return energy
with pytest.raises(ValueError) as excinfo:
build_model(mod_x)
assert "read-only" in str(excinfo.value)
def test_multiorbital_onsite():
def multi_orbital_lattice():
lat = pb.Lattice([1, 0], [0, 1])
tau_z = np.array([[1, 0],
[0, -1]])
tau_x = np.array([[0, 1],
[1, 0]])
lat.add_sublattices(("A", [0, 0], tau_z + 2 * tau_x),
("B", [0, 0.1], 0.5),
("C", [0, 0.2], [1, 2, 3]))
lat.add_hoppings(([0, -1], "A", "A", 3 * tau_z),
([1, 0], "A", "A", 3 * tau_z),
([0, 0], "B", "C", [[2, 3, 4]]))
return lat
capture = {}
@pb.onsite_energy_modifier
def onsite(energy, x, y, z, sub_id):
capture[sub_id] = [v.copy() for v in (energy, x, y, z)]
return energy
def assert_positions(name, **expected):
_, x, y, z = capture[name]
assert pytest.fuzzy_equal(x.squeeze(), expected["x"])
assert pytest.fuzzy_equal(y.squeeze(), expected["y"])
assert pytest.fuzzy_equal(z.squeeze(), expected["z"])
def assert_onsite(name, **expected):
energy, *_ = capture[name]
assert energy.shape == expected["shape"]
for i in range(energy.shape[0]):
assert pytest.fuzzy_equal(energy[i], expected["energy"])
model = pb.Model(multi_orbital_lattice(), pb.rectangle(2, 1), onsite)
assert model.system.num_sites == 6
assert model.hamiltonian.shape[0] == 12
assert_positions("A", x=[0, 1], y=[0, 0], z=[0, 0])
assert_positions("B", x=[0, 1], y=[0.1, 0.1], z=[0, 0])
assert_positions("C", x=[0, 1], y=[0.2, 0.2], z=[0, 0])
assert_onsite("A", shape=(2, 2, 2), energy=[[1, 2],
[2, -1]])
assert_onsite("B", shape=(2,), energy=[0.5])
assert_onsite("C", shape=(2, 3, 3), energy=[[1, 0, 0],
[0, 2, 0],
[0, 0, 3]])
@pb.onsite_energy_modifier
def onsite_mod(energy, x, y, z, sub_id):
if sub_id == "A":
energy += sub_id.eye * (x > -1)
elif sub_id == "B":
energy *= 2
elif sub_id == "C":
energy += [[0, 1, 0]]
capture[sub_id] = [v.copy() for v in (energy, x, y, z)]
return energy
model = pb.Model(multi_orbital_lattice(), pb.rectangle(2, 1), onsite_mod)
assert model.system.num_sites == 6
assert model.hamiltonian.shape[0] == 12
assert_onsite("A", shape=(2, 2, 2), energy=[[2, 2],
[2, 0]])
assert_onsite("B", shape=(2,), energy=[1])
assert_onsite("C", shape=(2, 3, 3), energy=[[1, 1, 0],
[0, 3, 0],
[0, 1, 3]])
def test_multiorbital_hoppings():
"""For multi-orbital lattices, hopping modifiers get `energy` as 3D array"""
def multi_orbital_lattice():
lat = pb.Lattice([1, 0], [0, 1])
tau_z = np.array([[1, 0],
[0, -1]])
tau_x = np.array([[0, 1],
[1, 0]])
lat.add_sublattices(("A", [-0.25, 0.0], tau_z + 2 * tau_x),
("B", [0.0, 0.5], 0.5),
("C", [0.25, 0.0], [1, 2, 3]))
lat.register_hopping_energies({
"t11": 1,
"t1|2": 2,
"t1|3": 3,
"t22": 3 * tau_z,
"t23": [[0, 1, 2],
[3, 4, 5]],
"t13": [[11, 12, 13]],
})
lat.add_hoppings(([1, 0], "B", "B", "t11"),
([0, 1], "B", "B", "t11"),
([1, 1], "B", "B", "t1|2"),
([1, -1], "B", "B", "t1|3"),
([0, 1], "A", "A", "t22"),
([0, 0], "A", "C", "t23"),
([0, 0], "B", "C", "t13"))
return lat
capture = {}
@pb.hopping_energy_modifier
def hopping(energy, hop_id, x1, y1, z1, x2, y2, z2):
capture[hop_id] = [v.copy() for v in (energy, x1, y1, z1, x2, y2, z2)]
return energy
def assert_positions(name, **expected):
_, x1, y1, z1, x2, y2, z2 = capture[name]
assert pytest.fuzzy_equal(x1.squeeze(), expected["x1"])
assert pytest.fuzzy_equal(y1.squeeze(), expected["y1"])
assert pytest.fuzzy_equal(z1.squeeze(), expected["z1"])
assert pytest.fuzzy_equal(x2.squeeze(), expected["x2"])
assert pytest.fuzzy_equal(y2.squeeze(), expected["y2"])
assert pytest.fuzzy_equal(z1.squeeze(), expected["z2"])
def assert_hoppings(name, **expected):
energy, *_ = capture[name]
assert energy.shape == expected["shape"]
for i in range(energy.shape[0]):
assert pytest.fuzzy_equal(energy[i], expected["energy"])
model = pb.Model(multi_orbital_lattice(), pb.primitive(2, 2), hopping)
assert model.system.num_sites == 12
assert model.hamiltonian.shape[0] == 24
assert_positions("t11",
x1=[-1, -1, 0, -1], y1=[-0.5, -0.5, -0.5, 0.5], z1=[0, 0, 0, 0],
x2=[0, -1, 0, 0], y2=[-0.5, 0.5, 0.5, 0.5], z2=[0, 0, 0, 0])
assert_positions("t22",
x1=[-1.25, -0.25], y1=[-1, -1], z1=[0, 0],
x2=[-1.25, -0.25], y2=[0, 0], z2=[0, 0])
assert_positions("t23",
x1=[-1.25, -0.25, -1.25, -0.25], y1=[-1, -1, 0, 0], z1=[0, 0, 0, 0],
x2=[-0.75, 0.25, -0.75, 0.25], y2=[-1, -1, 0, 0], z2=[0, 0, 0, 0])
assert_positions("t13",
x1=[-1, 0, -1, 0], y1=[-0.5, -0.5, 0.5, 0.5], z1=[0, 0, 0, 0],
x2=[-0.75, 0.25, -0.75, 0.25], y2=[-1, -1, 0, 0], z2=[0, 0, 0, 0])
assert_hoppings("t11", shape=(4,), energy=[1])
assert_hoppings("t22", shape=(2, 2, 2), energy=[[3, 0],
[0, -3]])
assert_hoppings("t23", shape=(4, 2, 3), energy=[[0, 1, 2],
[3, 4, 5]])
assert_hoppings("t13", shape=(4, 1, 3), energy=[[11, 12, 13]])
@pb.hopping_energy_modifier
def hopping_mod(energy, hop_id, x1, y1, z1, x2, y2, z2):
if hop_id == "t11":
energy *= x1 * 0
elif hop_id == "t1":
energy *= 3
elif hop_id == "t22":
energy += [[0, 1],
[1, 0]]
elif hop_id == "t23":
energy += [[1, 0, 0]]
elif hop_id == "t13":
energy *= 2
capture[hop_id] = [v.copy() for v in (energy, x1, y1, z1, x2, y2, z2)]
return energy
model = pb.Model(multi_orbital_lattice(), pb.primitive(2, 2), hopping_mod)
assert model.system.num_sites == 12
assert model.hamiltonian.shape[0] == 24
assert_hoppings("t11", shape=(4,), energy=[0])
assert_hoppings("t1|2", shape=(1,), energy=[6])
assert_hoppings("t1|3", shape=(1,), energy=[9])
assert_hoppings("t22", shape=(2, 2, 2), energy=[[3, 1],
[1, -3]])
assert_hoppings("t23", shape=(4, 2, 3), energy=[[1, 1, 2],
[4, 4, 5]])
assert_hoppings("t13", shape=(4, 1, 3), energy=[[22, 24, 26]])
def test_hopping_buffer():
"""The energy passed to hopping modifiers is buffered, but users should not be aware of it"""
def lattice():
lat = pb.Lattice([1, 0], [0, 1])
lat.add_sublattices(("A", [0, 0], [0, 0, 0, 0]))
lat.register_hopping_energies({
"t44": [[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11],
[12, 13, 14, 15]]
})
lat.add_hoppings(([1, 0], "A", "A", "t44"),
([0, 1], "A", "A", "t44"))
return lat
capture = {}
@pb.hopping_energy_modifier
def check_buffer(energy, hop_id):
capture.setdefault(hop_id, [])
capture[hop_id] += [energy.copy()]
energy[0] = 99
return energy
model = pb.Model(lattice(), pb.primitive(3000, 2), check_buffer)
assert model.system.num_sites == 6000
assert model.hamiltonian.shape[0] == 24000
energies = capture["t44"]
assert len(energies) >= 2
assert energies[0].shape == (6250, 4, 4)
for energy in energies:
assert np.argwhere(energy == 99).size == 0
| Python |
2D | dean0x7d/pybinding | tests/test_lattice.py | .py | 11,364 | 308 | import pytest
import numpy as np
import pybinding as pb
from pybinding.repository import graphene
from pybinding.support.deprecated import LoudDeprecationWarning
lattices = {
"graphene-monolayer": graphene.monolayer(),
"graphene-monolayer-nn": graphene.monolayer(2),
"graphene-monolayer-4atom": graphene.monolayer_4atom(),
"graphene-bilayer": graphene.bilayer(),
}
@pytest.fixture(scope='module', ids=list(lattices.keys()), params=lattices.values())
def lattice(request):
return request.param
def test_pickle_round_trip(lattice):
import pickle
unpickled = pickle.loads(pickle.dumps(lattice))
assert pytest.fuzzy_equal(lattice, unpickled)
def test_expected(lattice, baseline, plot_if_fails):
expected = baseline(lattice)
plot_if_fails(lattice, expected, "plot")
assert pytest.fuzzy_equal(lattice, expected)
def test_init():
lat1d = pb.Lattice(1)
assert lat1d.ndim == 1
assert len(lat1d.vectors) == 1
assert pytest.fuzzy_equal(lat1d.vectors[0], [1, 0, 0])
lat2d = pb.Lattice([1, 0], [0, 1])
assert lat2d.ndim == 2
assert len(lat2d.vectors) == 2
assert pytest.fuzzy_equal(lat2d.vectors[0], [1, 0, 0])
assert pytest.fuzzy_equal(lat2d.vectors[1], [0, 1, 0])
lat3d = pb.Lattice([1, 0, 0], [0, 1, 0], [0, 0, 1])
assert lat3d.ndim == 3
assert len(lat3d.vectors) == 3
assert pytest.fuzzy_equal(lat3d.vectors[0], [1, 0, 0])
assert pytest.fuzzy_equal(lat3d.vectors[1], [0, 1, 0])
assert pytest.fuzzy_equal(lat3d.vectors[2], [0, 0, 1])
def test_add_sublattice(capsys):
lat = pb.Lattice(1)
assert lat.nsub == 0
lat.add_one_sublattice("A", 0.0)
assert lat.nsub == 1
lat.add_sublattices(("B", 0.1),
("C", 0.2))
assert lat.nsub == 3
subs = lat.sublattices
assert len(subs) == 3
assert all(v in subs for v in ("A", "B", "C"))
assert pytest.fuzzy_equal(subs["A"].position, [0, 0, 0])
assert subs["A"].energy == 0
assert subs["A"].unique_id == 0
assert subs["A"].alias_id == 0
assert pytest.fuzzy_equal(subs["B"].position, [0.1, 0, 0])
assert subs["B"].energy == 0
assert subs["B"].unique_id == 1
assert subs["B"].alias_id == 1
assert pytest.fuzzy_equal(subs["C"].position, [0.2, 0, 0])
assert subs["C"].energy == 0
assert subs["C"].unique_id == 2
assert subs["C"].alias_id == 2
with pytest.raises(RuntimeError) as excinfo:
lat.add_one_sublattice("", 0)
assert "Sublattice name can't be blank" in str(excinfo.value)
with pytest.raises(RuntimeError) as excinfo:
lat.add_one_sublattice("A", 0)
assert "Sublattice 'A' already exists" in str(excinfo.value)
with pytest.warns(LoudDeprecationWarning):
assert lat["A"] == "A"
capsys.readouterr()
def test_add_multiorbital_sublattice():
lat = pb.Lattice([1, 0], [0, 1])
lat.add_one_sublattice("A", [0, 0])
assert lat.nsub == 1
lat.add_one_sublattice("B", [0, 0], [1, 2, 3])
assert pytest.fuzzy_equal(lat.sublattices["B"].energy, [[1, 0, 0],
[0, 2, 0],
[0, 0, 3]])
lat.add_one_sublattice("C", [0, 0], [[1, 2, 3],
[0, 4, 5],
[0, 0, 6]])
assert pytest.fuzzy_equal(lat.sublattices["C"].energy, [[1, 2, 3],
[2, 4, 5],
[3, 5, 6]])
lat.add_one_sublattice("D", [0, 0], [[1, 2j, 3],
[0, 4, 5j],
[0, 0, 6]])
assert pytest.fuzzy_equal(lat.sublattices["D"].energy, [[ 1, 2j, 3],
[-2j, 4, 5j],
[ 3, -5j, 6]])
lat.add_one_sublattice("E", [0, 0], [[1, 2, 3],
[2, 4, 5],
[3, 5, 6]])
assert pytest.fuzzy_equal(lat.sublattices["E"].energy, [[1, 2, 3],
[2, 4, 5],
[3, 5, 6]])
assert lat.nsub == 5
with pytest.raises(RuntimeError) as excinfo:
lat.add_one_sublattice("zero-dimensional", [0, 0], [])
assert "can't be zero-dimensional" in str(excinfo.value)
with pytest.raises(RuntimeError) as excinfo:
lat.add_one_sublattice("complex onsite energy", [0, 0], [1j, 2j, 3j])
assert "must be a real vector or a square matrix" in str(excinfo.value)
with pytest.raises(RuntimeError) as excinfo:
lat.add_one_sublattice("not square", [0, 0], [[1, 2, 3],
[4, 5, 6]])
assert "must be a real vector or a square matrix" in str(excinfo.value)
with pytest.raises(RuntimeError) as excinfo:
lat.add_one_sublattice("not square", [0, 0], [[1j, 2, 3],
[ 2, 4j, 5],
[ 3, 5, 6j]])
assert "The main diagonal of the onsite hopping term must be real" in str(excinfo.value)
with pytest.raises(RuntimeError) as excinfo:
lat.add_one_sublattice("not Hermitian", [0, 0], [[1, 2, 3],
[4, 5, 6],
[7, 8, 9]])
assert "The onsite hopping matrix must be upper triangular or Hermitian" in str(excinfo.value)
def test_add_sublattice_alias(capsys):
lat = pb.Lattice([1, 0], [0, 1])
lat.add_sublattices(("A", [0.0, 0.5]),
("B", [0.5, 0.0]))
c_position = [0, 9]
lat.add_one_alias("C", "A", c_position)
assert lat.sublattices["C"].unique_id != lat.sublattices["A"].unique_id
assert lat.sublattices["C"].alias_id == lat.sublattices["A"].alias_id
model = pb.Model(lat)
c_index = model.system.find_nearest(c_position)
assert model.system.sublattices[c_index] == lat.sublattices["C"].alias_id
assert c_index in np.argwhere(model.system.sublattices == "A")
with pytest.raises(IndexError) as excinfo:
lat.add_one_alias("D", "bad_name", [0, 0])
assert "There is no sublattice named 'bad_name'" in str(excinfo.value)
with pytest.warns(LoudDeprecationWarning):
lat.add_one_sublattice("Z", c_position, alias="A")
capsys.readouterr()
def test_add_hopping(capsys):
lat = pb.Lattice([1, 0], [0, 1])
lat.add_sublattices(("A", [0.0, 0.5]),
("B", [0.5, 0.0]))
lat.add_hoppings(([0, 0], "A", "B", 1),
([1, -1], "A", "B", 1),
([0, -1], "A", "B", 2))
assert lat.nhop == 2
assert lat.hoppings["__anonymous__0"].family_id == 0
assert lat.hoppings["__anonymous__0"].energy == 1
assert lat.hoppings["__anonymous__1"].family_id == 1
assert lat.hoppings["__anonymous__1"].energy == 2
lat.add_hoppings(([0, 1], "A", "B", 1))
assert lat.nhop == 2
lat.add_hoppings(([1, 0], "A", "B", 3))
assert lat.nhop == 3
with pytest.raises(RuntimeError) as excinfo:
lat.add_one_hopping([0, 0], "A", "B", 1)
assert "hopping already exists" in str(excinfo.value)
with pytest.raises(RuntimeError) as excinfo:
lat.add_one_hopping([0, 0], "A", "A", 1)
assert "Don't define onsite energy here" in str(excinfo.value)
with pytest.raises(IndexError) as excinfo:
lat.add_one_hopping([0, 0], "C", "A", 1)
assert "There is no sublattice named 'C'" in str(excinfo.value)
lat.register_hopping_energies({
"t_nn": 0.1,
"t_nnn": 0.01
})
assert lat.nhop == 5
assert lat.hoppings["t_nn"].energy == 0.1
assert lat.hoppings["t_nnn"].energy == 0.01
lat.add_one_hopping([0, 1], "A", "A", "t_nn")
with pytest.raises(RuntimeError) as excinfo:
lat.register_hopping_energies({"": 0.0})
assert "Hopping name can't be blank" in str(excinfo.value)
with pytest.raises(RuntimeError) as excinfo:
lat.register_hopping_energies({"t_nn": 0.2})
assert "Hopping 't_nn' already exists" in str(excinfo.value)
with pytest.raises(IndexError) as excinfo:
lat.add_one_hopping((0, 1), "A", "A", "tt")
assert "There is no hopping named 'tt'" in str(excinfo.value)
with pytest.warns(LoudDeprecationWarning):
assert lat("t_nn") == "t_nn"
capsys.readouterr()
def test_add_matrix_hopping():
lat = pb.Lattice([1, 0], [0, 1])
lat.add_sublattices(("A", [0.0, 0.5]),
("B", [0.5, 0.0]))
lat.add_hoppings(([0, 0], "A", "B", 1),
([1, -1], "A", "B", 1),
([0, -1], "A", "B", 2))
assert lat.nsub == 2
assert lat.nhop == 2
lat.add_sublattices(("A2", [0, 0], [1, 2]),
("B2", [0, 0], [1, 2]),
("C3", [0, 0], [1, 2, 3]))
assert lat.nsub == 5
lat.register_hopping_energies({"t22": [[1, 2],
[3, 4]],
"t23": [[1, 2, 3],
[4, 5, 6]]})
assert lat.nhop == 4
with pytest.raises(RuntimeError) as excinfo:
lat.register_hopping_energies({"zero-dimensional": []})
assert "can't be zero-dimensional" in str(excinfo.value)
lat.add_hoppings(([0, 0], "A2", "B2", "t22"),
([1, 0], "A2", "A2", "t22"),
([0, 0], "A2", "C3", "t23"),
([1, 0], "A2", "C3", "t23"))
with pytest.raises(RuntimeError) as excinfo:
lat.add_one_hopping([0, 0], 'A2', 'A2', "t22")
assert "Don't define onsite energy here" in str(excinfo.value)
with pytest.raises(RuntimeError) as excinfo:
lat.add_one_hopping([0, 0], 'B2', 'C3', "t22")
assert "mismatch: from 'B2' (2) to 'C3' (3) with matrix 't22' (2, 2)" in str(excinfo.value)
with pytest.raises(RuntimeError) as excinfo:
lat.add_one_hopping([0, 0], 'C3', 'B2', "t23")
assert "mismatch: from 'C3' (3) to 'B2' (2) with matrix 't23' (2, 3)" in str(excinfo.value)
def test_builder():
"""Builder pattern methods"""
lattice = pb.Lattice([1, 0], [0, 1])
copy = lattice.with_offset([0, 0.5])
assert pytest.fuzzy_equal(copy.offset, [0, 0.5, 0])
assert pytest.fuzzy_equal(lattice.offset, [0, 0, 0])
copy = lattice.with_min_neighbors(5)
assert copy.min_neighbors == 5
assert lattice.min_neighbors == 1
def test_brillouin_zone():
from math import pi, sqrt
lat = pb.Lattice(a1=1)
assert pytest.fuzzy_equal(lat.brillouin_zone(), [-pi, pi])
lat = pb.Lattice(a1=[0, 1], a2=[0.5, 0.5])
assert pytest.fuzzy_equal(lat.brillouin_zone(),
[[0, -2 * pi], [2 * pi, 0], [0, 2 * pi], [-2 * pi, 0]])
# Identical lattices represented using acute and obtuse angles between primitive vectors
acute = pb.Lattice(a1=[1, 0], a2=[1/2, 1/2 * sqrt(3)])
obtuse = pb.Lattice(a1=[1/2, 1/2 * sqrt(3)], a2=[1/2, -1/2 * sqrt(3)])
assert pytest.fuzzy_equal(acute.brillouin_zone(), obtuse.brillouin_zone())
| Python |
2D | dean0x7d/pybinding | tests/test_solver.py | .py | 3,071 | 92 | import pytest
import numpy as np
import pybinding as pb
from pybinding.repository import graphene
solvers = ['arpack']
if hasattr(pb._cpp, 'FEAST'):
solvers.append('feast')
models = {
'graphene-magnetic_field': {'model': [graphene.monolayer(), pb.rectangle(6),
graphene.constant_magnetic_field(10)],
'arpack': [30],
'feast': [(-0.1, 0.1), 18]},
}
@pytest.fixture(scope='module', ids=list(models.keys()), params=models.values())
def model_ex(request):
return pb.Model(*request.param['model']), request.param
@pytest.fixture(scope='module', params=solvers)
def solver(request, model_ex):
model, solver_cfg = model_ex
make_solver = getattr(pb.solver, request.param)
solver = make_solver(model, *solver_cfg[request.param])
solver.solve()
return solver
def test_eigenvalues(solver, baseline, plot_if_fails):
eig = solver.calc_eigenvalues(map_probability_at=(0, 0))
expected = baseline(eig)
plot_if_fails(eig, expected, 'plot_heatmap')
assert pytest.fuzzy_equal(eig, expected, 2.e-2, 1.e-5)
def test_dos(solver, baseline, plot_if_fails):
energy = np.linspace(0, 0.075, 15)
result = solver.calc_dos(energy, 0.01)
expected = result.with_data(baseline(result.data))
plot_if_fails(result, expected, 'plot')
assert pytest.fuzzy_equal(result, expected, rtol=2e-2, atol=1e-5)
def test_ldos(solver, plot_if_fails):
"""Compare an LDOS sum at every position with directly calculated DOS"""
energy = np.linspace(0, 0.075, 15)
broadening = 0.01
expected = solver.calc_dos(energy, broadening)
ldos = np.stack([solver.calc_ldos(energy, broadening, position).data
for position in zip(*solver.system.positions)])
result = expected.with_data(np.sum(ldos, axis=0))
plot_if_fails(result, expected, 'plot')
assert pytest.fuzzy_equal(result, expected)
def test_spatial_ldos(solver, baseline, plot_if_fails):
ldos_map = solver.calc_spatial_ldos(energy=0.05, broadening=0.01)
x_max = solver.system.x.max()
y_max = solver.system.y.max()
ldos_map = ldos_map.cropped(x=(x_max - 1, x_max + 1), y=(y_max - 1, y_max + 1))
expected = ldos_map.with_data(baseline(ldos_map.data))
plot_if_fails(ldos_map, expected, "plot")
assert pytest.fuzzy_equal(ldos_map, expected, rtol=1e-2, atol=1e-5)
def test_lapack(baseline, plot_if_fails):
model = pb.Model(graphene.monolayer(), pb.translational_symmetry())
solver = pb.solver.lapack(model)
assert pytest.fuzzy_equal(solver.eigenvalues, [-3*abs(graphene.t), 3*abs(graphene.t)])
from math import pi, sqrt
g = [0, 0]
k1 = [-4*pi / (3*sqrt(3) * graphene.a_cc), 0]
m = [0, 2*pi / (3 * graphene.a_cc)]
k2 = [2*pi / (3*sqrt(3) * graphene.a_cc), 2*pi / (3 * graphene.a_cc)]
bands = solver.calc_bands(k1, g, m, k2, step=3)
expected = baseline(bands)
plot_if_fails(bands, expected, 'plot')
assert pytest.fuzzy_equal(bands, expected, 2.e-2, 1.e-6)
| Python |
2D | dean0x7d/pybinding | tests/test_leads.py | .py | 3,665 | 107 | import pytest
import numpy as np
import pybinding as pb
from pybinding.repository import graphene, examples
@pytest.fixture
def ring_model():
def ring(inner_radius, outer_radius):
def contains(x, y, _):
r = np.sqrt(x**2 + y**2)
return np.logical_and(inner_radius < r, r < outer_radius)
return pb.FreeformShape(contains, width=[2 * outer_radius, 2 * outer_radius])
return pb.Model(graphene.monolayer(), ring(3, 5))
def square_model(width=2, height=3):
def square_lattice(d=1, t=1):
lat = pb.Lattice(a1=[d, 0], a2=[0, d])
lat.add_sublattices(('A', [0, 0]))
lat.add_hoppings(
([0, 1], 'A', 'A', -t),
([1, 0], 'A', 'A', -t),
)
return lat
return pb.Model(square_lattice(), pb.rectangle(width, height))
def linear_onsite(k=1):
@pb.onsite_energy_modifier
def onsite(x):
return k * x
return onsite
def linear_hopping(k=1):
@pb.hopping_energy_modifier
def hopping(x1, x2):
return 0.5 * k * (x1 + x2)
return hopping
def test_api(ring_model):
with pytest.raises(RuntimeError) as excinfo:
ring_model.attach_lead(0, pb.line(0, 0))
assert "Lead direction must be one of" in str(excinfo.value)
for direction in [3, -3]:
with pytest.raises(RuntimeError) as excinfo:
ring_model.attach_lead(direction, pb.line(0, 0))
assert "not valid for a 2D lattice" in str(excinfo.value)
with pytest.raises(RuntimeError) as excinfo:
pb.Model(examples.chain_lattice()).attach_lead(2, pb.line(0, 0))
assert "Attaching leads to 1D lattices is not supported" in str(excinfo.value)
def test_partial_miss(ring_model):
with pytest.raises(RuntimeError) as excinfo:
ring_model.attach_lead(2, pb.line([0, -5], [5, -5]))
assert ring_model.system
assert "partially misses main structure" in str(excinfo.value)
def test_complete_miss(ring_model):
with pytest.raises(RuntimeError) as excinfo:
ring_model.attach_lead(2, pb.line([4, -5], [5, -5]))
assert ring_model.system
assert "completely misses main structure" in str(excinfo.value)
def test_empty(ring_model):
with pytest.raises(RuntimeError) as excinfo:
ring_model.attach_lead(2, pb.line(0, 0))
assert ring_model.system
assert "no sites in lead junction" in str(excinfo.value)
def test_attach():
"""Attach 2 leads to a square lattice system"""
w, h = 2, 3
model = square_model(w, h)
model.attach_lead(-1, pb.line([0, -h/2], [0, h/2]))
model.attach_lead(+1, pb.line([0, -h/2], [0, h/2]))
assert len(model.leads) == 2
assert np.all(model.leads[0].indices == [0, 2, 4])
assert np.all(model.leads[1].indices == [1, 3, 5])
# Linear hopping grows from lead 0 to system to lead 1
model.add(linear_hopping())
assert model.leads[0].h1.data.max() < model.hamiltonian.data.min()
assert model.hamiltonian.data.max() < model.leads[1].h1.data.min()
# With the linear hopping modifier, the h1 hoppings should be equal to the
# x position between the lead and main system
x_mid_0 = (model.system.x.min() + model.leads[0].system.x.max()) / 2
assert np.allclose(model.leads[0].h1.data, x_mid_0)
x_mid_1 = (model.system.x.max() + model.leads[1].system.x.min()) / 2
assert np.allclose(model.leads[1].h1.data, x_mid_1)
# Linear onsite potential grows from lead 0 to system to lead 1
model.add(linear_onsite())
assert model.leads[0].h0.diagonal().max() < model.hamiltonian.diagonal().min()
assert model.hamiltonian.diagonal().max() < model.leads[1].h0.diagonal().min()
| Python |
2D | dean0x7d/pybinding | tests/conftest.py | .py | 3,408 | 109 | import pytest
from contextlib import suppress
import matplotlib as mpl
mpl.use('Agg') # disable `plt.show()` popup window during testing
import matplotlib.pyplot as plt
import pybinding as pb
from .utils.path import path_from_fixture
from .utils.compare_figures import CompareFigure
from .utils.fuzzy_equal import FuzzyEqual
def pytest_configure():
pytest.fuzzy_equal = FuzzyEqual
def pytest_addoption(parser):
parser.addoption("--alwaysplot", action="store_true",
help="Plot even for tests which pass.")
parser.addoption("--failpath", action="store", default="failed",
help="Where to put failure plots. Relative to tests dir or absolute path.")
parser.addoption("--savebaseline", action="store_true",
help="Save a new baseline for all tests.")
parser.addoption("--readonly", action="store_true",
help="Don't save new baseline data.")
@pytest.hookimpl(hookwrapper=True)
def pytest_runtest_makereport(item):
"""Allows fixtures to access test reports
Adds test reports `rep_setup`, `rep_call`, `rep_teardown` to `request.node`.
Required by the `plot_if_fails` fixture to determine if a test failed.
"""
outcome = yield
report = outcome.get_result()
setattr(item, "rep_" + report.when, report)
return report
@pytest.fixture
def baseline(request):
"""Return baseline data for this result. If non exist create it."""
def get_expected(result, group=''):
file = path_from_fixture(request, prefix='baseline_data', ext='.pbz',
override_group=group)
if not request.config.getoption("--savebaseline") and file.exists():
return pb.load(file)
elif not request.config.getoption("--readonly"):
if not file.parent.exists():
file.parent.mkdir(parents=True)
pb.save(result, file)
return result
else:
raise RuntimeError("Missing baseline data: {}".format(file))
return get_expected
@pytest.fixture
def compare_figure(request):
"""Compare a figure to a baseline image"""
return CompareFigure(request)
@pytest.yield_fixture
def plot_if_fails(request):
"""This fixture will plot the actual and expected data if the test fails"""
class Gather:
def __init__(self):
self.data = []
def __call__(self, result, expected, method, *args, **kwargs):
self.data.append(locals().copy())
def plot(self, what):
for d in self.data:
getattr(d[what], d['method'])(*d['args'], **d['kwargs'])
plt.title(what)
pb.pltutils.legend()
gather = Gather()
yield gather
prefix = request.config.getoption("--failpath")
figure_path = path_from_fixture(request, prefix, ext='.png')
if request.config.getoption("--alwaysplot") or request.node.rep_call.failed:
plt.figure(figsize=(6, 3))
plt.subplot(121)
gather.plot('result')
plt.subplot(122)
gather.plot('expected')
if not figure_path.parent.exists():
figure_path.parent.mkdir(parents=True)
plt.savefig(str(figure_path))
plt.close()
elif figure_path.exists():
# test passed -> delete old fail figure file
with suppress(OSError):
figure_path.unlink()
| Python |
2D | dean0x7d/pybinding | tests/utils/fuzzy_equal.py | .py | 5,396 | 160 | import math
import numbers
from functools import singledispatch, update_wrapper
import numpy as np
from scipy.sparse import csr_matrix, coo_matrix
import pybinding as pb
def _assertdispatch(func):
"""Adapted `@singledispatch` for custom assertions
* Works with methods instead of functions
* Keeps track of the data structure via context stack
* Detects objects which can be used with `pb.save` and `pb.load`
"""
dispatcher = singledispatch(func)
def wrapper(self, actual, expected, context=None):
if context is not None:
self.stack.append(context)
is_pb_savable = any(hasattr(actual, s) for s in ['__getstate__', '__getinitargs__'])
kind = type(pb.save) if is_pb_savable else actual.__class__
dispatcher.dispatch(kind)(self, actual, expected)
if context is not None and self.stack:
self.stack.pop()
wrapper.register = dispatcher.register
update_wrapper(wrapper, func)
return wrapper
def _assert_fuzzy_equal(actual, expected, rtol, atol):
"""Explains failed fuzzy_equal asserts
For example:
actual = array([3, 1, 7, 2, 9])
expected = array([3, 5, 7, 4, 6])
> assert pytest.fuzzy_equal(actual, expected)
E AssertionError:
E
E Failed on 3 of 5 values: 60%
E actual: [1, 2, 9]
E expected: [5, 4, 6]
E indices: [1, 3, 4]
"""
if len(actual) != 0 and not isinstance(actual[0], numbers.Number):
raise TypeError("`_assert_fuzzy_equal` only works on arrays of numbers")
actual, expected = map(np.asanyarray, (actual, expected))
if actual.shape != expected.shape:
raise AssertionError("\n".join([
"\nFailed on shape mismatch",
"actual: {}".format(actual.shape),
"expected: {}".format(expected.shape),
]))
isclose = np.isclose(actual, expected, rtol, atol)
if np.all(isclose):
return
notclose = np.logical_not(isclose)
num_failed = np.sum(notclose)
if len(notclose) > 10:
a = actual[notclose]
b = expected[notclose]
else:
a, b = actual, expected
raise AssertionError("\n".join([
"\nFailed on {} of {} values: {:.0%}".format(num_failed, actual.size,
num_failed / actual.size),
" actual: {}".format(a),
" expected: {}".format(b),
" indices: {}".format([idx[0] if idx.size == 1 else list(idx)
for idx in np.argwhere(notclose)]),
" abs diff: {}".format(abs(a - b)),
" rel diff: {}".format(abs(a - b) / abs(b)),
]))
class FuzzyEqual:
"""Recursively compares structures of ndarrays using np.isclose() comparison
The `stack` attribute shows the structure depth at a given assert.
"""
def __init__(self, actual, expected, rtol=1e-05, atol=1e-08):
self.actual = actual
self.expected = expected
self.rtol = rtol
self.atol = atol
self.decimal = -math.frexp(rtol)[1]
self.stack = []
def __bool__(self):
# noinspection PyUnusedLocal
__tracebackhide__ = True # hide traceback for pytest
try:
self._assert(self.actual, self.expected)
except AssertionError as e:
msg = str(e)
else:
return True
if self.stack:
msg = ''.join(self.stack) + "\n" + msg
raise AssertionError(msg.strip())
def __repr__(self):
return ''.join(self.stack)
@_assertdispatch
def _assert(self, actual, expected):
if hasattr(actual, "__dict__"):
return self._assert(actual.__dict__, expected.__dict__)
else:
try:
return np.testing.assert_almost_equal(actual, expected, self.decimal)
except TypeError:
pass
return np.testing.assert_equal(actual, expected)
@_assert.register(csr_matrix)
def _(self, actual, expected):
for s in ['shape', 'data', 'indices', 'indptr']:
self._assert(getattr(actual, s), getattr(expected, s), context=".{}".format(s))
@_assert.register(coo_matrix)
def _(self, actual, expected):
for s in ['shape', 'data', 'row', 'col']:
self._assert(getattr(actual, s), getattr(expected, s), context=".{}".format(s))
@_assert.register(tuple)
@_assert.register(list)
@_assert.register(np.ndarray)
def _(self, actual, expected):
try:
return _assert_fuzzy_equal(actual, expected, rtol=self.rtol, atol=self.atol)
except TypeError:
pass
# Fallback for non-numeric lists and tuples
assert len(actual) == len(expected)
for index, (a, b) in enumerate(zip(actual, expected)):
self._assert(a, b, context="[{}]".format(index))
@_assert.register(dict)
def _(self, actual, expected):
assert sorted(actual) == sorted(expected)
for key in actual:
self._assert(actual[key], expected[key], context="['{}']".format(key))
@_assert.register(type(pb.save))
def _(self, actual, expected):
specials = [s for s in ['__getstate__', '__getinitargs__'] if hasattr(actual, s)]
for s in specials:
self._assert(getattr(actual, s)(), getattr(expected, s)(), context="{}()".format(s))
| Python |
2D | dean0x7d/pybinding | tests/utils/__init__.py | .py | 0 | 0 | null | Python |
2D | dean0x7d/pybinding | tests/utils/compare_figures.py | .py | 4,392 | 130 | import os
import shutil
import tempfile
import warnings
from contextlib import suppress
import matplotlib as mpl
import matplotlib.style
import matplotlib.units
import matplotlib.pyplot as plt
from matplotlib.testing.compare import compare_images
import pybinding.pltutils as pltutils
from .path import path_from_fixture
def _remove_text(figure):
from matplotlib import ticker
figure.suptitle("")
for ax in figure.get_axes():
ax.set_title("")
ax.set_xlabel("")
ax.set_ylabel("")
ax.xaxis.set_major_formatter(ticker.NullFormatter())
ax.xaxis.set_minor_formatter(ticker.NullFormatter())
ax.yaxis.set_major_formatter(ticker.NullFormatter())
ax.yaxis.set_minor_formatter(ticker.NullFormatter())
with suppress(AttributeError):
ax.zaxis.set_major_formatter(ticker.NullFormatter())
ax.zaxis.set_minor_formatter(ticker.NullFormatter())
class CompareFigure:
def __init__(self, request):
self.request = request
self.passed = False
self._original_rc = {}
self._original_units_registry = {}
def __call__(self, ext='.png', tol=10, remove_text=True, savefig_kwargs=None):
self.ext = ext
self.tol = tol
self.remove_text = remove_text
self.savefig_kwargs = savefig_kwargs or {}
return self
def _enter_style(self, style=pltutils.pb_style):
self._original_rc = mpl.rcParams.copy()
self._original_units_registry = matplotlib.units.registry.copy()
with warnings.catch_warnings():
warnings.simplefilter("ignore", matplotlib.MatplotlibDeprecationWarning)
matplotlib.style.use(style)
mpl.use('Agg')
def _exit_style(self):
with warnings.catch_warnings():
warnings.simplefilter("ignore", matplotlib.MatplotlibDeprecationWarning)
mpl.rcParams.clear()
mpl.rcParams.update(self._original_rc)
matplotlib.units.registry.clear()
matplotlib.units.registry.update(self._original_units_registry)
def __enter__(self):
self._enter_style()
self.fig = plt.figure()
return self
def __exit__(self, exception, *_):
if exception:
return
if self.remove_text:
_remove_text(self.fig)
with tempfile.TemporaryDirectory() as tmpdir:
actual_file = path_from_fixture(self.request, prefix=tmpdir, ext=self.ext)
actual_filename = str(actual_file)
if not actual_file.parent.exists():
actual_file.parent.mkdir(parents=True)
plt.savefig(actual_filename, **self.savefig_kwargs)
baseline = path_from_fixture(self.request, prefix='baseline_plots', ext=self.ext)
baseline_filename = str(baseline)
if baseline.exists():
try:
data = compare_images(baseline_filename, actual_filename,
self.tol, in_decorator=True)
except ValueError as exc:
if 'could not be broadcast' not in str(exc):
raise
else:
data = dict(actual=actual_filename, expected=baseline_filename)
self.passed = data is None
self.report(data)
else:
shutil.copyfile(actual_filename, baseline_filename)
self.passed = True
plt.close()
self._exit_style()
def report(self, fail_data):
def reportfile(variant):
path = path_from_fixture(self.request, prefix="failed", variant=variant, ext=self.ext)
if not path.parent.exists():
path.parent.mkdir(parents=True)
return str(path)
def delete(variant):
filename = reportfile(variant)
if os.path.exists(filename):
with suppress(OSError):
os.remove(filename)
if fail_data:
shutil.copyfile(fail_data['actual'], reportfile("_actual"))
shutil.copyfile(fail_data['expected'], reportfile("_baseline"))
if 'diff' in fail_data:
shutil.copyfile(fail_data['diff'], reportfile("_diff"))
else:
delete("_actual")
delete("_baseline")
delete("_diff")
| Python |
2D | dean0x7d/pybinding | tests/utils/path.py | .py | 1,192 | 37 | import pathlib
def path_from_fixture(request, prefix, variant='', ext='', override_group=''):
"""Use a fixture's `request` argument to create a unique file path
The final return path will look like:
prefix/module_name/test_name[fixture_param]variant.ext
Parameters
----------
request
Pytest fixture argument.
prefix : str
Path prefix. If a relative path is given it's assumed to be inside the tests dir.
variant : str, optional
Appended to the path just before the suffix.
ext : str, optional
File name extension
override_group : str, optional
'test_name[fixture_param]' -> 'override_group[fixture_param]'
Returns
-------
pathlib.Path
"""
test_dir = pathlib.Path(str(request.fspath.join('..')))
module_name = request.module.__name__.split('.')[-1].replace('test_', '')
name = request.node.name.replace('test_', '') + variant
if override_group:
# 'test_name[fixture_param]' -> 'override_name[fixture_param]'
part = name.partition('[')
name = override_group + part[1] + part[2]
return (test_dir / prefix / module_name / name).with_suffix(ext)
| Python |
2D | AbbasHub/Improved_Phase-Field_LBM_2D | Improved_phase-field_Periodic_2D.f90 | .f90 | 12,048 | 486 | !****************************************************************
!
! Improved conservative phase-field LBM solver
! for two-phase flows in a periodic domain (2D)
!
!----------------------------------------------------------------
! Based on the following paper:
!
! A. Fakhari, T. Mitchell, C. Leonardi, and D. Bolster,
! "Improved locality of the phase-field lattice-Boltzmann model
! for immiscible fluids at high density ratios",
! Physical Review E 96, 053301 (2017)
!----------------------------------------------------------------
!
! written by Abbas Fakhari 10/30/2016
! 03/23/2017: updated
! 10/18/2018: minor updates
!
!****************************************************************
MODULE SHARE
IMPLICIT NONE
INTEGER :: t, X, Y
INTEGER,PARAMETER :: L0 = 128
INTEGER,PARAMETER :: tf = 10000
INTEGER,PARAMETER :: step = tf/10
INTEGER,PARAMETER :: Nx = L0
INTEGER,PARAMETER :: Ny = L0
INTEGER,PARAMETER :: X0 = L0/2 + 1
INTEGER,PARAMETER :: Y0 = L0/2 + 1
INTEGER,PARAMETER :: ex(0:8) = [0, 1, 0,-1, 0, 1,-1,-1, 1]
INTEGER,PARAMETER :: ey(0:8) = [0, 0, 1, 0,-1, 1, 1,-1,-1]
REAL(8),PARAMETER :: Wa(0:8) = [16,4, 4, 4, 4, 1, 1, 1, 1] / 36.d0
REAL(8),PARAMETER :: R = L0/8.d0
REAL(8),PARAMETER :: Rhol = 0.001d0
REAL(8),PARAMETER :: Rhoh = 1
REAL(8),PARAMETER :: dRho3 = (Rhoh - Rhol)/3
REAL(8),PARAMETER :: Sigma = 0.01d0
REAL(8),PARAMETER :: tau = 0.3d0 + 0.5d0
REAL(8),PARAMETER :: s8 = 1.d0/tau
REAL(8),PARAMETER :: W = 4
REAL(8),PARAMETER :: Beta = 12.d0 * Sigma/W
REAL(8),PARAMETER :: k = 1.5d0 * Sigma*W
REAL(8),PARAMETER :: M = 0.02d0
REAL(8),PARAMETER :: w_c = 1.d0/(0.5d0 + 3.d0*M)
REAL(8) :: h(0:8,0:Nx+1,0:Ny+1), g(0:8,0:Nx+1,0:Ny+1)
REAL(8) :: Gamma(0:8), Ga_Wa(0:8), heq(0:8), geq(0:8), hlp(0:8), eF(0:8)
REAL(8) :: C(0:Nx+1,0:Ny+1), P(Nx,Ny), mu(Nx,Ny), DcDx(Nx,Ny), DcDy(Nx,Ny)
REAL(8) :: Rho(Nx,Ny), Ux(Nx,Ny), Uy(Nx,Ny), ni(Nx,Ny), nj(Nx,Ny)
REAL(8) :: tmp, Ri, Fx, Fy
END MODULE SHARE
!**********************************************************************
PROGRAM Conservative_PhaseField_Periodic_2D
USE SHARE
IMPLICIT NONE
CALL Initialize_distributions
OPEN (1, file = 'LBM.out')
WRITE(1,*) 'Variables = X, Y, Ux, Uy, C, P'
!=========================================================================================
PRINT '(/A/)', ' tf Sigma W M R tau s8 Rhol Rhoh L0'
PRINT '(I6,F8.4,F7.1,2F8.3,4F7.3,I7)', tf, Sigma, W, M, R, tau, s8, Rhol, Rhoh, L0
PRINT '(/A6,5A12,A12/)', 't', 'C_min', 'C_max', 'Ux_max', 'Uy_max', '|U_max|', 'Mass_C'
!=========================================================================================
DO t = 0, tf
IF( ISNAN(C(2,2)) )THEN
PRINT '(/A,I5/)', '!!! THE PROGRAM DIVERGED AT t =', t
STOP
ELSEIF( MOD(t,step)==0 )THEN
CALL RESULTS_Output
PRINT '(I7,2F12.6,3E12.3,F11.2)', t, MINVAL(C), MAXVAL(C), MAXVAL(ABS(Ux)), MAXVAL(ABS(Uy)), DSQRT( MAXVAL(Ux**2+Uy**2) ), SUM(C(1:Nx,1:Ny))
END IF
CALL Improved_PhaseField_h_g
END DO
CALL CPU_TIME( tmp )
PRINT '(/A)',' *****************************************'
PRINT '(A,F12.1)', ' Time Elapsed:', tmp
PRINT '( A)',' *****************************************'
END
!**********************************************************************
SUBROUTINE Initialize_distributions
USE SHARE
IMPLICIT NONE
P = 0
Ux = 0
Uy = 0
DO Y = 0, Ny+1 !!1, Ny
DO X = 0, Nx+1 !!1, Nx
Ri = DSQRT( (X-(X0-0.5d0))**2.d0 + (Y-(Y0-0.5d0))**2.d0 )
! C(X,Y) = 0.5d0 + 0.5d0 * TANH(2*(R-Ri)/W) !drop
C(X,Y) = 0.5d0 - 0.5d0 * TANH(2*(R-Ri)/W) !bubble
END DO
END DO
!! CALL Boundary_Conditions_C( C )
CALL Chemical_Potential
CALL Isotropic_Gradient( C, DcDx, DcDy )
CALL normal_FD
DO Y = 1, Ny
DO X = 1, Nx
Rho(X,Y) = Rhol + C(X,Y) * (Rhoh - Rhol)
! P(X,Y) = P(X,Y) + C(X,Y) * Sigma/R /(Rho(X,Y)/3) !in 2D (drop)
P(X,Y) = P(X,Y) - C(X,Y) * Sigma/R /(Rho(X,Y)/3) !in 2D (bubble)
CALL Equilibrium_new( Ux(X,Y), Uy(X,Y) )
Gamma(:) = Ga_Wa(:) + Wa(:)
!******************* heq
eF(:) = ( 1.d0 - 4.d0*(C(X,Y)-0.5d0)**2.d0 )/W * ( ex(:)*ni(X,Y) + ey(:)*nj(X,Y) )
hlp(:) = Wa(:) * eF(:)
h(:, X,Y) = C(X,Y)*Gamma(:) - 0.5d0 * hlp(:)
!******************* geq
g(:, X,Y) = P(X,Y) * Wa(:) + Ga_Wa(:)
END DO
END DO
END
!**********************************************************************
SUBROUTINE Equilibrium_new( U, V )
USE SHARE, ONLY: ex, ey, Wa, Ga_Wa
IMPLICIT NONE
REAL(8), INTENT(IN) :: U, V
REAL(8) :: U2, eU(0:8)
U2 = U*U + V*V
eU(:) = ex(:) * U + ey(:) * V
Ga_Wa(:) = Wa(:) * ( eU(:)*(3.d0 + 4.5d0*eU(:)) - 1.5d0*U2 )
END
!**********************************************************************
SUBROUTINE Improved_PhaseField_h_g
USE SHARE, ONLY: h, g
IMPLICIT NONE
CALL Collision_h_g
CALL Boundary_Conditions_f( h )
CALL Boundary_Conditions_f( g )
CALL Streaming( h )
CALL Streaming( g )
CALL Macroscopic_Properties_h
CALL Macroscopic_Properties_g
END
!**********************************************************************
SUBROUTINE Collision_h_g
USE SHARE
IMPLICIT NONE
REAL(8) :: FpX, FpY, Fmx, FmY
!! CALL Boundary_Conditions_C( C ) !no need (already called)
!! CALL Isotropic_Gradient( C, DcDx, DcDy ) !no need (already called)
CALL normal_FD
DO Y = 1, Ny
DO X = 1, Nx
CALL Equilibrium_new( Ux(X,Y), Uy(X,Y) )
Gamma(:) = Ga_Wa(:) + Wa(:)
!******************* COLLISION (h)
eF(:) = ( 1.d0 - 4.d0*(C(X,Y)-0.5d0)**2.d0 )/W * ( ex(:)*ni(X,Y) + ey(:)*nj(X,Y) )
hlp(:) = Wa(:) * eF(:)
heq(:) = C(X,Y)*Gamma(:) - 0.5d0 * hlp(:)
h(:, X,Y) = h(:, X,Y) * (1.d0-w_c) + heq(:) * w_c + hlp(:)
!******************* COLLISION (g) ******************
!******************* calculate the forcing terms
FpX = - P(X,Y) * dRho3 * DcDx(X,Y)
FpY = - P(X,Y) * dRho3 * DcDy(X,Y)
geq(:) = P(X,Y) * Wa(:) + Ga_Wa(:)
CALL Calculate_Viscous_Force( tau, DcDx(X,Y), DcDy(X,Y), g(:,X,Y)-geq(:), FmX, FmY )
Fx = mu(X,Y) * DcDx(X,Y) + FpX + FmX
Fy = mu(X,Y) * DcDy(X,Y) + FpY + FmY
eF(:) = ex(:) * Fx + ey(:) * Fy
hlp(:) = 3.d0 * Wa(:) * eF(:) / Rho(X,Y)
geq(:) = P(X,Y) * Wa(:) + Ga_Wa(:) - 0.5d0 * hlp(:)
g(:, X,Y) = g(:, X,Y) * (1-s8) + geq(:) * s8 + hlp(:)
END DO
END DO
END
!**********************************************************************
SUBROUTINE Boundary_Conditions_f( f )
USE SHARE, ONLY: Nx, Ny
IMPLICIT NONE
REAL(8), INTENT(INOUT) :: f(0:8, 0:Nx+1,0:Ny+1)
!-- left and right boundaries
f(:, 0 ,:) = f(:, Nx,:) !periodic
f(:, Nx+1,:) = f(:, 1 ,:) !periodic
!-- bottom and top boundaries
f(:, :, 0 ) = f(:, :,Ny) !periodic
f(:, :,Ny+1) = f(:, :,1 ) !periodic
END
!**********************************************************************
SUBROUTINE Boundary_Conditions_C( A )
USE SHARE, ONLY: Nx, Ny
IMPLICIT NONE
REAL(8),INTENT(INOUT) :: A(0:Nx+1,0:Ny+1)
CALL PeriodicXY_C( A )
END
!**********************************************************************
SUBROUTINE PeriodicXY_C( A )
USE SHARE, ONLY: Nx, Ny
IMPLICIT NONE
REAL(8),INTENT(INOUT):: A(0:Nx+1,0:Ny+1)
!-- bottom and top boundaries
A(:, 0 ) = A(:,Ny ) ! periodic
A(:,Ny+1) = A(:, 1 ) ! periodic
!-- left and right boundaries
A( 0 ,:) = A(Nx ,:) ! periodic
A(Nx+1,:) = A( 1 ,:) ! periodic
END
!**********************************************************************
SUBROUTINE Streaming( f )
USE SHARE, ONLY: X, Y, Nx, Ny, ex, ey
IMPLICIT NONE
REAL(8), INTENT(INOUT) :: f(0:8, 0:Nx+1,0:Ny+1)
INTEGER :: I
REAL(8) :: fnew(8,Nx,Ny)
DO Y=1,Ny
DO X=1,Nx
DO I = 1, 8
fnew(I,X,Y) = f(I,X-ex(I),Y-ey(I))
END DO
END DO
END DO
f(1:8,1:Nx,1:Ny) = fnew
END
!**********************************************************************
SUBROUTINE Macroscopic_Properties_h
USE SHARE
IMPLICIT NONE
C(1:Nx,1:Ny) = SUM( h(:, 1:Nx,1:Ny), 1 )
Rho = Rhol + C(1:Nx,1:Ny) * (Rhoh - Rhol)
END
!**********************************************************************
SUBROUTINE Macroscopic_Properties_g
USE SHARE
IMPLICIT NONE
REAL(8) :: FpX, FpY, Fmx, FmY
CALL Boundary_Conditions_C( C )
CALL Chemical_Potential
CALL Isotropic_Gradient( C, DcDx, DcDy )
DO Y = 1, Ny
DO X = 1, Nx
P(X,Y) = SUM( g(:, X,Y) )
FpX = - P(X,Y) * dRho3 * DcDx(X,Y)
FpY = - P(X,Y) * dRho3 * DcDy(X,Y)
CALL Equilibrium_new( Ux(X,Y), Uy(X,Y) )
geq(:) = P(X,Y) * Wa(:) + Ga_Wa(:)
CALL Calculate_Viscous_Force( tau, DcDx(X,Y), DcDy(X,Y), g(:,X,Y)-geq(:), FmX, FmY )
Fx = mu(X,Y) * DcDx(X,Y) + FpX + FmX
Fy = mu(X,Y) * DcDy(X,Y) + FpY + FmY
Ux(X,Y) = g(1,X,Y)-g(3,X,Y)+g(5,X,Y)-g(6,X,Y)-g(7,X,Y)+g(8,X,Y) + 0.5d0*Fx/Rho(X,Y)
Uy(X,Y) = g(2,X,Y)-g(4,X,Y)+g(5,X,Y)+g(6,X,Y)-g(7,X,Y)-g(8,X,Y) + 0.5d0*Fy/Rho(X,Y)
END DO
END DO
END
!**********************************************************************
SUBROUTINE Chemical_Potential
USE SHARE, ONLY: X, Y, Nx, Ny, Beta, k, C, mu
IMPLICIT NONE
REAL(8) :: D2C
DO Y = 1, Ny
DO X = 1, Nx
D2C = ( C(X-1,Y-1)+C(X+1,Y-1)+C(X-1,Y+1)+C(X+1,Y+1) &
+4*(C(X ,Y-1)+C(X-1,Y )+C(X+1,Y )+C(X ,Y+1)) - 20*C(X,Y) )/6
mu(X,Y) = 4*Beta * C(X,Y) * (C(X,Y)-1.d0) * (C(X,Y)-0.5d0) - k*D2C
END DO
END DO
END
!**********************************************************************
SUBROUTINE normal_FD
USE SHARE, ONLY: X, Y, Nx, Ny, C, DcDx, DcDy, tmp, ni, nj
IMPLICIT NONE
DO Y = 1, Ny
DO X = 1, Nx
tmp = DSQRT( DcDx(X,Y)**2 + DcDy(X,Y)**2 + 1.d-32 )
ni(X,Y) = DcDx(X,Y) / tmp
nj(X,Y) = DcDy(X,Y) / tmp
END DO
END DO
END
!**********************************************************************
SUBROUTINE Isotropic_Gradient( C, DcDx, DcDy )
USE SHARE, ONLY: X, Y, Nx, Ny
IMPLICIT NONE
REAL(8),INTENT(IN) :: C(0:Nx+1,0:Ny+1)
REAL(8),INTENT(OUT):: DcDx(Nx,Ny), DcDy(Nx,Ny)
DO Y = 1, Ny
DO X = 1, Nx
DcDx(X,Y) = (C(X+1,Y ) - C(X-1,Y ))/3 + ( C(X+1,Y-1) + C(X+1,Y+1) - C(X-1,Y-1) - C(X-1,Y+1))/12
DcDy(X,Y) = (C(X ,Y+1) - C(X ,Y-1))/3 + ( C(X-1,Y+1) + C(X+1,Y+1) - C(X-1,Y-1) - C(X+1,Y-1))/12
END DO
END DO
END
!**********************************************************************
SUBROUTINE Calculate_Viscous_Force( tau, DcDx, DcDy, gneq, FmX, FmY )
IMPLICIT NONE
REAL(8),INTENT(IN) :: tau, DcDx, DcDy, gneq(0:8)
REAL(8),INTENT(OUT) :: FmX, FmY
CALL Calculate_Viscous_Force_BGK( tau, DcDx, DcDy, gneq, FmX, FmY )
END
!**********************************************************************
SUBROUTINE Calculate_Viscous_Force_BGK( tau, DcDx, DcDy, gneq, FmX, FmY )
USE SHARE, ONLY: Rhoh, Rhol
IMPLICIT NONE
REAL(8),INTENT(IN) :: tau, DcDx, DcDy, gneq(0:8)
REAL(8),INTENT(OUT) :: FmX, FmY
REAL(8) :: sxx, sxy, syy
CALL Calculate_Stress_Tensor_BGK( gneq(1:), sxx, sxy, syy )
FmX = (0.5d0-tau)/tau * (sxx*DcDx+sxy*DcDy) * (Rhoh-Rhol)
FmY = (0.5d0-tau)/tau * (sxy*DcDx+syy*DcDy) * (Rhoh-Rhol)
END
!**********************************************************************
SUBROUTINE Calculate_Stress_Tensor_BGK( gneq, sxx, sxy, syy )
USE SHARE, ONLY: ex, ey
IMPLICIT NONE
REAL(8),INTENT(IN) :: gneq(1:8)
REAL(8),INTENT(OUT):: sxx, sxy, syy
sxx = SUM( gneq(1:) * ex(1:) * ex(1:) )
sxy = SUM( gneq(1:) * ex(1:) * ey(1:) )
syy = SUM( gneq(1:) * ey(1:) * ey(1:) )
END
!**********************************************************************
SUBROUTINE RESULTS_Output
USE SHARE, ONLY: X, Y, Nx, Ny, Ux, Uy, C, T, L0, P, Rho
IMPLICIT NONE
WRITE(1,*) 'Zone T = "', T, '" F=Point, I=', Nx, ', J=', Ny
DO Y = 1, Ny
DO X = 1, Nx
WRITE(1,'(2F8.3,4E14.6)') (X-0.5d0)/L0, (Y-0.5d0)/L0, Ux(X,Y), Uy(X,Y), C(X,Y)-0.5d0, P(X,Y)*Rho(X,Y)/3
END DO
END DO
END
| Fortran |
2D | cheminfo/nmrium | CHANGELOG.md | .md | 187,750 | 1,835 | # Changelog
## [1.10.1](https://github.com/cheminfo/nmrium/compare/v1.10.0...v1.10.1) (2025-12-12)
### Bug Fixes
* display molecule when no active tab ([bc903f7](https://github.com/cheminfo/nmrium/commit/bc903f77a5fbc35b0a52d6fb5c7d48781d62c301))
## [1.10.0](https://github.com/cheminfo/nmrium/compare/v1.9.0...v1.10.0) (2025-12-11)
### Features
* improve ium integration ([#3881](https://github.com/cheminfo/nmrium/issues/3881)) ([42fbc5f](https://github.com/cheminfo/nmrium/commit/42fbc5f6dfa4bea5446557f646ee466dc8b49ee8))
* improving and simplifying the 1D assignment ([#3835](https://github.com/cheminfo/nmrium/issues/3835)) ([9f724fd](https://github.com/cheminfo/nmrium/commit/9f724fdbe138447b88d8157d7501c2cb5292acd1))
* migrate form to tanstack & zod ([#3810](https://github.com/cheminfo/nmrium/issues/3810)) ([89bad18](https://github.com/cheminfo/nmrium/commit/89bad1820c1d08ab70411bd8c37a5a84e134d8e6))
### Bug Fixes
* check that a spectrum is selected and it is 1D before the range cut ([b641b4f](https://github.com/cheminfo/nmrium/commit/b641b4faa7ede11d3e99cf2517419ea73b5dd8ff))
* clear assignments associated with selected molecule atoms ([#3851](https://github.com/cheminfo/nmrium/issues/3851)) ([20fa63b](https://github.com/cheminfo/nmrium/commit/20fa63bad33b78fe4b0ebc74202f7ad6d4d8c3bc))
* correct rendering of 1D traces over the 2D ([#3870](https://github.com/cheminfo/nmrium/issues/3870)) ([a6098c8](https://github.com/cheminfo/nmrium/commit/a6098c8a43b8f8f45790267c31e7b8a955b585b2))
* do not emit unhandled rejection in clipboard reads ([#3853](https://github.com/cheminfo/nmrium/issues/3853)) ([1c2151d](https://github.com/cheminfo/nmrium/commit/1c2151d1a319867d9d9bef9a3e13f110c6f402a3))
* filter temp data handling ([ce669ce](https://github.com/cheminfo/nmrium/commit/ce669ceab61d6e5eb53b68270daab83c1489c78a))
* improve zone detection typings ([#3871](https://github.com/cheminfo/nmrium/issues/3871)) ([a774e68](https://github.com/cheminfo/nmrium/commit/a774e68d4343429b40e21ed6aa5c83e07d0bedbe))
* keep an even number of rows when the acquisition is incomplete ([#3882](https://github.com/cheminfo/nmrium/issues/3882)) ([e865067](https://github.com/cheminfo/nmrium/commit/e865067245a806dca3e86cd14266822a997752fb))
* prevent zone tool from activating on 1D traces ([c1d1df9](https://github.com/cheminfo/nmrium/commit/c1d1df9e2811795a189be1ce3e667667ca4c6fdb))
* remove use of `any` in 1D components and brush tracker ([e25d653](https://github.com/cheminfo/nmrium/commit/e25d653251fce36b7eecf4ec64e9630d298b076e))
* remove use of `any` in 2D components ([c3f777a](https://github.com/cheminfo/nmrium/commit/c3f777a0b429968fcb2c3d7433b1a870cfec6b73))
* render peak edition above annotations ([c114785](https://github.com/cheminfo/nmrium/commit/c1147851e1e0f8a8472e655f2e187f483b63a4f6))
* reset current workspace after removing the active workspace ([9c038f0](https://github.com/cheminfo/nmrium/commit/9c038f09a50f172ba8aa5e8d5dedb9a70c95eb61))
* simplify handling of active spectrum, better checks, improve types ([#3862](https://github.com/cheminfo/nmrium/issues/3862)) ([e00b30b](https://github.com/cheminfo/nmrium/commit/e00b30b78b5cfb48283e7c11f85657f6b39c54c0))
* update the mol locally in prediction panel on load ([#3860](https://github.com/cheminfo/nmrium/issues/3860)) ([4830a0d](https://github.com/cheminfo/nmrium/commit/4830a0d53d40d0de5f0b5b66c62fa6d7966b1eda))
## [1.9.0](https://github.com/cheminfo/nmrium/compare/v1.8.0...v1.9.0) (2025-11-25)
### Features
* add more custom info for resurrected spectrum from database ([b291c7b](https://github.com/cheminfo/nmrium/commit/b291c7bc0ef2f6cad2bde2dc8dd5d04a7fbd8b72)), closes [#3827](https://github.com/cheminfo/nmrium/issues/3827)
* display the information related to a database entry ([376033a](https://github.com/cheminfo/nmrium/commit/376033a475579b378fe629649e82952d3d0445e5)), closes [#3828](https://github.com/cheminfo/nmrium/issues/3828)
* flatten custom info object when resurrecting spectrum from the database ([01b9ee2](https://github.com/cheminfo/nmrium/commit/01b9ee2b9f8cf5761be5f8d8ebfdf2f9ce8bebf8)), closes [#3826](https://github.com/cheminfo/nmrium/issues/3826)
* improve multiple spectra integration tooltip ([1cc2752](https://github.com/cheminfo/nmrium/commit/1cc2752fede35976857cc79950e8404da2c1812c)), closes [#3840](https://github.com/cheminfo/nmrium/issues/3840)
### Bug Fixes
* increase the J max value for multiplet analysis ([#3837](https://github.com/cheminfo/nmrium/issues/3837)) ([abc8cb4](https://github.com/cheminfo/nmrium/commit/abc8cb4b75d895968d7796db905ae7112ccf5c7f))
* return empty array when active spectra nuclei are not defined ([a919e45](https://github.com/cheminfo/nmrium/commit/a919e45546cbc9047a3edb43781f7489e884e22f))
* validate parse smiles/molfile ([#3850](https://github.com/cheminfo/nmrium/issues/3850)) ([479de38](https://github.com/cheminfo/nmrium/commit/479de38d8ec9cdbd3a63a44675e866dbd3394a8a))
## [1.8.0](https://github.com/cheminfo/nmrium/compare/v1.7.0...v1.8.0) (2025-11-19)
### Features
* adapt to flat nmrium archive structure ([#3811](https://github.com/cheminfo/nmrium/issues/3811)) ([fb978cd](https://github.com/cheminfo/nmrium/commit/fb978cd83a0f9299f13737cfcf4eb0427d5b46e7))
* assign range assignment label from atom custom label ([#3820](https://github.com/cheminfo/nmrium/issues/3820)) ([13c5554](https://github.com/cheminfo/nmrium/commit/13c55540fa33c2677d627eba83b9d3d43198aea9))
* clear molecule custom atom labels ([940d434](https://github.com/cheminfo/nmrium/commit/940d434429c1620875958c9733c73286051bc0d4))
* improve molecule view options ([#3800](https://github.com/cheminfo/nmrium/issues/3800)) ([444ec94](https://github.com/cheminfo/nmrium/commit/444ec94d25f453179431d3064788c6bc8ce114b4))
### Bug Fixes
* add missing 1D and 2D tools to general and workspace settings ([87adaa5](https://github.com/cheminfo/nmrium/commit/87adaa549fd7642492e017605e3336bfd7d7b89d))
* assign heavy atoms correctly ([7b522b3](https://github.com/cheminfo/nmrium/commit/7b522b31d2748a0db951e67f68eef37ebd13ae49))
* improve peak picking in ranges ([d6f35ef](https://github.com/cheminfo/nmrium/commit/d6f35efad86a94df56084085719505807e5be1be))
* prevent 'space' key from triggering other focused elements ([#3830](https://github.com/cheminfo/nmrium/issues/3830)) ([0281885](https://github.com/cheminfo/nmrium/commit/028188504f8b251331f2afc83280d698048e6784))
* show/hide customs label over floating molecule ([5a299e2](https://github.com/cheminfo/nmrium/commit/5a299e24683670f37078d197e214715f18762b14))
## [1.7.0](https://github.com/cheminfo/nmrium/compare/v1.6.1...v1.7.0) (2025-10-31)
### Features
* add more signal kinds ([#3782](https://github.com/cheminfo/nmrium/issues/3782)) ([f282586](https://github.com/cheminfo/nmrium/commit/f2825863e07b0ac0e6f0392e44ba214f7fe3eede))
* copy DB meta information to customInfo ([2fafb02](https://github.com/cheminfo/nmrium/commit/2fafb029c88b00963331fb9b6ab01a7b582f5bb1))
* dim non-signal elements (peaks and integrals) ([502f854](https://github.com/cheminfo/nmrium/commit/502f854fa3295d5bd57206da042ea9ebd8108462)), closes [#3795](https://github.com/cheminfo/nmrium/issues/3795)
* display 2D Y-axis unit label ([6b9286c](https://github.com/cheminfo/nmrium/commit/6b9286c540dcd2dfe50ecc094b53ca5d7cbdf472)), closes [#3712](https://github.com/cheminfo/nmrium/issues/3712)
* hide C if custom labels and atom is a carbon ([466a5f1](https://github.com/cheminfo/nmrium/commit/466a5f1da75137adcd335dec72d507d89d3eeb0b))
* support experimental nmrium archive file format ([#3733](https://github.com/cheminfo/nmrium/issues/3733)) ([2c33f81](https://github.com/cheminfo/nmrium/commit/2c33f81e5f0f4880c65691e5e3d00d5cd22492d3))
### Bug Fixes
* assign traces in 2d ([#3777](https://github.com/cheminfo/nmrium/issues/3777)) ([5fdb708](https://github.com/cheminfo/nmrium/commit/5fdb708bfec09112160dde751b00729e9d67394c))
* auto ranges picking pass the number of protons as integrationsum if the molecule exists. ([a842b08](https://github.com/cheminfo/nmrium/commit/a842b083fb536dc4114c14381187b4cb7f5b12b1))
* **auto-processing:** correct handling of sine bell (SSB) parameter in Bruker format ([#3750](https://github.com/cheminfo/nmrium/issues/3750)) ([2657985](https://github.com/cheminfo/nmrium/commit/2657985ae436932b5d8e6e82daa68ccd2b52310e))
* correct highlighting of assigned 1D ranges ([576f30d](https://github.com/cheminfo/nmrium/commit/576f30da88c03913151e53a03568b90db76d78a5)), closes [#3788](https://github.com/cheminfo/nmrium/issues/3788)
* correctly position multiplicity tree in stack mode ([6d21b89](https://github.com/cheminfo/nmrium/commit/6d21b8907e8e422d4ae14dd5ed58fd3a33a60ab4)), closes [#3779](https://github.com/cheminfo/nmrium/issues/3779)
* multiple call to `readNMRiumObject` into `NMRiumStateProvider` ([#3790](https://github.com/cheminfo/nmrium/issues/3790)) ([e8823b8](https://github.com/cheminfo/nmrium/commit/e8823b8236857e5ac7c72164f633aa556dbdabc5))
* property of structures in DB is ocl and not oclid ([084bbae](https://github.com/cheminfo/nmrium/commit/084bbaeddadcabc4c55380487009199e5d8c1fa8))
* put correct extension for `.tsv`, `.svg` and `.png` ([#3793](https://github.com/cheminfo/nmrium/issues/3793)) ([b03dd45](https://github.com/cheminfo/nmrium/commit/b03dd453864bc1bdca8c0767d5a356d7358ddd0e))
* remove explicit URL validations ([0321238](https://github.com/cheminfo/nmrium/commit/0321238806ad2e807a8f83c282345d7c6a10d5cb))
* rollback spectrum before reapplying shift in 2D ([25cf896](https://github.com/cheminfo/nmrium/commit/25cf896652555e295e4c490f2c20343646f338a2)), closes [#3785](https://github.com/cheminfo/nmrium/issues/3785)
## [1.6.1](https://github.com/cheminfo/nmrium/compare/v1.6.0...v1.6.1) (2025-10-16)
### Bug Fixes
* only suppress solvent for 13C ([#3766](https://github.com/cheminfo/nmrium/issues/3766)) ([38dda06](https://github.com/cheminfo/nmrium/commit/38dda065b3ecf6cc2aa6cfb809b1a59845495da4))
## [1.6.0](https://github.com/cheminfo/nmrium/compare/v1.5.0...v1.6.0) (2025-10-14)
### Features
* carbon solvent labelling ([#3693](https://github.com/cheminfo/nmrium/issues/3693)) ([720722b](https://github.com/cheminfo/nmrium/commit/720722bedbf7d4a79aee2a8499b2615991a5bc85))
### Bug Fixes
* use package wrapper for native ESM support in pdnd ([#3756](https://github.com/cheminfo/nmrium/issues/3756)) ([de0fabf](https://github.com/cheminfo/nmrium/commit/de0fabf845814f428ffe3885ca7470315297fa85))
## [1.5.0](https://github.com/cheminfo/nmrium/compare/v1.4.0...v1.5.0) (2025-10-12)
### Features
* hide labels of overlapping peaks ([402c832](https://github.com/cheminfo/nmrium/commit/402c832688c94b539b8c5055d160a4ab648954c1))
* improve peaks overlap detection ([402c832](https://github.com/cheminfo/nmrium/commit/402c832688c94b539b8c5055d160a4ab648954c1))
* show integrals by default only for 1H spectra ([ab4a1d3](https://github.com/cheminfo/nmrium/commit/ab4a1d3602209c8fbdb6da726347db7a710b98e6)), closes [#3739](https://github.com/cheminfo/nmrium/issues/3739)
* show peaks by default only for carbon spectra ([d6e7617](https://github.com/cheminfo/nmrium/commit/d6e7617fdba2ff34b3eab3ce311cf741f6f6370e))
### Bug Fixes
* correctly assign and highlight homoNuclear nuclei ([5ccecde](https://github.com/cheminfo/nmrium/commit/5ccecde3ab31b2a59e9fcbf9dba277b92d0c9baf)), closes [#3738](https://github.com/cheminfo/nmrium/issues/3738)
## [1.4.0](https://github.com/cheminfo/nmrium/compare/v1.3.0...v1.4.0) (2025-10-09)
### Features
* add yellow highlight to assigned 2D signals ([c39c27b](https://github.com/cheminfo/nmrium/commit/c39c27bd55d5498f6c7046665d4a475ad08d511e)), closes [#3718](https://github.com/cheminfo/nmrium/issues/3718)
* CT exports with alias atoms ([e777d01](https://github.com/cheminfo/nmrium/commit/e777d017d90fae940d96f8b385aacf1cd7c15a96))
* improve export publication string options ([#3677](https://github.com/cheminfo/nmrium/issues/3677)) ([8f134c5](https://github.com/cheminfo/nmrium/commit/8f134c58e793a46221a76e7351c2ec0055ebb93b))
* position the ranges assignment popup near the cursor ([fcd2015](https://github.com/cheminfo/nmrium/commit/fcd2015712e9232e338896c54064cdc791e6c099))
### Bug Fixes
* clear structure query should reset hexagon icon state ([e916fec](https://github.com/cheminfo/nmrium/commit/e916fec3a6db0db7a9aefb80e1e1bf5a6a255e5b))
* correctly assign both x and y axes in 2D ([76fdc89](https://github.com/cheminfo/nmrium/commit/76fdc89131c980f18fbb904642e9934a5ca5eb7a))
* correctly position zone assignment popup ([ce43d72](https://github.com/cheminfo/nmrium/commit/ce43d723835eac5d2e661c2ea5ba656452626423))
* debounce and set peak picking minMaxRatio default to 0.01 ([1a454e5](https://github.com/cheminfo/nmrium/commit/1a454e5ffb144e92c1ded8f4cd188e113551f2e1))
* only render dialog contents styles with fallback ([#3746](https://github.com/cheminfo/nmrium/issues/3746)) ([df969c6](https://github.com/cheminfo/nmrium/commit/df969c608c3671c3978e5ad820692d16a63dd2e0))
* prevent duplicate entries in export and import menus ([a9ddcfc](https://github.com/cheminfo/nmrium/commit/a9ddcfc6e652e605e1d4c5e3e93a596b8d25688b)), closes [#3715](https://github.com/cheminfo/nmrium/issues/3715)
* recalculate ranges integrations when sum changes ([97a1387](https://github.com/cheminfo/nmrium/commit/97a1387ac281af9c995ebbff135d7e034f9f5ab7))
* revert auto peak-picking threshold to 0.05 ([#3747](https://github.com/cheminfo/nmrium/issues/3747)) ([3aca81e](https://github.com/cheminfo/nmrium/commit/3aca81edda93df64bec36b50d25e989a05d5c52f))
## [1.3.0](https://github.com/cheminfo/nmrium/compare/v1.2.1...v1.3.0) (2025-09-02)
### Features
* **slot:** support `topbar.about_us.modal` slot with fallback ([#3676](https://github.com/cheminfo/nmrium/issues/3676)) ([80562a3](https://github.com/cheminfo/nmrium/commit/80562a3f7b239dfe00c6fb0088bbdba90bbdca09))
* support custom label edition on atom ([#3668](https://github.com/cheminfo/nmrium/issues/3668)) ([04e5ff7](https://github.com/cheminfo/nmrium/commit/04e5ff7cf15afbdf73faf280ec81d2871c4965a0))
### Bug Fixes
* add missing 'nbPoints' property to simulated spectrum ([#3630](https://github.com/cheminfo/nmrium/issues/3630)) ([60c6686](https://github.com/cheminfo/nmrium/commit/60c6686c426d921b94218cc1e8df91740a68d0f5))
* display FFT second dimension after applying first dimension ([74f1947](https://github.com/cheminfo/nmrium/commit/74f194769855b5c9e8eb11fa7f642aad1853a0cb))
* prevent adding molecule when molfile is corrupted ([33508e2](https://github.com/cheminfo/nmrium/commit/33508e273ca4e11e9374da4d6d6eb83eb4333a36))
* prevent domain refresh when selecting Ft spectra ([b22e25c](https://github.com/cheminfo/nmrium/commit/b22e25c47f99cdcacb9c4f854d569015b8e7af0e))
* support exporting floating molecules as SVG ([a647599](https://github.com/cheminfo/nmrium/commit/a647599aa7cd3ede59f1881b73bee77cba7f162a))
* use selector for ReactRnd bounds ([ac0f511](https://github.com/cheminfo/nmrium/commit/ac0f51113f4755b1446fb062cd05fb6f18a5911a)), closes [#3669](https://github.com/cheminfo/nmrium/issues/3669)
## [1.2.1](https://github.com/cheminfo/nmrium/compare/v1.2.0...v1.2.1) (2025-08-27)
### Bug Fixes
* add '.zip' extension when exporting CT files ([b334685](https://github.com/cheminfo/nmrium/commit/b33468568ce2679759cb0af070f4e89971a13bdb))
* correctly show fully processed live preview for apodization filter ([08651f6](https://github.com/cheminfo/nmrium/commit/08651f6709ab6df290f71e590c33dace9ecb16b8))
* disable editing of read-only filters ([4808d0d](https://github.com/cheminfo/nmrium/commit/4808d0d6b7fdf3324331ebacf32de7d5e53b4144))
* make printing use the same handling logic as export ([0545c33](https://github.com/cheminfo/nmrium/commit/0545c33cd48fe4c907b658683089d5eb2e627da3))
* mark exclusion zones data as dirty to allow changes to be applied ([52bfafc](https://github.com/cheminfo/nmrium/commit/52bfafc6f974ecf18b34e98b8873e2b1b0f4daaa))
* rollback to full processed spectrum when cancelling filter edit ([3499ea3](https://github.com/cheminfo/nmrium/commit/3499ea32a31f492305098b5ac46d1dc995636559)), closes [#3654](https://github.com/cheminfo/nmrium/issues/3654)
## [1.2.0](https://github.com/cheminfo/nmrium/compare/v1.1.0...v1.2.0) (2025-08-21)
### Features
* support filter insertion after spectrum rollback ([1dd1f9e](https://github.com/cheminfo/nmrium/commit/1dd1f9e26c26baf59b9a12647390e4e2f5daafe6))
### Bug Fixes
* display feedback message when JSON export fails ([a5261af](https://github.com/cheminfo/nmrium/commit/a5261af9f895027e827fe13b69de9d6ae18db756))
* exports mapping and update dependencies ([#3634](https://github.com/cheminfo/nmrium/issues/3634)) ([2a20938](https://github.com/cheminfo/nmrium/commit/2a2093830d1bfab1ebcb2cec53820ff92bba32c2))
* handle jcamp filtering correctly during NMRium file load ([5ddd5af](https://github.com/cheminfo/nmrium/commit/5ddd5af3916aad9f367299d7ccb2fdf60a7bea44))
* improve useFilter hook to safely handle empty filters ([a4b7cb8](https://github.com/cheminfo/nmrium/commit/a4b7cb87ad56370b83134a956c3164a928d37b13))
* show 'No spectra available for export' message when no exportable spectra is present ([dbf20ee](https://github.com/cheminfo/nmrium/commit/dbf20ee64e4ebba64a68741be1f9770a5f6b6dd1))
## [1.1.0](https://github.com/cheminfo/nmrium/compare/v1.0.0...v1.1.0) (2025-07-29)
### Features
* extend 2D prediction points range starting from 64 up to 4096 ([70f737f](https://github.com/cheminfo/nmrium/commit/70f737fa75e5c3435f5485db65862f9bcabe345c))
* move 2D processing from experimental to stable feature ([5df91f3](https://github.com/cheminfo/nmrium/commit/5df91f340b29c4a0b68870f6da2626c5584d2594))
* move inset tool from experimental to stable feature ([cf421fe](https://github.com/cheminfo/nmrium/commit/cf421fe86e69f936a46132a6a11e17904d1b444e))
* **plugin:** support `topbar.right` plugin ui slot ([#3621](https://github.com/cheminfo/nmrium/issues/3621)) ([c353b3f](https://github.com/cheminfo/nmrium/commit/c353b3fdf44c3bddcc8e8bbc29fe1c3abb8de03d))
## [1.0.0](https://github.com/cheminfo/nmrium/compare/v0.65.2...v1.0.0) (2025-07-24)
### ⚠ BREAKING CHANGES
* `file-collection` is now used to manage data sources
### Code Refactoring
* remove `filelist-utils` and `jszip` for better alternatives ([#3615](https://github.com/cheminfo/nmrium/issues/3615)) ([c110206](https://github.com/cheminfo/nmrium/commit/c110206d74446e0697ba67e3cba3a83f69cf765c))
## [0.65.2](https://github.com/cheminfo/nmrium/compare/v0.65.1...v0.65.2) (2025-07-15)
### Bug Fixes
* don't display publication string when there are no ranges ([2774b3b](https://github.com/cheminfo/nmrium/commit/2774b3b0501f09d692b32670cc60aecb02921019))
* prediction panel structure editor scrolls on overflow ([5c8a937](https://github.com/cheminfo/nmrium/commit/5c8a937286f6ca1109bdd66d042b2745e0cbc9b6))
## [0.65.1](https://github.com/cheminfo/nmrium/compare/v0.65.0...v0.65.1) (2025-07-10)
### Bug Fixes
* live update filters in processed mode when editing apodization ([1267b4f](https://github.com/cheminfo/nmrium/commit/1267b4fda27042616e32a23e44d24723443604fc)), closes [#3586](https://github.com/cheminfo/nmrium/issues/3586)
## [0.65.0](https://github.com/cheminfo/nmrium/compare/v0.64.0...v0.65.0) (2025-06-20)
### Features
* add 'clickTriggerMode' to support native or debounced click handling ([c7f6ef6](https://github.com/cheminfo/nmrium/commit/c7f6ef623c05729cff534c32ad58a3adab1c0cd8))
* cancel brushing on 'Escape' key press ([cedbfad](https://github.com/cheminfo/nmrium/commit/cedbfad395614b22901311302caad67c54612255))
* copy as smiles ([906c12d](https://github.com/cheminfo/nmrium/commit/906c12d1f11141d7f4c94e0e8fc4d11eb5060568))
* improve brush selection ([#3588](https://github.com/cheminfo/nmrium/issues/3588)) ([bc2faec](https://github.com/cheminfo/nmrium/commit/bc2faeca80605513d003136572fc07d959053f45))
* improve multiple spectra analysis formula calculation ([#3590](https://github.com/cheminfo/nmrium/issues/3590)) ([b740969](https://github.com/cheminfo/nmrium/commit/b7409694758e04c6af2b49ac1fe40ff45443f13f))
* remove related insets when a spectrum is deleted ([87b20fd](https://github.com/cheminfo/nmrium/commit/87b20fd522314760a60ba618f6624fe2bf0299d0)), closes [#3552](https://github.com/cheminfo/nmrium/issues/3552)
### Bug Fixes
* align 1D spectra to the same top when loading ([#3556](https://github.com/cheminfo/nmrium/issues/3556)) ([7cd1237](https://github.com/cheminfo/nmrium/commit/7cd123708e62d2e4a4d7dabd31d1c5d32b4067fa))
* avoid large delta on first CTRL + bidirectional zoom ([7a9196d](https://github.com/cheminfo/nmrium/commit/7a9196d19ac2df796814f9535697f19005d40661))
* clone matrix options before dispatch ([#3570](https://github.com/cheminfo/nmrium/issues/3570)) ([7dcc0ef](https://github.com/cheminfo/nmrium/commit/7dcc0effec7a0c024261432b15a906b4ee299112))
* validate simulation form correctly and debounce value change ([c227474](https://github.com/cheminfo/nmrium/commit/c227474a0d5a8371816c27c084015f0e46fa6256)), closes [#3555](https://github.com/cheminfo/nmrium/issues/3555) [#3554](https://github.com/cheminfo/nmrium/issues/3554)
## [0.64.0](https://github.com/cheminfo/nmrium/compare/v0.63.2...v0.64.0) (2025-05-31)
### Features
* add basic reorder feature to sections component ([1da85c1](https://github.com/cheminfo/nmrium/commit/1da85c160e645447d3927a9826671556fba4e318))
* assign 1d from 2d ([6409e59](https://github.com/cheminfo/nmrium/commit/6409e590c4e28cf69812a3158161ecc6ea8cbf75))
* display prediction errors ([cc3a473](https://github.com/cheminfo/nmrium/commit/cc3a473cd1659dd46b7ca9906c9c2f131603c96b))
* past molfile/SMILES in prediction panel ([4bf7af7](https://github.com/cheminfo/nmrium/commit/4bf7af7b4e22e1e29568e8ca83679da3d1016c50))
* reorder filters ([284c1dc](https://github.com/cheminfo/nmrium/commit/284c1dcb32beefcf79a24e29441ba4b3a009f4b5))
### Bug Fixes
* 2d phase correction and spectrum rollback ([502b621](https://github.com/cheminfo/nmrium/commit/502b621dfe7d480a582b1d74113fa4257a402611))
* allow 250MHz simulation ([087a0c4](https://github.com/cheminfo/nmrium/commit/087a0c4a4226618db2319d9aef7ebd37b7086e6e))
* move Accordion component to controlled component ([#3520](https://github.com/cheminfo/nmrium/issues/3520)) ([e3921ee](https://github.com/cheminfo/nmrium/commit/e3921eea1839a4409fd5352044099beed8b415eb))
* new approach for determining the default contour levels in 2D ([#3542](https://github.com/cheminfo/nmrium/issues/3542)) ([3761276](https://github.com/cheminfo/nmrium/commit/37612765cde46e61da91c1f7d670b29759e16d86))
* prevent combined zoom in stack mode ([#3553](https://github.com/cheminfo/nmrium/issues/3553)) ([2c1f15c](https://github.com/cheminfo/nmrium/commit/2c1f15c61eb84130a4fa0d33e2fac77b133ef47e))
* prevent unnecessary re-renders ([ccae049](https://github.com/cheminfo/nmrium/commit/ccae049011dcff7154e64d394d04c8579c1ced28))
* reset domain when filter is cancelled ([bb327c1](https://github.com/cheminfo/nmrium/commit/bb327c1d14c323c0c989c4eedb5ed3c9c6c2aec4))
* toggle default open database ([#3547](https://github.com/cheminfo/nmrium/issues/3547)) ([d68495b](https://github.com/cheminfo/nmrium/commit/d68495bb033a8acf8df0443a33f7facafc97043c))
* use 'getBBox' function for layout in SVG ([#3559](https://github.com/cheminfo/nmrium/issues/3559)) ([547cc3e](https://github.com/cheminfo/nmrium/commit/547cc3ec9a051a70848fe463298dd47a8f04de5a))
* zoom history manager should take into account the base zoom ([23f0de5](https://github.com/cheminfo/nmrium/commit/23f0de5d3ad17b789d32cc0d892dbe8bbe381e39))
## [0.63.2](https://github.com/cheminfo/nmrium/compare/v0.63.1...v0.63.2) (2025-05-13)
### Bug Fixes
* check if a spectrum is selected before fetching assigned IDs ([242682d](https://github.com/cheminfo/nmrium/commit/242682d7bee25fa945b476122705e1832ad2ee69))
## [0.63.1](https://github.com/cheminfo/nmrium/compare/v0.63.0...v0.63.1) (2025-05-12)
### Bug Fixes
* apply inline style on assignment guide lines when export as svg ([a3968c2](https://github.com/cheminfo/nmrium/commit/a3968c254485c73a92b0e10e5f6c38f8993de102))
* generate ranges from signals instead to directly use it as range ([#3465](https://github.com/cheminfo/nmrium/issues/3465)) ([74a685e](https://github.com/cheminfo/nmrium/commit/74a685ed0859ba31fb5ac07645cdeb5ce0382a59))
* prediction panel usability ([#3511](https://github.com/cheminfo/nmrium/issues/3511)) ([9c182f6](https://github.com/cheminfo/nmrium/commit/9c182f6e4570048c1944e2959d0a6a9aa9c40884))
## [0.63.0](https://github.com/cheminfo/nmrium/compare/v0.62.1...v0.63.0) (2025-05-09)
### ⚠ BREAKING CHANGES
* It was exported by `nmr-load-save`, `@zakodium/nmrium-core` do not export this method. It is callable from instantiated core only.
### Features
* add support for inverted scroll behavior ([f2ef939](https://github.com/cheminfo/nmrium/commit/f2ef939da097f74b0431b4772a9bdb872bee56a8))
* assign 1D labels from 2D spectra ([45f931a](https://github.com/cheminfo/nmrium/commit/45f931ab135a815dfa1e0df4d8db1d56ab9ce407))
* assignments guidelines over the first and second dimensions ([f0821a3](https://github.com/cheminfo/nmrium/commit/f0821a3f5f12f61296569784bb4723981e52c246))
* bidirectional 1D zoom ([#3472](https://github.com/cheminfo/nmrium/issues/3472)) ([339c67d](https://github.com/cheminfo/nmrium/commit/339c67d5f5e362358de6aa8e315174373504eaf7))
* control structure size (default minHeight: 100px) ([e56ef9a](https://github.com/cheminfo/nmrium/commit/e56ef9abeffc7c76e9747727570aab0342bdf775))
* control structure size (default minHeight: 100px) ([d434888](https://github.com/cheminfo/nmrium/commit/d434888b55f717d50b259b5489d4a9d61af514f7))
* hide 2D phase correction for non-quadrant spectra ([b6d7c46](https://github.com/cheminfo/nmrium/commit/b6d7c461a54ddbd30060d44e1f5a02cf5cdc4b34))
* horizontal and vertical zoom with CTRL + drag ([#3469](https://github.com/cheminfo/nmrium/issues/3469)) ([f0e99b2](https://github.com/cheminfo/nmrium/commit/f0e99b22d05b0d3af6674feeb60361a2f01ea7bf))
* improve database panel ([#3455](https://github.com/cheminfo/nmrium/issues/3455)) ([#3461](https://github.com/cheminfo/nmrium/issues/3461)) ([e56ef9a](https://github.com/cheminfo/nmrium/commit/e56ef9abeffc7c76e9747727570aab0342bdf775))
* minimum width for overlay highlight range ([d4872e7](https://github.com/cheminfo/nmrium/commit/d4872e7043037cd83cae1dc93598e92d8909118e))
* processed apodization ([#3447](https://github.com/cheminfo/nmrium/issues/3447)) ([3fbbfdc](https://github.com/cheminfo/nmrium/commit/3fbbfdc3e3ce994ed30032951654ad35faec270c))
* reopen the collapsed panels area when toggling the panel from the panels bar ([3cf40ff](https://github.com/cheminfo/nmrium/commit/3cf40ffd91f3b2871d90ff543fc7b09ce6a53c5d))
* stack range assignment labels to avoid overlap ([b7fe786](https://github.com/cheminfo/nmrium/commit/b7fe7868cd310a60016319c692e87587f443f98c))
* suggest default assignment label for 2D assignment based on closest signal to center ([fce426a](https://github.com/cheminfo/nmrium/commit/fce426a9cebc265c7b6cea470dba7bcc461bc818))
* update OpenChemLib to v9 ([#3471](https://github.com/cheminfo/nmrium/issues/3471)) ([1e7d403](https://github.com/cheminfo/nmrium/commit/1e7d4032bf3156f3f73317c2b784b84493c0ebc6))
### Bug Fixes
* correct search range ([fce426a](https://github.com/cheminfo/nmrium/commit/fce426a9cebc265c7b6cea470dba7bcc461bc818))
* ensure assignment labels are unique across Cosy F1 and F2 dimensions ([45f931a](https://github.com/cheminfo/nmrium/commit/45f931ab135a815dfa1e0df4d8db1d56ab9ce407))
* ensure data is not empty before looking for a spectrum ([0cff982](https://github.com/cheminfo/nmrium/commit/0cff9820a4bb519a95f792ccfa9e85afc5e93b51))
* find the signal closest to the center of the zone ([fce426a](https://github.com/cheminfo/nmrium/commit/fce426a9cebc265c7b6cea470dba7bcc461bc818))
* fix: ensure only the first signal has the assignment label ([fce426a](https://github.com/cheminfo/nmrium/commit/fce426a9cebc265c7b6cea470dba7bcc461bc818))
* **jcamp1Dexport:** add frequencyOffset and spectralWidth info ([#3504](https://github.com/cheminfo/nmrium/issues/3504)) ([8fccd4e](https://github.com/cheminfo/nmrium/commit/8fccd4e57c087494a1f3e48827a40c2484ba8c8d))
* update OpenChemLib to v9.1.1 ([#3492](https://github.com/cheminfo/nmrium/issues/3492)) ([736babb](https://github.com/cheminfo/nmrium/commit/736babb34391dcdc68f23f7a27d700298193229a))
* useWatch hook to watch matrix generation changes ([aa97dda](https://github.com/cheminfo/nmrium/commit/aa97dda3051cdef0b772423acc378a64632e620b))
* useWatch hook to watch prediction form changes ([3549c9b](https://github.com/cheminfo/nmrium/commit/3549c9ba925950e706e4dee40e9bf89592b9fe85)), closes [#3485](https://github.com/cheminfo/nmrium/issues/3485)
* useWatch hook to watch range editing form change ([f62aa1c](https://github.com/cheminfo/nmrium/commit/f62aa1ca8dcf7982d7812c1598b7383f512878cd)), closes [#3486](https://github.com/cheminfo/nmrium/issues/3486)
* useWatch hook to watch simulation form changes ([2292592](https://github.com/cheminfo/nmrium/commit/229259218e7170c53e0eaa23737fc5e613286dd0))
### Code Refactoring
* replace `nmr-load-save` deps by `nmrium-core` and `nmrium-core-plugins` ([#3473](https://github.com/cheminfo/nmrium/issues/3473)) ([af1503d](https://github.com/cheminfo/nmrium/commit/af1503dca49a3b24123276069140019f77f85639))
## [0.62.1](https://github.com/cheminfo/nmrium/compare/v0.62.0...v0.62.1) (2025-04-02)
### Bug Fixes
* update react-science ([#3452](https://github.com/cheminfo/nmrium/issues/3452)) ([bcf2496](https://github.com/cheminfo/nmrium/commit/bcf24969e575bfeaf724f7fd3de8e1f40134bb66))
* validate simulation options ([1b7b04a](https://github.com/cheminfo/nmrium/commit/1b7b04a40d7d9deb7e95a60b007f9e9631f6a35f))
## [0.62.0](https://github.com/cheminfo/nmrium/compare/v0.61.0...v0.62.0) (2025-03-25)
### Features
* collapse molecule all hydrogens ([f825f1e](https://github.com/cheminfo/nmrium/commit/f825f1e00b387e90a6d689eecdccf5f858637f27))
* expand molecule all hydrogens ([8bbba04](https://github.com/cheminfo/nmrium/commit/8bbba04598919b706c454894307e9a1f4fe9cf6f))
* improve 2d zoom with horizontal, vertical, and bidirectional ([2734993](https://github.com/cheminfo/nmrium/commit/27349938e13e6fbdb535b67bc5b798077e11cd69))
* improve brushing ([5912783](https://github.com/cheminfo/nmrium/commit/59127834b4254c7e06d74dbfc88c5c742ccb8c51))
### Bug Fixes
* append couplings when edit range ([#3442](https://github.com/cheminfo/nmrium/issues/3442)) ([e7652ff](https://github.com/cheminfo/nmrium/commit/e7652ff93fecea8323fa97395f2b7f48bcd5fcf1))
## [0.61.0](https://github.com/cheminfo/nmrium/compare/v0.60.0...v0.61.0) (2025-03-24)
### Features
* 2d apodization ([450d0e6](https://github.com/cheminfo/nmrium/commit/450d0e6e531928b1f4a7fa904a00d514a1fe257a))
* 2d zero filling ([#3306](https://github.com/cheminfo/nmrium/issues/3306)) ([613eb18](https://github.com/cheminfo/nmrium/commit/613eb18ed7a2259616ac2456f154451e561b6ae2))
* add new Filter section in case the filter does not exists ([c0dfee0](https://github.com/cheminfo/nmrium/commit/c0dfee07c07bf1dd35902ec1ee8d0cb2ff12b57a))
* adjust inset position and size using percentages instead of pixels ([57b9bde](https://github.com/cheminfo/nmrium/commit/57b9bde4364ecff22efe33996ea0a15803d007f2))
* change floating molecule position from pixels to percentage ([a778abc](https://github.com/cheminfo/nmrium/commit/a778abcd596180f31cd8bcfda11143d4fe654aa1))
* clear all added spectra from the database ([#3240](https://github.com/cheminfo/nmrium/issues/3240)) ([1ae01cd](https://github.com/cheminfo/nmrium/commit/1ae01cd263864c4987572d94fac50c891acddd52)), closes [#3235](https://github.com/cheminfo/nmrium/issues/3235)
* control the margin top of the peaks label ([e177d56](https://github.com/cheminfo/nmrium/commit/e177d56bae9fa33d6f6d0b7a403ad6e793c540cf)), closes [#3112](https://github.com/cheminfo/nmrium/issues/3112)
* create resizable svg element ([#3333](https://github.com/cheminfo/nmrium/issues/3333)) ([7216b6f](https://github.com/cheminfo/nmrium/commit/7216b6ff76ba066716c1c78d25243db856ab1bf5))
* customize assignment highlight color ([#3230](https://github.com/cheminfo/nmrium/issues/3230)) ([b6ae57c](https://github.com/cheminfo/nmrium/commit/b6ae57c1f04435faf527cc8644ab8b8dfcbbc269))
* customize tools indicator line color ([#3411](https://github.com/cheminfo/nmrium/issues/3411)) ([fc98768](https://github.com/cheminfo/nmrium/commit/fc9876809a3084df631d143540e24f8b3335a848))
* display 'No filters' when no filters ([cd28f64](https://github.com/cheminfo/nmrium/commit/cd28f649f91a5f22791ff5286db3ec151b6f9c4c))
* display tracking for selected spectra ([d29fad9](https://github.com/cheminfo/nmrium/commit/d29fad9b156f32a6f03e9ac1de003c589831c790)), closes [#3231](https://github.com/cheminfo/nmrium/issues/3231)
* enhance svg table styling and auto row spanning ([c033501](https://github.com/cheminfo/nmrium/commit/c033501ff4e7dbdc4dc4edf9bba3feb41030b910))
* export spectra insets ([57b9bde](https://github.com/cheminfo/nmrium/commit/57b9bde4364ecff22efe33996ea0a15803d007f2))
* fill chemical shift input by using the cursor on the spectrum ([#3334](https://github.com/cheminfo/nmrium/issues/3334)) ([02ee2f8](https://github.com/cheminfo/nmrium/commit/02ee2f8107f4af15dbd186c12ab7b2518c825089))
* floating publication string over spectrum ([a22a55a](https://github.com/cheminfo/nmrium/commit/a22a55af0e3d958aaa350799f8c7ce6611999d0d))
* floating ranges over the spectrum ([69decfb](https://github.com/cheminfo/nmrium/commit/69decfb8ff82c926fde94d2d2729945c5c52be04))
* hiding integration value should lower the spectrum ([2ce8ef9](https://github.com/cheminfo/nmrium/commit/2ce8ef9d0f16c7a466feb7d72c1c70e51bcd16cd))
* hook to manager syn filter options ([84e9dc7](https://github.com/cheminfo/nmrium/commit/84e9dc708d87c396e509a2019aee2aed56b8aebe))
* implement right-side panels bar ([#3318](https://github.com/cheminfo/nmrium/issues/3318)) ([a4be76f](https://github.com/cheminfo/nmrium/commit/a4be76fa096644cd2b65095cbeae5bbcd9006f30))
* improve 1D apodization ([#3260](https://github.com/cheminfo/nmrium/issues/3260)) ([797fea4](https://github.com/cheminfo/nmrium/commit/797fea40e91caee106e3c1b5a815b684c2a6df9f))
* improve 1D phase correction options panel ([18f5574](https://github.com/cheminfo/nmrium/commit/18f55744a751ecf05018d4c8e3fa383d07eaf4cb))
* improve 2D phase correction filter options panel ([bcf945e](https://github.com/cheminfo/nmrium/commit/bcf945e5235331f74805ee36207da17fc4a3ffa3))
* improve apodization filter options ([860473c](https://github.com/cheminfo/nmrium/commit/860473ca6c1100f1ba510d1c917b266605b5463f))
* improve baseline correction filter options panel ([7db0a08](https://github.com/cheminfo/nmrium/commit/7db0a0814aad7928dc19318cc72cc13cf6aee9e2))
* improve editing of exclusion zones filter options ([fc2bc59](https://github.com/cheminfo/nmrium/commit/fc2bc5985fa93428f866c841dc18298f2b94a4c2))
* improve editing of Shift filter options ([c850388](https://github.com/cheminfo/nmrium/commit/c850388e753892f69e70157dfe9d0fd3671a0438))
* improve export publication string options ([9f2e971](https://github.com/cheminfo/nmrium/commit/9f2e9711f279ae9b85e6a3c83455ce0e5392d7a5))
* improve filter selection and editing behavior ([#3265](https://github.com/cheminfo/nmrium/issues/3265)) ([5fa9fd1](https://github.com/cheminfo/nmrium/commit/5fa9fd17918398c3681ce2b22e2add0ffc5328ac))
* improve image export scaling for PNG and SVG ([967e289](https://github.com/cheminfo/nmrium/commit/967e289e645e20f3323443fdaf7b5ceca3a22119))
* improve inset ([57b9bde](https://github.com/cheminfo/nmrium/commit/57b9bde4364ecff22efe33996ea0a15803d007f2))
* improve manual range picking and fix simulation of diagonal peaks in COSY prediction ([#3308](https://github.com/cheminfo/nmrium/issues/3308)) ([24dbc50](https://github.com/cheminfo/nmrium/commit/24dbc502cb51b6f61160c4a3a29333acc4964781))
* improve multiple spectra analysis data export ([9bcf680](https://github.com/cheminfo/nmrium/commit/9bcf680d781e796ec6b2d6c3388b9cca126c4c16)), closes [#3233](https://github.com/cheminfo/nmrium/issues/3233)
* improve path builder ([d0ca68d](https://github.com/cheminfo/nmrium/commit/d0ca68d014206a7e72299668fca597a8a140b984))
* improve processing user interaction ([#3327](https://github.com/cheminfo/nmrium/issues/3327)) ([513280f](https://github.com/cheminfo/nmrium/commit/513280f681d1a00e1abc58f657127da5825a032e))
* improve save as PNG, SVG and copy to clipboard ([#3252](https://github.com/cheminfo/nmrium/issues/3252)) ([683eb63](https://github.com/cheminfo/nmrium/commit/683eb63d2ca33cf2b5886eb5793f1f2ac8d5af38))
* inset ([57b9bde](https://github.com/cheminfo/nmrium/commit/57b9bde4364ecff22efe33996ea0a15803d007f2))
* inset actions ([57b9bde](https://github.com/cheminfo/nmrium/commit/57b9bde4364ecff22efe33996ea0a15803d007f2))
* inset brush end ([57b9bde](https://github.com/cheminfo/nmrium/commit/57b9bde4364ecff22efe33996ea0a15803d007f2))
* inset pain ([57b9bde](https://github.com/cheminfo/nmrium/commit/57b9bde4364ecff22efe33996ea0a15803d007f2))
* inset zoom out and zoom history ([57b9bde](https://github.com/cheminfo/nmrium/commit/57b9bde4364ecff22efe33996ea0a15803d007f2))
* interactive positioning of peak labels ([e177d56](https://github.com/cheminfo/nmrium/commit/e177d56bae9fa33d6f6d0b7a403ad6e793c540cf))
* make module compatible with native ESM ([#3271](https://github.com/cheminfo/nmrium/issues/3271)) ([a3db8cf](https://github.com/cheminfo/nmrium/commit/a3db8cf0001a3f3e77b05b4961268f86b9274df0))
* PNG export resolution ([#3237](https://github.com/cheminfo/nmrium/issues/3237)) ([4cbf6c4](https://github.com/cheminfo/nmrium/commit/4cbf6c40aa1043d91f214908ab6d83cc475a7efd))
* scale integrals in inset ([57b9bde](https://github.com/cheminfo/nmrium/commit/57b9bde4364ecff22efe33996ea0a15803d007f2))
* section component ([3f23dcd](https://github.com/cheminfo/nmrium/commit/3f23dcd031f3cc54574c9dff52a4162b5e016c8e))
* sort spectra by specific parameter ([1ccb784](https://github.com/cheminfo/nmrium/commit/1ccb784fff13432b99d6f8e275a50967b3ff35c6)), closes [#3232](https://github.com/cheminfo/nmrium/issues/3232)
* sort spectra without mutating the original state ([47fca1e](https://github.com/cheminfo/nmrium/commit/47fca1e201b59495f379caad89dd858c8556c7af))
* svg table component ([c033501](https://github.com/cheminfo/nmrium/commit/c033501ff4e7dbdc4dc4edf9bba3feb41030b910))
* toggle ranges, peaks, and integrals view properties inside insets ([57b9bde](https://github.com/cheminfo/nmrium/commit/57b9bde4364ecff22efe33996ea0a15803d007f2))
* **UI:** improve Sections component ([6302db2](https://github.com/cheminfo/nmrium/commit/6302db2a8a49fc3f5301b16ff853b586dbdc5c9e))
* update dependencies ([#3359](https://github.com/cheminfo/nmrium/issues/3359)) ([64b58b6](https://github.com/cheminfo/nmrium/commit/64b58b631dc326f88e12b78cc2a18705074835d7))
* vertical and horizontal zoom ([57b9bde](https://github.com/cheminfo/nmrium/commit/57b9bde4364ecff22efe33996ea0a15803d007f2))
### Bug Fixes
* assign indicator margin ([fc98768](https://github.com/cheminfo/nmrium/commit/fc9876809a3084df631d143540e24f8b3335a848))
* avoid React duplicated key ([19e663d](https://github.com/cheminfo/nmrium/commit/19e663d85a8f944a91340bf058a126ac410745c6))
* be more resilient with invalid types ([25aad7f](https://github.com/cheminfo/nmrium/commit/25aad7f194b6686f6047b45a7ae7cb0460caed65))
* convert range analysis from Pixel to PPM ([de4109b](https://github.com/cheminfo/nmrium/commit/de4109b8ffc4244a8172d44655e10a692dd64513)), closes [#3378](https://github.com/cheminfo/nmrium/issues/3378)
* delete filter ([7f6b32d](https://github.com/cheminfo/nmrium/commit/7f6b32dc207f5890de6d646567e6ce973a0bf07a))
* delete ranges,peaks, and integrals in insets ([57b9bde](https://github.com/cheminfo/nmrium/commit/57b9bde4364ecff22efe33996ea0a15803d007f2))
* disabled range pop actions menu if it is inset ([57b9bde](https://github.com/cheminfo/nmrium/commit/57b9bde4364ecff22efe33996ea0a15803d007f2))
* ensure apodization panel inputs fields shrink properly ([c976d34](https://github.com/cheminfo/nmrium/commit/c976d340fa791ec41b1c611b06b2ebb73c0e9652))
* ensure shortcuts are not ignored when the focused element is a radio or checkbox ([e8f3667](https://github.com/cheminfo/nmrium/commit/e8f3667f1dff1d77107110ec3853e69a9e9ff362))
* floating molecule position ([162946d](https://github.com/cheminfo/nmrium/commit/162946d2cafd8f7db70bc9dfb50b90184a5121f5))
* hide/show zone assignment label button ([a8f9092](https://github.com/cheminfo/nmrium/commit/a8f9092826d40cd3a5fad15879eaddfa444d34c5))
* highlight when toggling hydrogens in molecule could fail ([#3245](https://github.com/cheminfo/nmrium/issues/3245)) ([2276fe0](https://github.com/cheminfo/nmrium/commit/2276fe03cfead4fbd9e85b1f293c96a083327b60))
* import BoundingBox from nmr-load-save ([2837a0b](https://github.com/cheminfo/nmrium/commit/2837a0b0163652155762c763741db2330cc53ba5))
* import couplings from JCAMP-DX assignment ([#3398](https://github.com/cheminfo/nmrium/issues/3398)) ([6666a33](https://github.com/cheminfo/nmrium/commit/6666a33512d5e4776fdd0e9770b0a32ab0b5f2b7))
* inset viewer root ([57b9bde](https://github.com/cheminfo/nmrium/commit/57b9bde4364ecff22efe33996ea0a15803d007f2))
* inset zoom ([57b9bde](https://github.com/cheminfo/nmrium/commit/57b9bde4364ecff22efe33996ea0a15803d007f2))
* mark form as dirty when toggle apodization algorithms ([1b41b02](https://github.com/cheminfo/nmrium/commit/1b41b02aa8949eeef721d139470171ffbca4f67f))
* migration to version 8 ([0b964fd](https://github.com/cheminfo/nmrium/commit/0b964fd040f6fecc23e08aa9d5589ce8ca8a9461))
* molecule export as SVG ([#3371](https://github.com/cheminfo/nmrium/issues/3371)) ([c0d8191](https://github.com/cheminfo/nmrium/commit/c0d81916b673887951695aafbfc255d24c3086b0))
* multiplicity parsing of JCAMP-DX ([#3390](https://github.com/cheminfo/nmrium/issues/3390)) ([ebe92be](https://github.com/cheminfo/nmrium/commit/ebe92bebbb7112762acf6fa9edf5d227b5790e6f))
* pass start and end in PPM for 'ANALYZE_SPECTRA' action ([#3412](https://github.com/cheminfo/nmrium/issues/3412)) ([207bd1d](https://github.com/cheminfo/nmrium/commit/207bd1df7d3d1cf9b671ff71c3da9095c97f873d))
* prevent 'isOpen' and 'overflow' from being passed to the DOM ([75c9bd8](https://github.com/cheminfo/nmrium/commit/75c9bd8a82bf5e84c09ecbce9745e6d47202c9f3)), closes [#3399](https://github.com/cheminfo/nmrium/issues/3399)
* prevent click event if the user dragged the mouse ([#3388](https://github.com/cheminfo/nmrium/issues/3388)) ([0562360](https://github.com/cheminfo/nmrium/commit/0562360598b2b4ae54bd994fbd9761dbad1142bc))
* remove group delay points ([#3246](https://github.com/cheminfo/nmrium/issues/3246)) ([960ac94](https://github.com/cheminfo/nmrium/commit/960ac947fce7c665de1ff0cba110391e0d869fa9))
* rescale the canvas based on the DPI ([4cbf6c4](https://github.com/cheminfo/nmrium/commit/4cbf6c40aa1043d91f214908ab6d83cc475a7efd))
* reset domain when cancel filter in live preview ([32a0e23](https://github.com/cheminfo/nmrium/commit/32a0e2346311b7adcf9766dd4818ce4d479d7bfa))
* rollback spectrum to the point right before the shift ([#3435](https://github.com/cheminfo/nmrium/issues/3435)) ([48c6576](https://github.com/cheminfo/nmrium/commit/48c6576a40f1a4f86e3d44f6f18bbf2898e58988))
* select component style ([f1a24e5](https://github.com/cheminfo/nmrium/commit/f1a24e5a1289ed4bde2d42a2610b9fa41ff11f66))
* show/hide the spectra legend fields ([20126dd](https://github.com/cheminfo/nmrium/commit/20126dd157b07e04041306407d8f2bf6554050db))
* sort the selected the range ([b164290](https://github.com/cheminfo/nmrium/commit/b164290c0324b9b4b9dfd2a239e9394b7c21963f))
* spectrum opacity inside inset ([57b9bde](https://github.com/cheminfo/nmrium/commit/57b9bde4364ecff22efe33996ea0a15803d007f2))
* take into account the line width in 1D prediction ([ea224b8](https://github.com/cheminfo/nmrium/commit/ea224b8c429f08507e402c788021230a54277bb1))
* update dependencies ([#3431](https://github.com/cheminfo/nmrium/issues/3431)) ([991bab4](https://github.com/cheminfo/nmrium/commit/991bab41e26294c8cad6563cf6df4fd87aa1fe36))
* update domain in 2D ([b860f84](https://github.com/cheminfo/nmrium/commit/b860f84bb1409bd7bc284d02c6aba4184fe61efd))
* update react-dropzone ([de05c71](https://github.com/cheminfo/nmrium/commit/de05c71fdae44558e1a2dd8c353525df190b2d07))
* update react-science and resolve React warnings ([#3369](https://github.com/cheminfo/nmrium/issues/3369)) ([3ba4ad5](https://github.com/cheminfo/nmrium/commit/3ba4ad53a90ec053117151fc010fc49ef817bad0))
* **varian:** include procPar into metadata ([#3241](https://github.com/cheminfo/nmrium/issues/3241)) ([39ee706](https://github.com/cheminfo/nmrium/commit/39ee706f07a0fa9b1be1d37e27ab41c1f35d30dd))
* zones preferences ([e9a2b0c](https://github.com/cheminfo/nmrium/commit/e9a2b0cd41c5d1e589b065ac42d45a6b9f1250de))
## [0.60.0](https://github.com/cheminfo/nmrium/compare/v0.59.0...v0.60.0) (2024-08-24)
### Features
* add draggable functionality for BlueprintJS dialog ([960e844](https://github.com/cheminfo/nmrium/commit/960e84416edab1e8f036fe33ce2618d43eaed35b))
* implement dialog manager ([61a7192](https://github.com/cheminfo/nmrium/commit/61a719269706a79a5155a6707cb8a915c6cd28a6))
* improve draggable dialog ([0af665b](https://github.com/cheminfo/nmrium/commit/0af665b2d79828782abdc3a5ac9f0ce06907af4e))
### Bug Fixes
* automatic phase correction if phase correction values is undefined ([#3204](https://github.com/cheminfo/nmrium/issues/3204)) ([3ce2b4f](https://github.com/cheminfo/nmrium/commit/3ce2b4f0fc4a5c190c6323f356099de6cb4c459a))
* display error message when pasting MOL or SMILES fails ([0ada098](https://github.com/cheminfo/nmrium/commit/0ada098b88ec04020832c8884a2cbe2b0d554789))
* keep matrix range unchanged when adding exclusion zones ([dbf70c7](https://github.com/cheminfo/nmrium/commit/dbf70c7660aafd60a22b46ec7162b7beb60797cd)), closes [#3198](https://github.com/cheminfo/nmrium/issues/3198)
* prevent spectrum selection during zoom in stack mode ([4f4cd45](https://github.com/cheminfo/nmrium/commit/4f4cd45664adca979913aa9ef647f20799ab141b)), closes [#3190](https://github.com/cheminfo/nmrium/issues/3190)
* restore pivot functionality and add test case ([571fc64](https://github.com/cheminfo/nmrium/commit/571fc64bff52711c3f3473f924897c067b370e2e))
## [0.59.0](https://github.com/cheminfo/nmrium/compare/v0.58.0...v0.59.0) (2024-08-08)
### ⚠ BREAKING CHANGES
* rename `NMRiumRef` type to `NMRiumRefAPI`
### release-as
* v0.59.0 ([#3187](https://github.com/cheminfo/nmrium/issues/3187)) ([0bed397](https://github.com/cheminfo/nmrium/commit/0bed3979cb998524380364c099aeb730c19832b9))
### Features
* add external ref API to load files ([#3147](https://github.com/cheminfo/nmrium/issues/3147)) ([3620af4](https://github.com/cheminfo/nmrium/commit/3620af47e72127426f89c00b6571a6fac06f9ef2))
* avoid splitting molecule fragments into separate molecules ([#3174](https://github.com/cheminfo/nmrium/issues/3174)) ([c05db64](https://github.com/cheminfo/nmrium/commit/c05db642f1a4f4351bfcaa1d3f7c96faa518a872))
* create alert component ([6de9be1](https://github.com/cheminfo/nmrium/commit/6de9be125355ab361f16c1c05681602b1c2572fe))
* export as JCAMP-DX includes all metadata ([#3162](https://github.com/cheminfo/nmrium/issues/3162)) ([6caf0a7](https://github.com/cheminfo/nmrium/commit/6caf0a71f0d3ed5ea12e415b39636a94ab1fbc22))
* export for CT ([23b2f1d](https://github.com/cheminfo/nmrium/commit/23b2f1df55037a8d76f997021f3b6913022cf92b))
* export JCAMP-DX from the main export menu ([cbc5a4c](https://github.com/cheminfo/nmrium/commit/cbc5a4c6f85cc8712a3006270917bea717b1bd81))
* export ranges as TSV file ([cea8135](https://github.com/cheminfo/nmrium/commit/cea81353adb1d72a24206c7cff99bd8c668f61d6))
* hide External APIs tab behind experimental feature flag ([7dae46b](https://github.com/cheminfo/nmrium/commit/7dae46bceb52ca84580ec91fb266b0e303ed67d3))
* implement external APIs management in general settings ([7dae46b](https://github.com/cheminfo/nmrium/commit/7dae46bceb52ca84580ec91fb266b0e303ed67d3))
* improve selection of spectra ([#3159](https://github.com/cheminfo/nmrium/issues/3159)) ([2df4b33](https://github.com/cheminfo/nmrium/commit/2df4b3345c44b0758ce9ae7145157183e6f0f2c2))
* print spectra ([#2786](https://github.com/cheminfo/nmrium/issues/2786)) ([1287bc1](https://github.com/cheminfo/nmrium/commit/1287bc18e8f7d6073c1f905cd3564f257508b563)), closes [#3139](https://github.com/cheminfo/nmrium/issues/3139)
* resurrect spectrum from signals ([c32b594](https://github.com/cheminfo/nmrium/commit/c32b594dfbad2394ee5fdd81c153fdb0cb38e0c9))
### Bug Fixes
* allow big couplings when a range is added manually ([#3157](https://github.com/cheminfo/nmrium/issues/3157)) ([e6fb70a](https://github.com/cheminfo/nmrium/commit/e6fb70ac17341c21624edb1b79cc197a70896e2c))
* avoid nesting a button within another button inside accordion item ([#3167](https://github.com/cheminfo/nmrium/issues/3167)) ([903ca53](https://github.com/cheminfo/nmrium/commit/903ca530b66725e1c7a524624cd433b63eafa520))
* delete all filters should be enabled ([6a12a9d](https://github.com/cheminfo/nmrium/commit/6a12a9d635afc71a26e02430ca7d365bc9e3966b))
* disabled toolbar popover item ([9c59558](https://github.com/cheminfo/nmrium/commit/9c59558ad1662520d14205da01a1bc1179c6b45c))
* do not allow deletion of digital filter ([e41fa05](https://github.com/cheminfo/nmrium/commit/e41fa05e95b37afc4c7d4e34047fbbd4df644b2b)), closes [#3136](https://github.com/cheminfo/nmrium/issues/3136)
* extract atoms correctly using mf-parser ([2b5b905](https://github.com/cheminfo/nmrium/commit/2b5b905507ed2c9af30d3bc001308025c4c8d98f))
* import from publication string with common names of multiplicities ([#3154](https://github.com/cheminfo/nmrium/issues/3154)) ([9ff4ee0](https://github.com/cheminfo/nmrium/commit/9ff4ee02634dec0459d58f93930060e3a07d325c))
* pre-calculated baseline zones using Dietrich algor ([#3153](https://github.com/cheminfo/nmrium/issues/3153)) ([90a3f97](https://github.com/cheminfo/nmrium/commit/90a3f9749d1340fe362ab0b925cf9b04435bb566))
* prevent deletion in case no correlations links in summary panel ([5f2b614](https://github.com/cheminfo/nmrium/commit/5f2b6143c948c80629afe1321315babbdf78c1a9))
* prevent vertical 2D scale from triggering data change callback ([d1a48f1](https://github.com/cheminfo/nmrium/commit/d1a48f10061ecf5a80c97f7408de905b7ef40f60))
* remove associated objects from the view and keyPreferences upon spectrum deletion ([b0d41e9](https://github.com/cheminfo/nmrium/commit/b0d41e9dc3250d99714174a0ea220c691837eaae)), closes [#3125](https://github.com/cheminfo/nmrium/issues/3125)
* reprocess spectra when all filters are deleted ([af618ec](https://github.com/cheminfo/nmrium/commit/af618ecafc7fe51bb96e7e477f51e75b39873a0c))
* rollback to digital filter ([218891b](https://github.com/cheminfo/nmrium/commit/218891b5f392fd49e90c98321b4c477c334f7050)), closes [#3163](https://github.com/cheminfo/nmrium/issues/3163)
* switch between baseline algorithms should affect the spectrum ([1549ce0](https://github.com/cheminfo/nmrium/commit/1549ce0b5afbc860b52e6d2c1d1e2921c80d4e4f))
## [0.58.0](https://github.com/cheminfo/nmrium/compare/v0.57.1...v0.58.0) (2024-07-10)
### Features
* improve info block ([b838b34](https://github.com/cheminfo/nmrium/commit/b838b3432c4af5a1396397b1dde986388cba06a0))
* move the title block ([b838b34](https://github.com/cheminfo/nmrium/commit/b838b3432c4af5a1396397b1dde986388cba06a0))
### Bug Fixes
* apply apodization on the fly when opening its options panel ([506bc4b](https://github.com/cheminfo/nmrium/commit/506bc4bc6c6743a72a325f30c4bfe801bedf6c09))
* apply baseline correction on the fly when opening its options panel ([1b8ebdc](https://github.com/cheminfo/nmrium/commit/1b8ebdc32b80d9935724a0f49f202dd0fe68ca5b))
* apply zero filling on the fly when opening its options panel ([d43911d](https://github.com/cheminfo/nmrium/commit/d43911d786b46eab03a1347f3c4c3ace79d24903))
* correctly handle optional mapValue function ([106f2c9](https://github.com/cheminfo/nmrium/commit/106f2c94c948ce5199eec8adbd09dff1856606a2))
* read title file in bruker pdata ([#3114](https://github.com/cheminfo/nmrium/issues/3114)) ([f4a18b5](https://github.com/cheminfo/nmrium/commit/f4a18b5ad3a7ce2bfb03d2e6b8ecb2a12dc35e17))
* save preferences in the local storage ([6f0ac78](https://github.com/cheminfo/nmrium/commit/6f0ac783c4835b6eff71139dd0ee9d686bc3e15b))
## [0.57.1](https://github.com/cheminfo/nmrium/compare/v0.57.0...v0.57.1) (2024-07-04)
### Bug Fixes
* set query value to an empty string when it is null in the suggest input ([75108c6](https://github.com/cheminfo/nmrium/commit/75108c68b73f69be456afe72869976a9714bc1ea))
## [0.57.0](https://github.com/cheminfo/nmrium/compare/v0.56.0...v0.57.0) (2024-07-03)
### Features
* edit meta info ([965f316](https://github.com/cheminfo/nmrium/commit/965f316a875ba9307f46398162adaf636cb430dc))
* improve database ([#3102](https://github.com/cheminfo/nmrium/issues/3102)) ([d33a9f0](https://github.com/cheminfo/nmrium/commit/d33a9f0f75c3cd92b02da16e1f9a73385c9e057d))
* improve recolor by distinct value ([#3082](https://github.com/cheminfo/nmrium/issues/3082)) ([5c52a37](https://github.com/cheminfo/nmrium/commit/5c52a370e2bfa88f0dac3b93a099fcbd2310d723))
### Bug Fixes
* calculate of decimal digits in getDecimalsCount function ([53568de](https://github.com/cheminfo/nmrium/commit/53568dec78b8c06347902313927de6475e8f19fd))
* improve speed of contour plot ([#3050](https://github.com/cheminfo/nmrium/issues/3050)) ([1b62142](https://github.com/cheminfo/nmrium/commit/1b62142ff692e6d2019319128e211fcbcfea72a4))
* load raw bruker data from nmredata ([#3098](https://github.com/cheminfo/nmrium/issues/3098)) ([addb7bc](https://github.com/cheminfo/nmrium/commit/addb7bc6eef2d279936749e8539317c9d22cd56c))
* predicted spectrum name and frequency ([#3081](https://github.com/cheminfo/nmrium/issues/3081)) ([67ad22c](https://github.com/cheminfo/nmrium/commit/67ad22c68af4375b24332b48b6f887c5a3552ed1))
* radio button ([258efc7](https://github.com/cheminfo/nmrium/commit/258efc7779cb625f35309d6de847c6a7c8dd84bb))
* update dependencies ([#3099](https://github.com/cheminfo/nmrium/issues/3099)) ([a6319a2](https://github.com/cheminfo/nmrium/commit/a6319a2d8e02c46473807a7b4069a3e0de1af589))
* useForm types ([258efc7](https://github.com/cheminfo/nmrium/commit/258efc7779cb625f35309d6de847c6a7c8dd84bb))
## [0.56.0](https://github.com/cheminfo/nmrium/compare/v0.55.0...v0.56.0) (2024-06-01)
### Features
* generate and display stocsy and boxplot ([#3055](https://github.com/cheminfo/nmrium/issues/3055)) ([83ff531](https://github.com/cheminfo/nmrium/commit/83ff53108a2c2555fafaf227fb632a8e8270adae))
### Bug Fixes
* select stocsy pivot point when the exclusion zones tool selected ([c527775](https://github.com/cheminfo/nmrium/commit/c527775296149c1f5e38e12cda8a57bc0a99062c))
* set minimum width and height for the database molecule structure ([#3069](https://github.com/cheminfo/nmrium/issues/3069)) ([4ce0d2b](https://github.com/cheminfo/nmrium/commit/4ce0d2b363b73d561a0ba2e5810c84d28bedf341))
* toggle the matrix generation exclusion zones tool ([c527775](https://github.com/cheminfo/nmrium/commit/c527775296149c1f5e38e12cda8a57bc0a99062c))
## [0.55.0](https://github.com/cheminfo/nmrium/compare/v0.54.0...v0.55.0) (2024-05-18)
### Features
* exercise workspace has invert by default ([#3047](https://github.com/cheminfo/nmrium/issues/3047)) ([ab72c58](https://github.com/cheminfo/nmrium/commit/ab72c582d369e4b13462aa5fc52c62293615ce9a))
* implement settings migration ([cabfa87](https://github.com/cheminfo/nmrium/commit/cabfa876f1d7b53b857e1cb66f20ab46a1e006e9))
* improve range assignment label addition and editing functionality ([021656c](https://github.com/cheminfo/nmrium/commit/021656cc6b2fa82e3474b353fb3c9277de6ee1a3))
* improve zone assignment label addition and editing functionality ([#3034](https://github.com/cheminfo/nmrium/issues/3034)) ([d626f5e](https://github.com/cheminfo/nmrium/commit/d626f5e8c0f7e0c31732bfa1339616346c7bce1d))
* map shortcut with Shift key based on invert flag ([#3049](https://github.com/cheminfo/nmrium/issues/3049)) ([65e7cb1](https://github.com/cheminfo/nmrium/commit/65e7cb15c78fc89674c51324b4d9597988c71f9b))
* update nmr-load-save to version 0.32.0 ([cabfa87](https://github.com/cheminfo/nmrium/commit/cabfa876f1d7b53b857e1cb66f20ab46a1e006e9))
* zone assignment label ([#3018](https://github.com/cheminfo/nmrium/issues/3018)) ([5c3c2a5](https://github.com/cheminfo/nmrium/commit/5c3c2a5ce34e73e7532fc109d7455b83a45eede1))
* zoom out based on defined axis domain preferences ([d0bab9b](https://github.com/cheminfo/nmrium/commit/d0bab9b524bcb30cdd671b638b7ba7cb1025ec65)), closes [#3024](https://github.com/cheminfo/nmrium/issues/3024)
### Bug Fixes
* 0 value should be taken in account in the axis domain ([d0bab9b](https://github.com/cheminfo/nmrium/commit/d0bab9b524bcb30cdd671b638b7ba7cb1025ec65))
* multiple spectra analysis sorting option ([bde952b](https://github.com/cheminfo/nmrium/commit/bde952bb813d0d344f45646f25ab0735a736f5e9))
* react table warnings ([8dedfe5](https://github.com/cheminfo/nmrium/commit/8dedfe58bedb826e1ac67f790e14c7ac449c1253))
* recalculate integral reducer points based on the zoom range ([95cd297](https://github.com/cheminfo/nmrium/commit/95cd29730eb6805c0abb335a960a25dffcd788a0)), closes [#3027](https://github.com/cheminfo/nmrium/issues/3027)
* remove useless border and invalid flex config from DropZone wrapper ([#3053](https://github.com/cheminfo/nmrium/issues/3053)) ([a8a5697](https://github.com/cheminfo/nmrium/commit/a8a56978473bada380fc684f0716545e559c6984))
## [0.54.0](https://github.com/cheminfo/nmrium/compare/v0.53.0...v0.54.0) (2024-04-18)
### Features
* automatic two dimensions phase correction ([#3022](https://github.com/cheminfo/nmrium/issues/3022)) ([690971f](https://github.com/cheminfo/nmrium/commit/690971f9dc0774379d97a655e20285bf3c20d297))
* improve main toolbar tooltip ([#3008](https://github.com/cheminfo/nmrium/issues/3008)) ([dc5703c](https://github.com/cheminfo/nmrium/commit/dc5703c9a3bd93bcf619637bd9f85a21d08d127d))
* improve spectra recoloring ([#2997](https://github.com/cheminfo/nmrium/issues/2997)) ([c446198](https://github.com/cheminfo/nmrium/commit/c446198ce3231c7d4ec47edc0fab4406e4e2a5c9))
### Bug Fixes
* add more gyromagnetic ratio constants ([#3006](https://github.com/cheminfo/nmrium/issues/3006)) ([cf9cb10](https://github.com/cheminfo/nmrium/commit/cf9cb10f274de3bfe8ce4c4cd1e227f996bf3d9f))
* create a simple signal if data length is smaller than 7 points ([#3020](https://github.com/cheminfo/nmrium/issues/3020)) ([c0b406d](https://github.com/cheminfo/nmrium/commit/c0b406d0e43617e4de8e2a8a567a623c2aa7f726))
* crosshair label position ([#3001](https://github.com/cheminfo/nmrium/issues/3001)) ([9381c21](https://github.com/cheminfo/nmrium/commit/9381c2183d98befa81ee5187800909c1377ebcff))
* info pane appearance ([#3005](https://github.com/cheminfo/nmrium/issues/3005)) ([4fca536](https://github.com/cheminfo/nmrium/commit/4fca536605a16355545e7f8533ddf5a0fb05e8fc))
* set the same workspace for the base and current object, in case, the source is a nmriumFile ([cafc51a](https://github.com/cheminfo/nmrium/commit/cafc51a7af4ed5a7aba8eba1cf0836ed80ce7f81))
* set the workspace settings from the nmrium object ([acb20a6](https://github.com/cheminfo/nmrium/commit/acb20a60618d06e4c8f1523c574ab874daf3eb02))
* vertical slicing on phase correction ([#3015](https://github.com/cheminfo/nmrium/issues/3015)) ([e1c7b7c](https://github.com/cheminfo/nmrium/commit/e1c7b7c7e3be8aad1282d1bdd6194a9f5108b94e))
## [0.53.0](https://github.com/cheminfo/nmrium/compare/v0.52.0...v0.53.0) (2024-03-22)
### Features
* create and edit assignment labels for ranges ([#2971](https://github.com/cheminfo/nmrium/issues/2971)) ([31297a2](https://github.com/cheminfo/nmrium/commit/31297a2521d9b543b958894ad5402d7d42ee5f24))
* set zoom in/out as the default behavior with Shift + scroll ([#2975](https://github.com/cheminfo/nmrium/issues/2975)) ([b5d28f6](https://github.com/cheminfo/nmrium/commit/b5d28f61f4e89648fa776f24d9114b8e7416c19f))
### Bug Fixes
* avoid reselecting the tool if it's already selected ([19f5857](https://github.com/cheminfo/nmrium/commit/19f585711b4145e5f2606801760cdc617c2a2809))
* **Bruker 2D SER:** fix imaginary data ([#2977](https://github.com/cheminfo/nmrium/issues/2977)) ([0a6c21d](https://github.com/cheminfo/nmrium/commit/0a6c21de1972470763dc19c7cfa9b548e194dcd8))
* ensure activeSpectrum and tempData are not null ([9e50f1c](https://github.com/cheminfo/nmrium/commit/9e50f1c22cbe1a1c7ba0f529c04f24fabb618256))
* re-initialize FifoLogger instance when opening the modal ([73f2750](https://github.com/cheminfo/nmrium/commit/73f275063a7b13605753ac62fcff0bf6625e5223)), closes [#2981](https://github.com/cheminfo/nmrium/issues/2981)
* spectra simulation options validation ([988dfec](https://github.com/cheminfo/nmrium/commit/988dfec1c29fcba5f0004de621fd087cd2e5c0be))
* Y axis in 2D jcamp from jeol delta ([#2992](https://github.com/cheminfo/nmrium/issues/2992)) ([6f0f2c5](https://github.com/cheminfo/nmrium/commit/6f0f2c51d4bde54cfba5426c24d66071bd9ff2ef))
## [0.52.0](https://github.com/cheminfo/nmrium/compare/v0.51.0...v0.52.0) (2024-03-19)
### Features
* **zones:** add access to maxPercentCutOff option ([#2963](https://github.com/cheminfo/nmrium/issues/2963)) ([544c2cc](https://github.com/cheminfo/nmrium/commit/544c2ccbd44c63791838dbaf3853976b29d57567))
### Bug Fixes
* add missing dep ([#2972](https://github.com/cheminfo/nmrium/issues/2972)) ([72e969d](https://github.com/cheminfo/nmrium/commit/72e969d813557733c2cfce2d8b4a3905f5159c17))
* add missing dep ([#2972](https://github.com/cheminfo/nmrium/issues/2972)) ([72e969d](https://github.com/cheminfo/nmrium/commit/72e969d813557733c2cfce2d8b4a3905f5159c17))
* improve consistency of labels ([#2970](https://github.com/cheminfo/nmrium/issues/2970)) ([92fd75d](https://github.com/cheminfo/nmrium/commit/92fd75d14cc262bcfcf087e4f36ddee7f6becf8b))
* set the size correctly for real part in slicing function ([#2973](https://github.com/cheminfo/nmrium/issues/2973)) ([47233fc](https://github.com/cheminfo/nmrium/commit/47233fcb5e76dc582254c346f39ccdc11ba7c94b))
## [0.51.0](https://github.com/cheminfo/nmrium/compare/v0.50.1...v0.51.0) (2024-03-16)
### Features
* edit range peaks ([#2953](https://github.com/cheminfo/nmrium/issues/2953)) ([bcddb6e](https://github.com/cheminfo/nmrium/commit/bcddb6e742b4bbbee7809bf70d5a9b43ae76efd3))
* enable spectrum selection only when the zoom tool is activated ([#2957](https://github.com/cheminfo/nmrium/issues/2957)) ([a650eac](https://github.com/cheminfo/nmrium/commit/a650eac95897f03ad114eeb3d99c6abfeb233e96))
* improve multiple spectra analysis ([#2946](https://github.com/cheminfo/nmrium/issues/2946)) ([acce39e](https://github.com/cheminfo/nmrium/commit/acce39e33f45a96360f42b4170ae26e0abb46c1c))
* two dimensions phase correction filter ([#2930](https://github.com/cheminfo/nmrium/issues/2930)) ([adb8098](https://github.com/cheminfo/nmrium/commit/adb8098e2732ce925c6521945374afd66f10cce4))
* zoom in/out with the mouse wheel ([#2964](https://github.com/cheminfo/nmrium/issues/2964)) ([a54569f](https://github.com/cheminfo/nmrium/commit/a54569f4f201978017bac9e09d5897867c7fb559))
### Bug Fixes
* clear zoom history and hide filter options panel when apply FFT ([#2947](https://github.com/cheminfo/nmrium/issues/2947)) ([e7fb21f](https://github.com/cheminfo/nmrium/commit/e7fb21fb04ae9fcb335dba51ae802017173be58b)), closes [#2923](https://github.com/cheminfo/nmrium/issues/2923)
* do not raise an error if no 1D trace spectra are found ([#2944](https://github.com/cheminfo/nmrium/issues/2944)) ([c141116](https://github.com/cheminfo/nmrium/commit/c1411162d60146cc4da0217d3f4cc0769875c9c8))
* improve peak picking ([#2949](https://github.com/cheminfo/nmrium/issues/2949)) ([f169495](https://github.com/cheminfo/nmrium/commit/f16949563927c0af0b2274dce87266b060ce9d67))
* improve wrapping of small prediction panel toolbar ([#2954](https://github.com/cheminfo/nmrium/issues/2954)) ([31be6ba](https://github.com/cheminfo/nmrium/commit/31be6ba0cf16b5a217ea1088fe1224fa12088c13))
* pass the data to the filter before the filter affects it ([#2948](https://github.com/cheminfo/nmrium/issues/2948)) ([d8341e9](https://github.com/cheminfo/nmrium/commit/d8341e94e107f46038d8d770b7ad860ddac48e9a))
## [0.50.1](https://github.com/cheminfo/nmrium/compare/v0.50.0...v0.50.1) (2024-02-26)
### Documentation
* add BigMap in about NMRium ([#2925](https://github.com/cheminfo/nmrium/issues/2925)) ([5cb4fc4](https://github.com/cheminfo/nmrium/commit/5cb4fc4cde64221d01d13bff7c8cebb209ca14eb))
* fix bigmap funding ([#2924](https://github.com/cheminfo/nmrium/issues/2924)) ([52eeaf7](https://github.com/cheminfo/nmrium/commit/52eeaf7608ddd967513bba080e2f552be1c7a864))
## [0.50.0](https://github.com/cheminfo/nmrium/compare/v0.49.0...v0.50.0) (2024-02-21)
### Features
* display the tree for similarity ([2a21d17](https://github.com/cheminfo/nmrium/commit/2a21d1786e74b9fa8b646c07abdf7275a3cb7a51)), closes [#2905](https://github.com/cheminfo/nmrium/issues/2905)
* export spectrum as text file ([c5ad409](https://github.com/cheminfo/nmrium/commit/c5ad409c30f71bf1b6b1e99263f0ab55f11da16b))
### Bug Fixes
* confirmation box ([fe44670](https://github.com/cheminfo/nmrium/commit/fe44670a27ad4938efb5eb75556b8db67fcc8abe))
* exclude export the the rectangle over the spectrum in stack mode ([b6f9a99](https://github.com/cheminfo/nmrium/commit/b6f9a9910f758de07156833bc6fd366eaf3120d9))
* experiment type by pulse sequence ([#2920](https://github.com/cheminfo/nmrium/issues/2920)) ([7d51e12](https://github.com/cheminfo/nmrium/commit/7d51e12c09b98bd92801feda89400e0de302f7c5))
* improve info from Nanalysis n adapt bruker phase correction parameters ([#2914](https://github.com/cheminfo/nmrium/issues/2914)) ([348ed95](https://github.com/cheminfo/nmrium/commit/348ed95dc9d9fc43df6aaa6fa993661b37f101bd))
* range select for j coupling ([#2917](https://github.com/cheminfo/nmrium/issues/2917)) ([2d033e8](https://github.com/cheminfo/nmrium/commit/2d033e87461b57fa58fbe081281b37441925ed6a))
## [0.49.0](https://github.com/cheminfo/nmrium/compare/v0.48.0...v0.49.0) (2024-02-09)
### Features
* add a general preference for a popup logging level ([7b532c1](https://github.com/cheminfo/nmrium/commit/7b532c1a4db54a98dc76da0922d9729615c26365))
* add a link to NMRium videos channel ([4ddf7fe](https://github.com/cheminfo/nmrium/commit/4ddf7fe872fc080b53ac0e4ab56ef65edfbb568c)), closes [#2883](https://github.com/cheminfo/nmrium/issues/2883)
* detect baseline zones automatically ([6358e89](https://github.com/cheminfo/nmrium/commit/6358e89db0d33f509aa99334efbff5713657239b))
* display horizontal line at y = 0 for phase and baseline correction ([fda80c5](https://github.com/cheminfo/nmrium/commit/fda80c5f483a3d457312ed7af3506b5e8f4a449b)), closes [#2870](https://github.com/cheminfo/nmrium/issues/2870) [#2871](https://github.com/cheminfo/nmrium/issues/2871)
* improve resurrect spectrum from publication string and avoid crash ([#2879](https://github.com/cheminfo/nmrium/issues/2879)) ([004d983](https://github.com/cheminfo/nmrium/commit/004d98374acac909df2e2219772887e6c9c4beb2))
* improve SVG exportation ([#2882](https://github.com/cheminfo/nmrium/issues/2882)) ([a974c15](https://github.com/cheminfo/nmrium/commit/a974c1507e1a453bc52268090bbaa3ba56f9cf35))
* invert actions ([#2862](https://github.com/cheminfo/nmrium/issues/2862)) ([3b18b4e](https://github.com/cheminfo/nmrium/commit/3b18b4ebf3f0e31bdb0e6035d4f710dd2cfe5c56))
* resize baseline zones ([a3291b7](https://github.com/cheminfo/nmrium/commit/a3291b77599f268845c4955fba185e5841a6dd3a))
* show assignment atoms over ranges ([#2869](https://github.com/cheminfo/nmrium/issues/2869)) ([63e7785](https://github.com/cheminfo/nmrium/commit/63e77859f2d816d31af68d4ae8c8f979622ed192))
* sort ranges by chemical shifts ([d88c8c2](https://github.com/cheminfo/nmrium/commit/d88c8c216025f7d5dd1404f360efb07c055d8b7c)), closes [#2866](https://github.com/cheminfo/nmrium/issues/2866)
* split pseudo2D inversion recovery spectra ([#2846](https://github.com/cheminfo/nmrium/issues/2846)) ([ab43ee2](https://github.com/cheminfo/nmrium/commit/ab43ee2dbaef18073edb1194c78d33cf9d5e63ec))
### Bug Fixes
* baseline correction options ([44261ae](https://github.com/cheminfo/nmrium/commit/44261aea95738f856e15492273e8d0b95f0d1d04))
* correct rollback spectrum behaviour ([4f316a3](https://github.com/cheminfo/nmrium/commit/4f316a34284900f5a6b9a6f3030cc0851d360cf1)), closes [#2876](https://github.com/cheminfo/nmrium/issues/2876) [#2889](https://github.com/cheminfo/nmrium/issues/2889)
* prevent the refresh of the scale in baseline correction ([cdeb286](https://github.com/cheminfo/nmrium/commit/cdeb286d7373c3b1da9f0a6592037dcfbe2678bf)), closes [#2872](https://github.com/cheminfo/nmrium/issues/2872)
* reorder sub matrices from bruker data n fix varian loading ([#2847](https://github.com/cheminfo/nmrium/issues/2847)) ([ef7e1b3](https://github.com/cheminfo/nmrium/commit/ef7e1b33585340d5ec85fb0ce1c83f988805ef41))
* spectra preferences validation ([788cb45](https://github.com/cheminfo/nmrium/commit/788cb4537fc08b29c488ac609b568d3c31824800))
## [0.48.0](https://github.com/cheminfo/nmrium/compare/v0.47.0...v0.48.0) (2024-01-26)
### Features
* allow save range with no signals ([6f7bfad](https://github.com/cheminfo/nmrium/commit/6f7bfadae2610cd54c1fdec6f587a466c66f0b19))
* allow to delete info.name and info.solvent ([8fcfb77](https://github.com/cheminfo/nmrium/commit/8fcfb7719c7fd5fe0fb038c730486585b8d9b009)), closes [#2823](https://github.com/cheminfo/nmrium/issues/2823)
* improve matrix exportation ([8b57b9f](https://github.com/cheminfo/nmrium/commit/8b57b9f9c0c0f3db93dac0833a94ec394107d801)), closes [#2837](https://github.com/cheminfo/nmrium/issues/2837)
* select spectrum from the displayer ([313c3bd](https://github.com/cheminfo/nmrium/commit/313c3bde8fd08b841826a725e81ecc04d7e6612f)), closes [#2849](https://github.com/cheminfo/nmrium/issues/2849)
### Bug Fixes
* copy image to clipboard in Firefox ([21ce320](https://github.com/cheminfo/nmrium/commit/21ce3209fab4c7ec9c9ef4c64e748f02760f8392))
* create info1D for projections ([#2841](https://github.com/cheminfo/nmrium/issues/2841)) ([1571b50](https://github.com/cheminfo/nmrium/commit/1571b506abec003628a3566d73ca0b5c6c267f6b))
* disable auto-translate of the NMRium component ([#2859](https://github.com/cheminfo/nmrium/issues/2859)) ([d5e178e](https://github.com/cheminfo/nmrium/commit/d5e178e4df44f5c335c1ccd1377fba2adf37cfb2))
* plotting the derived value ([f176fc0](https://github.com/cheminfo/nmrium/commit/f176fc0cf50b001e8408fb719c4a7b27dbc9d166)), closes [#2834](https://github.com/cheminfo/nmrium/issues/2834)
* reapply filters when applying spectra processing filter ([14b344c](https://github.com/cheminfo/nmrium/commit/14b344c0bbfa819e3b0e7c69df14a4fae95aef94)), closes [#2835](https://github.com/cheminfo/nmrium/issues/2835)
* refresh local molecule state after past a new one ([1162900](https://github.com/cheminfo/nmrium/commit/1162900969ac8980ed5574dd7a383b30f44b0394))
* refresh the X domain after hiding all spectra and then showing one ([b7a80af](https://github.com/cheminfo/nmrium/commit/b7a80af25d6a06bc2f642b1ed1f013d2086a19ef))
* remove empty values from search key array ([7fe44d2](https://github.com/cheminfo/nmrium/commit/7fe44d2035745388a34184523444c9896e210d83)), closes [#2831](https://github.com/cheminfo/nmrium/issues/2831)
* set a fixed virtual scrolling height for spectra table rows ([15084d7](https://github.com/cheminfo/nmrium/commit/15084d790b632667455ef0fad5acf89264b277e9)), closes [#2824](https://github.com/cheminfo/nmrium/issues/2824)
* validate spin system data ([47c5fba](https://github.com/cheminfo/nmrium/commit/47c5fbaa7a1a656fbb02e14f1c5f390f533eb79c))
## [0.47.0](https://github.com/cheminfo/nmrium/compare/v0.46.1...v0.47.0) (2024-01-11)
### Features
* custom color schema validation ([cb0fa8c](https://github.com/cheminfo/nmrium/commit/cb0fa8c6504668be5a81f20e9ac5b4d7a847d749))
* customize the color scheme for spectra ([cb0fa8c](https://github.com/cheminfo/nmrium/commit/cb0fa8c6504668be5a81f20e9ac5b4d7a847d749)), closes [#2794](https://github.com/cheminfo/nmrium/issues/2794)
* show/hide the value of integrals ([f2a0ce3](https://github.com/cheminfo/nmrium/commit/f2a0ce3bafd1424277b6e5689ce3e3ba99ac6a4b)), closes [#2797](https://github.com/cheminfo/nmrium/issues/2797)
### Bug Fixes
* add missing peaks when use multiplet-analysis ([#2814](https://github.com/cheminfo/nmrium/issues/2814)) ([12d03b8](https://github.com/cheminfo/nmrium/commit/12d03b85a12085593210dcd986a2f6c1522ca8f1))
* disable/enable filter ([dbab8f8](https://github.com/cheminfo/nmrium/commit/dbab8f893c84e0a76f446475f5c63a1c066fb95e))
## [0.46.1](https://github.com/cheminfo/nmrium/compare/v0.46.0...v0.46.1) (2023-12-19)
### Bug Fixes
* Blueprint-related warnings ([#2808](https://github.com/cheminfo/nmrium/issues/2808)) ([6618ec1](https://github.com/cheminfo/nmrium/commit/6618ec1f26eec0a2c22bda4a17aae6e5f218c0cc))
* combined approach in manual range picking ([51f88dd](https://github.com/cheminfo/nmrium/commit/51f88ddad070a9e2474f075de49206805443db99))
* resizing range to the same size should not add a new range ([#2807](https://github.com/cheminfo/nmrium/issues/2807)) ([592fe11](https://github.com/cheminfo/nmrium/commit/592fe11db9bfdbf56f98a810775fe3fae3851c4c))
## [0.46.0](https://github.com/cheminfo/nmrium/compare/v0.45.0...v0.46.0) (2023-12-14)
### Features
* load files in parallel ([82a15d4](https://github.com/cheminfo/nmrium/commit/82a15d4457624dd21848b54dd0148144f910ee5a))
* remap existing assignments when molecule is edited ([#2779](https://github.com/cheminfo/nmrium/issues/2779)) ([840c3e5](https://github.com/cheminfo/nmrium/commit/840c3e50851035678ac49b45f2c85bdfb142e619))
### Bug Fixes
* auto phase correction ([82a15d4](https://github.com/cheminfo/nmrium/commit/82a15d4457624dd21848b54dd0148144f910ee5a))
* auto phase correction ([#2787](https://github.com/cheminfo/nmrium/issues/2787)) ([82a15d4](https://github.com/cheminfo/nmrium/commit/82a15d4457624dd21848b54dd0148144f910ee5a))
* check spectrum has imaginary part before calling xMultiply ([e8d736b](https://github.com/cheminfo/nmrium/commit/e8d736b879410aecb71c34467106b95462d5ab59))
* could loose assignement of expanded hydrogens ([#2793](https://github.com/cheminfo/nmrium/issues/2793)) ([cde96e1](https://github.com/cheminfo/nmrium/commit/cde96e1d15c8763e8b02a7dccb2c992ad6f89a8a))
* filter out bruker experiments without required files to process ([a40c318](https://github.com/cheminfo/nmrium/commit/a40c318a0b3bff9eebcd8ffe7954d4a96b923011))
* inverted fft spectrum-migration to 6 version ([#2766](https://github.com/cheminfo/nmrium/issues/2766)) ([1995e6d](https://github.com/cheminfo/nmrium/commit/1995e6dde22829170c0108ec36192a94bc44f4de))
* large negative spectra peak scale ([3262b0d](https://github.com/cheminfo/nmrium/commit/3262b0daabbcd3bbdcd68c685ad41d2f6afe0b80)), closes [#1657](https://github.com/cheminfo/nmrium/issues/1657)
* large negative spectra peak scale ([19fd560](https://github.com/cheminfo/nmrium/commit/19fd560c3ec9991e788e5afc8fbe3b6dc32f3479)), closes [#1657](https://github.com/cheminfo/nmrium/issues/1657)
* negative peak picking ([c35089f](https://github.com/cheminfo/nmrium/commit/c35089fe984cee6fe7db759e093d6262170ad39a))
* render the info value correctly in the info block ([d51ce3d](https://github.com/cheminfo/nmrium/commit/d51ce3d7630e3984304207c039513aceb923a051))
* set the first FT spectrum for 2d projection if none selected ([#2770](https://github.com/cheminfo/nmrium/issues/2770)) ([2d3fcd8](https://github.com/cheminfo/nmrium/commit/2d3fcd85cce855671a93a15fe1476d9f04ec07fd))
* title block field filter ([0345ccb](https://github.com/cheminfo/nmrium/commit/0345ccbd070b3952ebde55f871769cca4ff6c4a9)), closes [#2778](https://github.com/cheminfo/nmrium/issues/2778)
* update react-science with Modal fix ([5a74af1](https://github.com/cheminfo/nmrium/commit/5a74af1d3137f07f245ec415266459d42785fb04))
* zero filling size list ([d44f519](https://github.com/cheminfo/nmrium/commit/d44f51972c5458c88643baffe0e511ebe66a1949))
* zoom out ([76fb39b](https://github.com/cheminfo/nmrium/commit/76fb39b1c5368cd7946aa7a75b719c001778629d))
## [0.45.0](https://github.com/cheminfo/nmrium/compare/v0.44.0...v0.45.0) (2023-11-24)
### ⚠ BREAKING CHANGES
* The NMRium component is no longer rendered inside an isolated shadow DOM. I depends on a style reset such as the one done by TailwindCSS (available in `react-science/styles/preflight.css`) to function correctly.
* remove commonJS build and update TS to 5.2 ([#2670](https://github.com/cheminfo/nmrium/issues/2670))
### Features
* change mouse event to pointer event ([5f65a4c](https://github.com/cheminfo/nmrium/commit/5f65a4cb5ffa1b6375ebcfe3887aedc36f8aa43d))
* delete the phase correction trace ([0a8331d](https://github.com/cheminfo/nmrium/commit/0a8331d28129a52afc116033402ba7dc11d8d405))
* display spectrum vertically for the vertical phase correction ([af0d95b](https://github.com/cheminfo/nmrium/commit/af0d95b7e18735f43ac4214113fc32cb5f6ecd5c))
* hide the integrals within ranges by default ([7257d84](https://github.com/cheminfo/nmrium/commit/7257d84649b68e1b6ac772cd1ef0044826064dc8)), closes [#2656](https://github.com/cheminfo/nmrium/issues/2656)
* hide the peaks within ranges by default ([5492f8a](https://github.com/cheminfo/nmrium/commit/5492f8a848392c92d0ee01f2c968ebdce2c523f9))
* oxford instrument jcamp by filters ([#2706](https://github.com/cheminfo/nmrium/issues/2706)) ([42bc8e8](https://github.com/cheminfo/nmrium/commit/42bc8e82144715d8babfae31adc3e24641bd4984))
* phase correction 1d traces ([6b88bc4](https://github.com/cheminfo/nmrium/commit/6b88bc4b9b36b11e348e2ff94770ce0db056ca05))
* phase correction traces for both directions ([c625982](https://github.com/cheminfo/nmrium/commit/c6259822dfa5c8455e15dc9c815bd20389d583bf))
* scale 2D phase correction traces ([9cb5a1f](https://github.com/cheminfo/nmrium/commit/9cb5a1f7c73c37b9a132f84483487de53684c565))
* set two dimension pivot point ([f530827](https://github.com/cheminfo/nmrium/commit/f5308277be6a137b5fc54fc579bd4f2d9f1c637a))
* spectra multiple analysis chart ([8cd9122](https://github.com/cheminfo/nmrium/commit/8cd9122b91488e44be68e078f9033e0133c8f560))
### Bug Fixes
* add peaks in manual range picking ([#2668](https://github.com/cheminfo/nmrium/issues/2668)) ([50de770](https://github.com/cheminfo/nmrium/commit/50de770729ac86bec9dbd680aef57ae214d1319f))
* add range with no signals ([#2703](https://github.com/cheminfo/nmrium/issues/2703)) ([0365fdf](https://github.com/cheminfo/nmrium/commit/0365fdfe584949422b8d84a85d530dc44dcb2a89)), closes [#2687](https://github.com/cheminfo/nmrium/issues/2687)
* build esm, not cjs ([#2712](https://github.com/cheminfo/nmrium/issues/2712)) ([00ac175](https://github.com/cheminfo/nmrium/commit/00ac17505475ac151ddca9b5da20e66e13114edb))
* correct ranges-preferences to generate acs string ([#2684](https://github.com/cheminfo/nmrium/issues/2684)) ([d7c2dc1](https://github.com/cheminfo/nmrium/commit/d7c2dc1a8bd8a4236b5cf49aa02cc73929ac5076))
* detect negative in auto range picking ([#2719](https://github.com/cheminfo/nmrium/issues/2719)) ([86530ac](https://github.com/cheminfo/nmrium/commit/86530ac4c9d0a8204f16d83521e090ba6e4649db))
* display title block correctly in Safari ([a281edd](https://github.com/cheminfo/nmrium/commit/a281edd802b499f56ab59b7b99c00c0edd99e52b)), closes [#2677](https://github.com/cheminfo/nmrium/issues/2677)
* Fid plotting ([b67dfe7](https://github.com/cheminfo/nmrium/commit/b67dfe7241f77c52517bd86cfa66ae325e5e8634))
* filter spectrum columns correctly ([785850a](https://github.com/cheminfo/nmrium/commit/785850ac1cbd061e5cf3dfb6b98f683f199cb15a)), closes [#2675](https://github.com/cheminfo/nmrium/issues/2675)
* generating real data in the vertical slicing ([7991f19](https://github.com/cheminfo/nmrium/commit/7991f19d85db8008fa30bc059fbc27f13df4b01e)), closes [#2693](https://github.com/cheminfo/nmrium/issues/2693)
* integrals vertical zooms ([cacfff4](https://github.com/cheminfo/nmrium/commit/cacfff4a4e738c3be9eac333342b345b21b7e4e2))
* jcamp tree filtering n wrong scale on F1 ([#2761](https://github.com/cheminfo/nmrium/issues/2761)) ([72447eb](https://github.com/cheminfo/nmrium/commit/72447eb8639d2e95b77ec87e166095657baece59))
* load jcamp files correctly ([#2752](https://github.com/cheminfo/nmrium/issues/2752)) ([1a32500](https://github.com/cheminfo/nmrium/commit/1a325000aff031cd1d7115859567324f7c08b592)), closes [#2751](https://github.com/cheminfo/nmrium/issues/2751)
* load spectrum n assignment from jcamp ([#2754](https://github.com/cheminfo/nmrium/issues/2754)) ([c8bee9c](https://github.com/cheminfo/nmrium/commit/c8bee9c92ede5fd32cf7a03dc55d0c8e5b6bf7b2))
* manual peak picking pointer head position ([4dfa666](https://github.com/cheminfo/nmrium/commit/4dfa66682a5cd4e0a9ce1f37cbb02256ea142ab9))
* open the log history automatically if we have error or fatal ([5c7629e](https://github.com/cheminfo/nmrium/commit/5c7629eeddac7276beb05b641fda210d900b0815)), closes [#2755](https://github.com/cheminfo/nmrium/issues/2755)
* phase correction 2D slices ([#2748](https://github.com/cheminfo/nmrium/issues/2748)) ([110998a](https://github.com/cheminfo/nmrium/commit/110998a7cf38344a38df2e7d0c07255e0a9a5773))
* read gyromagnetic ratio correctly ([db978d9](https://github.com/cheminfo/nmrium/commit/db978d95ffab5ad2cb73f517d8d2820a272beb75))
* resolve the conflict of the analysis modal correctly ([#2727](https://github.com/cheminfo/nmrium/issues/2727)) ([fe6a81c](https://github.com/cheminfo/nmrium/commit/fe6a81c84413ff6120e8e24b0a8553e63fcfe4a7))
* set active spectra ([4f0626b](https://github.com/cheminfo/nmrium/commit/4f0626b3c01ab19ea690beb8822e1674e256eec3))
* shift spectrum 2D ([#2744](https://github.com/cheminfo/nmrium/issues/2744)) ([bd77ab4](https://github.com/cheminfo/nmrium/commit/bd77ab4c61b4efda212c194babfa105f79bfd57b))
* slicing 1d left trace clip width and its container's zindex ([f7e976a](https://github.com/cheminfo/nmrium/commit/f7e976a81834aa678a4b0e48814a013c8a5abbe8))
* support nmredata extension ([#2692](https://github.com/cheminfo/nmrium/issues/2692)) ([a2736cf](https://github.com/cheminfo/nmrium/commit/a2736cf322edd872289c7e41ec504fdffcb00ae8))
* traces ([0a8331d](https://github.com/cheminfo/nmrium/commit/0a8331d28129a52afc116033402ba7dc11d8d405))
### Miscellaneous Chores
* remove commonJS build and update TS to 5.2 ([#2670](https://github.com/cheminfo/nmrium/issues/2670)) ([82c871c](https://github.com/cheminfo/nmrium/commit/82c871c91ee8f02db393608e61abca5c2745f11a))
* update react-science ([#2700](https://github.com/cheminfo/nmrium/issues/2700)) ([f918969](https://github.com/cheminfo/nmrium/commit/f918969057d5afea1d6ad21117032b9355dfe010))
## [0.44.0](https://github.com/cheminfo/nmrium/compare/v0.43.0...v0.44.0) (2023-09-13)
### ⚠ BREAKING CHANGES
* rename key prefix 'origin' to 'original'
### Features
* control the visibility of NMRium header items ([7a24c77](https://github.com/cheminfo/nmrium/commit/7a24c779adb15e310a99378a376fe9c473d75ce4))
* delete range peak ([045418d](https://github.com/cheminfo/nmrium/commit/045418d20e4811998ab73b7c8ae3f26d8e420ec6))
* display ranges peaks ([5655c02](https://github.com/cheminfo/nmrium/commit/5655c020fbeeab71ca5a6813877c631145793705))
* helper function to create action column ([123377c](https://github.com/cheminfo/nmrium/commit/123377cb6bb15b8655d7b43242f6c21c5e08f948))
* improve bruker files loading ([#2662](https://github.com/cheminfo/nmrium/issues/2662)) ([d3d231f](https://github.com/cheminfo/nmrium/commit/d3d231f0b9cdce41e1b28820de278d35bf07d254))
* improve peaks and integrals preferences ([123377c](https://github.com/cheminfo/nmrium/commit/123377cb6bb15b8655d7b43242f6c21c5e08f948))
* improve ranges preferences ([a8b397f](https://github.com/cheminfo/nmrium/commit/a8b397fe573fb033eb8e343badeef52265a561bc))
* improve signal kinds for ranges and integrals ([a8ca174](https://github.com/cheminfo/nmrium/commit/a8ca174863b498fc78b99b21702e9da3dcf9e7dd)), closes [#2600](https://github.com/cheminfo/nmrium/issues/2600)
* improve zones preferences ([4966d90](https://github.com/cheminfo/nmrium/commit/4966d90b6fc9e5117d3a33bf11700fc00daa55db))
* toggle 'ranges peaks' visibility and displaying mode ([133de16](https://github.com/cheminfo/nmrium/commit/133de16bc499b7fbd683d8ade8dc62a09d9db956))
* validate the option and the spectra based on the selected options ([f5eb365](https://github.com/cheminfo/nmrium/commit/f5eb365fa50f5205879d5b21758aae1dfb83d37f))
### Bug Fixes
* check peaks array before mapping ([a43bfb7](https://github.com/cheminfo/nmrium/commit/a43bfb7c0ad0e7d928844abc202b1803465ff7c1))
* consecutive selection ([53fff90](https://github.com/cheminfo/nmrium/commit/53fff90b3f3fe28cc69fe7531b34e719db63949d)), closes [#2664](https://github.com/cheminfo/nmrium/issues/2664)
* define sum options for ranges and integrals when initiating the spectrum ([d1fc56f](https://github.com/cheminfo/nmrium/commit/d1fc56fb24db69c600ae9ec053d86f927112264d))
* do not raise an error if no 1D trace spectra are found ([ac56101](https://github.com/cheminfo/nmrium/commit/ac5610169be72ad4d14fbaa2a45991ca38378289)), closes [#2643](https://github.com/cheminfo/nmrium/issues/2643)
* extract the number correctly from the editable column value ([0e11fd6](https://github.com/cheminfo/nmrium/commit/0e11fd6dbd88888b76a4e2e411e0d37de39fea4a))
* full zoom out ([#2640](https://github.com/cheminfo/nmrium/issues/2640)) ([ff0361f](https://github.com/cheminfo/nmrium/commit/ff0361f829b5919409ba23fb915de1c63239d2d8)), closes [#2639](https://github.com/cheminfo/nmrium/issues/2639)
* integrals in fid data ([1291818](https://github.com/cheminfo/nmrium/commit/12918182c102f46b5c4d65442c3061fdd6466b9d))
* recalculate integration when toggling or deleting filter ([81d4388](https://github.com/cheminfo/nmrium/commit/81d43886b2f6c9836552720ce8baabd6b54d60d7)), closes [#2637](https://github.com/cheminfo/nmrium/issues/2637)
* reduce min resolution for smart range picking ([#2630](https://github.com/cheminfo/nmrium/issues/2630)) ([f01d0e4](https://github.com/cheminfo/nmrium/commit/f01d0e4a4f372e33cbac146925982a4d59182cf6))
* spectra calibration ([f5eb365](https://github.com/cheminfo/nmrium/commit/f5eb365fa50f5205879d5b21758aae1dfb83d37f)), closes [#2566](https://github.com/cheminfo/nmrium/issues/2566)
### Code Refactoring
* rename key prefix 'origin' to 'original' ([adfe8d3](https://github.com/cheminfo/nmrium/commit/adfe8d384ae5b1253b2deac17d36eb7153c252ef))
## [0.43.0](https://github.com/cheminfo/nmrium/compare/v0.42.0...v0.43.0) (2023-08-17)
### ⚠ BREAKING CHANGES
* NMRium is now a named export and some types were renamed for consistency
### Features
* 2d Fourier transform ([#2294](https://github.com/cheminfo/nmrium/issues/2294)) ([40e1a4f](https://github.com/cheminfo/nmrium/commit/40e1a4fc509cccab65cf5f4572ce424f5c27b243))
* add integrals from Bruker 1D data ([#2599](https://github.com/cheminfo/nmrium/issues/2599)) ([0c5fda5](https://github.com/cheminfo/nmrium/commit/0c5fda550e2226315eefe7ba1f39ecfc569c1d49))
* add molecule labels and improve speed of molecules ([#2623](https://github.com/cheminfo/nmrium/issues/2623)) ([ce9c7b9](https://github.com/cheminfo/nmrium/commit/ce9c7b983cce6b76563aafddd0ba152a478e0ef5))
* add new way to display peaks ([#2562](https://github.com/cheminfo/nmrium/issues/2562)) ([12e88a1](https://github.com/cheminfo/nmrium/commit/12e88a15a5566c8c3752d089ba49c67b18c6fb69))
* cut integral ([6ea9103](https://github.com/cheminfo/nmrium/commit/6ea91037732ea42e841294516d5c3cb211f900a3))
* cut range ([3a8856d](https://github.com/cheminfo/nmrium/commit/3a8856d1a54e3e4923c7c0984b507e210fbd094e))
* hook for enabling/disabling resizing with Shift key modifier ([eb477d9](https://github.com/cheminfo/nmrium/commit/eb477d9b6f17540e6abe0850d7668a3f8d60b137))
* key modifiers listener ([06f56ea](https://github.com/cheminfo/nmrium/commit/06f56ea05de1842d1f6370606644f29abda25dc8))
* perform resizing only when Shift key is not active ([ac14483](https://github.com/cheminfo/nmrium/commit/ac14483a23acb8793ed55eb826282d417b4ec020)), closes [#2570](https://github.com/cheminfo/nmrium/issues/2570)
* report error contains debug state ([#2555](https://github.com/cheminfo/nmrium/issues/2555)) ([05e40c0](https://github.com/cheminfo/nmrium/commit/05e40c0d1cdc1a58743b6d7bfbf7cac8ce7c998b))
* show label under floating molecules ([#2554](https://github.com/cheminfo/nmrium/issues/2554)) ([5c2ba0d](https://github.com/cheminfo/nmrium/commit/5c2ba0d26e1199ea447cf17089f8df612ec0f30f))
### Bug Fixes
* 2d shift filter ([#2594](https://github.com/cheminfo/nmrium/issues/2594)) ([b63fe93](https://github.com/cheminfo/nmrium/commit/b63fe933f489d227f35ef3754db590dec13f25c8)), closes [#2591](https://github.com/cheminfo/nmrium/issues/2591)
* correct the integration sum for integrals and ranges ([#2617](https://github.com/cheminfo/nmrium/issues/2617)) ([7977041](https://github.com/cheminfo/nmrium/commit/7977041923451c7c75bf0423facb3b923562cc5f))
* do not render two buttons in ChangeSumModal ([3f273d2](https://github.com/cheminfo/nmrium/commit/3f273d2d4ec859516a771e8db02892341009c5e5))
* filters live preview ([#2620](https://github.com/cheminfo/nmrium/issues/2620)) ([b798502](https://github.com/cheminfo/nmrium/commit/b7985021d93d73f15e18d35064f4818fb5d2eb68))
* improve prediction ([#2613](https://github.com/cheminfo/nmrium/issues/2613)) ([5f35c00](https://github.com/cheminfo/nmrium/commit/5f35c0060afb312ced3a4be08c36426e3fb1402d))
* load good ones and catch error in the logger ([#2616](https://github.com/cheminfo/nmrium/issues/2616)) ([4413975](https://github.com/cheminfo/nmrium/commit/44139757f34a04fb9b74944dc9670224a9af3c67))
* update react-science ([#2593](https://github.com/cheminfo/nmrium/issues/2593)) ([795ace9](https://github.com/cheminfo/nmrium/commit/795ace9f65142d7e0e2319e122929daf65b9195f))
### Code Refactoring
* move public types to their own file ([a921a8b](https://github.com/cheminfo/nmrium/commit/a921a8bf6f8285bc3dd1eaccae2ae28ba253aa6d))
## [0.42.0](https://github.com/cheminfo/nmrium/compare/v0.41.0...v0.42.0) (2023-07-27)
### Features
* create Scroller component ([128662e](https://github.com/cheminfo/nmrium/commit/128662e3630fc2b24aae02d1fe8fb01b55a1166f))
* format the number fields in the info block ([#2546](https://github.com/cheminfo/nmrium/issues/2546)) ([0e81e02](https://github.com/cheminfo/nmrium/commit/0e81e0237308acaca6b2f305d2ad67792668e14c))
* paste / import a list of structures ([#2544](https://github.com/cheminfo/nmrium/issues/2544)) ([f092df6](https://github.com/cheminfo/nmrium/commit/f092df68d42a6793f0fd1312dbce1d828420841b)), closes [#2382](https://github.com/cheminfo/nmrium/issues/2382)
* scroll to the active nucleus spectra preferences ([d71db46](https://github.com/cheminfo/nmrium/commit/d71db4609cf8dcc7a30dc0ac3846f19f8fc6fd72)), closes [#2547](https://github.com/cheminfo/nmrium/issues/2547)
### Bug Fixes
* clamp SVG paths to avoid rendering issues ([#2551](https://github.com/cheminfo/nmrium/issues/2551)) ([b8fe1a4](https://github.com/cheminfo/nmrium/commit/b8fe1a42d7e0df9050a6d932def0fb1a89422b91))
* save new workspace ([#2541](https://github.com/cheminfo/nmrium/issues/2541)) ([93cabc8](https://github.com/cheminfo/nmrium/commit/93cabc86a3bff97dbbc75f0b8262b456b363054c))
* search should be by ideCode beside the other criteria ([0e18164](https://github.com/cheminfo/nmrium/commit/0e18164cd388a3ffd484fb228e6ddc7c20f8903c))
* use spectralWidth as an option to spectralWidthClipped jeol ([#2553](https://github.com/cheminfo/nmrium/issues/2553)) ([95de3b0](https://github.com/cheminfo/nmrium/commit/95de3b09be824c8c844a19715e424073da265d14))
## [0.41.0](https://github.com/cheminfo/nmrium/compare/v0.40.1...v0.41.0) (2023-07-22)
### Features
* 1D pan horizontally and 2D pan vertically and horizontally ([#2498](https://github.com/cheminfo/nmrium/issues/2498)) ([594e791](https://github.com/cheminfo/nmrium/commit/594e79193b5d32064e40ab2aabdcd9f08a911c02))
* 1d spectrum simulation ([#2513](https://github.com/cheminfo/nmrium/issues/2513)) ([caf4cbd](https://github.com/cheminfo/nmrium/commit/caf4cbd31bbd146447c755a4242cb759b6f6617a))
* add the "frequency" and spin system as "name" to the simulated spectrum info ([#2530](https://github.com/cheminfo/nmrium/issues/2530)) ([21b1e1b](https://github.com/cheminfo/nmrium/commit/21b1e1b47d370a6aec6d615b0e22873d2b9b3c56))
* create a workspace for simulation ([#2532](https://github.com/cheminfo/nmrium/issues/2532)) ([1ca5910](https://github.com/cheminfo/nmrium/commit/1ca59100ab8358810ee3baf823dd56825e3e7182)), closes [#2527](https://github.com/cheminfo/nmrium/issues/2527)
### Bug Fixes
* autoExtendRange option and logs for simulation with signals are out of range. ([#2507](https://github.com/cheminfo/nmrium/issues/2507)) ([31c3844](https://github.com/cheminfo/nmrium/commit/31c3844cdeacdc3ce34458386a41a388686ab891))
* baseline correction zones visibility ([0f27e2f](https://github.com/cheminfo/nmrium/commit/0f27e2f45efdb928e0fddf7a7fed810709a981aa)), closes [#2348](https://github.com/cheminfo/nmrium/issues/2348)
* integral value editing if the sum 0 ([#2464](https://github.com/cheminfo/nmrium/issues/2464)) ([e6d6e0a](https://github.com/cheminfo/nmrium/commit/e6d6e0a31c1fe674e95fc05f54c56f5b00ae24e9))
* manual range multiplicity ([#2535](https://github.com/cheminfo/nmrium/issues/2535)) ([9aa7cd2](https://github.com/cheminfo/nmrium/commit/9aa7cd2a9f1c4121176f22c073d72e85b7d039e2))
* preferFt bruker data filtering was not working for 2D ([#2538](https://github.com/cheminfo/nmrium/issues/2538)) ([3663544](https://github.com/cheminfo/nmrium/commit/36635440383cffe07ea9f3a8ef61ad1c221496ce))
* prevent clearing the molecule from the structure editor after changing the settings ([8cb98a3](https://github.com/cheminfo/nmrium/commit/8cb98a3630c9722d8138bd7d3922c079650810c7)), closes [#2512](https://github.com/cheminfo/nmrium/issues/2512)
* unexpected errors in reducer crashing the app ([dbd2b8c](https://github.com/cheminfo/nmrium/commit/dbd2b8c8570955d8623c30a52e0d70e28f5875f2))
* update frequency for the simulated spectrum ([#2534](https://github.com/cheminfo/nmrium/issues/2534)) ([23958a0](https://github.com/cheminfo/nmrium/commit/23958a08c84c1982c6750733cf499c0e6d53dbad)), closes [#2533](https://github.com/cheminfo/nmrium/issues/2533)
## [0.40.1](https://github.com/cheminfo/nmrium/compare/v0.40.0...v0.40.1) (2023-07-06)
### Bug Fixes
* **release:** trigger new release ([#2501](https://github.com/cheminfo/nmrium/issues/2501)) ([5ba9c07](https://github.com/cheminfo/nmrium/commit/5ba9c07262557754d29b36704f94d355236eeb75))
## [0.40.0](https://github.com/cheminfo/nmrium/compare/v0.39.0...v0.40.0) (2023-07-06)
### Features
* open logger dialog automatically ([b80a2d1](https://github.com/cheminfo/nmrium/commit/b80a2d1c88969632ef00c83d0b88924488156d4f)), closes [#2485](https://github.com/cheminfo/nmrium/issues/2485)
### Bug Fixes
* some modal sizes ([#2377](https://github.com/cheminfo/nmrium/issues/2377)) ([7d114d9](https://github.com/cheminfo/nmrium/commit/7d114d9aede5e7acadaeee64eeb768519df116e5))
* unhandled error when clipboard read permissions are not granted ([#2492](https://github.com/cheminfo/nmrium/issues/2492)) ([41b4cd8](https://github.com/cheminfo/nmrium/commit/41b4cd885839be9ee251af4c45bb9d8177226521))
## [0.39.0](https://github.com/cheminfo/nmrium/compare/v0.38.2...v0.39.0) (2023-06-30)
### Features
* add low res prediction ([#2478](https://github.com/cheminfo/nmrium/issues/2478)) ([44ff57e](https://github.com/cheminfo/nmrium/commit/44ff57e89f4e746ed8950c3acb269b8e5f3c50e5))
* allow to render NMRium without error boundary ([#2489](https://github.com/cheminfo/nmrium/issues/2489)) ([8bde9b9](https://github.com/cheminfo/nmrium/commit/8bde9b9a31f6d730fe8502a3371f6088f3b82285))
### Bug Fixes
* close the 'range editing' model of the range or spectra deleted ([0bc6183](https://github.com/cheminfo/nmrium/commit/0bc61839c1b177676a66ef397e28b1684f214ccb))
* extract and check id object correctly ([56ec65a](https://github.com/cheminfo/nmrium/commit/56ec65a5ed3a4e10026eadacdce970ebd88c5d03))
* log errors to the console to help debugging ([#2486](https://github.com/cheminfo/nmrium/issues/2486)) ([89cccd1](https://github.com/cheminfo/nmrium/commit/89cccd1c1be7e17cc51e5b28ca8325a16da6cd91))
* manual zones detection for predicted 2D spectra ([#2487](https://github.com/cheminfo/nmrium/issues/2487)) ([8da944b](https://github.com/cheminfo/nmrium/commit/8da944b790a29ac8c5a3ed9c34342e36b8b36e25))
* peaks and integrals panels should be visible only in 1D mode ([dded4f4](https://github.com/cheminfo/nmrium/commit/dded4f40484d4b8d03b6c7f84c8832fd56af8798))
* reset the selected tool to zoom when switching between spectra or nuclei ([eee03ca](https://github.com/cheminfo/nmrium/commit/eee03cafe40ab4bdffb26a3a4ddcd2a6848b3c1e))
* set preferences ([24d7613](https://github.com/cheminfo/nmrium/commit/24d7613927b6beb2dc20a68e8da0eba17c740188))
* simulate spectra with negative chemical shift and catch some errors ([#2488](https://github.com/cheminfo/nmrium/issues/2488)) ([e677e06](https://github.com/cheminfo/nmrium/commit/e677e0622368b7fec5aa9832042ce90b38acb37c))
* spectra zones detection should be only on FT 2D spectra ([293d2fb](https://github.com/cheminfo/nmrium/commit/293d2fb8678eb31b004f1b6bb63bee0bce4bde45))
* validate JCAMP file URL correctly ([82b4c42](https://github.com/cheminfo/nmrium/commit/82b4c427591ade7ea4fdbb8bb441ab6778a8c599))
## [0.38.2](https://github.com/cheminfo/nmrium/compare/v0.38.1...v0.38.2) (2023-06-22)
### Bug Fixes
* auto (peaks and ranges) picking window size ([2b6a045](https://github.com/cheminfo/nmrium/commit/2b6a0454e01e532344c4e3da35705a700d194f39))
* check 'delta' is exists before call the toFixed function ([#2437](https://github.com/cheminfo/nmrium/issues/2437)) ([b46f6ec](https://github.com/cheminfo/nmrium/commit/b46f6eceab35ad2adaf66e5f422256ede2b62a85))
* check for the nucleus before extracting info from the atom ([fecc3f8](https://github.com/cheminfo/nmrium/commit/fecc3f8e96e354c73b4b3d02aa58e178f9e9f65d))
* check the meta file has an accepted mimeType ([#2445](https://github.com/cheminfo/nmrium/issues/2445)) ([2974e54](https://github.com/cheminfo/nmrium/commit/2974e54ddfa3c9b68e637e99a1f61c4cb2e23152)), closes [#2418](https://github.com/cheminfo/nmrium/issues/2418)
* disable the 'preview publication string' button when no ranges ([0d5b6b7](https://github.com/cheminfo/nmrium/commit/0d5b6b7ff09c6a373a1400821098d41528dcc110))
* display react-table empty row correctly ([443f62e](https://github.com/cheminfo/nmrium/commit/443f62edfb8dfc6d8270ec31838de15ce9b292bf))
* do not prevent triggering onChange when props are changed ([37dadf8](https://github.com/cheminfo/nmrium/commit/37dadf8addff251795dd93c2c181528a0cf3f888))
* hide spectrum settings dialog if it's 2d Fid ([5a780f6](https://github.com/cheminfo/nmrium/commit/5a780f691ea524d431b1c4e89a4d43224d6f9d6b)), closes [#2424](https://github.com/cheminfo/nmrium/issues/2424)
* jcamp-dx generation n move filters to nmr-processing ([#2386](https://github.com/cheminfo/nmrium/issues/2386)) ([470abab](https://github.com/cheminfo/nmrium/commit/470abab98a53a6ddee6bc93818b0cff90a41bdfb))
## [0.38.1](https://github.com/cheminfo/nmrium/compare/v0.38.0...v0.38.1) (2023-06-09)
### Bug Fixes
* parse jcamp URL correctly ([#2407](https://github.com/cheminfo/nmrium/issues/2407)) ([714f1a6](https://github.com/cheminfo/nmrium/commit/714f1a66145879793f16313ab6ac606440c4fd4a))
* spectra prediction ([#2408](https://github.com/cheminfo/nmrium/issues/2408)) ([45c52ba](https://github.com/cheminfo/nmrium/commit/45c52bab522b0ed8941c325510b4281885d10862))
## [0.38.0](https://github.com/cheminfo/nmrium/compare/v0.37.0...v0.38.0) (2023-06-08)
### Features
* include 'view' object with the normal save ([#2388](https://github.com/cheminfo/nmrium/issues/2388)) ([f69d213](https://github.com/cheminfo/nmrium/commit/f69d2137597be577c4f5a57e356f82e93149d914))
* rename metaInfo to customInfo and reorder information panel ([#2380](https://github.com/cheminfo/nmrium/issues/2380)) ([1731ce4](https://github.com/cheminfo/nmrium/commit/1731ce493da010495ee03adfce1e2f077dd2eed9))
### Bug Fixes
* correctly determine if a molecule is empty ([#2403](https://github.com/cheminfo/nmrium/issues/2403)) ([72e6979](https://github.com/cheminfo/nmrium/commit/72e69792bb97820cddb28d7b7e712c19ba114d4e)), closes [#2400](https://github.com/cheminfo/nmrium/issues/2400)
* do not use p element in NoData component ([#2401](https://github.com/cheminfo/nmrium/issues/2401)) ([f86d42c](https://github.com/cheminfo/nmrium/commit/f86d42cda9502eb2e1b7a0da8137ad80ac69b2af))
* manual 'add range' crash when no spectrum is selected ([#2399](https://github.com/cheminfo/nmrium/issues/2399)) ([3ab5514](https://github.com/cheminfo/nmrium/commit/3ab5514f7563b78fe4c467aa686f322e385a4c95)), closes [#2390](https://github.com/cheminfo/nmrium/issues/2390)
* manual coupling edition ([#2384](https://github.com/cheminfo/nmrium/issues/2384)) ([fb8b576](https://github.com/cheminfo/nmrium/commit/fb8b576aac7abecbf2cd4a0cfce788645857321f)), closes [#2353](https://github.com/cheminfo/nmrium/issues/2353)
* show time domain spectrum if none of the selected spectrum is FT ([#2370](https://github.com/cheminfo/nmrium/issues/2370)) ([480d9de](https://github.com/cheminfo/nmrium/commit/480d9dea4afbc83e0aeb79bc2888f6910252278b))
## [0.37.0](https://github.com/cheminfo/nmrium/compare/v0.36.0...v0.37.0) (2023-05-26)
### Features
* add onError callback to support errors caught by the boundary ([32eea35](https://github.com/cheminfo/nmrium/commit/32eea353b6422a1085ee91425c6fec770f48de54))
* improve 2d assignments ([#2357](https://github.com/cheminfo/nmrium/issues/2357)) ([ff99d1e](https://github.com/cheminfo/nmrium/commit/ff99d1e0f9bc897991c09aa29f459720863c115c))
* improve floating structure initial position ([#2378](https://github.com/cheminfo/nmrium/issues/2378)) ([6312cf9](https://github.com/cheminfo/nmrium/commit/6312cf9eb68fd808d21bba2df70c47f8bdb8f3a7))
* show information about the Spectra prediction ([#2372](https://github.com/cheminfo/nmrium/issues/2372)) ([6ecd8ab](https://github.com/cheminfo/nmrium/commit/6ecd8ab0108e3f807e9fb4f0007de9e6113dc016)), closes [#2367](https://github.com/cheminfo/nmrium/issues/2367)
### Bug Fixes
* processing spectra on load ([#2365](https://github.com/cheminfo/nmrium/issues/2365)) ([15c22b7](https://github.com/cheminfo/nmrium/commit/15c22b739a80bf574a9f0427022e102345c1667b))
## [0.36.0](https://github.com/cheminfo/nmrium/compare/v0.35.0...v0.36.0) (2023-05-18)
### Features
* display assigned indicator on the top of ranges ([#2341](https://github.com/cheminfo/nmrium/issues/2341)) ([eefcaa4](https://github.com/cheminfo/nmrium/commit/eefcaa4546a07b8e63c38ef0d9872fd25beea398)), closes [#2338](https://github.com/cheminfo/nmrium/issues/2338)
* manual zone selection create only one zone/signal ([#2354](https://github.com/cheminfo/nmrium/issues/2354)) ([d6e6232](https://github.com/cheminfo/nmrium/commit/d6e6232768511b9ac264f3728f3df5ee7869028e))
### Bug Fixes
* check symmetry first for manual range picking ([#2339](https://github.com/cheminfo/nmrium/issues/2339)) ([0886f50](https://github.com/cheminfo/nmrium/commit/0886f504497a118ae7f1d1ce899122a50a861a7d))
* manage correctly 19F n 31P jeol data ([#2355](https://github.com/cheminfo/nmrium/issues/2355)) ([e01ffdf](https://github.com/cheminfo/nmrium/commit/e01ffdf896439c2aa9a85573528ddc0b51c73be9))
* normalize nucleus for jeol n varian ([#2356](https://github.com/cheminfo/nmrium/issues/2356)) ([a4acc6b](https://github.com/cheminfo/nmrium/commit/a4acc6b60608f2ffde3a50635c8ccb7b4ed69ef4))
* reverse varian data to avoid inverted spectrum ([#2347](https://github.com/cheminfo/nmrium/issues/2347)) ([34c41b5](https://github.com/cheminfo/nmrium/commit/34c41b5f1d566b6659e9155befe8cd4071b81505))
* spectrum object should include the sourceSelector ([#2360](https://github.com/cheminfo/nmrium/issues/2360)) ([8d9161b](https://github.com/cheminfo/nmrium/commit/8d9161b7cb7713d6880c31fc8bdc73ef8724b679))
* use a central source of possible patterns for multiplicities ([#2352](https://github.com/cheminfo/nmrium/issues/2352)) ([fa4dc72](https://github.com/cheminfo/nmrium/commit/fa4dc72d725b9de76a040aca67426034e71e81e6))
## [0.35.0](https://github.com/cheminfo/nmrium/compare/v0.34.0...v0.35.0) (2023-05-04)
### Features
* add popup title over assign ranges and signals column ([#2332](https://github.com/cheminfo/nmrium/issues/2332)) ([f0cdd50](https://github.com/cheminfo/nmrium/commit/f0cdd501932147bb68c55ac02e15b864e05972ed)), closes [#2312](https://github.com/cheminfo/nmrium/issues/2312)
* export as JCAMP-DX ([#2283](https://github.com/cheminfo/nmrium/issues/2283)) ([7a5f520](https://github.com/cheminfo/nmrium/commit/7a5f520b8e760519b24229000b0a72087dec702c))
* improve assignments ([#2288](https://github.com/cheminfo/nmrium/issues/2288)) ([d861d18](https://github.com/cheminfo/nmrium/commit/d861d1844f055fb7f1180cbf35330e94f427cb29))
* match phase correction to topspin ([#2305](https://github.com/cheminfo/nmrium/issues/2305)) ([e13047d](https://github.com/cheminfo/nmrium/commit/e13047d21533b43bc670fe1b984172dd303dd86b))
* save database product as .nmrium file ([#2273](https://github.com/cheminfo/nmrium/issues/2273)) ([1b103e1](https://github.com/cheminfo/nmrium/commit/1b103e1dee0acbe0eb8bb4c393ac7985d79086b0))
* show a message when the database panel is not available ([#2334](https://github.com/cheminfo/nmrium/issues/2334)) ([d7a555f](https://github.com/cheminfo/nmrium/commit/d7a555f7b7b02383bd3ae845ece817b45ae5c68c))
### Bug Fixes
* actionType should not be empty ([#2319](https://github.com/cheminfo/nmrium/issues/2319)) ([26c573a](https://github.com/cheminfo/nmrium/commit/26c573ac0bea1c2491fa70255407bbee45ddd51f)), closes [#2318](https://github.com/cheminfo/nmrium/issues/2318)
* assignments ([#2322](https://github.com/cheminfo/nmrium/issues/2322)) ([8a11cda](https://github.com/cheminfo/nmrium/commit/8a11cda333dbb1ad5048dc2fc742596a38132672))
* crash with full cytisine and assignment summary ([#2331](https://github.com/cheminfo/nmrium/issues/2331)) ([c1f29de](https://github.com/cheminfo/nmrium/commit/c1f29de38ceb85bb963dd490316285d8eec18417))
* do not add empty string for name in migration ([#2316](https://github.com/cheminfo/nmrium/issues/2316)) ([e33bcab](https://github.com/cheminfo/nmrium/commit/e33bcab88f9a1fefb3d5c8a42a94caf74a564db1))
* erase setting completely when the settings version changed ([#2323](https://github.com/cheminfo/nmrium/issues/2323)) ([5c1af96](https://github.com/cheminfo/nmrium/commit/5c1af96ac58800f470f64c7b477e4e69fc062601))
* onChange callback debounce ([#2296](https://github.com/cheminfo/nmrium/issues/2296)) ([ec822d8](https://github.com/cheminfo/nmrium/commit/ec822d8c7ed5e0ac95f4a5b2d3f1335584679dfc))
* peak, ranges, and zones picking options input refresh ([#2317](https://github.com/cheminfo/nmrium/issues/2317)) ([6a6ef64](https://github.com/cheminfo/nmrium/commit/6a6ef6448de41c554b8b4ac13ca7bbb202aff302))
* ph0 value starts from zero ([#2315](https://github.com/cheminfo/nmrium/issues/2315)) ([5d08c1a](https://github.com/cheminfo/nmrium/commit/5d08c1a50ae99e93e79cf23be4ca2e08f6d0e450)), closes [#2314](https://github.com/cheminfo/nmrium/issues/2314)
* react-table layout ([#2293](https://github.com/cheminfo/nmrium/issues/2293)) ([d40f76b](https://github.com/cheminfo/nmrium/commit/d40f76baefe4771b0538de1148448e904c2ae1e8))
* spectra intensity change after step out horizontally ([#2281](https://github.com/cheminfo/nmrium/issues/2281)) ([b1aa905](https://github.com/cheminfo/nmrium/commit/b1aa90596561183d90597fd0025e4663d66d3b7f))
* structures labels uniqueness ([#2333](https://github.com/cheminfo/nmrium/issues/2333)) ([3c7126d](https://github.com/cheminfo/nmrium/commit/3c7126de05ff45ab51da489b1f98b839ea12a527)), closes [#2303](https://github.com/cheminfo/nmrium/issues/2303)
## [0.34.0](https://github.com/cheminfo/nmrium/compare/v0.33.0...v0.34.0) (2023-03-24)
### Features
* 2d fid ([#1633](https://github.com/cheminfo/nmrium/issues/1633)) ([1a89ffc](https://github.com/cheminfo/nmrium/commit/1a89ffcac8dde7173e6f92288c6dd3d0539aec21))
* add description for predefined columns ([741646d](https://github.com/cheminfo/nmrium/commit/741646d883990c099e63e096cd96900cb3a6b5c4))
* add importation filters tab to general settings ([#1957](https://github.com/cheminfo/nmrium/issues/1957)) ([7769d6c](https://github.com/cheminfo/nmrium/commit/7769d6c6a48689721e6f07a5746bae034ed8d197)), closes [#1607](https://github.com/cheminfo/nmrium/issues/1607)
* add Matrix generation options per nucleus in the View state ([878910a](https://github.com/cheminfo/nmrium/commit/878910a5dbe46b34af497b461be75b900c6b16f2))
* add signal processing filter ([7ea6416](https://github.com/cheminfo/nmrium/commit/7ea641613ecc8d1cb8478ae4fa960c9c1c28434a))
* add spectra column customization ([741646d](https://github.com/cheminfo/nmrium/commit/741646d883990c099e63e096cd96900cb3a6b5c4))
* add the 'source' property for original file ([#2126](https://github.com/cheminfo/nmrium/issues/2126)) ([c1dbe93](https://github.com/cheminfo/nmrium/commit/c1dbe93b743c32673fe9b239e88d52f88d0bd142))
* auto-complete for spectra objects paths ([6af9af5](https://github.com/cheminfo/nmrium/commit/6af9af502edec5acbf7f77011492b1f10796f4af)), closes [#2045](https://github.com/cheminfo/nmrium/issues/2045)
* change contours levels for all 2d spectra if no spectrum is selected ([#2074](https://github.com/cheminfo/nmrium/issues/2074)) ([ce89796](https://github.com/cheminfo/nmrium/commit/ce89796b16e5e5eb0d5510bfbfc7e730b1a1a2d3)), closes [#2069](https://github.com/cheminfo/nmrium/issues/2069)
* copy and past workspace ([c7c012b](https://github.com/cheminfo/nmrium/commit/c7c012ba64776db6cc9b3408b1da6bd21645b8f2))
* copy molfile as V3 or V2 ([#2201](https://github.com/cheminfo/nmrium/issues/2201)) ([9692f5a](https://github.com/cheminfo/nmrium/commit/9692f5ab646df77cd87a2cf1175e2fa99095fb6c))
* create a new workspace "assignment" ([#1895](https://github.com/cheminfo/nmrium/issues/1895)) ([c04d6df](https://github.com/cheminfo/nmrium/commit/c04d6df91f3d34b910f4f874319f0886ef29e704))
* custom layout component for svg elements ([f019c0a](https://github.com/cheminfo/nmrium/commit/f019c0a5b4426937eb5861804ca5f52d1df0a663))
* customize spectra legends ([a332ead](https://github.com/cheminfo/nmrium/commit/a332ead8ccd79a208a2160e462f915f92eeba5bc))
* database table scroll position ([#1860](https://github.com/cheminfo/nmrium/issues/1860)) ([2e480a1](https://github.com/cheminfo/nmrium/commit/2e480a15017b1dd5a196373726b1152b320292b5))
* delete all filters under a specific spectrum ([4198f17](https://github.com/cheminfo/nmrium/commit/4198f171551408d244d1301b9eb0d83c5bf8d7d0))
* display matrix generation panel ([#1955](https://github.com/cheminfo/nmrium/issues/1955)) ([d1d326e](https://github.com/cheminfo/nmrium/commit/d1d326ee8e4ebc188cc8f23544ec74566f93c96d)), closes [#1953](https://github.com/cheminfo/nmrium/issues/1953)
* display spectra info block ([1f1cfd8](https://github.com/cheminfo/nmrium/commit/1f1cfd87229a3c24d780b4b2ff92c34ec06abdd4))
* distinguish FT spectrum which processed by NMRium with an icon ([#2157](https://github.com/cheminfo/nmrium/issues/2157)) ([efa979f](https://github.com/cheminfo/nmrium/commit/efa979f257fdfa904f56f5f56d05943e9c65dcb1)), closes [#2149](https://github.com/cheminfo/nmrium/issues/2149)
* field auto complete ([7b3590c](https://github.com/cheminfo/nmrium/commit/7b3590c2820a45bc5ac7162924f87cf7e7de604b))
* fileCollection as source in .nmrium files ([#2022](https://github.com/cheminfo/nmrium/issues/2022)) ([8aad5c6](https://github.com/cheminfo/nmrium/commit/8aad5c6878595c77f080ae5c9ba6686479c95cd9))
* import meta information automatically ([54b48da](https://github.com/cheminfo/nmrium/commit/54b48dad1795b7ccb02946cb420f9596fac7d1e5))
* import spectra meta information ([77ff6a3](https://github.com/cheminfo/nmrium/commit/77ff6a3441be6d439a99526011c18d53516e2536)), closes [#1462](https://github.com/cheminfo/nmrium/issues/1462)
* improve general settings UI ([#1966](https://github.com/cheminfo/nmrium/issues/1966)) ([82a33e8](https://github.com/cheminfo/nmrium/commit/82a33e8790af71461f6574d906e4ae70149d8638))
* improve multiple spectra analysis panel ([#1964](https://github.com/cheminfo/nmrium/issues/1964)) ([93158dd](https://github.com/cheminfo/nmrium/commit/93158ddec4fbffdaff65a2729b43f71c9843586b)), closes [#1921](https://github.com/cheminfo/nmrium/issues/1921)
* improve spectra analysis ([#1987](https://github.com/cheminfo/nmrium/issues/1987)) ([64c029d](https://github.com/cheminfo/nmrium/commit/64c029d3abbe46d0c7c3200fd3cd8c59c1f27d57)), closes [#1980](https://github.com/cheminfo/nmrium/issues/1980)
* integrate with fifo-logger ([#2231](https://github.com/cheminfo/nmrium/issues/2231)) ([0282462](https://github.com/cheminfo/nmrium/commit/02824625bfdad165173dbc78509f09701325e3f2))
* load .nmrium file without spectra ([#2123](https://github.com/cheminfo/nmrium/issues/2123)) ([#2125](https://github.com/cheminfo/nmrium/issues/2125)) ([aff9a4e](https://github.com/cheminfo/nmrium/commit/aff9a4eba8e46210f274053637ee082d80a7adff))
* load .nmrium file without spectra and have iew or, and setting… ([#2123](https://github.com/cheminfo/nmrium/issues/2123)) ([106ad9b](https://github.com/cheminfo/nmrium/commit/106ad9beb17025b2f7d1920807f9414abe9ef18d))
* matrix generation ([53b9832](https://github.com/cheminfo/nmrium/commit/53b9832ec306d6424a9903cd476056108d07b05f))
* message component (success, error, warning, and info) ([653f459](https://github.com/cheminfo/nmrium/commit/653f459a352051a917ea37b7b8489fcdd61585db))
* nmr-load-save prerelease with filters ([#1965](https://github.com/cheminfo/nmrium/issues/1965)) ([f0a9471](https://github.com/cheminfo/nmrium/commit/f0a9471ce568766d5aad0507b4dc4ce77fe6bab8))
* order multiple spectra analysis table ([#1887](https://github.com/cheminfo/nmrium/issues/1887)) ([9f90f13](https://github.com/cheminfo/nmrium/commit/9f90f1354b5f4a9d03b503f0ecea75144bd483d6))
* process FID spectra automatically to FT ([#2141](https://github.com/cheminfo/nmrium/issues/2141)) ([d3b87ad](https://github.com/cheminfo/nmrium/commit/d3b87adaa24ce941b58e8dfac32806a2811a1f3d))
* re-coloring spectra based on the distinct value ([1cdedf9](https://github.com/cheminfo/nmrium/commit/1cdedf9a521f73091afb2937e47a18cd19949c22)), closes [#1882](https://github.com/cheminfo/nmrium/issues/1882)
* react table columns virtual scroll ([2282a75](https://github.com/cheminfo/nmrium/commit/2282a754ba5b47a8247ca8ff041001ab68875c96))
* recolor spectra ([b57ed9d](https://github.com/cheminfo/nmrium/commit/b57ed9d51be64e03edaa9b83d4c70e4829936102)), closes [#2081](https://github.com/cheminfo/nmrium/issues/2081)
* redetect signal when resizing the range ([#2007](https://github.com/cheminfo/nmrium/issues/2007)) ([90d8487](https://github.com/cheminfo/nmrium/commit/90d8487ea0d64a9f4dffdb57abeb13933e8a5fb6))
* resize floating molecule ([52d16e6](https://github.com/cheminfo/nmrium/commit/52d16e6e40cc81a5180c7328cf9a137ee9408cb7)), closes [#1929](https://github.com/cheminfo/nmrium/issues/1929)
* save vertical splitter position in workspace ([#2203](https://github.com/cheminfo/nmrium/issues/2203)) ([b35418f](https://github.com/cheminfo/nmrium/commit/b35418f94417bdd1646ec72b55d9aba82b47389c))
* select multiple active spectra ([#2104](https://github.com/cheminfo/nmrium/issues/2104)) ([0c214a8](https://github.com/cheminfo/nmrium/commit/0c214a81d63097a5198e4591567f5079521117c6))
* set custom workspaces at the level of the NMRium component ([#1956](https://github.com/cheminfo/nmrium/issues/1956)) ([f3b3c65](https://github.com/cheminfo/nmrium/commit/f3b3c65a68f0b0d3260b3714aebad4c5a29f5d4f))
* show a message when drag/drop files raise an error ([#1962](https://github.com/cheminfo/nmrium/issues/1962)) ([9b3c956](https://github.com/cheminfo/nmrium/commit/9b3c95679baa1311b6268106950c32a6c724b0b7))
* show molecule atoms number ([#1918](https://github.com/cheminfo/nmrium/issues/1918)) ([3468b96](https://github.com/cheminfo/nmrium/commit/3468b966caceedbbda5b99a37181941903df08e9)), closes [#1916](https://github.com/cheminfo/nmrium/issues/1916)
* signal processing filter ([4a1bccf](https://github.com/cheminfo/nmrium/commit/4a1bccfe88bc687ccc4d4ba8795f59c4925dc463))
* sort spectra ([fde2fbc](https://github.com/cheminfo/nmrium/commit/fde2fbc2328bac1ae69c2759319e97456443d48b)), closes [#2018](https://github.com/cheminfo/nmrium/issues/2018)
* use 2D data quadrants and reload assignment from JCAMP-DX ([#1861](https://github.com/cheminfo/nmrium/issues/1861)) ([435e961](https://github.com/cheminfo/nmrium/commit/435e961b974da9ca167f699aa67f524dc22c9606))
### Bug Fixes
* add one level in filters ([#2120](https://github.com/cheminfo/nmrium/issues/2120)) ([24b6f36](https://github.com/cheminfo/nmrium/commit/24b6f3673087249a707304614623a4dd8ba75665))
* alert messages are outside the visible page ([#1890](https://github.com/cheminfo/nmrium/issues/1890)) ([221cf24](https://github.com/cheminfo/nmrium/commit/221cf24eab188afb9790d53a41f95a336f23b795)), closes [#1875](https://github.com/cheminfo/nmrium/issues/1875)
* avoid timeout during assignment ([d813541](https://github.com/cheminfo/nmrium/commit/d813541cea903b022e38e04ac3ffdf494123e928))
* avoid unmounts in spectra panel ([#2197](https://github.com/cheminfo/nmrium/issues/2197)) ([fc2f07a](https://github.com/cheminfo/nmrium/commit/fc2f07a27c4604b260736263be423923ae65825d)), closes [#1901](https://github.com/cheminfo/nmrium/issues/1901)
* baseline correction live preview ([#1969](https://github.com/cheminfo/nmrium/issues/1969)) ([c7c012b](https://github.com/cheminfo/nmrium/commit/c7c012ba64776db6cc9b3408b1da6bd21645b8f2))
* coupling constant format in database table ([#1877](https://github.com/cheminfo/nmrium/issues/1877)) ([d72a1a1](https://github.com/cheminfo/nmrium/commit/d72a1a195832a3bcb713afd79cc5185d09a34676)), closes [#1853](https://github.com/cheminfo/nmrium/issues/1853)
* coupling constants format ([#1856](https://github.com/cheminfo/nmrium/issues/1856)) ([4e899e6](https://github.com/cheminfo/nmrium/commit/4e899e6ba7bc33515f952be54f0a4ddea5b3de14))
* digits format ([#2137](https://github.com/cheminfo/nmrium/issues/2137)) ([fc38f51](https://github.com/cheminfo/nmrium/commit/fc38f51c8c0ef0cb82eb49e47be0bd64b1c114c8))
* dropdown list position ([#2010](https://github.com/cheminfo/nmrium/issues/2010)) ([9545851](https://github.com/cheminfo/nmrium/commit/9545851c33fd889d44168c82704599ee170bbced)), closes [#2008](https://github.com/cheminfo/nmrium/issues/2008)
* edit range ([#1975](https://github.com/cheminfo/nmrium/issues/1975)) ([27141bc](https://github.com/cheminfo/nmrium/commit/27141bc4781dc291a4e50b673b118e6d4f0008b6))
* empty test cases not working ([#2180](https://github.com/cheminfo/nmrium/issues/2180)) ([45cb60d](https://github.com/cheminfo/nmrium/commit/45cb60d5840ec985afb9f9f07f9dac1e4f394762)), closes [#2172](https://github.com/cheminfo/nmrium/issues/2172)
* exclusion zones ([#1897](https://github.com/cheminfo/nmrium/issues/1897)) ([4766608](https://github.com/cheminfo/nmrium/commit/4766608a091459023fda5cf871f0abff51c4cfa6))
* export as raw data should not include the 'source' object ([#2241](https://github.com/cheminfo/nmrium/issues/2241)) ([c5eba03](https://github.com/cheminfo/nmrium/commit/c5eba031c3fdf11ea222343c6ea0c7c86a8c199d))
* extend preference dataSelection to jcamp format ([#2185](https://github.com/cheminfo/nmrium/issues/2185)) ([b88f7fd](https://github.com/cheminfo/nmrium/commit/b88f7fdad1e348964ba98ed41aecbae5fc28dbd7))
* handle correctly only bruker SER ([#2067](https://github.com/cheminfo/nmrium/issues/2067)) ([ad33c74](https://github.com/cheminfo/nmrium/commit/ad33c741b5c25340c0ffc6f36ece1930beb00d9d))
* hide/show spectra ([#1961](https://github.com/cheminfo/nmrium/issues/1961)) ([189dc94](https://github.com/cheminfo/nmrium/commit/189dc947a8c9962ecf276addf0f456bd1f054f9e)), closes [#1960](https://github.com/cheminfo/nmrium/issues/1960)
* import spectrum data with nmr-load-save ([#1862](https://github.com/cheminfo/nmrium/issues/1862)) ([520ce89](https://github.com/cheminfo/nmrium/commit/520ce89f5626fc77cab2f6385023010e676c30f3))
* importation ranges relative value from publication string ([#2228](https://github.com/cheminfo/nmrium/issues/2228)) ([893e3e5](https://github.com/cheminfo/nmrium/commit/893e3e56ff695d3c890261c146dade3609b64a59))
* jeol files with data not power of 2 ([af13a62](https://github.com/cheminfo/nmrium/commit/af13a621d4be0955c92e04734962df67cd785cb7))
* jpath ([91d9f7f](https://github.com/cheminfo/nmrium/commit/91d9f7f1989cfb45812c894be921c828f2af42c2)), closes [#2080](https://github.com/cheminfo/nmrium/issues/2080)
* multiple spectra analysis columns preferences ([#1878](https://github.com/cheminfo/nmrium/issues/1878)) ([7d45a4a](https://github.com/cheminfo/nmrium/commit/7d45a4a297ded9c788f8746223b767fd720fb4cd)), closes [#1874](https://github.com/cheminfo/nmrium/issues/1874)
* onload processing ([#2254](https://github.com/cheminfo/nmrium/issues/2254)) ([ede4887](https://github.com/cheminfo/nmrium/commit/ede488750bae842abce70931b1c34f9422bb93bf)), closes [#2250](https://github.com/cheminfo/nmrium/issues/2250)
* parse hex color and extract opacity ([#2233](https://github.com/cheminfo/nmrium/issues/2233)) ([991748a](https://github.com/cheminfo/nmrium/commit/991748a6ca416332770c196b8095d4dea4f5d6b3))
* prediction and improve speediness ([#1971](https://github.com/cheminfo/nmrium/issues/1971)) ([1f9aa4d](https://github.com/cheminfo/nmrium/commit/1f9aa4d7fd35f82f8eaf074b2e3ed482c96d9bde))
* rangesToACS don't guess multiplicity ([#2028](https://github.com/cheminfo/nmrium/issues/2028)) ([494fcc3](https://github.com/cheminfo/nmrium/commit/494fcc36f6b8f71ac9c642859a73507cdc031f90))
* re-edition of zero filling ([925cea7](https://github.com/cheminfo/nmrium/commit/925cea78eaf6fb271c2322813a4990c40c974bbd)), closes [#2150](https://github.com/cheminfo/nmrium/issues/2150)
* react table virtual scroll ([#1879](https://github.com/cheminfo/nmrium/issues/1879)) ([8b6def9](https://github.com/cheminfo/nmrium/commit/8b6def94f65f93767a566b7b1d954e8c0bf62ec3)), closes [#1863](https://github.com/cheminfo/nmrium/issues/1863)
* set `default` workspace if the specified workspace does not exists in the workspaces object ([#1989](https://github.com/cheminfo/nmrium/issues/1989)) ([733e3a8](https://github.com/cheminfo/nmrium/commit/733e3a842faeb7266280211ed1934d896ddf40d4)), closes [#1979](https://github.com/cheminfo/nmrium/issues/1979)
* set the zoom tool active when deselecting another tool ([ef718c7](https://github.com/cheminfo/nmrium/commit/ef718c7d05f2a6640b6a5fc0c57646502e21f14b)), closes [#2066](https://github.com/cheminfo/nmrium/issues/2066)
* sorting by solvent ([#2037](https://github.com/cheminfo/nmrium/issues/2037)) ([23f7660](https://github.com/cheminfo/nmrium/commit/23f76601d5f74a626e6c6903f2da6f990bf545a4)), closes [#2017](https://github.com/cheminfo/nmrium/issues/2017)
* spectra table columns width ([#2210](https://github.com/cheminfo/nmrium/issues/2210)) ([40a9f5b](https://github.com/cheminfo/nmrium/commit/40a9f5b37750db000ab5be684d3d790626cc30d9))
* speed of database load with precalculated indexes ([3c76502](https://github.com/cheminfo/nmrium/commit/3c765027eff0f3603dca9f96aac65c66da98b2f5))
* support .jcamp extensions ([d78acd4](https://github.com/cheminfo/nmrium/commit/d78acd43c8fa48727b8b176d1bcda938e17ac71b))
* swapped family and given name in citation.cff ([#2047](https://github.com/cheminfo/nmrium/issues/2047)) ([9fae0ad](https://github.com/cheminfo/nmrium/commit/9fae0adaab0620961abf6f50f4d0a3bc1ee8d5e1))
* the 2d tab should be active by default if we have 2d and 1d spectra ([741646d](https://github.com/cheminfo/nmrium/commit/741646d883990c099e63e096cd96900cb3a6b5c4))
* use svg transform instead of css transform ([#2204](https://github.com/cheminfo/nmrium/issues/2204)) ([1631aac](https://github.com/cheminfo/nmrium/commit/1631aacfd281bde38845694a2280beaf82759c0d))
* vertical axis for the slicing tool ([#1846](https://github.com/cheminfo/nmrium/issues/1846)) ([06e2787](https://github.com/cheminfo/nmrium/commit/06e2787b7bf76c15e01ea22c9dc173a5e6d1a0d6))
* wait for the container height value before calculating the virtual scroll boundary ([#2027](https://github.com/cheminfo/nmrium/issues/2027)) ([424328f](https://github.com/cheminfo/nmrium/commit/424328f5a33ad79320adee7dd43bdacc4f40fb2a))
## [0.33.0](https://github.com/cheminfo/nmrium/compare/v0.32.0...v0.33.0) (2022-10-27)
### Features
* show a message when the 2d has too many lines ([55617e2](https://github.com/cheminfo/nmrium/commit/55617e2f8ea17d6ee36d80a7d340584d45f6692e))
* support for inline jcamp from nmr-load-save ([#1816](https://github.com/cheminfo/nmrium/issues/1816)) ([c9fcbf4](https://github.com/cheminfo/nmrium/commit/c9fcbf4bdee6c224e5b2e573396fb7fba2072be9))
### Bug Fixes
* absolute integration column format ([#1828](https://github.com/cheminfo/nmrium/issues/1828)) ([f87886b](https://github.com/cheminfo/nmrium/commit/f87886bee312f6a09e0072f370cc4d470eecd352)), closes [#1827](https://github.com/cheminfo/nmrium/issues/1827)
* add `jcamp` to data source types ([bc1bd11](https://github.com/cheminfo/nmrium/commit/bc1bd11a69071aef5a31e4481701c49a1c7af91f))
* chemical shift in 'ranges' has no impact ([e55c35f](https://github.com/cheminfo/nmrium/commit/e55c35fa4739bec1db543ed7ce746bf2b4ba46fa)), closes [#1808](https://github.com/cheminfo/nmrium/issues/1808)
* remove DC offset if AQ_mod is qsim ([#1804](https://github.com/cheminfo/nmrium/issues/1804)) ([135a072](https://github.com/cheminfo/nmrium/commit/135a072693d0de425025abeb8d90429b1a7a3008))
## [0.32.0](https://github.com/cheminfo/nmrium/compare/v0.31.0...v0.32.0) (2022-10-13)
### Features
* add ellipsis to molecule label when exceeding the defined size ([62b268a](https://github.com/cheminfo/nmrium/commit/62b268a45db1e0b119642d8ca4d834f07236d207)), closes [#1784](https://github.com/cheminfo/nmrium/issues/1784)
* display the index of the x array of the spectrum in the 1D footer ([8f32820](https://github.com/cheminfo/nmrium/commit/8f328209d741cf823815eb00acd903bb7d01f868)), closes [#1795](https://github.com/cheminfo/nmrium/issues/1795)
* improve zoom tool ([#1794](https://github.com/cheminfo/nmrium/issues/1794)) ([9fe278f](https://github.com/cheminfo/nmrium/commit/9fe278f4ed0b0b92c0d480ef230532a73f342bcf)), closes [#1783](https://github.com/cheminfo/nmrium/issues/1783)
* limit the Molecule label length to a maximum of 10 characters ([9a49474](https://github.com/cheminfo/nmrium/commit/9a4947477fb190f270e1e15d73a7aea74f3c717d)), closes [#1691](https://github.com/cheminfo/nmrium/issues/1691)
* sync 2d chart spectrum colors ([#1807](https://github.com/cheminfo/nmrium/issues/1807)) ([10c7b1a](https://github.com/cheminfo/nmrium/commit/10c7b1af7d8d5399233237fedf5ade34eb66aad8))
### Bug Fixes
* **contours:** use xSanplot instead of absMedian ([#1790](https://github.com/cheminfo/nmrium/issues/1790)) ([e8b16c7](https://github.com/cheminfo/nmrium/commit/e8b16c7a08624cc32212dc71cee487dab326bfb9))
* copy to clipboard in Safari ([a6b54c9](https://github.com/cheminfo/nmrium/commit/a6b54c956a7b3c8b860ecd346174879d91df769c))
* count callback tests ([#1802](https://github.com/cheminfo/nmrium/issues/1802)) ([2d69b50](https://github.com/cheminfo/nmrium/commit/2d69b50c1c821775fb6025c508f07b1f48963c67))
* phase correction crash after absolute ([e185b71](https://github.com/cheminfo/nmrium/commit/e185b712c4b497e1b665323299afb3b129fdfaf1)), closes [#1766](https://github.com/cheminfo/nmrium/issues/1766)
* shift spectrum not working when change the value directly from peaks table ([acd1ab3](https://github.com/cheminfo/nmrium/commit/acd1ab3c88aeeb52f6ce1b8665769792b55e19d8))
* stop page scrolling when zooming in spectra by mouse wheel ([46e0b16](https://github.com/cheminfo/nmrium/commit/46e0b16cf3503260abbeae7f9f3bb53344ca63b6)), closes [#1799](https://github.com/cheminfo/nmrium/issues/1799)
* switch between Real and imaginary spectra ([bfbae61](https://github.com/cheminfo/nmrium/commit/bfbae61840e8f8e404eb7506218128ab4061bc5b)), closes [#1780](https://github.com/cheminfo/nmrium/issues/1780)
## [0.31.0](https://github.com/cheminfo/nmrium/compare/v0.30.0...v0.31.0) (2022-09-23)
### Features
* allow apodization, zf, ft in exercises ([4ee24ba](https://github.com/cheminfo/nmrium/commit/4ee24bad78882c8d55e3d1f3a44d6d7f8e905fe2))
* implement onViewChange callback ([#1743](https://github.com/cheminfo/nmrium/issues/1743)) ([865cfe6](https://github.com/cheminfo/nmrium/commit/865cfe65e5e97d15eec7565d3acbaa1823bd3d14))
* remember position of floating molecule ([#1730](https://github.com/cheminfo/nmrium/issues/1730)) ([179e4a0](https://github.com/cheminfo/nmrium/commit/179e4a0fe32b27d9ae8e53aab344fedb050f7392))
* use nmr-load-save to allow among other to drag / drop directly a bruker folder ([#1753](https://github.com/cheminfo/nmrium/issues/1753)) ([11a6fa3](https://github.com/cheminfo/nmrium/commit/11a6fa30b0f4a9cdd73739566b1b753eb3087518))
### Bug Fixes
* dialog box position ([#1757](https://github.com/cheminfo/nmrium/issues/1757)) ([ce1ab49](https://github.com/cheminfo/nmrium/commit/ce1ab49750f04279ce7cd6543f86a009c413042c))
* peak shape drawing ([#1767](https://github.com/cheminfo/nmrium/issues/1767)) ([90a75a7](https://github.com/cheminfo/nmrium/commit/90a75a77d25630170d806007664aa5ef184b5466)), closes [#1746](https://github.com/cheminfo/nmrium/issues/1746)
* peaks, signals, ranges, zones with id ([#1732](https://github.com/cheminfo/nmrium/issues/1732)) ([bdb4daa](https://github.com/cheminfo/nmrium/commit/bdb4daa917a149fe2186a9a668511ffdc291565a))
* refactor range tools state to fix state-related bugs ([#1731](https://github.com/cheminfo/nmrium/issues/1731)) ([ebac30a](https://github.com/cheminfo/nmrium/commit/ebac30a305b5f1dd0da4e3caa29a83d50235bf61))
* support changing onViewChange callback ([ff529ed](https://github.com/cheminfo/nmrium/commit/ff529ed8e4a0d3b9a60e1763ce59622c6290f76c))
## [0.30.0](https://github.com/cheminfo/nmrium/compare/v0.29.0...v0.30.0) (2022-08-26)
### ⚠ BREAKING CHANGES
* React v18 is now mandatory
### Features
* activate resizing for integrals/ranges when its tool selected ([4c75f34](https://github.com/cheminfo/nmrium/commit/4c75f345735e718fcf8687867ba9fb393b824399)), closes [#1648](https://github.com/cheminfo/nmrium/issues/1648)
* apodization window preview ([#1647](https://github.com/cheminfo/nmrium/issues/1647)) ([16b97b3](https://github.com/cheminfo/nmrium/commit/16b97b36a3df275ade018f10769a33fc6ea26aa0))
* change the spectra alignment from stack to center when pressing on 'c' shortcut ([7be801f](https://github.com/cheminfo/nmrium/commit/7be801f62a8ab4e3f726d08e2e7b80ea03b005ec)), closes [#1652](https://github.com/cheminfo/nmrium/issues/1652)
* disable baseline correction live preview ([b1e7845](https://github.com/cheminfo/nmrium/commit/b1e784591a7aa7f222c52a4f552bad7d2ec40000))
* enable/disable resize in the resizer component ([6797c43](https://github.com/cheminfo/nmrium/commit/6797c4362249700c8af28538e4bab471e638c619))
* improve 1d filters ([#1623](https://github.com/cheminfo/nmrium/issues/1623)) ([4651216](https://github.com/cheminfo/nmrium/commit/465121603fe468f751401521257a892a9f94bd3b))
* improve multiple spectra range deletion ([e6007e3](https://github.com/cheminfo/nmrium/commit/e6007e3e998b0eb310162ddec7a2a0c572a7ced7)), closes [#1661](https://github.com/cheminfo/nmrium/issues/1661)
* improve peak picking ([ecc091c](https://github.com/cheminfo/nmrium/commit/ecc091c4a7957e4c5fd332e44f7d1b6f7a6c50d3)), closes [#1651](https://github.com/cheminfo/nmrium/issues/1651)
* improve remove exclusion zone/s ([d24dfb1](https://github.com/cheminfo/nmrium/commit/d24dfb10e0476bdb9e053ea02a6b9d3b91506c7a)), closes [#1667](https://github.com/cheminfo/nmrium/issues/1667)
* improvement of prediction panel ([fa9d49c](https://github.com/cheminfo/nmrium/commit/fa9d49cf607740be9f2df70dedde0b1436e42969)), closes [#1664](https://github.com/cheminfo/nmrium/issues/1664)
* move selected spectrum to front ([784a793](https://github.com/cheminfo/nmrium/commit/784a793e30f429392eeb502b70b16efe415ddbbd))
* open spectra panel after prediction ([a939255](https://github.com/cheminfo/nmrium/commit/a939255b45f93589c3a2d280fdbce04419ad03f1)), closes [#1663](https://github.com/cheminfo/nmrium/issues/1663)
* peaks annotations should not be displayed if the spectrum not active ([e10f0bd](https://github.com/cheminfo/nmrium/commit/e10f0bdf1972fc8a94c15d0602a0ac284706133e)), closes [#1662](https://github.com/cheminfo/nmrium/issues/1662)
* React v18 is now mandatory ([2793d90](https://github.com/cheminfo/nmrium/commit/2793d907181b33783e30f2fdbaf4f0d35ee3d4c0))
* zero-filling filter live preview ([5979a85](https://github.com/cheminfo/nmrium/commit/5979a855a622b4d6219db58fa349acffd1b0c246)), closes [#1646](https://github.com/cheminfo/nmrium/issues/1646)
### Bug Fixes
* absolute median as noise level for 2D ([#1660](https://github.com/cheminfo/nmrium/issues/1660)) ([735eb90](https://github.com/cheminfo/nmrium/commit/735eb9087cf001f0948b4a52910fec0e8a78e9a1))
* correct and refactor floating molecules ([#1715](https://github.com/cheminfo/nmrium/issues/1715)) ([9000808](https://github.com/cheminfo/nmrium/commit/9000808ea53b53f90d86a7fac4626dd49e938af9))
* database search ([c9af976](https://github.com/cheminfo/nmrium/commit/c9af97637f908dda1252fb77a025094f8f1e3bc0)), closes [#1678](https://github.com/cheminfo/nmrium/issues/1678)
* import molecules id on loading json data ([#1725](https://github.com/cheminfo/nmrium/issues/1725)) ([5c43d1f](https://github.com/cheminfo/nmrium/commit/5c43d1fdc5fbd5875d432ec2a7a157653ee68037))
* improve 2D first display performance ([78be996](https://github.com/cheminfo/nmrium/commit/78be9969cac8118332c376bba2308b16fa5f9bca))
* **prediction2D:** right place for experiment ([#1675](https://github.com/cheminfo/nmrium/issues/1675)) ([e331998](https://github.com/cheminfo/nmrium/commit/e331998554cadd22eeea2641fbe23dfd4f1fcde9))
* **prediction:** empty multiplicity for singulets ([b2d6b2d](https://github.com/cheminfo/nmrium/commit/b2d6b2d006ec932f74691bc6eb0b52c7cfbe45aa))
* resizing multiple spectra range ([e6007e3](https://github.com/cheminfo/nmrium/commit/e6007e3e998b0eb310162ddec7a2a0c572a7ced7))
* round data to dataPoints reported ([#1685](https://github.com/cheminfo/nmrium/issues/1685)) ([f271ade](https://github.com/cheminfo/nmrium/commit/f271adef416c34bac8cfdebde76617c9626d25b3))
* show change sum modal when structure panel is visible ([f58ad99](https://github.com/cheminfo/nmrium/commit/f58ad9992b8252fcf5061faac78375f473e2c1c1)), closes [#1687](https://github.com/cheminfo/nmrium/issues/1687)
## [0.29.0](https://github.com/cheminfo/nmrium/compare/v0.28.0...v0.29.0) (2022-07-25)
### Features
* activate/deactivate baseline correction live preview ([e835290](https://github.com/cheminfo/nmrium/commit/e835290f2281fac5ef9476c08cf2dfe922c28780))
* improve general settings ([#1611](https://github.com/cheminfo/nmrium/issues/1611)) ([92d1c93](https://github.com/cheminfo/nmrium/commit/92d1c938562ba4f5004b6bf41bf62e4216e48079))
### Bug Fixes
* resetting database ([23fa7b5](https://github.com/cheminfo/nmrium/commit/23fa7b5e7849ba892cc95dcbd432bee25686b33b)), closes [#1638](https://github.com/cheminfo/nmrium/issues/1638)
## [0.28.0](https://github.com/cheminfo/nmrium/compare/v0.27.0...v0.28.0) (2022-07-15)
### Features
* add hyperlink to database record in preferences if google docs ([abfaa6a](https://github.com/cheminfo/nmrium/commit/abfaa6a21dad2f6d28cb4d7d176f49f20faade54)), closes [#1499](https://github.com/cheminfo/nmrium/issues/1499)
* add ranges when adding jcamp from the database ([8a4bd63](https://github.com/cheminfo/nmrium/commit/8a4bd639a502b938a64608a01610cbaefa6f539a)), closes [#1571](https://github.com/cheminfo/nmrium/issues/1571)
* automatically close the right side of the split ([d94cc68](https://github.com/cheminfo/nmrium/commit/d94cc6895b25170c791ec3a3b6b87cbc68a96f8c)), closes [#1570](https://github.com/cheminfo/nmrium/issues/1570)
* automatically load the default database when open its panel ([#1612](https://github.com/cheminfo/nmrium/issues/1612)) ([d61c0aa](https://github.com/cheminfo/nmrium/commit/d61c0aa5c1bec89dd938257d1e25cbc8ad9fc932)), closes [#1608](https://github.com/cheminfo/nmrium/issues/1608)
* database advanced search by molecule structure ([#1602](https://github.com/cheminfo/nmrium/issues/1602)) ([fed6872](https://github.com/cheminfo/nmrium/commit/fed6872c382050b30a17ec0e6eac5443b5bc06e0))
* database can have `ocl` property that will be used index if available ([9afad9b](https://github.com/cheminfo/nmrium/commit/9afad9b033f8439ff394797e79048bb36b002ee6))
* disable drag and drop ([503f1c0](https://github.com/cheminfo/nmrium/commit/503f1c0cf026af2a5ca760fadaf77e1103c8bffb)), closes [#1582](https://github.com/cheminfo/nmrium/issues/1582)
* expanded hydrogens in the floating molecule ([7dd5e9c](https://github.com/cheminfo/nmrium/commit/7dd5e9cc27e309ee633761e03d4311b9048f8ac0)), closes [#1572](https://github.com/cheminfo/nmrium/issues/1572)
* force component preferences over local storage preferences ([0c9b63d](https://github.com/cheminfo/nmrium/commit/0c9b63df9b64091161a89e124670019ddae7d236))
* force SplitPanel re-render when hidePanelOnLoad value change ([9f01e7f](https://github.com/cheminfo/nmrium/commit/9f01e7f97b1e18a5274adf4d444c23a453e6e5ef))
* format the decimal fields in database panel ([4700745](https://github.com/cheminfo/nmrium/commit/470074583328838c22613b1773b3423a0d8a6675)), closes [#1592](https://github.com/cheminfo/nmrium/issues/1592)
* generate spectra viewer as blob from outside component ([#1589](https://github.com/cheminfo/nmrium/issues/1589)) ([d64597c](https://github.com/cheminfo/nmrium/commit/d64597cc648fd3753dca0bd821a1dcf9cb51cd24))
* improve loading database ([#1615](https://github.com/cheminfo/nmrium/issues/1615)) ([288e4b0](https://github.com/cheminfo/nmrium/commit/288e4b03720d4428759f5fbcbc3f79d9caf63a44)), closes [#1614](https://github.com/cheminfo/nmrium/issues/1614)
* live preview for baseline correction ([#1621](https://github.com/cheminfo/nmrium/issues/1621)) ([1993aa3](https://github.com/cheminfo/nmrium/commit/1993aa3ca13efdbab6be33f9bc285c3663b219b4))
* reapply the line broadening filter should take the last value and not the sum ([c083073](https://github.com/cheminfo/nmrium/commit/c0830737d48158e233552232ebbdbcbf99a9898e)), closes [#1618](https://github.com/cheminfo/nmrium/issues/1618)
* return .nmrium format when trigger onDataChange ([bf97af0](https://github.com/cheminfo/nmrium/commit/bf97af01799992191b3eabd369d7143fc149279b)), closes [#1584](https://github.com/cheminfo/nmrium/issues/1584)
* set default alignment 'stack' when loading many spectra ([72599ea](https://github.com/cheminfo/nmrium/commit/72599ea2a327860357cc1127b24950471b492fa9)), closes [#1577](https://github.com/cheminfo/nmrium/issues/1577)
* show a message if the import is disabled ([581d587](https://github.com/cheminfo/nmrium/commit/581d587895c2961f7dacc433d9ad21c231e14ccc)), closes [#1586](https://github.com/cheminfo/nmrium/issues/1586)
* throttling to display jcamp from database ([99c7c34](https://github.com/cheminfo/nmrium/commit/99c7c3457055301d38cd6fe78626dcf4a2d70441)), closes [#1575](https://github.com/cheminfo/nmrium/issues/1575)
* use idCode in database lookup ([#1609](https://github.com/cheminfo/nmrium/issues/1609)) ([f2f631e](https://github.com/cheminfo/nmrium/commit/f2f631e3d66d35232b833d79408dc9d02841f674))
### Bug Fixes
* database numberic column format ([5353842](https://github.com/cheminfo/nmrium/commit/5353842fbb36c20c3f13792b6686fe19212c8d01))
* database numeric column format ([057976e](https://github.com/cheminfo/nmrium/commit/057976e20d01c8f38d638bc09d76bc9163710c20))
* edition of range after automatic assignment crash ([a4357bf](https://github.com/cheminfo/nmrium/commit/a4357bf5225ad5e0fd16bb784b3619eae5cca5c6)), closes [#1597](https://github.com/cheminfo/nmrium/issues/1597)
* Ignoring of wobble curve does not work ([#1590](https://github.com/cheminfo/nmrium/issues/1590)) ([ec2607d](https://github.com/cheminfo/nmrium/commit/ec2607ded131243d73cbd59a900952cd15a3f0f5)), closes [#1581](https://github.com/cheminfo/nmrium/issues/1581)
* molecule panel resizing ([d06c992](https://github.com/cheminfo/nmrium/commit/d06c992121142f6ea6e9af579930c6531b98e964)), closes [#1574](https://github.com/cheminfo/nmrium/issues/1574)
* pressing 's' when having one spectrum affects the other vertical alignment options ([6b2792c](https://github.com/cheminfo/nmrium/commit/6b2792c48474fe447ca22dc7191824276300d9b6))
* side panel not initially closed when hidePanelOnLoad is true ([9ddcbe7](https://github.com/cheminfo/nmrium/commit/9ddcbe7159c90748c78ba855a7b76f2978f7e7e4))
* update local storage when NMRium preference changed ([43dd395](https://github.com/cheminfo/nmrium/commit/43dd3955c6e46defb34cf5edaa377b79d231240e))
* wheel zoom ([5017036](https://github.com/cheminfo/nmrium/commit/50170363a6a08560970aaf262c1cda2f674b8a83))
* when tool button is not available shortcut should not be available neither ([4c08578](https://github.com/cheminfo/nmrium/commit/4c08578e6345ef1998f30a0a99a6c190a6523a46)), closes [#1504](https://github.com/cheminfo/nmrium/issues/1504)
* wrong "search by structure" button status ([8c84764](https://github.com/cheminfo/nmrium/commit/8c847647aa51de1733a9d3b957bff37f4cc2abfa)), closes [#1603](https://github.com/cheminfo/nmrium/issues/1603)
## [0.27.0](https://github.com/cheminfo/nmrium/compare/v0.26.0...v0.27.0) (2022-06-03)
### Features
* add automatic assignment panel to general preferences ([31e14d1](https://github.com/cheminfo/nmrium/commit/31e14d146b167f24d25528f6782b51a1c063d838)), closes [#1461](https://github.com/cheminfo/nmrium/issues/1461)
* allow edition of equivalence for hetero atoms ([#1550](https://github.com/cheminfo/nmrium/issues/1550)) ([b0453fb](https://github.com/cheminfo/nmrium/commit/b0453fb881f0f9457a1971f503332a65aec0d9e3))
* customize the initial width of the side panel ([9a2be39](https://github.com/cheminfo/nmrium/commit/9a2be39ef132c828d68c3c9a469a3ab5eb3682e5)), closes [#1558](https://github.com/cheminfo/nmrium/issues/1558)
* databases management ([#1505](https://github.com/cheminfo/nmrium/issues/1505)) ([e283960](https://github.com/cheminfo/nmrium/commit/e283960c6bf176c48436234b05daf78a4001d588))
* default displayed name when import jcamp ([b451ab9](https://github.com/cheminfo/nmrium/commit/b451ab973bd1e8c5d2d8947108ed14afcd903afe)), closes [#1493](https://github.com/cheminfo/nmrium/issues/1493)
* edit molecule by double-click on the floating molecule structure ([c071f5a](https://github.com/cheminfo/nmrium/commit/c071f5ad9143be406a8cb19e743e2fb03444a40e)), closes [#1529](https://github.com/cheminfo/nmrium/issues/1529)
* embedded workspace ([cc3ad59](https://github.com/cheminfo/nmrium/commit/cc3ad59f6431899a32537e393aad5b6c03b6fd4d))
* float molecule structures over the spectrum ([#1525](https://github.com/cheminfo/nmrium/issues/1525)) ([843173d](https://github.com/cheminfo/nmrium/commit/843173d9456f3007a0ceb71583844572b822c5b7))
* improve panels and general preferences ([#1547](https://github.com/cheminfo/nmrium/issues/1547)) ([88eee3c](https://github.com/cheminfo/nmrium/commit/88eee3c2758b66c0556e52f8933e8f9fa6d5b849))
* keep Molecule structure floating over the spectrum when editing it ([64fd971](https://github.com/cheminfo/nmrium/commit/64fd971d746f8690534bba8606595dde045eaa60)), closes [#1528](https://github.com/cheminfo/nmrium/issues/1528)
* label the molecule ([907d09a](https://github.com/cheminfo/nmrium/commit/907d09a974143434efdd1117027549432a0169fa)), closes [#1342](https://github.com/cheminfo/nmrium/issues/1342)
* preview spectrum from database ([#1561](https://github.com/cheminfo/nmrium/issues/1561)) ([24174cc](https://github.com/cheminfo/nmrium/commit/24174cc729d9fa0dcbd59b82a35c57f77a81ad01))
* show/hide kind column in ranges panels ([6c3899b](https://github.com/cheminfo/nmrium/commit/6c3899bd2fe76919b302d01ea6930433769237d5)), closes [#1562](https://github.com/cheminfo/nmrium/issues/1562)
* specify whether the split pane is initially closed or not ([ecc7b86](https://github.com/cheminfo/nmrium/commit/ecc7b86f77a67aad9a53d2d598874d6bf90e5af1)), closes [#1494](https://github.com/cheminfo/nmrium/issues/1494)
### Bug Fixes
* 1d data not converted to typed array ([7472a77](https://github.com/cheminfo/nmrium/commit/7472a7702321d0cae6db1d4342399048b4e59087)), closes [#1555](https://github.com/cheminfo/nmrium/issues/1555)
* coupling tree not working ([4c660c1](https://github.com/cheminfo/nmrium/commit/4c660c19e46272f7065675197f5f2408c431313a)), closes [#1544](https://github.com/cheminfo/nmrium/issues/1544)
* manual 1D ranges detection crash after processing spectrum FID to FTT ([dd470ce](https://github.com/cheminfo/nmrium/commit/dd470ce0a0015f60689b110c5225689c83acbeb6)), closes [#1465](https://github.com/cheminfo/nmrium/issues/1465)
* Peak width is given in Hz and correctly formatted ([43d6c3b](https://github.com/cheminfo/nmrium/commit/43d6c3b82c7bb015e420906ddc65004bf237f34d))
* ranges notations do not exist when exported as SVG or jpeg ([109f900](https://github.com/cheminfo/nmrium/commit/109f900996efc95efef0c690887a7c1f24d27654)), closes [#1567](https://github.com/cheminfo/nmrium/issues/1567)
* resurrect spectrum from ranges crash ([#1565](https://github.com/cheminfo/nmrium/issues/1565)) ([2ebdeb1](https://github.com/cheminfo/nmrium/commit/2ebdeb1316841ee5254273f995b8008c1efe9f22))
* spectra stack alignment does not work when load .nmrium ([33ce29b](https://github.com/cheminfo/nmrium/commit/33ce29b40b25cb04e986066565ecddd3086fe0f0)), closes [#1495](https://github.com/cheminfo/nmrium/issues/1495)
* wrong SVG generated in 2D ([b1f8ae1](https://github.com/cheminfo/nmrium/commit/b1f8ae14be802d2fd041b5af46cbe9a65724ae1b)), closes [#1551](https://github.com/cheminfo/nmrium/issues/1551)
## [0.26.0](https://www.github.com/cheminfo/nmrium/compare/v0.25.0...v0.26.0) (2022-04-21)
### Features
* add .zenodo.json ([a904dae](https://www.github.com/cheminfo/nmrium/commit/a904daefd5d076d2b2dec6111712f671ec608b95))
* auto assignments ([#1456](https://www.github.com/cheminfo/nmrium/issues/1456)) ([1024c2e](https://www.github.com/cheminfo/nmrium/commit/1024c2e81febaeef916fbedfd0a9fe6ef3aa1921))
* auto-assignment by clicking on the row of the table ([132afb1](https://www.github.com/cheminfo/nmrium/commit/132afb17be12175503ad1c999b0bb5c8ecb3cc16))
* automatically assign the first result of the assignments ([d3d8ad1](https://www.github.com/cheminfo/nmrium/commit/d3d8ad164f8bcd7bac959511724692b4ce3ec4bc)), closes [#1477](https://www.github.com/cheminfo/nmrium/issues/1477)
* highlight clicked row in auto-assignments table ([b988f7d](https://www.github.com/cheminfo/nmrium/commit/b988f7de8c97f91c8bed36c16563e187b968de12)), closes [#1486](https://www.github.com/cheminfo/nmrium/issues/1486)
* read jcamp raw data ([def0ee8](https://www.github.com/cheminfo/nmrium/commit/def0ee817549dfe64ae415143cac273f0be780c0)), closes [#1481](https://www.github.com/cheminfo/nmrium/issues/1481)
* replicate spectra Peak picking function in automatic assignment panel ([d8e6180](https://www.github.com/cheminfo/nmrium/commit/d8e6180d5c12126bb62a3b2274b52343cac86ead)), closes [#1480](https://www.github.com/cheminfo/nmrium/issues/1480)
* reset automatic assignments ([1441c5c](https://www.github.com/cheminfo/nmrium/commit/1441c5c248c68987ddb0880629e934e2276874ba)), closes [#1488](https://www.github.com/cheminfo/nmrium/issues/1488)
### Bug Fixes
* assignment tool not assign all diaIDs ([3ae5cd3](https://www.github.com/cheminfo/nmrium/commit/3ae5cd3235646775324addebde9022b126b8c85a)), closes [#1478](https://www.github.com/cheminfo/nmrium/issues/1478)
* data change does not re-initiate the state ([1b96235](https://www.github.com/cheminfo/nmrium/commit/1b9623589997ce007ace2e0c46a2a2109b670609))
* difference of assignment with and without 'explode' protons ([fd365f3](https://www.github.com/cheminfo/nmrium/commit/fd365f3e9fae8a9a9fa548b1591d5abcd06c30bd)), closes [#1479](https://www.github.com/cheminfo/nmrium/issues/1479)
* highlight in some assignment ([a736e7d](https://www.github.com/cheminfo/nmrium/commit/a736e7da2f25041e290ee0227c8184bf66b03a72)), closes [#1490](https://www.github.com/cheminfo/nmrium/issues/1490)
* leaving a zone is not always detected ([cd6d86e](https://www.github.com/cheminfo/nmrium/commit/cd6d86e5976ff281f7db2f5aa1e6407a7df38b36)), closes [#1474](https://www.github.com/cheminfo/nmrium/issues/1474)
* Nuclei formatting in general settings ([42a20a1](https://www.github.com/cheminfo/nmrium/commit/42a20a1e1b6f2f576a25e2e28a1c4e1fd6f789b0)), closes [#1471](https://www.github.com/cheminfo/nmrium/issues/1471) [#1473](https://www.github.com/cheminfo/nmrium/issues/1473)
* use CITATION.cff ([bfd9c69](https://www.github.com/cheminfo/nmrium/commit/bfd9c69ae4abee8d1132ea54037f6caeab0d07e2))
## [0.25.0](https://www.github.com/cheminfo/nmrium/compare/v0.24.1...v0.25.0) (2022-04-07)
### Features
* Button component ([44fd565](https://www.github.com/cheminfo/nmrium/commit/44fd565bea14a7650eb7af41d9d86211f537b850))
### Bug Fixes
* pressing "Enter" in NMRium triggers the file selector dialog ([012e28b](https://www.github.com/cheminfo/nmrium/commit/012e28bb0a24cb8f750167de3207487a1aa77875)), closes [#1460](https://www.github.com/cheminfo/nmrium/issues/1460)
* update dependencies ([#1428](https://www.github.com/cheminfo/nmrium/issues/1428)) ([21ffc50](https://www.github.com/cheminfo/nmrium/commit/21ffc501a5fb359fde7a0918c5cb4951425898fc))
### [0.24.1](https://www.github.com/cheminfo/nmrium/compare/v0.24.0...v0.24.1) (2022-03-31)
### Bug Fixes
* full ethyl benzene sample crash ([b8626de](https://www.github.com/cheminfo/nmrium/commit/b8626de6f96c35874acb2e769620bf94bfb13a39))
* reload NMRium with the last selected workspace ([cb52cdc](https://www.github.com/cheminfo/nmrium/commit/cb52cdc8f1c1c1d7c217eb80f4259dda58c3577c)), closes [#1453](https://www.github.com/cheminfo/nmrium/issues/1453)
## [0.24.0](https://www.github.com/cheminfo/nmrium/compare/v0.23.0...v0.24.0) (2022-03-29)
### Features
* add name for predicted spectra ([e032417](https://www.github.com/cheminfo/nmrium/commit/e0324177cdea7bd27751d95dcbc669a0468f5c68)), closes [#1452](https://www.github.com/cheminfo/nmrium/issues/1452)
* distinguish predicted spectra color per sample ([f2b5acb](https://www.github.com/cheminfo/nmrium/commit/f2b5acba7d8cc2608db5821e4d830154b0368680))
* NMRium workspaces ([#1431](https://www.github.com/cheminfo/nmrium/issues/1431)) ([cd0ccbd](https://www.github.com/cheminfo/nmrium/commit/cd0ccbd3eae286de7f55dd84367b6e39130d9156))
* quick workspace change ([a1808a7](https://www.github.com/cheminfo/nmrium/commit/a1808a7da86c70616c4cb7c5ce4ba54ae94a8bd7)), closes [#1446](https://www.github.com/cheminfo/nmrium/issues/1446)
### Bug Fixes
* bug when drag / drop second NMRium file ([fe64cb1](https://www.github.com/cheminfo/nmrium/commit/fe64cb166b020b80d9665d4547cda30c3b8b69f7)), closes [#1421](https://www.github.com/cheminfo/nmrium/issues/1421)
* change integral sum option by selecting a molecule is hidden ([64c4887](https://www.github.com/cheminfo/nmrium/commit/64c4887cff1759b3b0502cacbb59185786373147))
* crash when unselect 2d spectrum ([790b27c](https://www.github.com/cheminfo/nmrium/commit/790b27c370918ce74e217c032e40a3431807a9b4)), closes [#1434](https://www.github.com/cheminfo/nmrium/issues/1434)
* generateSpectrum2D n getFrequency function ([#1450](https://www.github.com/cheminfo/nmrium/issues/1450)) ([ce8eb1b](https://www.github.com/cheminfo/nmrium/commit/ce8eb1b88c27cd37902d73d7202076af1dd59117))
* Reset workspace crash ([c2481d1](https://www.github.com/cheminfo/nmrium/commit/c2481d14a89ebb471c48f13697fede2781b81633)), closes [#1448](https://www.github.com/cheminfo/nmrium/issues/1448)
* sorting columns in ranges table ([67e850a](https://www.github.com/cheminfo/nmrium/commit/67e850a89bc4f6dc5e458a6e814857282d61433a))
* y scale was not refreshed after applying FFT Filter ([011ef72](https://www.github.com/cheminfo/nmrium/commit/011ef724265a90ed4c774d338749e1cb8fe4692c)), closes [#1430](https://www.github.com/cheminfo/nmrium/issues/1430)
## [0.23.0](https://www.github.com/cheminfo/nmrium/compare/v0.22.0...v0.23.0) (2022-03-11)
### Features
* create prediction panel ([3c96406](https://www.github.com/cheminfo/nmrium/commit/3c96406d50cc3a216c1cb4489bba064a13e6944c))
### Bug Fixes
* Bug when drag / drop second NMRium file ([08ada51](https://www.github.com/cheminfo/nmrium/commit/08ada516b698f7b540fa7c57683e79a54704feee)), closes [#1421](https://www.github.com/cheminfo/nmrium/issues/1421)
* change enum to be a simple string ([#1422](https://www.github.com/cheminfo/nmrium/issues/1422)) ([38066dc](https://www.github.com/cheminfo/nmrium/commit/38066dc9eeeb4cd98408aa2f005578ec14de210d))
## [0.22.0](https://www.github.com/cheminfo/nmrium/compare/v0.21.0...v0.22.0) (2022-03-10)
### Features
* add possibility to reset preferences ([6334620](https://www.github.com/cheminfo/nmrium/commit/63346207be1177f96dc58c52436e72c9f1758b94))
* create automatic assignment panel UI ([2307c82](https://www.github.com/cheminfo/nmrium/commit/2307c82b703526674578559b3322dbdbd56ee54d))
### Bug Fixes
* exclusion zone still visible when disabled its filter ([6b4d4cd](https://www.github.com/cheminfo/nmrium/commit/6b4d4cd9e3f9a53c2665357eefaf12666c198002)), closes [#1414](https://www.github.com/cheminfo/nmrium/issues/1414)
* integral or Multiple Spectra Analysis panels do not open when selecting its tool ([a170519](https://www.github.com/cheminfo/nmrium/commit/a1705198f3c9db36c1821b0f5c37087f9ad0ddf0)), closes [#1407](https://www.github.com/cheminfo/nmrium/issues/1407)
* nmrium crash when some keys not exists ([450decd](https://www.github.com/cheminfo/nmrium/commit/450decd8a274880a7332f519346bb85140179224)), closes [#1404](https://www.github.com/cheminfo/nmrium/issues/1404)
* onDataChange triggered when mouse enter/leave the displayer ([0b271e9](https://www.github.com/cheminfo/nmrium/commit/0b271e9c977c09da1f1575e7425c49a9c0af519b))
* vertical scroll on Firefox ([df4ad3b](https://www.github.com/cheminfo/nmrium/commit/df4ad3b58ef3a469dcbaedb902fe6258244c8ed2)), closes [#1418](https://www.github.com/cheminfo/nmrium/issues/1418)
* vertical zoom for spectra and integrals ([#1416](https://www.github.com/cheminfo/nmrium/issues/1416)) ([c2df1ec](https://www.github.com/cheminfo/nmrium/commit/c2df1ecdf503d063a31a969e3111078db65d687f))
## [0.21.0](https://www.github.com/cheminfo/nmrium/compare/v0.20.2...v0.21.0) (2022-03-03)
### Features
* clear zoom history when pressing the "f" key ([fc1e457](https://www.github.com/cheminfo/nmrium/commit/fc1e457e8ea11354e4d097ef03e027abc56389d9)), closes [#1399](https://www.github.com/cheminfo/nmrium/issues/1399)
* hide multiple spectra auto range picking when ranges picking tool not active ([1690c82](https://www.github.com/cheminfo/nmrium/commit/1690c82a18a171f1035f03aeb1ae4ab28359a36a)), closes [#1396](https://www.github.com/cheminfo/nmrium/issues/1396)
* hide zones picking and slicing tool in exercise workspace ([c1f2c5d](https://www.github.com/cheminfo/nmrium/commit/c1f2c5d1215b173e8bc03599cae4c78d507d1fe3))
* save NMRium preferences by workspace ([#1393](https://www.github.com/cheminfo/nmrium/issues/1393)) ([83ddbc5](https://www.github.com/cheminfo/nmrium/commit/83ddbc5c26af990fd1ce662b0216b030eff1606b))
* show only spectra and integral panels in exercise workspace ([43b6c65](https://www.github.com/cheminfo/nmrium/commit/43b6c65883600b5c3b8db4a71ad87ae63a1a7029)), closes [#1395](https://www.github.com/cheminfo/nmrium/issues/1395)
### Bug Fixes
* manual option of changing an integral sum not selected in the exercise mode ([70640e9](https://www.github.com/cheminfo/nmrium/commit/70640e9e33d338338c578d224625d7e185833aff)), closes [#1397](https://www.github.com/cheminfo/nmrium/issues/1397)
* Processed file can not be loaded on dev.nmrium.org ([0a51dd5](https://www.github.com/cheminfo/nmrium/commit/0a51dd5f84891972b9b7fc17ca941bd66e4263e2)), closes [#1316](https://www.github.com/cheminfo/nmrium/issues/1316)
* select tool by pressing its shortcut when no spectrum is selected ([61bd971](https://www.github.com/cheminfo/nmrium/commit/61bd9713083a0545a5b5b92a4ca7c0eb704677e9)), closes [#1373](https://www.github.com/cheminfo/nmrium/issues/1373)
* zoom history in 2D ([c2c989a](https://www.github.com/cheminfo/nmrium/commit/c2c989ab64eb08ff5f4990328ee7c02d8b275807)), closes [#1371](https://www.github.com/cheminfo/nmrium/issues/1371)
### [0.20.2](https://www.github.com/cheminfo/nmrium/compare/v0.20.1...v0.20.2) (2022-02-28)
### Bug Fixes
* update and dedupe dependencies ([#1383](https://www.github.com/cheminfo/nmrium/issues/1383)) ([4995931](https://www.github.com/cheminfo/nmrium/commit/4995931f5b4d4beee55800b688ca91b088fb9df6))
### [0.20.1](https://www.github.com/cheminfo/nmrium/compare/v0.20.0...v0.20.1) (2022-02-24)
### Bug Fixes
* workaround duplicate cheminfo-types ([a2eb9d2](https://www.github.com/cheminfo/nmrium/commit/a2eb9d21c0e83761049f82fc64e822dd8d8302cd))
## [0.20.0](https://www.github.com/cheminfo/nmrium/compare/v0.19.1...v0.20.0) (2022-02-23)
### Features
* add colored text to the ZonesTable (F1 - F2) ([fbcad47](https://www.github.com/cheminfo/nmrium/commit/fbcad4791ede14db2937684f1e04f098c37e7c07))
* add exclusion zones filter ([#1376](https://www.github.com/cheminfo/nmrium/issues/1376)) ([5d0cdf4](https://www.github.com/cheminfo/nmrium/commit/5d0cdf4a79da7087e1df6b1698bea75f13469319))
* open Zone panel while you click on the sidebar tool ([#1369](https://www.github.com/cheminfo/nmrium/issues/1369)) ([c0fb1c0](https://www.github.com/cheminfo/nmrium/commit/c0fb1c09369f5d10c4841dbfe055180a8af17d66))
### Bug Fixes
* autoRanges detection for HR spectra ([bc9f475](https://www.github.com/cheminfo/nmrium/commit/bc9f4759efa4b283dc5d398d7745b642010d91a7))
* change san plot text to be displayed in line ([#1350](https://www.github.com/cheminfo/nmrium/issues/1350)) ([efe0f0a](https://www.github.com/cheminfo/nmrium/commit/efe0f0a4b4f94df2535fc51390956f5320db840b))
* create an empty molecule throws an error ([a99d95c](https://www.github.com/cheminfo/nmrium/commit/a99d95c03c95aeaf7d54a3fcd695cd36d3754eea))
* make the "Structures" responsive ([#1361](https://www.github.com/cheminfo/nmrium/issues/1361)) ([59df13f](https://www.github.com/cheminfo/nmrium/commit/59df13f1bf85ec9f873e72ffd9392f715487729e))
* prevent crash if range picking without finding peaks ([e472eaa](https://www.github.com/cheminfo/nmrium/commit/e472eaa15cfb887abecd6c08f6e51cadf460d955))
* prevent crash in auto-range picking ([2b52066](https://www.github.com/cheminfo/nmrium/commit/2b520663186c1b50cd6574525c873e6c581d1851))
* prevent crash with multiplet analysis ([#1356](https://www.github.com/cheminfo/nmrium/issues/1356)) ([ca8fb76](https://www.github.com/cheminfo/nmrium/commit/ca8fb7653b072a0dbb97ad8f76b13f88777b92f0))
* remove useless calculation in BrushTracker and replace it by a real test ([50c4d3b](https://www.github.com/cheminfo/nmrium/commit/50c4d3bee8c57a12481ca89912d6622e88449c44))
* resolve crash on recall zoom level ([#1349](https://www.github.com/cheminfo/nmrium/issues/1349)) ([cc13abc](https://www.github.com/cheminfo/nmrium/commit/cc13abc18f77b6787b923e3c4edaef51750d9e90))
* resolve error on zoom ([6285e22](https://www.github.com/cheminfo/nmrium/commit/6285e22321c5994751aa10bced5fcaed265fb4d3))
* resolve missing key error ([#1355](https://www.github.com/cheminfo/nmrium/issues/1355)) ([3436331](https://www.github.com/cheminfo/nmrium/commit/3436331a82c04f743cc12adb458b6fb3a5c41de0))
* resolve shifting issue with chart 2D ([#1364](https://www.github.com/cheminfo/nmrium/issues/1364)) ([4b219b5](https://www.github.com/cheminfo/nmrium/commit/4b219b5b4240101c0b10090e91cf72a7292c4606))
* we remove the condition that an atom may only be assigned once ([035887c](https://www.github.com/cheminfo/nmrium/commit/035887c2c383eebec463128734908490e9b84760))
* wrap main nmrium component in error boundary ([f5d8de1](https://www.github.com/cheminfo/nmrium/commit/f5d8de13b932d739de1e8a5fff361f02346a2d9e))
### [0.19.1](https://www.github.com/cheminfo/nmrium/compare/v0.19.0...v0.19.1) (2022-01-24)
### Bug Fixes
* rescale the molecule according to available space ([#1339](https://www.github.com/cheminfo/nmrium/issues/1339)) ([72b6642](https://www.github.com/cheminfo/nmrium/commit/72b6642b25146bff10476f7a9f42a378cea8eb0e))
## [0.19.0](https://www.github.com/cheminfo/nmrium/compare/v0.18.3...v0.19.0) (2022-01-24)
### Features
* complete database panel with filters ([1641d90](https://www.github.com/cheminfo/nmrium/commit/1641d909d03de0d0a2f667c33b9ec9a276f6c080)), closes [#1254](https://www.github.com/cheminfo/nmrium/issues/1254) [#1255](https://www.github.com/cheminfo/nmrium/issues/1255) [#1256](https://www.github.com/cheminfo/nmrium/issues/1256) [#1257](https://www.github.com/cheminfo/nmrium/issues/1257)
* Display integrals for the ranges ([2644fae](https://www.github.com/cheminfo/nmrium/commit/2644faed147ed9339e8b993fe55b6f19421d65e9)), closes [#1225](https://www.github.com/cheminfo/nmrium/issues/1225)
* Display spectra for each range when mouse enter over database record ([6b457f8](https://www.github.com/cheminfo/nmrium/commit/6b457f80ddcf4c13fe4a4c3e594ec693eb92de1e))
* generate spectrum from publication string ([2b5d66a](https://www.github.com/cheminfo/nmrium/commit/2b5d66a90230d738c6a4c719f0de5502ffcb5a74))
* improvements correlation table, i.e. allow movement of links ([#1268](https://www.github.com/cheminfo/nmrium/issues/1268)) ([2410e65](https://www.github.com/cheminfo/nmrium/commit/2410e65f036a90dd730c02c5cb8827eee7fa5925))
* Integral scaling ([1f16152](https://www.github.com/cheminfo/nmrium/commit/1f1615204c9e98adec42ff8705ac1321e174b534))
* J Graph ([#1311](https://www.github.com/cheminfo/nmrium/issues/1311)) ([cebc3c0](https://www.github.com/cheminfo/nmrium/commit/cebc3c02cf1aa862bc11743b8edc85330e5e68c4))
* resurrect spectrum from database set ([cf6c8b0](https://www.github.com/cheminfo/nmrium/commit/cf6c8b0b5828c96a5d256efa8785ecf0aee9bec7)), closes [#1259](https://www.github.com/cheminfo/nmrium/issues/1259)
* resurrect spectrum from database spectrum ([010129f](https://www.github.com/cheminfo/nmrium/commit/010129fef5d44dd5723678c11973949c6f911f8d)), closes [#1259](https://www.github.com/cheminfo/nmrium/issues/1259)
* use nmr processing types ([#1310](https://www.github.com/cheminfo/nmrium/issues/1310)) ([fc576ef](https://www.github.com/cheminfo/nmrium/commit/fc576efad1ef78678e144e00193c5a350c2a3c88))
### Bug Fixes
* avoid enhanceSymmetry for manual zone detection ([e5be7ca](https://www.github.com/cheminfo/nmrium/commit/e5be7caa5834ba866dc67c046e5b14e89d2ce8da))
* basic panel style import ([b46bdd4](https://www.github.com/cheminfo/nmrium/commit/b46bdd4fc8d59bacf38e2f05a034b08136f5b747))
* Center and stacked function/icon for FID files ([0e22f8c](https://www.github.com/cheminfo/nmrium/commit/0e22f8ca19bfe896fd815735b855533de7aaee51))
* crashes due to missing plural name of peak in nmr-correlation ([#1237](https://www.github.com/cheminfo/nmrium/issues/1237)) ([907ade3](https://www.github.com/cheminfo/nmrium/commit/907ade3e0a1f1e9535f3ddc7f60164c64ceab868))
* increase default frequency cluster close [#1309](https://www.github.com/cheminfo/nmrium/issues/1309) ([e326ca4](https://www.github.com/cheminfo/nmrium/commit/e326ca4b58c1095e39d7b958d82bbf00711ba463))
* nmredata importation ([#1292](https://www.github.com/cheminfo/nmrium/issues/1292)) ([8e252a3](https://www.github.com/cheminfo/nmrium/commit/8e252a3ea910990c779074cee07331b7872bf6db))
* refactor nH parameter to integrationSum close [#1318](https://www.github.com/cheminfo/nmrium/issues/1318) ([#1319](https://www.github.com/cheminfo/nmrium/issues/1319)) ([1138d1d](https://www.github.com/cheminfo/nmrium/commit/1138d1d9b5b46015273df1a3fe84f4bc8675c987))
* save preferences ([7c13cc9](https://www.github.com/cheminfo/nmrium/commit/7c13cc91bfc81878fd2d3754fc441ace59b38d98))
* summary header styles ([#1296](https://www.github.com/cheminfo/nmrium/issues/1296)) ([ee1d0b9](https://www.github.com/cheminfo/nmrium/commit/ee1d0b9f82c7f44bae0b57eb819525ef2c4d895e))
* summation field annotation when assigned ([5752608](https://www.github.com/cheminfo/nmrium/commit/575260855b15e1a899b80902ead493f31ca2df23))
* table style when panel filp ([71702b9](https://www.github.com/cheminfo/nmrium/commit/71702b99d88c372f0f2da0af11f5a4fc69591d9e))
* table style when panel flip ([51cd874](https://www.github.com/cheminfo/nmrium/commit/51cd874403d593ab851f309fe47dbb70b4d1c251))
* Toolbar menu y transform when menu greater than screen height ([cf704d3](https://www.github.com/cheminfo/nmrium/commit/cf704d3fc6081bca7d81ffa726f8dc40a26d65b1))
* update minor deps and remove react-card-flip ([#1321](https://www.github.com/cheminfo/nmrium/issues/1321)) ([54b7608](https://www.github.com/cheminfo/nmrium/commit/54b7608cf266b6f69f2776a8a6a7646ad7c7f1d4))
* update nmr-processing to 3.3.1 ([eacea85](https://www.github.com/cheminfo/nmrium/commit/eacea85c68a203766a8abe6f1ee3b2a457c8be99))
### [0.18.3](https://www.github.com/cheminfo/nmrium/compare/v0.18.2...v0.18.3) (2021-09-05)
### Bug Fixes
* calculate the chart for NMR multiplet analysis ([b8279eb](https://www.github.com/cheminfo/nmrium/commit/b8279eb4993bcd5ef0df035a7a19a398be30b75c))
### [0.18.2](https://www.github.com/cheminfo/nmrium/compare/v0.18.1...v0.18.2) (2021-09-02)
### Bug Fixes
* add playwright* in tsconfig exclude ([f4eebc0](https://www.github.com/cheminfo/nmrium/commit/f4eebc0d39dacf9bff9ed8072486eaefac85f1dd))
### [0.18.1](https://www.github.com/cheminfo/nmrium/compare/v0.18.0...v0.18.1) (2021-09-02)
### Bug Fixes
* diaID to diaIDs in spectrum2D ([dd737c5](https://www.github.com/cheminfo/nmrium/commit/dd737c5c3fcc71487502a36aa6c6ddfe38922053))
* ensure plural js in multiplet-analysis ([eeb68f0](https://www.github.com/cheminfo/nmrium/commit/eeb68f0a1833c41380bc28871b98afc2e00acc7d))
* **jeol:** update nmr-parser to 1.6.2 ([b741c65](https://www.github.com/cheminfo/nmrium/commit/b741c65c0027f471b03bcd62736515923bbea23a))
* Peak annotations are not displayed correctly in Safari ([9233c9d](https://www.github.com/cheminfo/nmrium/commit/9233c9d7c30438bc9d8ce6314ee25f7898b32845)), closes [#1219](https://www.github.com/cheminfo/nmrium/issues/1219)
* update nmredata to 0.5.0 ([8c9b530](https://www.github.com/cheminfo/nmrium/commit/8c9b53083963390a4e6e0f081537bc72a0717971))
* wrong behavior in integration of the assigned signal ([#1224](https://www.github.com/cheminfo/nmrium/issues/1224)) ([b720846](https://www.github.com/cheminfo/nmrium/commit/b7208464da3c7b0b4e8300ce0626d8ae3270ea0b))
## [0.18.0](https://www.github.com/cheminfo/nmrium/compare/v0.17.1...v0.18.0) (2021-08-27)
### Features
* 1d and 2d prediction ([#1194](https://www.github.com/cheminfo/nmrium/issues/1194)) ([f5cb228](https://www.github.com/cheminfo/nmrium/commit/f5cb228a0927d059daa107b099b19c136228a45b))
* add prop to hide panel on initial load ([#1171](https://www.github.com/cheminfo/nmrium/issues/1171)) ([b0cdd08](https://www.github.com/cheminfo/nmrium/commit/b0cdd08a1b427ce6d73b5f84dd721a1d14113dcd))
* Automatic ranges / zones picking in all spectra ([31302a2](https://www.github.com/cheminfo/nmrium/commit/31302a2ed36726d028c3435bef47db62e45a0e50)), closes [#1212](https://www.github.com/cheminfo/nmrium/issues/1212)
* integrate with new carbon prediction service ([943432e](https://www.github.com/cheminfo/nmrium/commit/943432ef6dffba3a4c747d7a0d1fb3b6a2a52286))
* predict carbon from molfile ([8706b0e](https://www.github.com/cheminfo/nmrium/commit/8706b0ec6aeaa62f74bc2ffb335b46157a019b3a))
### Bug Fixes
* displayer crash when cursor come over 1d trace in 2d mode ([e8080a9](https://www.github.com/cheminfo/nmrium/commit/e8080a9206de27a2f6b68de1e41dd8973b6e94a6))
* gray lines indicators do not appear on prediction ([5e33fc7](https://www.github.com/cheminfo/nmrium/commit/5e33fc7ad8efa80c1d83ce9649d946e91f2882eb)), closes [#1211](https://www.github.com/cheminfo/nmrium/issues/1211)
* Range edition not working anymore ([2469601](https://www.github.com/cheminfo/nmrium/commit/2469601f3cd946edcfb6bb78cbebfe2718d3d2f4))
### [0.17.1](https://www.github.com/cheminfo/nmrium/compare/v0.17.0...v0.17.1) (2021-07-14)
### Bug Fixes
* set a default value for the data prop ([7daf6f4](https://www.github.com/cheminfo/nmrium/commit/7daf6f455eab1ed3b1bf14040cc5b1672de70b91))
## [0.17.0](https://www.github.com/cheminfo/nmrium/compare/v0.16.0...v0.17.0) (2021-07-14)
### Features
* change signal delta manually ([e079084](https://www.github.com/cheminfo/nmrium/commit/e079084cb6d62c7aa365ce10ab64e2b2948cc780))
* live update the tree during edition ([2886523](https://www.github.com/cheminfo/nmrium/commit/2886523a6994e0051fc7d9821d2c7616dd571cf2)), closes [#1079](https://www.github.com/cheminfo/nmrium/issues/1079)
### Bug Fixes
* [#879](https://www.github.com/cheminfo/nmrium/issues/879), [#898](https://www.github.com/cheminfo/nmrium/issues/898), [#961](https://www.github.com/cheminfo/nmrium/issues/961) and [#1089](https://www.github.com/cheminfo/nmrium/issues/1089) ([#1149](https://www.github.com/cheminfo/nmrium/issues/1149)) ([66dced0](https://www.github.com/cheminfo/nmrium/commit/66dced0b785625a8eaa00f80850af8476b6b428c))
* avoid re-renders due to the AlertProvider ([67f4edf](https://www.github.com/cheminfo/nmrium/commit/67f4edfa8da8c86e46134590335c8b0d6d035977))
* baseline correction crash when "degree" not between 1 - 6 ([defa111](https://www.github.com/cheminfo/nmrium/commit/defa111d9d4ecbdc893daec0896b6fb22c1e9c5f))
* correct style of molecule editor modal and ranges header outside of Vite ([7fa7775](https://www.github.com/cheminfo/nmrium/commit/7fa77753f7a3d6c7d79b5370ee7830a0ab5bec7f))
* do not use nullish coalescing operator ([1503727](https://www.github.com/cheminfo/nmrium/commit/150372717efe684efe715dfcfec51235b3a70b85))
* fill value in signal input field when select range not working ([aa837fe](https://www.github.com/cheminfo/nmrium/commit/aa837fe2a76f993ba3dcacb5c19fbe22319a6961))
* prevent re-renders due to chart data provider ([e72c8c7](https://www.github.com/cheminfo/nmrium/commit/e72c8c718d14e375013022007d4018b1baf68074))
* prevent re-renders due to dropzone loader ([68c5879](https://www.github.com/cheminfo/nmrium/commit/68c58791dc531ada2779e5fd99aab7f77d195056))
* prevent re-renders due to modal provider ([882d160](https://www.github.com/cheminfo/nmrium/commit/882d160d2661ece9974739a9c29e4e85db073920))
* simplify help provider to avoid re-renders ([54cb76c](https://www.github.com/cheminfo/nmrium/commit/54cb76c082bf08df549760d75ee8458ac60834b1))
* update nmr-parser to 1.6.0 close[#1145](https://www.github.com/cheminfo/nmrium/issues/1145) ([#1156](https://www.github.com/cheminfo/nmrium/issues/1156)) ([532f2d5](https://www.github.com/cheminfo/nmrium/commit/532f2d5cffb352544f049bde97c357a43c17e1a3))
* use Delete instead of Escape as Backspace alias ([cd04968](https://www.github.com/cheminfo/nmrium/commit/cd049689d5acfa1ea8231791480b9bfedc5098de))
## [0.16.0](https://www.github.com/cheminfo/nmrium/compare/v0.15.0...v0.16.0) (2021-06-21)
### ⚠ BREAKING CHANGES
* The docsBaseUrl prop was removed. Documentation will always be at https://docs.nmrium.org
### Bug Fixes
* convert value to string crash when have null value ([c632ee9](https://www.github.com/cheminfo/nmrium/commit/c632ee98359f9b58dac3f001a857500ce29c9398)), closes [#1144](https://www.github.com/cheminfo/nmrium/issues/1144)
* Drag and drop jcamp -> export -> import not working ([870d82a](https://www.github.com/cheminfo/nmrium/commit/870d82a1a3cfc0d9a7d1d72d27d4f451612d4a56)), closes [#1143](https://www.github.com/cheminfo/nmrium/issues/1143)
* Help broken ([fbaec53](https://www.github.com/cheminfo/nmrium/commit/fbaec535c2ed6c44be355bc4cc24ac6d52604552)), closes [#1132](https://www.github.com/cheminfo/nmrium/issues/1132)
* integral in fixed mode for integrals and ranges ([eaf7d4a](https://www.github.com/cheminfo/nmrium/commit/eaf7d4af23b9841c721da0c740978d04c9522f08)), closes [#1131](https://www.github.com/cheminfo/nmrium/issues/1131)
* Prop validation error when closing the right panels area ([ad1028e](https://www.github.com/cheminfo/nmrium/commit/ad1028e384714ebee0b9413b351d7396fbb1129e)), closes [#1141](https://www.github.com/cheminfo/nmrium/issues/1141)
* Ranges are displayed incorrectly in case of spectrum shifts ([985b583](https://www.github.com/cheminfo/nmrium/commit/985b5830e76bb86a89229a13d4b46b4d170cc5c5))
### Miscellaneous Chores
* remove docsBaseUrl and refactor constants ([c8a35af](https://www.github.com/cheminfo/nmrium/commit/c8a35af896bc483e80ba4fd1410de5985174b93f))
## [0.15.0](https://www.github.com/cheminfo/nmrium/compare/v0.14.0...v0.15.0) (2021-06-17)
### Features
* allows to continue to control phase when mouse leave the button ([613e5da](https://www.github.com/cheminfo/nmrium/commit/613e5da80b1c454c5cbc92de1c682b04c8eee9e5))
* improve error message ([68eda7c](https://www.github.com/cheminfo/nmrium/commit/68eda7c67368f3b4c7eea2366300afe34bfbe27e))
* update nmr-parser to 1.4.0 ([11d13b7](https://www.github.com/cheminfo/nmrium/commit/11d13b7985471d0ff16e64d1c85730e691314606))
### Bug Fixes
* change props to be non-required ([40dd75c](https://www.github.com/cheminfo/nmrium/commit/40dd75c9bb966d0f00475c900431458ee2519391))
* close [#1112](https://www.github.com/cheminfo/nmrium/issues/1112) ([#1114](https://www.github.com/cheminfo/nmrium/issues/1114)) ([5990eed](https://www.github.com/cheminfo/nmrium/commit/5990eedd0a4df4768bd6bf9bac685ccc993afebe))
* edit range manually crash ([254d10f](https://www.github.com/cheminfo/nmrium/commit/254d10fd9718887201062e8afb573c7d0c7962b4)), closes [#1124](https://www.github.com/cheminfo/nmrium/issues/1124)
* formating and filter general bugs ([ea19f6d](https://www.github.com/cheminfo/nmrium/commit/ea19f6db1b79d9cfd16c842c3fa3e73c6b6bead2)), closes [#1135](https://www.github.com/cheminfo/nmrium/issues/1135) [#1134](https://www.github.com/cheminfo/nmrium/issues/1134) [#1133](https://www.github.com/cheminfo/nmrium/issues/1133)
* improve phase correction ([c3d889e](https://www.github.com/cheminfo/nmrium/commit/c3d889ebe21eba02bac71c65d4646417807c9b96))
* integral value under integral plot not updating ([04a062b](https://www.github.com/cheminfo/nmrium/commit/04a062be16d6f82e23098c970596ad7183ce3f14)), closes [#1123](https://www.github.com/cheminfo/nmrium/issues/1123)
* Phase correction shortcut not working ([c56592d](https://www.github.com/cheminfo/nmrium/commit/c56592d238576eb6d1e074586087c487d81f41fe)), closes [#1121](https://www.github.com/cheminfo/nmrium/issues/1121)
* sanplot when not negative/positive values exist ([aa90fa0](https://www.github.com/cheminfo/nmrium/commit/aa90fa0c0e080f2be9190addc3bc745eb432c76f))
* use useRef ([b360911](https://www.github.com/cheminfo/nmrium/commit/b360911047fb9885a077863b86d882536f775382))
## [0.14.0](https://www.github.com/cheminfo/nmrium/compare/v0.13.0...v0.14.0) (2021-05-20)
### Features
* enhance sanplot ([#1090](https://www.github.com/cheminfo/nmrium/issues/1090)) ([adf371b](https://www.github.com/cheminfo/nmrium/commit/adf371b8f72d38c2a3eac74d447961f32bdb6e7c))
* improve default values for auto phase. close [#1093](https://www.github.com/cheminfo/nmrium/issues/1093) ([#1099](https://www.github.com/cheminfo/nmrium/issues/1099)) ([a2d67a4](https://www.github.com/cheminfo/nmrium/commit/a2d67a40119467da7d4931cfa118d1488a83a404))
### Bug Fixes
* allow to save as shortcut on osX ([ade53cd](https://www.github.com/cheminfo/nmrium/commit/ade53cdde82430ddd1ba0fd4be8d503fa79ed30d))
* always use the zones for polynomial baseline correction. ([#1092](https://www.github.com/cheminfo/nmrium/issues/1092)) ([cf7fa99](https://www.github.com/cheminfo/nmrium/commit/cf7fa99f5852f06a3be604e976df036591a23609))
* build demo site using relative URLs ([8e4f668](https://www.github.com/cheminfo/nmrium/commit/8e4f668498a982f3a24ffc4c041ad1edf5eb2ffc))
* change integral sum modal style ([e5cf78e](https://www.github.com/cheminfo/nmrium/commit/e5cf78e4e86c2b0dfec2909dab64d4f2344609b5)), closes [#1062](https://www.github.com/cheminfo/nmrium/issues/1062)
* crash when add spectra filter ([1a6ab62](https://www.github.com/cheminfo/nmrium/commit/1a6ab62e2f75590590761cacd61a19a3ba76c0ae)), closes [#1083](https://www.github.com/cheminfo/nmrium/issues/1083)
* In "Export As" data included even when "include data" unchecked ([5aa068a](https://www.github.com/cheminfo/nmrium/commit/5aa068a6c486f815d7c3cdbbcc997224113da7f0))
* **projection:** fix wrong number of points. close [#1041](https://www.github.com/cheminfo/nmrium/issues/1041) ([#1095](https://www.github.com/cheminfo/nmrium/issues/1095)) ([44139a0](https://www.github.com/cheminfo/nmrium/commit/44139a049363d6987b869985689c000d44ab8ae0))
## [0.13.0](https://www.github.com/cheminfo/nmrium/compare/v0.12.0...v0.13.0) (2021-05-13)
### Features
* add getAtomsFromMF ([e29bcbf](https://www.github.com/cheminfo/nmrium/commit/e29bcbf56fcbf89ae76fbb1c37f485b606d03140))
* update dependencies nmr-parser and ml-spectra-processing ([#1042](https://www.github.com/cheminfo/nmrium/issues/1042)) ([d443fd7](https://www.github.com/cheminfo/nmrium/commit/d443fd7e3bd9d34ecf9ccaa7e38153bef9e4f802))
### Bug Fixes
* better display for version and link to github ([4a2d70f](https://www.github.com/cheminfo/nmrium/commit/4a2d70fbfc674451b6b3b30f89ab5c77285b05c9))
* crash when edit and save range. ([907b49f](https://www.github.com/cheminfo/nmrium/commit/907b49f214f1d26dc47c536d8f6500be97c8ebd7)), closes [#1031](https://www.github.com/cheminfo/nmrium/issues/1031)
* do not import lodash directly ([ca47250](https://www.github.com/cheminfo/nmrium/commit/ca47250f078bc6d138ca4013076d148e739a5d8c))
## [0.12.0](https://www.github.com/cheminfo/nmrium/compare/v0.11.0...v0.12.0) (2021-05-07)
### Features
* " Export As " feature ([60e6430](https://www.github.com/cheminfo/nmrium/commit/60e6430fafd6ae7a40dddf4ba3cf66c1425cdd06))
* 1d histogram ([e4178f1](https://www.github.com/cheminfo/nmrium/commit/e4178f1f780eb55e7d9cbe6db59e5d4fd93e9134))
* 2d histogram ([50f83da](https://www.github.com/cheminfo/nmrium/commit/50f83dab4ed176dde8c9ed56e225b72d28610d5a))
* add equally spaced filter. ([5d9953c](https://www.github.com/cheminfo/nmrium/commit/5d9953c6722efd45d02a4810324fe6976f74a822))
* add new filters ([cdb9e98](https://www.github.com/cheminfo/nmrium/commit/cdb9e987ab12de0084e8040ca40a89ba84bf6624))
* Add new tool to draw exclusion zones ([1d48ebd](https://www.github.com/cheminfo/nmrium/commit/1d48ebdd425ef9a97b3dc2d28225f3fba1b2e859))
* add the base for Multiple spectra filter. ([39cf861](https://www.github.com/cheminfo/nmrium/commit/39cf861610a29931bb4040b32b22eaee5123ef4c))
* Advanced save in .nmrium data ([e59700b](https://www.github.com/cheminfo/nmrium/commit/e59700bb60fedd3546c72a5af0956664a0b00bd5))
* auto peak picking based on window zoom ([b7592b3](https://www.github.com/cheminfo/nmrium/commit/b7592b34efbf20caa239ea6e233b0441a730a480))
* auto ranges detection based on window zoom ([792ea3f](https://www.github.com/cheminfo/nmrium/commit/792ea3fdccc10152f064a2385f0754b38151e108))
* auto zone detection within zoom region ([#975](https://www.github.com/cheminfo/nmrium/issues/975)) ([f0452d4](https://www.github.com/cheminfo/nmrium/commit/f0452d493b74eacd07cd8f509086376e0e3338aa))
* avoid from > to in manual zone selection ([#978](https://www.github.com/cheminfo/nmrium/issues/978)) ([326ed14](https://www.github.com/cheminfo/nmrium/commit/326ed1452904d95d09f7a26adab71cce1d8285c6))
* change default color order ([7b95026](https://www.github.com/cheminfo/nmrium/commit/7b950263395370342fa7b2a6a33695db143b8f52))
* enable nmrium to load zip files with bruker folder and others ([#1024](https://www.github.com/cheminfo/nmrium/issues/1024)) ([0aa42b1](https://www.github.com/cheminfo/nmrium/commit/0aa42b1d492f518f77c944f64585899ab00cee60))
* fix wrong step size calculation-getSubMatrix ([e1e6ef0](https://www.github.com/cheminfo/nmrium/commit/e1e6ef08c58b6f0d98912e7747947faf6e15498b)), closes [#616](https://www.github.com/cheminfo/nmrium/issues/616) [#642](https://www.github.com/cheminfo/nmrium/issues/642) [#785](https://www.github.com/cheminfo/nmrium/issues/785) [#620](https://www.github.com/cheminfo/nmrium/issues/620)
* importation and exportation of nmredata ([#989](https://www.github.com/cheminfo/nmrium/issues/989)) ([7ae8c8c](https://www.github.com/cheminfo/nmrium/commit/7ae8c8cddce061023328c84224c728f2c1cabcb8))
* **nmredata:** refactor of importation/exportation ([#1007](https://www.github.com/cheminfo/nmrium/issues/1007)) ([3f539e0](https://www.github.com/cheminfo/nmrium/commit/3f539e08952bf6ab0406e6edc71ffc48096e8fa4))
* use refactored nmr-correlation package ([#1025](https://www.github.com/cheminfo/nmrium/issues/1025)) ([990eb54](https://www.github.com/cheminfo/nmrium/commit/990eb54b96130a740b26bd4a12104ba5abddfcf8))
### Bug Fixes
* " delete all " not delete all spectra. ([54907de](https://www.github.com/cheminfo/nmrium/commit/54907dec21890b74cb7eaee849c13571f8d5388e)), closes [#1028](https://www.github.com/cheminfo/nmrium/issues/1028)
* 1D and 2D histograms ([8211ff2](https://www.github.com/cheminfo/nmrium/commit/8211ff21026f6444676963c5b76d9f8a0501577a))
* avoid out-of-range indexes in zone detection ([984f297](https://www.github.com/cheminfo/nmrium/commit/984f297f7ad577f4a36909a3121ab05e58c7f66f))
* correctly build for CDN ([86dcce3](https://www.github.com/cheminfo/nmrium/commit/86dcce3a7b705df1d55d80a98429394a30385195))
* crash when select a filter. ([df6e2ba](https://www.github.com/cheminfo/nmrium/commit/df6e2baeced0caa0fd33283d8372cc1c0cde76fc))
* default color for noesy / roesy ([ccd7f9a](https://www.github.com/cheminfo/nmrium/commit/ccd7f9aa368691f7ea01a3f500bd1cb0862069a5))
* fromTo Filter ([aa8ccbc](https://www.github.com/cheminfo/nmrium/commit/aa8ccbc3961e083813df1150924c1a07c55f91fc))
* improve chart ([1695bda](https://www.github.com/cheminfo/nmrium/commit/1695bda0972bd6040393380f9a19cbc6667da33d))
* modal come over the table header, context menu not clickable. ([aac0944](https://www.github.com/cheminfo/nmrium/commit/aac094449a1ec9573a0f65f11301db4071394a39))
* Peak picking add repeatitive CSS in the DOM. ([40a5398](https://www.github.com/cheminfo/nmrium/commit/40a539894fb5929d2184d236de8bd66fd71cb5c8)), closes [#1009](https://www.github.com/cheminfo/nmrium/issues/1009)
* Peaks not align vertically in stack mode ([8d2bf59](https://www.github.com/cheminfo/nmrium/commit/8d2bf59f81024121c2c93a88886e955b915bbdf5)), closes [#1026](https://www.github.com/cheminfo/nmrium/issues/1026)
* peaks pointer vertical alignment in stack mode ([ac4fa8e](https://www.github.com/cheminfo/nmrium/commit/ac4fa8e0cba16ae52cb04e4777053df963826b02))
* prevent duplication in auto peaks detection. ([7bead8d](https://www.github.com/cheminfo/nmrium/commit/7bead8dbbbe94f2092c6e35e33998794115e6ba1))
* prevent duplication in auto ranges detection. ([2ca4a3a](https://www.github.com/cheminfo/nmrium/commit/2ca4a3aef6ca432d539312870ebe69875027dcee))
* prevent duplication in auto zones detection. ([1b13e26](https://www.github.com/cheminfo/nmrium/commit/1b13e262cbc10ed67a4f24ba3abadd60447596a8)), closes [#976](https://www.github.com/cheminfo/nmrium/issues/976)
* processed 13C example to deal with new peak format ([9dff439](https://www.github.com/cheminfo/nmrium/commit/9dff4391b5546ed6ca64f42ef301c5bdf37eb5e4))
* processed13C example and peak picking ([bad982f](https://www.github.com/cheminfo/nmrium/commit/bad982fe1701d1a39b98fdbec7d805badffd8930))
* Select component onChange event not firing on firefox ([f05e6d2](https://www.github.com/cheminfo/nmrium/commit/f05e6d2ac774620790327fa4852233db6ef98e3b)), closes [#991](https://www.github.com/cheminfo/nmrium/issues/991)
* update dependencies ([bd4e4e5](https://www.github.com/cheminfo/nmrium/commit/bd4e4e54aa4af97f83fe8184326ec1e70568298b))
* update nmr-parser / jcamp converter ([bd6d870](https://www.github.com/cheminfo/nmrium/commit/bd6d870e2223223f1cf46f960b045c100dfbbb80))
* use react-shadow to avoid being affected by external style ([fd7b803](https://www.github.com/cheminfo/nmrium/commit/fd7b803a4a567797caf258c2fee1210655f4fd00))
## [0.11.0](https://www.github.com/cheminfo/nmrium/compare/v0.10.0...v0.11.0) (2021-04-12)
### Features
* add prop to define the message on NMRium ([#967](https://www.github.com/cheminfo/nmrium/issues/967)) ([22db9ce](https://www.github.com/cheminfo/nmrium/commit/22db9ce6edaf4529fc563b107c9830d7b1d25b4f)), closes [#951](https://www.github.com/cheminfo/nmrium/issues/951)
* export and import NMRIUM file as ZIP. ([7bf6f44](https://www.github.com/cheminfo/nmrium/commit/7bf6f44b39122060b202a24030e2d3607f7c755d))
* export to nmredata ([#969](https://www.github.com/cheminfo/nmrium/issues/969)) ([c06e5ac](https://www.github.com/cheminfo/nmrium/commit/c06e5acfd19ec5c3c8e23a6ee3ee84e35c41650a))
* fix prefix of the path to jcamp file in nmredata exportation ([64b329a](https://www.github.com/cheminfo/nmrium/commit/64b329afcbdba237e7fd0d1f85dd87de66a6f0b6))
### Bug Fixes
* Keep table header fixed. ([cae5d0c](https://www.github.com/cheminfo/nmrium/commit/cae5d0c07086b0fde616e8d0798ebfb522ff19a5))
* **metadata:** export molfile without implicit hydrogens ([5b6f3cd](https://www.github.com/cheminfo/nmrium/commit/5b6f3cde97db43dd0d80db200ed69bb468565b43))
* Modals should not open outside of the component ([e599f8d](https://www.github.com/cheminfo/nmrium/commit/e599f8d7cbf896aa80b6c0f8083390997a616f01))
## [0.10.0](https://www.github.com/cheminfo/nmrium/compare/v0.9.0...v0.10.0) (2021-04-05)
### Features
* add getSpinner prop for custom loading spinner ([20a5137](https://www.github.com/cheminfo/nmrium/commit/20a51371b083f11f5128c352666a8c49666a8fa9))
* add links highlight in predicted 1H spectra ([c256fcf](https://www.github.com/cheminfo/nmrium/commit/c256fcf62159bbef05c10f9f91e2287aea3349f4))
* increase version to 0.9.0 ([9ea9758](https://www.github.com/cheminfo/nmrium/commit/9ea97585dbf4f78766fa1618f271ff15aa816774))
### Bug Fixes
* add padding to NoData element ([7505da7](https://www.github.com/cheminfo/nmrium/commit/7505da7153b3124c6d765c906bc847c4d0c28198))
* link in readme ([3513dab](https://www.github.com/cheminfo/nmrium/commit/3513dabde8a51e551fd02540429aa1eff154b56f))
* make display properties optional ([f9ca9e1](https://www.github.com/cheminfo/nmrium/commit/f9ca9e1972e2fa73e10da91ffbdd3079c74169ca))
| Markdown |
2D | lherron2/thermomaps-ising | thermomaps_ising.ipynb | .ipynb | 453,636 | 1,411 | {
"nbformat": 4,
"nbformat_minor": 0,
"metadata": {
"colab": {
"provenance": [],
"gpuType": "T4",
"authorship_tag": "ABX9TyOLqvU13qBmIUH3Vd3sPTRK",
"include_colab_link": true
},
"kernelspec": {
"name": "python3",
"display_name": "Python 3"
},
"language_info": {
"name": "python"
},
"accelerator": "GPU"
},
"cells": [
{
"cell_type": "markdown",
"metadata": {
"id": "view-in-github",
"colab_type": "text"
},
"source": [
"<a href=\"https://colab.research.google.com/github/lherron2/thermomaps-ising/blob/main/thermomaps_ising.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
]
},
{
"cell_type": "code",
"source": [
"!git clone https://github.com/lherron2/thermomaps-ising.git\n",
"%cd thermomaps-ising/thermomaps-root\n",
"! pip -q install .\n",
"! pip install -qr requirements.txt\n",
"%cd -"
],
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "jkAntsLj5Iti",
"outputId": "3d77e44e-2d53-4e65-e9d3-b3eece2b9b38"
},
"execution_count": null,
"outputs": [
{
"output_type": "stream",
"name": "stdout",
"text": [
"fatal: destination path 'thermomaps-ising' already exists and is not an empty directory.\n",
"/content/thermomaps-ising/thermomaps-root\n",
" Preparing metadata (setup.py) ... \u001b[?25l\u001b[?25hdone\n",
" Building wheel for thermomaps (setup.py) ... \u001b[?25l\u001b[?25hdone\n",
"/content\n"
]
}
]
},
{
"cell_type": "code",
"source": [
"import numpy as np\n",
"import matplotlib.pyplot as plt\n",
"from tqdm import tqdm\n",
"\n",
"from ising.observables import Energy, Magnetization\n",
"from ising.samplers import SwendsenWangSampler, SingleSpinFlipSampler\n",
"from ising.base import IsingModel\n",
"\n",
"from data.trajectory import EnsembleTrajectory, MultiEnsembleTrajectory\n",
"from data.dataset import MultiEnsembleDataset\n",
"from data.generic import Summary\n",
"\n",
"from tm.core.prior import GlobalEquilibriumHarmonicPrior, UnitNormalPrior\n",
"from tm.core.backbone import ConvBackbone\n",
"from tm.core.diffusion_model import DiffusionTrainer, SteeredDiffusionSampler\n",
"from tm.core.diffusion_process import VPDiffusion\n",
"from tm.architectures.unet_2d_mid_attn import Unet2D\n"
],
"metadata": {
"id": "s2Pb3O2u-yD7"
},
"execution_count": null,
"outputs": []
},
{
"cell_type": "markdown",
"source": [
"First we simulate the Ising model over a range of temperatures, recording a `trajectory` consisting of lattice configurations. These trajectories are then aggregated into a `MultiEnsembleDataset` (i.e. many trajectories gathered under different thermodynamic ensembles)."
],
"metadata": {
"id": "_3aDvMJUpcH0"
}
},
{
"cell_type": "code",
"source": [
"trajectories = []\n",
"for temperature in np.arange(0.3, 3.5, 0.2):\n",
" IM = IsingModel(sampler=SingleSpinFlipSampler, size = 8, warmup = 1000, temp = np.round(temperature,1), Jx = 1, Jy = 1)\n",
" IM.simulate(steps = 5000, observables = [Energy(Jx = 1, Jy = 1), Magnetization()], sampling_frequency = 1)\n",
" trajectories.append(IM.trajectory)\n",
"dataset = MultiEnsembleDataset(trajectories, Summary())"
],
"metadata": {
"id": "CPdFK84c5P5q"
},
"execution_count": null,
"outputs": []
},
{
"cell_type": "markdown",
"source": [
"\n",
"Each of the trajectories has a `Summary` object attached to it, which is just a `dict` containing metadata about the trajectory. If the summaries associated with all the trajectories in the `MultiEnsembleDataset` all have the same keys, the contents of the `MultiEnsembleDataset` can be conveniently cast as a pandas dataframe."
],
"metadata": {
"id": "hWxqhCpCqPLS"
}
},
{
"cell_type": "code",
"source": [
"df = dataset.to_dataframe()\n",
"df"
],
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 551
},
"id": "NdQcoCpuF2RE",
"outputId": "8b4cecf8-8d05-4935-9dfa-1c74281bb72c"
},
"execution_count": null,
"outputs": [
{
"output_type": "execute_result",
"data": {
"text/plain": [
" index name size temperature Jx Jy sampler\n",
"0 0 IsingModel 8 0.3 1 1 SwendsenWang\n",
"1 1 IsingModel 8 0.5 1 1 SwendsenWang\n",
"2 2 IsingModel 8 0.7 1 1 SwendsenWang\n",
"3 3 IsingModel 8 0.9 1 1 SwendsenWang\n",
"4 4 IsingModel 8 1.1 1 1 SwendsenWang\n",
"5 5 IsingModel 8 1.3 1 1 SwendsenWang\n",
"6 6 IsingModel 8 1.5 1 1 SwendsenWang\n",
"7 7 IsingModel 8 1.7 1 1 SwendsenWang\n",
"8 8 IsingModel 8 1.9 1 1 SwendsenWang\n",
"9 9 IsingModel 8 2.1 1 1 SwendsenWang\n",
"10 10 IsingModel 8 2.3 1 1 SwendsenWang\n",
"11 11 IsingModel 8 2.5 1 1 SwendsenWang\n",
"12 12 IsingModel 8 2.7 1 1 SwendsenWang\n",
"13 13 IsingModel 8 2.9 1 1 SwendsenWang\n",
"14 14 IsingModel 8 3.1 1 1 SwendsenWang\n",
"15 15 IsingModel 8 3.3 1 1 SwendsenWang"
],
"text/html": [
"\n",
" <div id=\"df-22550f88-6305-465d-a2c0-e52d21f2d33b\" class=\"colab-df-container\">\n",
" <div>\n",
"<style scoped>\n",
" .dataframe tbody tr th:only-of-type {\n",
" vertical-align: middle;\n",
" }\n",
"\n",
" .dataframe tbody tr th {\n",
" vertical-align: top;\n",
" }\n",
"\n",
" .dataframe thead th {\n",
" text-align: right;\n",
" }\n",
"</style>\n",
"<table border=\"1\" class=\"dataframe\">\n",
" <thead>\n",
" <tr style=\"text-align: right;\">\n",
" <th></th>\n",
" <th>index</th>\n",
" <th>name</th>\n",
" <th>size</th>\n",
" <th>temperature</th>\n",
" <th>Jx</th>\n",
" <th>Jy</th>\n",
" <th>sampler</th>\n",
" </tr>\n",
" </thead>\n",
" <tbody>\n",
" <tr>\n",
" <th>0</th>\n",
" <td>0</td>\n",
" <td>IsingModel</td>\n",
" <td>8</td>\n",
" <td>0.3</td>\n",
" <td>1</td>\n",
" <td>1</td>\n",
" <td>SwendsenWang</td>\n",
" </tr>\n",
" <tr>\n",
" <th>1</th>\n",
" <td>1</td>\n",
" <td>IsingModel</td>\n",
" <td>8</td>\n",
" <td>0.5</td>\n",
" <td>1</td>\n",
" <td>1</td>\n",
" <td>SwendsenWang</td>\n",
" </tr>\n",
" <tr>\n",
" <th>2</th>\n",
" <td>2</td>\n",
" <td>IsingModel</td>\n",
" <td>8</td>\n",
" <td>0.7</td>\n",
" <td>1</td>\n",
" <td>1</td>\n",
" <td>SwendsenWang</td>\n",
" </tr>\n",
" <tr>\n",
" <th>3</th>\n",
" <td>3</td>\n",
" <td>IsingModel</td>\n",
" <td>8</td>\n",
" <td>0.9</td>\n",
" <td>1</td>\n",
" <td>1</td>\n",
" <td>SwendsenWang</td>\n",
" </tr>\n",
" <tr>\n",
" <th>4</th>\n",
" <td>4</td>\n",
" <td>IsingModel</td>\n",
" <td>8</td>\n",
" <td>1.1</td>\n",
" <td>1</td>\n",
" <td>1</td>\n",
" <td>SwendsenWang</td>\n",
" </tr>\n",
" <tr>\n",
" <th>5</th>\n",
" <td>5</td>\n",
" <td>IsingModel</td>\n",
" <td>8</td>\n",
" <td>1.3</td>\n",
" <td>1</td>\n",
" <td>1</td>\n",
" <td>SwendsenWang</td>\n",
" </tr>\n",
" <tr>\n",
" <th>6</th>\n",
" <td>6</td>\n",
" <td>IsingModel</td>\n",
" <td>8</td>\n",
" <td>1.5</td>\n",
" <td>1</td>\n",
" <td>1</td>\n",
" <td>SwendsenWang</td>\n",
" </tr>\n",
" <tr>\n",
" <th>7</th>\n",
" <td>7</td>\n",
" <td>IsingModel</td>\n",
" <td>8</td>\n",
" <td>1.7</td>\n",
" <td>1</td>\n",
" <td>1</td>\n",
" <td>SwendsenWang</td>\n",
" </tr>\n",
" <tr>\n",
" <th>8</th>\n",
" <td>8</td>\n",
" <td>IsingModel</td>\n",
" <td>8</td>\n",
" <td>1.9</td>\n",
" <td>1</td>\n",
" <td>1</td>\n",
" <td>SwendsenWang</td>\n",
" </tr>\n",
" <tr>\n",
" <th>9</th>\n",
" <td>9</td>\n",
" <td>IsingModel</td>\n",
" <td>8</td>\n",
" <td>2.1</td>\n",
" <td>1</td>\n",
" <td>1</td>\n",
" <td>SwendsenWang</td>\n",
" </tr>\n",
" <tr>\n",
" <th>10</th>\n",
" <td>10</td>\n",
" <td>IsingModel</td>\n",
" <td>8</td>\n",
" <td>2.3</td>\n",
" <td>1</td>\n",
" <td>1</td>\n",
" <td>SwendsenWang</td>\n",
" </tr>\n",
" <tr>\n",
" <th>11</th>\n",
" <td>11</td>\n",
" <td>IsingModel</td>\n",
" <td>8</td>\n",
" <td>2.5</td>\n",
" <td>1</td>\n",
" <td>1</td>\n",
" <td>SwendsenWang</td>\n",
" </tr>\n",
" <tr>\n",
" <th>12</th>\n",
" <td>12</td>\n",
" <td>IsingModel</td>\n",
" <td>8</td>\n",
" <td>2.7</td>\n",
" <td>1</td>\n",
" <td>1</td>\n",
" <td>SwendsenWang</td>\n",
" </tr>\n",
" <tr>\n",
" <th>13</th>\n",
" <td>13</td>\n",
" <td>IsingModel</td>\n",
" <td>8</td>\n",
" <td>2.9</td>\n",
" <td>1</td>\n",
" <td>1</td>\n",
" <td>SwendsenWang</td>\n",
" </tr>\n",
" <tr>\n",
" <th>14</th>\n",
" <td>14</td>\n",
" <td>IsingModel</td>\n",
" <td>8</td>\n",
" <td>3.1</td>\n",
" <td>1</td>\n",
" <td>1</td>\n",
" <td>SwendsenWang</td>\n",
" </tr>\n",
" <tr>\n",
" <th>15</th>\n",
" <td>15</td>\n",
" <td>IsingModel</td>\n",
" <td>8</td>\n",
" <td>3.3</td>\n",
" <td>1</td>\n",
" <td>1</td>\n",
" <td>SwendsenWang</td>\n",
" </tr>\n",
" </tbody>\n",
"</table>\n",
"</div>\n",
" <div class=\"colab-df-buttons\">\n",
"\n",
" <div class=\"colab-df-container\">\n",
" <button class=\"colab-df-convert\" onclick=\"convertToInteractive('df-22550f88-6305-465d-a2c0-e52d21f2d33b')\"\n",
" title=\"Convert this dataframe to an interactive table.\"\n",
" style=\"display:none;\">\n",
"\n",
" <svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\" viewBox=\"0 -960 960 960\">\n",
" <path d=\"M120-120v-720h720v720H120Zm60-500h600v-160H180v160Zm220 220h160v-160H400v160Zm0 220h160v-160H400v160ZM180-400h160v-160H180v160Zm440 0h160v-160H620v160ZM180-180h160v-160H180v160Zm440 0h160v-160H620v160Z\"/>\n",
" </svg>\n",
" </button>\n",
"\n",
" <style>\n",
" .colab-df-container {\n",
" display:flex;\n",
" gap: 12px;\n",
" }\n",
"\n",
" .colab-df-convert {\n",
" background-color: #E8F0FE;\n",
" border: none;\n",
" border-radius: 50%;\n",
" cursor: pointer;\n",
" display: none;\n",
" fill: #1967D2;\n",
" height: 32px;\n",
" padding: 0 0 0 0;\n",
" width: 32px;\n",
" }\n",
"\n",
" .colab-df-convert:hover {\n",
" background-color: #E2EBFA;\n",
" box-shadow: 0px 1px 2px rgba(60, 64, 67, 0.3), 0px 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
" fill: #174EA6;\n",
" }\n",
"\n",
" .colab-df-buttons div {\n",
" margin-bottom: 4px;\n",
" }\n",
"\n",
" [theme=dark] .colab-df-convert {\n",
" background-color: #3B4455;\n",
" fill: #D2E3FC;\n",
" }\n",
"\n",
" [theme=dark] .colab-df-convert:hover {\n",
" background-color: #434B5C;\n",
" box-shadow: 0px 1px 3px 1px rgba(0, 0, 0, 0.15);\n",
" filter: drop-shadow(0px 1px 2px rgba(0, 0, 0, 0.3));\n",
" fill: #FFFFFF;\n",
" }\n",
" </style>\n",
"\n",
" <script>\n",
" const buttonEl =\n",
" document.querySelector('#df-22550f88-6305-465d-a2c0-e52d21f2d33b button.colab-df-convert');\n",
" buttonEl.style.display =\n",
" google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
"\n",
" async function convertToInteractive(key) {\n",
" const element = document.querySelector('#df-22550f88-6305-465d-a2c0-e52d21f2d33b');\n",
" const dataTable =\n",
" await google.colab.kernel.invokeFunction('convertToInteractive',\n",
" [key], {});\n",
" if (!dataTable) return;\n",
"\n",
" const docLinkHtml = 'Like what you see? Visit the ' +\n",
" '<a target=\"_blank\" href=https://colab.research.google.com/notebooks/data_table.ipynb>data table notebook</a>'\n",
" + ' to learn more about interactive tables.';\n",
" element.innerHTML = '';\n",
" dataTable['output_type'] = 'display_data';\n",
" await google.colab.output.renderOutput(dataTable, element);\n",
" const docLink = document.createElement('div');\n",
" docLink.innerHTML = docLinkHtml;\n",
" element.appendChild(docLink);\n",
" }\n",
" </script>\n",
" </div>\n",
"\n",
"\n",
"<div id=\"df-42df1472-5858-47e6-9803-f53e9d3b4071\">\n",
" <button class=\"colab-df-quickchart\" onclick=\"quickchart('df-42df1472-5858-47e6-9803-f53e9d3b4071')\"\n",
" title=\"Suggest charts\"\n",
" style=\"display:none;\">\n",
"\n",
"<svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\"viewBox=\"0 0 24 24\"\n",
" width=\"24px\">\n",
" <g>\n",
" <path d=\"M19 3H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zM9 17H7v-7h2v7zm4 0h-2V7h2v10zm4 0h-2v-4h2v4z\"/>\n",
" </g>\n",
"</svg>\n",
" </button>\n",
"\n",
"<style>\n",
" .colab-df-quickchart {\n",
" --bg-color: #E8F0FE;\n",
" --fill-color: #1967D2;\n",
" --hover-bg-color: #E2EBFA;\n",
" --hover-fill-color: #174EA6;\n",
" --disabled-fill-color: #AAA;\n",
" --disabled-bg-color: #DDD;\n",
" }\n",
"\n",
" [theme=dark] .colab-df-quickchart {\n",
" --bg-color: #3B4455;\n",
" --fill-color: #D2E3FC;\n",
" --hover-bg-color: #434B5C;\n",
" --hover-fill-color: #FFFFFF;\n",
" --disabled-bg-color: #3B4455;\n",
" --disabled-fill-color: #666;\n",
" }\n",
"\n",
" .colab-df-quickchart {\n",
" background-color: var(--bg-color);\n",
" border: none;\n",
" border-radius: 50%;\n",
" cursor: pointer;\n",
" display: none;\n",
" fill: var(--fill-color);\n",
" height: 32px;\n",
" padding: 0;\n",
" width: 32px;\n",
" }\n",
"\n",
" .colab-df-quickchart:hover {\n",
" background-color: var(--hover-bg-color);\n",
" box-shadow: 0 1px 2px rgba(60, 64, 67, 0.3), 0 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
" fill: var(--button-hover-fill-color);\n",
" }\n",
"\n",
" .colab-df-quickchart-complete:disabled,\n",
" .colab-df-quickchart-complete:disabled:hover {\n",
" background-color: var(--disabled-bg-color);\n",
" fill: var(--disabled-fill-color);\n",
" box-shadow: none;\n",
" }\n",
"\n",
" .colab-df-spinner {\n",
" border: 2px solid var(--fill-color);\n",
" border-color: transparent;\n",
" border-bottom-color: var(--fill-color);\n",
" animation:\n",
" spin 1s steps(1) infinite;\n",
" }\n",
"\n",
" @keyframes spin {\n",
" 0% {\n",
" border-color: transparent;\n",
" border-bottom-color: var(--fill-color);\n",
" border-left-color: var(--fill-color);\n",
" }\n",
" 20% {\n",
" border-color: transparent;\n",
" border-left-color: var(--fill-color);\n",
" border-top-color: var(--fill-color);\n",
" }\n",
" 30% {\n",
" border-color: transparent;\n",
" border-left-color: var(--fill-color);\n",
" border-top-color: var(--fill-color);\n",
" border-right-color: var(--fill-color);\n",
" }\n",
" 40% {\n",
" border-color: transparent;\n",
" border-right-color: var(--fill-color);\n",
" border-top-color: var(--fill-color);\n",
" }\n",
" 60% {\n",
" border-color: transparent;\n",
" border-right-color: var(--fill-color);\n",
" }\n",
" 80% {\n",
" border-color: transparent;\n",
" border-right-color: var(--fill-color);\n",
" border-bottom-color: var(--fill-color);\n",
" }\n",
" 90% {\n",
" border-color: transparent;\n",
" border-bottom-color: var(--fill-color);\n",
" }\n",
" }\n",
"</style>\n",
"\n",
" <script>\n",
" async function quickchart(key) {\n",
" const quickchartButtonEl =\n",
" document.querySelector('#' + key + ' button');\n",
" quickchartButtonEl.disabled = true; // To prevent multiple clicks.\n",
" quickchartButtonEl.classList.add('colab-df-spinner');\n",
" try {\n",
" const charts = await google.colab.kernel.invokeFunction(\n",
" 'suggestCharts', [key], {});\n",
" } catch (error) {\n",
" console.error('Error during call to suggestCharts:', error);\n",
" }\n",
" quickchartButtonEl.classList.remove('colab-df-spinner');\n",
" quickchartButtonEl.classList.add('colab-df-quickchart-complete');\n",
" }\n",
" (() => {\n",
" let quickchartButtonEl =\n",
" document.querySelector('#df-42df1472-5858-47e6-9803-f53e9d3b4071 button');\n",
" quickchartButtonEl.style.display =\n",
" google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
" })();\n",
" </script>\n",
"</div>\n",
" </div>\n",
" </div>\n"
]
},
"metadata": {},
"execution_count": 4
}
]
},
{
"cell_type": "markdown",
"source": [
"The dataframe representation is especially powerful for creating subsets of a `MultiEnsembleDataset`. In this cell we extract a sub-dataframe containing trajectories at temperatures `T=1.5` and `T=2.5`. The sub-dataset can be initialized from the restricted dataframe.\n",
"\n",
"**Our training data is going to be 5,000 samples from two temperatures (total of 10,000 samples) asymetrically spaced about the critical temperature $T_c \\approx 2.26$**"
],
"metadata": {
"id": "_x8GZb_uq0Rf"
}
},
{
"cell_type": "code",
"source": [
"sub_df = df[df['temperature'].isin([1.5,2.5])]\n",
"sub_dataset = dataset.from_dataframe(sub_df)\n",
"sub_df"
],
"metadata": {
"id": "5M3eyDXZCPZ2",
"colab": {
"base_uri": "https://localhost:8080/",
"height": 112
},
"outputId": "d99c4ae5-0a6b-4bbf-bb79-38452f45ccfa"
},
"execution_count": null,
"outputs": [
{
"output_type": "execute_result",
"data": {
"text/plain": [
" index name size temperature Jx Jy sampler\n",
"6 6 IsingModel 8 1.5 1 1 SwendsenWang\n",
"11 11 IsingModel 8 2.5 1 1 SwendsenWang"
],
"text/html": [
"\n",
" <div id=\"df-9be400b8-d059-4bd5-9dcc-906d4bdae2a1\" class=\"colab-df-container\">\n",
" <div>\n",
"<style scoped>\n",
" .dataframe tbody tr th:only-of-type {\n",
" vertical-align: middle;\n",
" }\n",
"\n",
" .dataframe tbody tr th {\n",
" vertical-align: top;\n",
" }\n",
"\n",
" .dataframe thead th {\n",
" text-align: right;\n",
" }\n",
"</style>\n",
"<table border=\"1\" class=\"dataframe\">\n",
" <thead>\n",
" <tr style=\"text-align: right;\">\n",
" <th></th>\n",
" <th>index</th>\n",
" <th>name</th>\n",
" <th>size</th>\n",
" <th>temperature</th>\n",
" <th>Jx</th>\n",
" <th>Jy</th>\n",
" <th>sampler</th>\n",
" </tr>\n",
" </thead>\n",
" <tbody>\n",
" <tr>\n",
" <th>6</th>\n",
" <td>6</td>\n",
" <td>IsingModel</td>\n",
" <td>8</td>\n",
" <td>1.5</td>\n",
" <td>1</td>\n",
" <td>1</td>\n",
" <td>SwendsenWang</td>\n",
" </tr>\n",
" <tr>\n",
" <th>11</th>\n",
" <td>11</td>\n",
" <td>IsingModel</td>\n",
" <td>8</td>\n",
" <td>2.5</td>\n",
" <td>1</td>\n",
" <td>1</td>\n",
" <td>SwendsenWang</td>\n",
" </tr>\n",
" </tbody>\n",
"</table>\n",
"</div>\n",
" <div class=\"colab-df-buttons\">\n",
"\n",
" <div class=\"colab-df-container\">\n",
" <button class=\"colab-df-convert\" onclick=\"convertToInteractive('df-9be400b8-d059-4bd5-9dcc-906d4bdae2a1')\"\n",
" title=\"Convert this dataframe to an interactive table.\"\n",
" style=\"display:none;\">\n",
"\n",
" <svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\" viewBox=\"0 -960 960 960\">\n",
" <path d=\"M120-120v-720h720v720H120Zm60-500h600v-160H180v160Zm220 220h160v-160H400v160Zm0 220h160v-160H400v160ZM180-400h160v-160H180v160Zm440 0h160v-160H620v160ZM180-180h160v-160H180v160Zm440 0h160v-160H620v160Z\"/>\n",
" </svg>\n",
" </button>\n",
"\n",
" <style>\n",
" .colab-df-container {\n",
" display:flex;\n",
" gap: 12px;\n",
" }\n",
"\n",
" .colab-df-convert {\n",
" background-color: #E8F0FE;\n",
" border: none;\n",
" border-radius: 50%;\n",
" cursor: pointer;\n",
" display: none;\n",
" fill: #1967D2;\n",
" height: 32px;\n",
" padding: 0 0 0 0;\n",
" width: 32px;\n",
" }\n",
"\n",
" .colab-df-convert:hover {\n",
" background-color: #E2EBFA;\n",
" box-shadow: 0px 1px 2px rgba(60, 64, 67, 0.3), 0px 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
" fill: #174EA6;\n",
" }\n",
"\n",
" .colab-df-buttons div {\n",
" margin-bottom: 4px;\n",
" }\n",
"\n",
" [theme=dark] .colab-df-convert {\n",
" background-color: #3B4455;\n",
" fill: #D2E3FC;\n",
" }\n",
"\n",
" [theme=dark] .colab-df-convert:hover {\n",
" background-color: #434B5C;\n",
" box-shadow: 0px 1px 3px 1px rgba(0, 0, 0, 0.15);\n",
" filter: drop-shadow(0px 1px 2px rgba(0, 0, 0, 0.3));\n",
" fill: #FFFFFF;\n",
" }\n",
" </style>\n",
"\n",
" <script>\n",
" const buttonEl =\n",
" document.querySelector('#df-9be400b8-d059-4bd5-9dcc-906d4bdae2a1 button.colab-df-convert');\n",
" buttonEl.style.display =\n",
" google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
"\n",
" async function convertToInteractive(key) {\n",
" const element = document.querySelector('#df-9be400b8-d059-4bd5-9dcc-906d4bdae2a1');\n",
" const dataTable =\n",
" await google.colab.kernel.invokeFunction('convertToInteractive',\n",
" [key], {});\n",
" if (!dataTable) return;\n",
"\n",
" const docLinkHtml = 'Like what you see? Visit the ' +\n",
" '<a target=\"_blank\" href=https://colab.research.google.com/notebooks/data_table.ipynb>data table notebook</a>'\n",
" + ' to learn more about interactive tables.';\n",
" element.innerHTML = '';\n",
" dataTable['output_type'] = 'display_data';\n",
" await google.colab.output.renderOutput(dataTable, element);\n",
" const docLink = document.createElement('div');\n",
" docLink.innerHTML = docLinkHtml;\n",
" element.appendChild(docLink);\n",
" }\n",
" </script>\n",
" </div>\n",
"\n",
"\n",
"<div id=\"df-ba881281-618e-497f-af16-5115e83d652a\">\n",
" <button class=\"colab-df-quickchart\" onclick=\"quickchart('df-ba881281-618e-497f-af16-5115e83d652a')\"\n",
" title=\"Suggest charts\"\n",
" style=\"display:none;\">\n",
"\n",
"<svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\"viewBox=\"0 0 24 24\"\n",
" width=\"24px\">\n",
" <g>\n",
" <path d=\"M19 3H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zM9 17H7v-7h2v7zm4 0h-2V7h2v10zm4 0h-2v-4h2v4z\"/>\n",
" </g>\n",
"</svg>\n",
" </button>\n",
"\n",
"<style>\n",
" .colab-df-quickchart {\n",
" --bg-color: #E8F0FE;\n",
" --fill-color: #1967D2;\n",
" --hover-bg-color: #E2EBFA;\n",
" --hover-fill-color: #174EA6;\n",
" --disabled-fill-color: #AAA;\n",
" --disabled-bg-color: #DDD;\n",
" }\n",
"\n",
" [theme=dark] .colab-df-quickchart {\n",
" --bg-color: #3B4455;\n",
" --fill-color: #D2E3FC;\n",
" --hover-bg-color: #434B5C;\n",
" --hover-fill-color: #FFFFFF;\n",
" --disabled-bg-color: #3B4455;\n",
" --disabled-fill-color: #666;\n",
" }\n",
"\n",
" .colab-df-quickchart {\n",
" background-color: var(--bg-color);\n",
" border: none;\n",
" border-radius: 50%;\n",
" cursor: pointer;\n",
" display: none;\n",
" fill: var(--fill-color);\n",
" height: 32px;\n",
" padding: 0;\n",
" width: 32px;\n",
" }\n",
"\n",
" .colab-df-quickchart:hover {\n",
" background-color: var(--hover-bg-color);\n",
" box-shadow: 0 1px 2px rgba(60, 64, 67, 0.3), 0 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
" fill: var(--button-hover-fill-color);\n",
" }\n",
"\n",
" .colab-df-quickchart-complete:disabled,\n",
" .colab-df-quickchart-complete:disabled:hover {\n",
" background-color: var(--disabled-bg-color);\n",
" fill: var(--disabled-fill-color);\n",
" box-shadow: none;\n",
" }\n",
"\n",
" .colab-df-spinner {\n",
" border: 2px solid var(--fill-color);\n",
" border-color: transparent;\n",
" border-bottom-color: var(--fill-color);\n",
" animation:\n",
" spin 1s steps(1) infinite;\n",
" }\n",
"\n",
" @keyframes spin {\n",
" 0% {\n",
" border-color: transparent;\n",
" border-bottom-color: var(--fill-color);\n",
" border-left-color: var(--fill-color);\n",
" }\n",
" 20% {\n",
" border-color: transparent;\n",
" border-left-color: var(--fill-color);\n",
" border-top-color: var(--fill-color);\n",
" }\n",
" 30% {\n",
" border-color: transparent;\n",
" border-left-color: var(--fill-color);\n",
" border-top-color: var(--fill-color);\n",
" border-right-color: var(--fill-color);\n",
" }\n",
" 40% {\n",
" border-color: transparent;\n",
" border-right-color: var(--fill-color);\n",
" border-top-color: var(--fill-color);\n",
" }\n",
" 60% {\n",
" border-color: transparent;\n",
" border-right-color: var(--fill-color);\n",
" }\n",
" 80% {\n",
" border-color: transparent;\n",
" border-right-color: var(--fill-color);\n",
" border-bottom-color: var(--fill-color);\n",
" }\n",
" 90% {\n",
" border-color: transparent;\n",
" border-bottom-color: var(--fill-color);\n",
" }\n",
" }\n",
"</style>\n",
"\n",
" <script>\n",
" async function quickchart(key) {\n",
" const quickchartButtonEl =\n",
" document.querySelector('#' + key + ' button');\n",
" quickchartButtonEl.disabled = true; // To prevent multiple clicks.\n",
" quickchartButtonEl.classList.add('colab-df-spinner');\n",
" try {\n",
" const charts = await google.colab.kernel.invokeFunction(\n",
" 'suggestCharts', [key], {});\n",
" } catch (error) {\n",
" console.error('Error during call to suggestCharts:', error);\n",
" }\n",
" quickchartButtonEl.classList.remove('colab-df-spinner');\n",
" quickchartButtonEl.classList.add('colab-df-quickchart-complete');\n",
" }\n",
" (() => {\n",
" let quickchartButtonEl =\n",
" document.querySelector('#df-ba881281-618e-497f-af16-5115e83d652a button');\n",
" quickchartButtonEl.style.display =\n",
" google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
" })();\n",
" </script>\n",
"</div>\n",
" </div>\n",
" </div>\n"
]
},
"metadata": {},
"execution_count": 5
}
]
},
{
"cell_type": "markdown",
"source": [
"Here we extract the relevant observables for the ising model from each temperature in the dataset and plot the distribution of magnetization and energy as a function of temperature."
],
"metadata": {
"id": "lxspEzdurX3U"
}
},
{
"cell_type": "code",
"source": [
"simulated_M_v_T_mean = {t.state_variables['temperature']: t.observables['magnetization'].quantity.mean() for t in dataset.trajectories}\n",
"simulated_E_v_T_mean = {t.state_variables['temperature']: t.observables['energy'].quantity.mean() for t in dataset.trajectories}\n",
"simulated_M_v_T_std = {t.state_variables['temperature']: t.observables['magnetization'].quantity.std() for t in dataset.trajectories}\n",
"simulated_E_v_T_std = {t.state_variables['temperature']: t.observables['energy'].quantity.std() for t in dataset.trajectories}\n",
"\n",
"train_M_v_T = {traj.state_variables['temperature']: simulated_M_v_T_mean[traj.state_variables['temperature']] for traj in sub_dataset.trajectories}\n",
"train_E_v_T = {traj.state_variables['temperature']: simulated_E_v_T_mean[traj.state_variables['temperature']] for traj in sub_dataset.trajectories}"
],
"metadata": {
"id": "BYXFsZmmWuHW"
},
"execution_count": null,
"outputs": []
},
{
"cell_type": "code",
"source": [
"# Vary these to view different trajectories/configurations\n",
"trajectory_idx = -1\n",
"frame = -1\n",
"\n",
"default_blue = plt.rcParams['axes.prop_cycle'].by_key()['color'][0]\n",
"fig, (ax1, ax2, ax3) = plt.subplots(1, 3, figsize=(12, 4), dpi=150)\n",
"ax1.plot(list(simulated_M_v_T_mean.keys()), list(simulated_M_v_T_mean.values()), c=default_blue)\n",
"ax1.scatter(list(simulated_M_v_T_mean.keys()), list(simulated_M_v_T_mean.values()), c=default_blue)\n",
"ax1.scatter(list(train_M_v_T.keys()), list(train_M_v_T.values()),\n",
" c='r', marker='*', edgecolors='k', s=200, zorder=2, label='Train Data')\n",
"ax1.fill_between(list(simulated_M_v_T_mean.keys()),\n",
" [max(m - s, 0) for m, s in zip(simulated_M_v_T_mean.values(), simulated_M_v_T_std.values())],\n",
" [min(m + s, 1) for m, s in zip(simulated_M_v_T_mean.values(), simulated_M_v_T_std.values())],\n",
" alpha=0.2, color=default_blue)\n",
"ax1.set_ylabel('Magnetization')\n",
"ax1.set_xlabel('Temperature')\n",
"\n",
"\n",
"ax2.plot(list(simulated_E_v_T_mean.keys()), list(simulated_E_v_T_mean.values()), c=default_blue)\n",
"ax2.scatter(list(simulated_E_v_T_mean.keys()), list(simulated_E_v_T_mean.values()), c=default_blue)\n",
"ax2.scatter(list(train_E_v_T.keys()), list(train_E_v_T.values()),\n",
" c='r', marker='*', edgecolors='k', s=200, zorder=2, label='Train Data')\n",
"ax2.fill_between(list(simulated_E_v_T_mean.keys()),\n",
" [m - s for m, s in zip(simulated_E_v_T_mean.values(), simulated_E_v_T_std.values())],\n",
" [m + s for m, s in zip(simulated_E_v_T_mean.values(), simulated_E_v_T_std.values())],\n",
" alpha=0.2, color=default_blue)\n",
"ax2.set_ylabel('Energy')\n",
"ax2.set_xlabel('Temperature')\n",
"\n",
"img = ax3.imshow(trajectories[-1].coordinates[-1], aspect='equal', cmap='binary')\n",
"ax3.set_title(f'Frame {range(len(trajectories[trajectory_idx].coordinates))[frame]} of sim. traj. at T = {trajectories[trajectory_idx].state_variables[\"temperature\"]}')\n",
"ax3.set_xticks([])\n",
"ax3.set_yticks([])\n",
"\n",
"ax1.legend()\n",
"ax2.legend()\n",
"plt.tight_layout()\n",
"plt.show()\n"
],
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 591
},
"id": "5_1RHIb3T_jR",
"outputId": "e57b7ed1-2f5f-4a54-ffeb-b4f9ef71fa90"
},
"execution_count": null,
"outputs": [
{
"output_type": "display_data",
"data": {
"text/plain": [
"<Figure size 1800x600 with 3 Axes>"
],
"image/png": "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\n"
},
"metadata": {}
}
]
},
{
"cell_type": "markdown",
"source": [
"Loaders for ThermoMap data can also be constructed from a `MultiEnsembleDataset`. The coordinates of the trajectory object are joined with the specified `state_variables` along the channel dimension."
],
"metadata": {
"id": "fbds5_s7rutF"
}
},
{
"cell_type": "code",
"source": [
"train_loader, test_loader = sub_dataset.to_TMLoader(train_size=0.8, test_size=0.2, state_variables=['temperature'])"
],
"metadata": {
"id": "MkkgYavBDvz9"
},
"execution_count": null,
"outputs": []
},
{
"cell_type": "markdown",
"source": [
"Here we initialize the components of the ThermoMap algorithm.\n",
"\n",
"First, we initialize the prior distribution that samples from the dataset will be mapped onto. The `GlobalEquilibriumHarmonicPrior` (`GEHP`) implements the temperature scaling at the core of the ThermoMap algorithm. We view the prior distribution as the equilibrium distribution arising from dynamics of a *physical* prior system. The `GEHP` assumes that the prior system is a particle in a harmonic trap, which results in a Normal equilibrium distribution whose variance is proportional to temperature.\n",
"\n",
"I have also provided a `UnitNormalPrior` (`UNP`) which is a drop-in replacement for the `GEHP` that does not include any temperature rescaling. As such, a ThermoMap trained with a `UNP` is a standard diffusion model.\n",
"\n",
"The prior requires the shape of the training data as input as well as the channels that are associated with coordinates and fluctuations (i.e. temperatures). The coordinate dimensions are sampled from a Normal distribution with variance determined by the fluctuation dimensions, while the fluctuation channels are sampled from a unit Normal distribution."
],
"metadata": {
"id": "0dZksKCVsiyH"
}
},
{
"cell_type": "code",
"source": [
"prior = GlobalEquilibriumHarmonicPrior(shape=train_loader.data.shape, channels_info={\"coordinate\": [0], \"fluctuation\": [1]})"
],
"metadata": {
"id": "kwVMp771sxkN"
},
"execution_count": null,
"outputs": []
},
{
"cell_type": "markdown",
"source": [
"The `model` is the black-box that is used to parameterize the score. Here we opt for a 2D U-net with attention at the upsampling/downsampling bottleneck."
],
"metadata": {
"id": "ntRN5_Kmsxvq"
}
},
{
"cell_type": "code",
"source": [
"model = Unet2D(dim=16, dim_mults=(1, 2, 4), resnet_block_groups=8, channels=2)"
],
"metadata": {
"id": "oA-u8PPfyENF"
},
"execution_count": null,
"outputs": []
},
{
"cell_type": "markdown",
"source": [
"The `backbone` is a wrapper around the model which contains the optimizer, scheduler, and other utilities and implements saving and loading the `model`."
],
"metadata": {
"id": "rS17t3qjyWY0"
}
},
{
"cell_type": "code",
"source": [
"backbone = ConvBackbone(model=model,\n",
" data_shape=train_loader.data_dim,\n",
" target_shape=8,\n",
" num_dims=4,\n",
" lr=1e-3,\n",
" eval_mode=\"train\")"
],
"metadata": {
"id": "jZR-jU6zzEvO"
},
"execution_count": null,
"outputs": []
},
{
"cell_type": "markdown",
"source": [
"The `diffusion` instantiates the noise schedule, and implements the forward and reverse transition kernels of the diffusion process. Functionally, the `diffusion` implements the Euler-Maryuma SDE/Euler ODE solver for the variance-preserving diffusion process."
],
"metadata": {
"id": "FwOzt1tSzLki"
}
},
{
"cell_type": "code",
"source": [
"diffusion = VPDiffusion(num_diffusion_timesteps=100)"
],
"metadata": {
"id": "NstDXiFqEgf3"
},
"execution_count": null,
"outputs": []
},
{
"cell_type": "markdown",
"source": [
"The `trainer` implements the training algorithm, consisting of sampling noise from the `prior`, calls to the transition kernels of the `diffusion`, and parameterizing the `backbone` to match the score."
],
"metadata": {
"id": "0iK1g87i0UOC"
}
},
{
"cell_type": "code",
"source": [
"trainer = DiffusionTrainer(diffusion,\n",
" backbone,\n",
" train_loader,\n",
" prior,\n",
" model_dir=\"/content/models\", # save models every epoch\n",
" pred_type=\"noise\", # set to \"noise\" or \"x0\"\n",
" test_loader=test_loader # optional\n",
" )"
],
"metadata": {
"id": "DKShurrs0Ud2"
},
"execution_count": null,
"outputs": []
},
{
"cell_type": "code",
"source": [
"trainer.train(20, loss_type=\"smooth_l1\", batch_size=8)\n",
"# Note that the test loss is usually slightly lower than the training loss. This is because\n",
"# the training loss is averaged over each epoch (which contains many updates to the weights\n",
"# via backprop) while the test loss is evaluated at the end of each epoch. Is there a\n",
"# better way to do this? Probably. But it's low priority at the moment."
],
"metadata": {
"id": "awYHZHHUEhMX",
"colab": {
"base_uri": "https://localhost:8080/"
},
"outputId": "b3f6d247-df1d-42f5-9448-73ab4ebe60ee"
},
"execution_count": null,
"outputs": [
{
"output_type": "stream",
"name": "stdout",
"text": [
"epoch: 0 | train loss: 0.191 | test loss: 0.123\n",
"epoch: 1 | train loss: 0.091 | test loss: 0.083\n",
"epoch: 2 | train loss: 0.076 | test loss: 0.078\n",
"epoch: 3 | train loss: 0.070 | test loss: 0.068\n",
"epoch: 4 | train loss: 0.066 | test loss: 0.073\n",
"epoch: 5 | train loss: 0.064 | test loss: 0.063\n",
"epoch: 6 | train loss: 0.063 | test loss: 0.061\n",
"epoch: 7 | train loss: 0.062 | test loss: 0.063\n",
"epoch: 8 | train loss: 0.061 | test loss: 0.062\n",
"epoch: 9 | train loss: 0.059 | test loss: 0.064\n",
"epoch: 10 | train loss: 0.060 | test loss: 0.063\n",
"epoch: 11 | train loss: 0.059 | test loss: 0.061\n",
"epoch: 12 | train loss: 0.059 | test loss: 0.063\n",
"epoch: 13 | train loss: 0.058 | test loss: 0.061\n",
"epoch: 14 | train loss: 0.058 | test loss: 0.057\n",
"epoch: 15 | train loss: 0.056 | test loss: 0.059\n",
"epoch: 16 | train loss: 0.056 | test loss: 0.057\n",
"epoch: 17 | train loss: 0.055 | test loss: 0.056\n",
"epoch: 18 | train loss: 0.055 | test loss: 0.056\n",
"epoch: 19 | train loss: 0.056 | test loss: 0.061\n"
]
}
]
},
{
"cell_type": "markdown",
"source": [
"The `sampler` is similar to the `trainer`, but rather than calling the $p(x_0|x_t)$ kernel, the `sampler` iteratively calls the $p(x_{t-1}|x_t)$ kernel."
],
"metadata": {
"id": "heK5m4xj4O7s"
}
},
{
"cell_type": "code",
"source": [
"sampler = SteeredDiffusionSampler(diffusion,\n",
" backbone,\n",
" train_loader,\n",
" prior,\n",
" pred_type='noise', # must be the same as in DiffusionTrainer\n",
" )"
],
"metadata": {
"id": "eypC6tCJ4PJx"
},
"execution_count": null,
"outputs": []
},
{
"cell_type": "markdown",
"source": [
"With our trained model, we generated samples at a range of different temperatures, store the coordinates in an `EnsembleTrajectory` object, and evaluate observables over the coordinates of the trajectory. Note that there is no temporal order between points in the trajectory, as was the case of the Ising simulator."
],
"metadata": {
"id": "FtCQp42L40Yz"
}
},
{
"cell_type": "code",
"source": [
"trajectories = []\n",
"pbar = tqdm(np.arange(0.3, 3.5, 0.2))\n",
"for temperature in pbar:\n",
" pbar.set_description(f\"Generating at T={temperature:.1f}\")\n",
" samples = sampler.sample_loop(num_samples=5000, batch_size=5000, temperature=temperature)\n",
" coords = samples[:,0,:,:].numpy() # take coordinate dimension\n",
" # binarize\n",
" coords[coords > 0] = 1\n",
" coords[coords < 0] = -1\n",
"\n",
" # store in trajectory\n",
" trajectory = EnsembleTrajectory(summary=Summary(info=\"Generated trajectory\"),\n",
" state_variables=Summary(temperature=temperature),\n",
" coordinates=coords)\n",
"\n",
" # evaluate observables over trajectory coordinates and add to trajectory object\n",
" energy = Energy()\n",
" energy.evaluate(trajectory.coordinates)\n",
"\n",
" mag = Magnetization()\n",
" mag.evaluate(trajectory.coordinates)\n",
"\n",
" trajectory.add_observable(energy)\n",
" trajectory.add_observable(mag)\n",
" trajectories.append(trajectory)"
],
"metadata": {
"id": "wH_KPSnoOaUE",
"colab": {
"base_uri": "https://localhost:8080/"
},
"outputId": "397d9ca4-896a-4299-c26d-1b31b51654b0"
},
"execution_count": null,
"outputs": [
{
"output_type": "stream",
"name": "stderr",
"text": [
"Generating at T=3.3: 100%|██████████| 16/16 [15:11<00:00, 56.98s/it]\n"
]
}
]
},
{
"cell_type": "code",
"source": [
"generated_M_v_T_mean = {t.state_variables['temperature']: t.observables['magnetization'].quantity.mean() for t in trajectories}\n",
"generated_E_v_T_mean = {t.state_variables['temperature']: t.observables['energy'].quantity.mean() for t in trajectories}\n",
"generated_M_v_T_std = {t.state_variables['temperature']: t.observables['magnetization'].quantity.std() for t in trajectories}\n",
"generated_E_v_T_std = {t.state_variables['temperature']: t.observables['energy'].quantity.std() for t in trajectories}"
],
"metadata": {
"id": "SZRlG4t_Obk7"
},
"execution_count": null,
"outputs": []
},
{
"cell_type": "markdown",
"source": [
"We find remarkable agreement overlaying the $M(T)$ and $E(T)$ dependence of the ThermoMap-generated and simulated samples."
],
"metadata": {
"id": "_enBJZzP5al1"
}
},
{
"cell_type": "code",
"source": [
"# Vary these to view different trajectories/configurations\n",
"trajectory_idx = -1\n",
"frame = -1\n",
"\n",
"default_blue = plt.rcParams['axes.prop_cycle'].by_key()['color'][0]\n",
"default_orange = plt.rcParams['axes.prop_cycle'].by_key()['color'][1]\n",
"\n",
"fig, (ax1, ax2, ax3) = plt.subplots(1, 3, figsize=(12, 4), dpi=150)\n",
"\n",
"# Plot the simulated ising data\n",
"ax1.plot(list(simulated_M_v_T_mean.keys()), list(simulated_M_v_T_mean.values()), c=default_blue, marker='o', label=\"MC-simulated\")\n",
"ax1.fill_between(list(simulated_M_v_T_mean.keys()),\n",
" [max(m - s, 0) for m, s in zip(simulated_M_v_T_mean.values(), simulated_M_v_T_std.values())],\n",
" [min(m + s, 1) for m, s in zip(simulated_M_v_T_mean.values(), simulated_M_v_T_std.values())],\n",
" alpha=0.2, color=default_blue)\n",
"\n",
"# Plot the generated ising data\n",
"ax1.plot(list(generated_M_v_T_mean.keys()), list(generated_M_v_T_mean.values()), c=default_orange, marker='o', label=\"TM-simulated\")\n",
"ax1.fill_between(list(simulated_M_v_T_mean.keys()),\n",
" [max(m - s, 0) for m, s in zip(generated_M_v_T_mean.values(), generated_M_v_T_std.values())],\n",
" [min(m + s, 1) for m, s in zip(generated_M_v_T_mean.values(), generated_M_v_T_std.values())],\n",
" alpha=0.2, color=default_orange)\n",
"\n",
"# Plot the training data\n",
"ax1.scatter(list(train_M_v_T.keys()), list(train_M_v_T.values()), c='r', marker='*', edgecolors='k', s=200, zorder=2, label='Train Data')\n",
"\n",
"ax1.set_ylabel('Magnetization')\n",
"ax1.set_xlabel('Temperature')\n",
"\n",
"# Plot the simulated ising data\n",
"ax2.plot(list(simulated_E_v_T_mean.keys()), list(simulated_E_v_T_mean.values()), c=default_blue, marker='o', label=\"MC-simulated\")\n",
"ax2.fill_between(list(simulated_E_v_T_mean.keys()),\n",
" [m - s for m, s in zip(simulated_E_v_T_mean.values(), simulated_E_v_T_std.values())],\n",
" [m + s for m, s in zip(simulated_E_v_T_mean.values(), simulated_E_v_T_std.values())],\n",
" alpha=0.2, color=default_blue)\n",
"\n",
"# Plot the generated ising data\n",
"ax2.plot(list(generated_E_v_T_mean.keys()), list(generated_E_v_T_mean.values()), c=default_orange, marker='o', label=\"TM-simulated\")\n",
"ax2.fill_between(list(simulated_E_v_T_mean.keys()),\n",
" [m - s for m, s in zip(generated_E_v_T_mean.values(), generated_E_v_T_std.values())],\n",
" [m + s for m, s in zip(generated_E_v_T_mean.values(), generated_E_v_T_std.values())],\n",
" alpha=0.2, color=default_orange)\n",
"\n",
"# Plot the training data\n",
"ax2.scatter(list(train_E_v_T.keys()), list(train_E_v_T.values()), c='r', marker='*', edgecolors='k', s=200, zorder=2, label='Train Data')\n",
"\n",
"ax2.set_ylabel('Energy')\n",
"ax2.set_xlabel('Temperature')\n",
"\n",
"img = ax3.imshow(trajectories[trajectory_idx].coordinates[frame], aspect='equal', cmap='binary')\n",
"ax3.set_title(f'Frame {range(len(trajectories[trajectory_idx].coordinates))[frame]} of gen. traj. at T = {round(trajectories[trajectory_idx].state_variables[\"temperature\"], 2)}')\n",
"ax3.set_xticks([])\n",
"ax3.set_yticks([])\n",
"\n",
"ax1.legend()\n",
"ax2.legend()\n",
"plt.tight_layout()\n",
"plt.show()"
],
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 592
},
"id": "YQk5rDc7P4MQ",
"outputId": "9049bbbb-2341-4dac-93e7-dcf172e1eea1"
},
"execution_count": null,
"outputs": [
{
"output_type": "display_data",
"data": {
"text/plain": [
"<Figure size 1800x600 with 3 Axes>"
],
"image/png": "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\n"
},
"metadata": {}
}
]
},
{
"cell_type": "code",
"source": [
"fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(8, 4), dpi=150)\n",
"\n",
"ax1.plot(list(simulated_M_v_T_mean.keys()),\n",
" -np.gradient(np.array(list(simulated_M_v_T_mean.values())), list(simulated_M_v_T_mean.keys())),\n",
" c=default_blue, marker='o', label=\"MC\")\n",
"\n",
"ax1.plot(list(generated_M_v_T_mean.keys()),\n",
" -np.gradient(np.array(list(generated_M_v_T_mean.values())), list(generated_M_v_T_mean.keys())),\n",
" c=default_orange, marker='o', label=\"TM\")\n",
"\n",
"ax2.plot(list(simulated_E_v_T_mean.keys()),\n",
" np.gradient(np.array(list(simulated_E_v_T_mean.values()))/8**2, list(simulated_E_v_T_mean.keys())),\n",
" c=default_blue, marker='o', label=\"MC\")\n",
"\n",
"ax2.plot(list(generated_E_v_T_mean.keys()),\n",
" np.gradient(np.array(list(generated_E_v_T_mean.values()))/8**2, list(generated_E_v_T_mean.keys())),\n",
" c=default_orange, marker='o', label=\"TM\")\n",
"\n",
"ax1.set_xlabel(\"Temperature\")\n",
"ax1.set_ylabel(fr\"$-\\partial M/\\partial T$\")\n",
"ax1.legend()\n",
"\n",
"ax2.set_xlabel(\"Temperature\")\n",
"ax2.set_ylabel(fr\"$C/k_BN = \\partial E/\\partial T$\")\n",
"ax2.legend()\n"
],
"metadata": {
"id": "r6jFKUphp9GC",
"colab": {
"base_uri": "https://localhost:8080/",
"height": 589
},
"outputId": "e1f0031c-0b09-4d3d-f9b5-33123e8fc330"
},
"execution_count": null,
"outputs": [
{
"output_type": "execute_result",
"data": {
"text/plain": [
"<matplotlib.legend.Legend at 0x7a4d683ca8c0>"
]
},
"metadata": {},
"execution_count": 52
},
{
"output_type": "display_data",
"data": {
"text/plain": [
"<Figure size 1200x600 with 2 Axes>"
],
"image/png": "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\n"
},
"metadata": {}
}
]
},
{
"cell_type": "code",
"source": [
"\n"
],
"metadata": {
"id": "FIu-Pr_gThCk"
},
"execution_count": null,
"outputs": []
}
]
} | Unknown |
2D | lherron2/thermomaps-ising | thermomaps-root/setup.py | .py | 719 | 27 | from setuptools import setup, find_packages
import os
setup(
name="thermomaps",
version="0.1",
packages=find_packages(),
install_requires=[],
author="Lukas",
author_email="lherron@umd.edu",
description="A Python module to study molecular dynamics simulations using Thermodynamic Maps",
classifiers=[
"Programming Language :: Python :: 3",
"License :: OSI Approved :: MIT License",
"Operating System :: OS Independent",
],
python_requires='>=3.6',
scripts=[f'cli/ising_cli.py' , f'cli/tm_cli.py'],
entry_points={
'console_scripts': [
'ising_model = ising_cli:main',
'thermomaps = tm_cli:main',
],
},
)
| Python |
2D | lherron2/thermomaps-ising | thermomaps-root/cli/tm_cli.py | .py | 4,080 | 99 | import os
import numpy as np
# import matplotlib.pyplot as plt
from slurmflow.serializer import ObjectSerializer
from data.generic import Summary
import argparse
import logging
# logging.getLogger('matplotlib').setLevel(logging.WARNING)
logging.getLogger('tm.core.DiffusionModel').setLevel(logging.INFO)
logging.getLogger('tm.core.DiffusionProcesses').setLevel(logging.INFO)
logging.getLogger('tm.core.Loader').setLevel(logging.INFO)
logging.getLogger('tm.core.Prior').setLevel(logging.INFO)
class TrainingTracker:
def __init__(self, trainer, summary):
self.test_losses = trainer.test_losses
self.train_losses = trainer.train_losses
self.summary = summary
def train(args):
from tm.core.backbone import ConvBackbone
from tm.core.diffusion_model import DiffusionTrainer
from tm.core.diffusion_process import VPDiffusion
from tm.core.prior import GlobalEquilibriumHarmonicPrior, UnitNormalPrior
from tm.architectures.unet_2d_mid_attn import Unet2D as Unet2D
# Initialize the dataset
OS = ObjectSerializer(args.train_loader_path)
train_loader = OS.load()
OS = ObjectSerializer(args.test_loader_path)
test_loader = OS.load()
# Initialize the prior
if args.prior == "GEHP":
prior = GlobalEquilibriumHarmonicPrior(shape=train_loader.data.shape,
channels_info={"coordinate": [0], "fluctuation": [1]})
elif args.prior == "UNP":
prior = UnitNormalPrior(shape=train_loader.data.shape,
channels_info={"coordinate": [0], "fluctuation": [1]})
# Initialize the model
model = Unet2D(dim=args.dim, dim_mults=(1, 2, 4), resnet_block_groups=8, channels=2)
backbone = ConvBackbone(model=model, data_shape=train_loader.data_dim, target_shape=8, num_dims=4,
lr=args.learning_rate, eval_mode="train", interpolate=False, self_condition=False)
diffusion = VPDiffusion(num_diffusion_timesteps=100)
trainer = DiffusionTrainer(diffusion, backbone, train_loader, model_dir=args.model_dir, pred_type=args.pred_mode,
prior=prior, device='cuda:0', test_loader=test_loader)
# training for 20 epochs
trainer.train(10, loss_type="smooth_l1", batch_size=args.batch_size, print_freq=100)
# Recording relevant information from the training run
summary = Summary(**{k:v for k,v in args.__dict__.items() if '__' not in k})
tracker = TrainingTracker(trainer, summary)
OS = ObjectSerializer(os.path.join(args.model_dir, "tracker.h5"))
OS.serialize(tracker)
def parse_args():
parser = argparse.ArgumentParser(description='Run Thermomaps.')
# Create subparsers for the two modes
subparsers = parser.add_subparsers(dest='mode')
# Single run parser
train_parser = subparsers.add_parser('train', help='Run a single simulation')
# Add arguments
train_parser.add_argument('--prior', type=str, default="GEHP", help='Prior type')
train_parser.add_argument('--sampler', type=str, default="ClusterFlip", help='Sampler type')
train_parser.add_argument('--size', type=int, default=8, help='Size parameter')
train_parser.add_argument('--batch_size', type=int, default=16, help='Batch size')
train_parser.add_argument('--learning_rate', type=float, default=1e-3, help='Learning rate')
train_parser.add_argument('--dim', type=int, default=8, help='Dimension')
train_parser.add_argument('--pred_mode', type=str, default="noise", help='Prediction mode')
train_parser.add_argument('--train_loader_path', type=str, default=None, help='Config file')
train_parser.add_argument('--test_loader_path', type=str, default=None, help='Config file')
train_parser.add_argument('--model_dir', type=str, default=None, help='Config file')
args = parser.parse_args()
return args
def main():
args = parse_args()
if args.mode == 'train':
train(args)
else:
raise ValueError("Invalid mode selected. Choose 'train'.")
if __name__ == "__main__":
main()
| Python |
2D | lherron2/thermomaps-ising | thermomaps-root/cli/ising_cli.py | .py | 6,656 | 117 | import numpy as np
import os
from slurmflow.config import ConfigParser
from slurmflow.serializer import ObjectSerializer
from slurmflow.driver import SlurmDriver
from ising.base import IsingModel
from ising.samplers import SwendsenWangSampler, SingleSpinFlipSampler
from ising.observables import Energy, Magnetization
import argparse
#for handler in logging.root.handlers[:]:
# logging.root.removeHandler(handler)
import sys
import logging
logger = logging.getLogger(__name__)
logger.setLevel(logging.INFO)
logger.addHandler(logging.StreamHandler(sys.stdout))
def single_run(args):
if args.sampler == "ClusterFlip":
sampler = SwendsenWangSampler
elif args.sampler == "SingleSpinFlip":
sampler = SingleSpinFlipSampler
else:
raise ValueError("Sampler not implemented")
observables = [Energy(Jx = args.Jx, Jy = args.Jy), Magnetization()]
# Initialize simulation
IM = IsingModel(sampler=sampler, size = args.size, warmup = args.warmup, temp = args.T, Jx = args.Jx, Jy = args.Jy)
IM.simulate(steps = args.steps, observables = observables, sampling_frequency = args.sampling_frequency)
trajectory_path = os.path.join(args.snapshot_dir, f"ising-trajectory_size={args.size}_T={round(args.T, 2)}_sampler={args.sampler}.h5")
IM.save(trajectory_path, overwrite=True)
def ensemble_run(args):
if args.slurm_config:
slurm_config = ConfigParser(args.slurm_config)
slurm_args = slurm_config.config_data
driver = SlurmDriver()
for T in np.arange(args.T_min, args.T_max + args.dT, args.dT):
args.T = T
excluded_args = ['T_min', 'T_max', 'dT', 'config', 'mode', 'slurm_config' ,'logging_dir']
cmd_args = " ".join([f"--{k} {v}" for k, v in vars(args).items() if v is not None and k not in excluded_args])
cmd = f"ising_model single_run {cmd_args}"
logger.info(f"Submitting job {cmd}")
slurm_args["job_name"] = f"ising_{args.size}_{args.T:.2f}_{args.sampler}"
slurm_args["output_dir"] = args.logging_dir
driver.submit_job(cmd, env="thermomaps-ising", slurm_args=slurm_args, track=True)
#driver.wait()
def parse_args():
parser = argparse.ArgumentParser(description='Run Ising model simulation.')
# Create subparsers for the two modes
subparsers = parser.add_subparsers(dest='mode')
# Single run parser
single_parser = subparsers.add_parser('single_run', help='Run a single simulation')
single_parser.add_argument('--sampler', type=str, default="ClusterFlip", help='Specifies the sampling method to be used in the simulation. Default is "ClusterFlip".')
single_parser.add_argument('--size', type=int, default=8, help='Defines the size of the lattice for the simulation.')
single_parser.add_argument('--T', type=float, default=1.0, help='Sets the temperature of the system for the simulation.')
single_parser.add_argument('--Jx', type=int, default=1, help='Specifies the strength of the spin-spin interaction along the x-axis.')
single_parser.add_argument('--Jy', type=int, default=1, help='Specifies the strength of the spin-spin interaction along the y-axis.')
single_parser.add_argument('--warmup', type=int, default=1000, help='Number of warmup steps before the actual simulation begins.')
single_parser.add_argument('--steps', type=int, default=10000, help='Total number of steps to run in the simulation.')
single_parser.add_argument('--sampling_frequency', type=int, default=1, help='Frequency at which the system state is sampled and recorded.')
single_parser.add_argument('--snapshot_dir', type=str, default="", help='Directory path where snapshots of the simulation will be stored.')
single_parser.add_argument('--config', type=str, required=False, help='Optionally read arguments from config file.')
# Ensemble run parser
ensemble_parser = subparsers.add_parser('ensemble_run', help='Run an ensemble of simulations with varying parameters.')
ensemble_parser.add_argument('--sampler', type=str, default="ClusterFlip", help='Specifies the sampling method to be used in the ensemble simulations. Default is "ClusterFlip".')
ensemble_parser.add_argument('--size', type=int, default=8, help='Defines the size of the lattice for the simulations in the ensemble.')
ensemble_parser.add_argument('--T_min', type=float, default=1.0, help='Sets the minimum temperature for the range of temperatures in the ensemble.')
ensemble_parser.add_argument('--T_max', type=float, default=2.0, help='Sets the maximum temperature for the range of temperatures in the ensemble.')
ensemble_parser.add_argument('--dT', type=float, default=0.5, help='Temperature step size between simulations in the ensemble.')
ensemble_parser.add_argument('--Jx', type=int, default=1, help='Specifies the strength of the spin-spin interaction along the x-axis for the ensemble simulations.')
ensemble_parser.add_argument('--Jy', type=int, default=1, help='Specifies the strength of the spin-spin interaction along the y-axis for the ensemble simulations.')
ensemble_parser.add_argument('--warmup', type=int, default=1000, help='Number of warmup steps before each simulation in the ensemble begins.')
ensemble_parser.add_argument('--steps', type=int, default=10000, help='Total number of steps to run in each simulation of the ensemble.')
ensemble_parser.add_argument('--sampling_frequency', type=int, default=1, help='Frequency at which the system state is sampled and recorded in each simulation of the ensemble.')
ensemble_parser.add_argument('--snapshot_dir', type=str, default="", help='Directory path where snapshots of the ensemble simulations will be stored.')
ensemble_parser.add_argument('--logging_dir', type=str, default="", help='Directory path where snapshots of the ensemble simulations will be stored.')
ensemble_parser.add_argument('--config', type=str, required=False, help='Optionally read arguments from a config file.')
ensemble_parser.add_argument('--slurm_config', type=str, required=False, help='Optionally read slurm arguments from a config file.')
args = parser.parse_args()
return args
def main():
args = parse_args()
if args.config:
config = ConfigParser(args.config)
args = config.override_args(args)
# Determine which function to call based on the subcommand used
if args.mode == 'single_run':
single_run(args)
elif args.mode == 'ensemble_run':
ensemble_run(args)
else:
raise ValueError("Invalid mode selected. Choose 'single_run' or 'ensemble_run'.")
if __name__ == "__main__":
main()
| Python |
2D | lherron2/thermomaps-ising | thermomaps-root/cli/__init__.py | .py | 14 | 2 | import pprint
| Python |
2D | lherron2/thermomaps-ising | thermomaps-root/cli/thermomap.py | .py | 10,407 | 332 | import os
import torch
import argparse
import numpy as np
from tm.core.backbone import ConvBackbone
from tm.core.diffusion_model import DiffusionTrainer, SteeredDiffusionSampler
from tm.core.diffusion_process import VPDiffusion
from tm.core.loader import Loader
from tm.core.prior import LocalEquilibriumHarmonicPrior, GlobalEquilibriumHarmonicPrior
from tm.architectures.unet_2D_mid_attn import Unet2D
from tm.core.utils import compute_model_dim
from cli.cli_utils import populate_args_from_config, save_dict_as_npy, load_diffusion_data
def init_directory(args):
device = "cuda" if torch.cuda.is_available() else "cpu"
num_devices = torch.cuda.device_count()
return Directory(
args.pdb,
args.expid,
args.iter,
args.identifier,
device,
num_devices,
experiment_path=args.experiment_path,
model_path=args.model_path,
dataset_path=args.dataset_path,
temperature_path=args.temperature_path,
fluctuation_path=args.fluctuation_path,
sample_path=args.sample_path,
)
def init_backbone(directory, loader, args):
model_dim = compute_model_dim(loader.data_dim, groups=8)
model = Unet2D(
dim=model_dim,
dim_mults=(1, 2, 2, 4),
resnet_block_groups=8,
learned_variance=False,
self_condition=eval(args.self_condition),
learned_sinusoidal_cond=True,
channels=5,
)
return ConvBackbone(
model=model,
data_shape=loader.data_dim,
target_shape=model_dim,
num_dims=4,
lr=1e-3,
eval_mode="train",
self_condition=eval(args.self_condition),
)
def train(args):
# Code specific to training
directory = init_directory(args)
rvecs = np.load(directory.fluct_path, allow_pickle=True).item(0)
temps = np.array(list(rvecs.keys()))
if args.fluctuation_mapping:
prior = LocalEquilibriumHarmonicPrior(
data=rvecs, temps=temps, cutoff=args.fluctuation_cutoff, fit_key="linear"
)
else:
prior = GlobalEquilibriumHarmonicPrior(
data=rvecs, temps=temps, cutoff=args.fluctuation_cutoff, fit_key="linear"
)
loader = Loader(
directory,
control_tuple=([1], [4, 5]),
transform_type="identity",
dequantize=True,
dequantize_scale=1e-2,
)
backbone = init_backbone(directory, loader, args)
diffusion = VPDiffusion(num_diffusion_timesteps=args.diffusion_timesteps)
trainer = DiffusionTrainer(
diffusion, backbone, loader, directory, args.pred_type, prior
)
trainer.train(
args.num_epochs, loss_type="l2", batch_size=args.batch_size, print_freq=100
)
def sample(args):
directory = init_directory(args)
# Code specific to sampling
rvecs = np.load(directory.fluct_path, allow_pickle=True).item(0)
temps = np.array(list(rvecs.keys()))
prior = LocalEquilibriumHarmonicPrior(
data=rvecs, temps=temps, fit_key="linear", cutoff=args.fluctuation_cutoff
)
loader = Loader(
directory,
control_tuple=([1], [4, 5]),
transform_type="identity",
dequantize_scale=1e-2,
)
backbone = init_backbone(directory, loader, args)
diffusion = VPDiffusion(num_diffusion_timesteps=args.diffusion_timesteps)
backbone.load_model(directory, args.epoch)
sampler = SteeredDiffusionSampler(
diffusion, backbone, loader, directory, args.pred_type, prior, gamma=1
)
sampler.sample_loop(
args.num_samples, args.batch_size, args.pdb, int(args.gen_temp), n_ch=5
)
def postprocess_samples(args):
diffusion_dict = load_diffusion_data(args.diffusion_path, args.subsample)
diffusion_file = os.path.join(args.data_path, args.outfile)
save_dict_as_npy(diffusion_file, diffusion_dict)
def main():
parser = argparse.ArgumentParser(description="Diffusion Model Operations")
parser.add_argument("--config_file", type=str, help="Path to a YAML config file.")
subparsers = parser.add_subparsers(dest="command", help="Sub-command to run.")
# Train subparser
parser_train = subparsers.add_parser("train", help="Train a diffusion model.")
parser_train.add_argument(
"--pdb", required=True, type=str, help="Path to the PDB file."
)
parser_train.add_argument(
"--iter", required=True, type=str, help="Number of iterations."
)
parser_train.add_argument("--expid", required=True, type=str, help="Experiment ID.")
parser_train.add_argument(
"--pred_type", required=True, type=str, help="Prediction type."
)
parser_train.add_argument(
"--num_epochs",
type=int,
default=250,
help="Number of training epochs. Default is 250.",
)
parser_train.add_argument(
"--self_condition",
type=str,
default="True",
help="Whether to self-condition. Default is True.",
)
parser_train.add_argument(
"--diffusion_timesteps",
type=int,
default=100,
help="Number of diffusion timesteps. Default is 100.",
)
parser_train.add_argument(
"--batch_size",
type=int,
default=16,
help="Batch size for training. Default is 16.",
)
parser_train.add_argument(
"--fluctuation_cutoff",
type=float,
default=5e-2,
help="Fluctuation cutoff value. Default is 5e-2.",
)
parser_train.add_argument(
"--experiment_path",
required=True,
type=str,
help="Path to the experiment directory.",
)
parser_train.add_argument(
"--model_path", required=True, type=str, help="Path to the model directory."
)
parser_train.add_argument(
"--dataset_path", required=True, type=str, help="Path to the dataset directory."
)
parser_train.add_argument(
"--temperature_path",
required=True,
type=str,
help="Path to the temperature data.",
)
parser_train.add_argument(
"--fluctuation_path",
required=True,
type=str,
help="Path to the fluctuation data.",
)
parser_train.add_argument(
"--sample_path", required=True, type=str, help="Path to the sample data."
)
parser_train.add_argument(
"--identifier",
required=True,
type=str,
help="Identifier for the experiment/model.",
)
parser_train.add_argument(
"--fluctuation_mapping",
action="store_true",
help="Flag to use LocalEquilibriumHarmonicPrior. If not provided, GlobalEquilibriumHarmonicPrior will be used.",
)
# Sample subparser
parser_sample = subparsers.add_parser(
"sample", help="Sample using a diffusion model."
)
parser_sample.add_argument(
"--pdb", required=True, type=str, help="Path to the PDB file."
)
parser_sample.add_argument(
"--iter", required=True, type=str, help="Number of iterations."
)
parser_sample.add_argument(
"--expid", required=True, type=str, help="Experiment ID."
)
parser_sample.add_argument("--epoch", required=True, type=int, help="Epoch number.")
parser_sample.add_argument(
"--gen_temp", required=True, type=float, help="Generation temperature."
)
parser_sample.add_argument(
"--pred_type", required=True, type=str, help="Prediction type."
)
parser_sample.add_argument(
"--num_samples", required=True, type=int, help="Number of samples to generate."
)
parser_sample.add_argument(
"--self_condition",
type=str,
default="True",
help="Whether to self-condition. Default is True.",
)
parser_sample.add_argument(
"--diffusion_timesteps",
type=int,
default=100,
help="Number of diffusion timesteps. Default is 100.",
)
parser_sample.add_argument(
"--batch_size",
type=int,
default=5000,
help="Batch size for sampling. Default is 5000.",
)
parser_sample.add_argument(
"--fluctuation_cutoff",
type=float,
default=5e-2,
help="Fluctuation cutoff value. Default is 5e-2.",
)
parser_sample.add_argument(
"--experiment_path",
required=True,
type=str,
help="Path to the experiment directory.",
)
parser_sample.add_argument(
"--model_path", required=True, type=str, help="Path to the model directory."
)
parser_sample.add_argument(
"--dataset_path", required=True, type=str, help="Path to the dataset directory."
)
parser_sample.add_argument(
"--temperature_path",
required=True,
type=str,
help="Path to the temperature data.",
)
parser_sample.add_argument(
"--fluctuation_path",
required=True,
type=str,
help="Path to the fluctuation data.",
)
parser_sample.add_argument(
"--sample_path", required=True, type=str, help="Path to the sample data."
)
parser_sample.add_argument(
"--identifier",
required=True,
type=str,
help="Identifier for the experiment/model.",
)
# Postprocess samples subparser
parser_postprocess = subparsers.add_parser(
"postprocess_samples", help="Postprocess samples from diffusion model."
)
parser_postprocess.add_argument("--pdbid", required=True, type=str, help="PDB ID.")
parser_postprocess.add_argument(
"--diffusion_path", type=str, help="Path to the diffusion data."
)
parser_postprocess.add_argument(
"--subsample", type=int, help="Factor by which to subsample the data."
)
parser_postprocess.add_argument(
"--data_path", type=str, help="Path to save the processed data."
)
parser_postprocess.add_argument(
"--outfile",
type=str,
help="Name of the output file to save the processed data.",
)
args = parser.parse_args()
subparsers_dict = {
"train": parser_train,
"sample": parser_sample,
"postprocess_samples": parser_postprocess,
}
if args.config:
args = populate_args_from_config(args, parser, subparsers_dict)
# If a sub-command is provided, call the relevant function
if args.command:
args.func(args)
else:
parser.print_help()
| Python |
2D | lherron2/thermomaps-ising | thermomaps-root/ising/samplers.py | .py | 5,609 | 166 | import numpy as np
import random
from typing import Callable, Dict, List, Type
from abc import ABC, abstractmethod
from ising.base import IsingModel
import logging
logger = logging.getLogger(__name__)
logger.setLevel(logging.INFO)
class Sampler(ABC):
"""
Abstract base class for samplers in the Ising model.
A sampler is a method for updating the state of the system.
Attributes:
name (str): The name of the sampler.
"""
def __init__(self, ising_model: Type[IsingModel]):
"""
Initialize a Sampler.
"""
self.IM = ising_model
@abstractmethod
def update(self):
"""
Perform one update step.
This is an abstract method that must be overridden by subclasses.
"""
pass
class SwendsenWangSampler(Sampler):
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.name = "SwendsenWang"
def update(self):
"""
Perform one update step using the Swendsen-Wang algorithm.
"""
# Initialize the clusters from the current lattice configuration
labels = self.initialize_clusters()
# Build the clusters of connected spins
self.build_clusters(labels)
# Flip the clusters
self.flip_clusters(labels)
return self.IM.lattice
def initialize_clusters(self) -> Dict[int, int]:
"""
Initialize the clusters for the Swendsen-Wang algorithm.
Returns:
Dict[int, int]: A dictionary mapping each site to its cluster label.
"""
return {i: i for i in range(self.IM.size * self.IM.size)}
def find_root(self, site: int, labels: Dict[int, int]) -> int:
"""
Find the root of the cluster that a site belongs to.
Args:
site (int): The linear index of the site.
labels (Dict[int, int]): A dictionary mapping each site to its cluster label.
Returns:
int: The root of the cluster that the site belongs to.
"""
while site != labels[site]:
site = labels[site]
return site
def union(self, site1: int, site2: int, labels: Dict[int, int]):
"""
Merge the clusters of two sites.
Args:
site1 (int): The linear index of the first site.
site2 (int): The linear index of the second site.
labels (Dict[int, int]): A dictionary mapping each site to its cluster label.
"""
root1, root2 = self.find_root(site1, labels), self.find_root(site2, labels)
if root1 != root2:
labels[root2] = root1
def build_clusters(self, labels: Dict[int, int]):
"""
Build clusters of connected spins in the same state.
"""
px = 1 - np.exp(-2 * self.IM.Jx / self.IM.temp)
py = 1 - np.exp(-2 * self.IM.Jy / self.IM.temp)
for x in range(self.IM.size):
for y in range(self.IM.size):
if x + 1 < self.IM.size and self.IM.lattice[x, y] == self.IM.lattice[x + 1, y] and random.random() < px:
self.union(x * self.IM.size + y, (x + 1) * self.IM.size + y, labels)
if y + 1 < self.IM.size and self.IM.lattice[x, y] == self.IM.lattice[x, y + 1] and random.random() < py:
self.union(x * self.IM.size + y, x * self.IM.size + (y + 1), labels)
def flip_clusters(self, labels: Dict[int, int]):
"""
Flip clusters of connected spins.
"""
should_flip = {root: random.choice([True, False]) for root in set(labels.values())}
for x in range(self.IM.size):
for y in range(self.IM.size):
root = self.find_root(x * self.IM.size + y, labels)
if should_flip[root]:
self.IM.lattice[x, y] *= -1
class SingleSpinFlipSampler(Sampler):
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.name = "SingleSpin"
def update(self):
"""
Perform one update step using the Metropolis-Hastings algorithm.
"""
for _ in range(self.IM.size * self.IM.size):
self.metropolis_hastings_step()
return self.IM.lattice
def metropolis_hastings_step(self):
"""
Perform a single Monte-Carlo sampling step using the Metropolis-Hastings algorithm.
"""
x, y = np.random.randint(self.IM.size), np.random.randint(self.IM.size)
delta_E = self.calculate_energy_change(x, y)
if delta_E < 0 or np.random.rand() < np.exp(-delta_E / self.IM.temp):
self.IM.lattice[x, y] *= -1
def calculate_energy_change(self, x: int, y: int) -> float:
"""
Calculate the energy change for flipping a spin at a given position in an anisotropic Ising model.
Args:
x (int): The x-coordinate of the spin.
y (int): The y-coordinate of the spin.
Returns:
float: The energy change for flipping the spin.
"""
S = self.IM.lattice[x, y]
# Neighbors along x direction
neighbors_x = self.IM.lattice[(x + 1) % self.IM.size, y] + self.IM.lattice[(x - 1) % self.IM.size, y]
# Neighbors along y direction
neighbors_y = self.IM.lattice[x, (y + 1) % self.IM.size] + self.IM.lattice[x, (y - 1) % self.IM.size]
# Calculate energy change with different interaction energies along x and y directions
delta_E = 2 * S * (self.IM.Jx * neighbors_x + self.IM.Jy * neighbors_y)
return delta_E
| Python |
2D | lherron2/thermomaps-ising | thermomaps-root/ising/swedsen_wang_simulator.py | .py | 14,503 | 375 | import numpy as np
import random
from typing import Callable, Dict, List
from abc import ABC, abstractmethod
class Observable(ABC):
"""
Abstract base class for observables in the Ising model.
An observable is a physical quantity that can be measured in a simulation.
Attributes:
name (str): The name of the observable.
"""
def __init__(self, name: str):
"""
Initialize an Observable.
Args:
name (str): The name of the observable.
"""
# Name of the observable
self.name = name
@abstractmethod
def evaluate(self, lattice: np.ndarray) -> float:
"""
Calculate the value of the observable for a given lattice.
This is an abstract method that must be overridden by subclasses.
Args:
lattice (np.ndarray): The lattice of spins.
Returns:
float: The value of the observable.
"""
pass
class Energy(Observable):
"""
Class for calculating the energy of a lattice.
Energy is defined as the sum of the interaction energies between each spin and its neighbors.
This class inherits from the Observable class.
Attributes:
name (str): The name of the observable, "energy".
Jx (float): The interaction energy along the x direction.
Jy (float): The interaction energy along the y direction.
"""
def __init__(self, Jx: float = 1.0, Jy: float = 1.0):
"""
Initialize an Energy observable.
Args:
Jx (float, optional): The interaction energy along the x direction. Defaults to 1.0.
Jy (float, optional): The interaction energy along the y direction. Defaults to 1.0.
"""
super().__init__("energy")
self.Jx = Jx # Interaction energy along the x direction
self.Jy = Jy # Interaction energy along the y direction
def evaluate(self, lattice: np.ndarray) -> float:
"""
Calculate the energy of a lattice.
Args:
lattice (np.ndarray): The lattice of spins.
Returns:
float: The energy of the lattice.
"""
energy = 0.0
size = len(lattice)
# Iterate over each spin in the lattice
for i in range(size):
for j in range(size):
S = lattice[i, j]
# Calculate the sum of the spins of the neighbors
neighbors_x = lattice[(i+1)%size, j] + lattice[(i-1)%size, j]
neighbors_y = lattice[i, (j+1)%size] + lattice[i, (j-1)%size]
# Add the interaction energy with the neighbors to the total energy
energy += -self.Jx * S * neighbors_x - self.Jy * S * neighbors_y
# Return the total energy, divided by 2 because each pair is counted twice
return energy / 2
class Magnetization(Observable):
"""
Class for calculating the magnetization of a lattice.
Magnetization is defined as the mean value of the spins in the lattice.
This class inherits from the Observable class.
Attributes:
name (str): The name of the observable, "magnetization".
"""
def __init__(self):
"""
Initialize a Magnetization observable.
"""
super().__init__("magnetization")
def evaluate(self, lattice: np.ndarray) -> float:
"""
Calculate the magnetization of a lattice.
Args:
lattice (np.ndarray): The lattice of spins.
Returns:
float: The magnetization of the lattice.
"""
# Magnetization is the mean value of the spins
return np.mean(lattice.ravel())
class IsingSwendsenWang:
"""
Class for simulating the Ising model using the Swendsen-Wang algorithm.
Attributes:
size (int): The size of the lattice.
lattice (np.ndarray): The lattice of spins.
warm_up (int): The number of warm-up steps.
temp (float): The temperature of the system.
snapshots (list): A list to store snapshots of the system state.
"""
def __init__(self, size: int, warm_up: int, temp: float, Jx: float = 1.0, Jy: float = 1.0):
"""
Initialize an IsingSwendsenWang simulator.
Args:
size (int): The size of the lattice.
warm_up (int): The number of warm-up steps.
temp (float): The temperature of the system.
Jx (float, optional): The interaction energy along the x direction. Defaults to 1.0.
Jy (float, optional): The interaction energy along the y direction. Defaults to 1.0.
"""
# Size of the lattice
self.size = size
# Initialize the lattice with random spins
self.lattice = np.random.choice([-1, 1], (size, size))
# Number of warm-up steps
self.warm_up = warm_up
# Temperature of the system
self.temp = temp
# Interaction energy along the x direction
self.Jx = Jx
# Interaction energy along the y direction
self.Jy = Jy
# List to store snapshots of the system state
self.snapshots = []
def initialize_clusters(self) -> Dict[int, int]:
"""
Initialize the clusters for the Swendsen-Wang algorithm.
This function creates a new cluster for each site in the lattice. Each site is its own root.
Returns:
Dict[int, int]: A dictionary mapping each site to its cluster label.
"""
# Create a new cluster for each site in the lattice
# Each site is its own root
return {i: i for i in range(self.size * self.size)}
def find_root(self, site: int, labels: Dict[int, int]) -> int:
"""
Find the root of the cluster that a site belongs to.
This function is part of the Swendsen-Wang algorithm for the Ising model.
It uses path compression to speed up future lookups.
Args:
site (int): The linear index of the site.
labels (Dict[int, int]): A dictionary mapping each site to its cluster label.
Returns:
int: The root of the cluster that the site belongs to.
"""
# Find the root of the cluster by following the parent pointers
root = site
while root != labels[root]:
root = labels[root]
# Compress the path from the site to the root
while site != root:
parent = labels[site]
labels[site] = root
site = parent
# Return the root of the cluster
return root
def union(self, site1: int, site2: int, labels: Dict[int, int]):
"""
Merge the clusters of two sites.
This function is part of the Swendsen-Wang algorithm for the Ising model.
It merges the clusters of site1 and site2 by setting the root of site2's cluster
to be the root of site1's cluster.
Args:
site1 (int): The linear index of the first site.
site2 (int): The linear index of the second site.
labels (Dict[int, int]): A dictionary mapping each site to its cluster label.
"""
# Find the roots of the clusters of site1 and site2
root1, root2 = self.find_root(site1, labels), self.find_root(site2, labels)
# If the sites are in different clusters, merge the clusters
if root1 != root2:
# Set the root of site2's cluster to be the root of site1's cluster
labels[root2] = root1
def build_clusters(self, labels: Dict[int, int]):
"""
Build clusters of connected spins in the same state.
This function implements part of the Swendsen-Wang algorithm for the Ising model.
It iterates over each spin in the lattice and, with a certain probability, creates bonds
between neighboring spins that are in the same state.
Args:
labels (Dict[int, int]): A dictionary mapping each spin to its cluster label.
"""
# Calculate the probability of creating a bond between two neighboring spins
px = 1 - np.exp(-2 * self.Jx / self.temp)
py = 1 - np.exp(-2 * self.Jy / self.temp)
# Iterate over each spin in the lattice
for x in range(self.size):
for y in range(self.size):
# With probability px, create bonds between neighboring spins in the same state along x direction
if random.random() < px:
# Check the spin to the right
if x + 1 < self.size and self.lattice[x, y] == self.lattice[x + 1, y]:
# If the spins are in the same state, create a bond between them
self.union(x * self.size + y, (x + 1) * self.size + y, labels)
# With probability py, create bonds between neighboring spins in the same state along y direction
if random.random() < py:
# Check the spin below
if y + 1 < self.size and self.lattice[x, y] == self.lattice[x, y + 1]:
# If the spins are in the same state, create a bond between them
self.union(x * self.size + y, x * self.size + (y + 1), labels)
def flip_clusters(self, labels: Dict[int, int]):
"""
Flip clusters of connected spins.
This function implements part of the Swendsen-Wang algorithm for the Ising model.
It decides randomly whether to flip each cluster of connected spins or not, and then
flips the spins in the selected clusters.
Args:
labels (Dict[int, int]): A dictionary mapping each spin to its cluster label.
"""
# Decide randomly whether to flip each cluster or not
should_flip = {root: random.choice([True, False]) for root in set(labels.values())}
# Iterate over each spin in the lattice
for x in range(self.size):
for y in range(self.size):
# Find the root of the cluster that the spin belongs to
root = self.find_root(x * self.size + y, labels)
# If the cluster should be flipped, flip the spin
if should_flip[root]:
self.lattice[x, y] *= -1
def swendsen_wang_step(self):
"""
Perform one step of the Swendsen-Wang algorithm.
This function implements one step of the Swendsen-Wang algorithm for the Ising model.
It first initializes the clusters, then builds the clusters of connected spins, and finally
flips the clusters.
"""
# Initialize the clusters from current lattice configuration
labels = self.initialize_clusters()
# Build the clusters of connected spins
self.build_clusters(labels)
# Flip the clusters
self.flip_clusters(labels)
def simulate(self, steps: int, observables: List[Callable[[np.ndarray], float]], sampling_frequency: int):
"""
Simulate the Ising model using the Swendsen-Wang algorithm.
This function performs a number of steps of the Swendsen-Wang algorithm, and periodically
samples the state of the system and the values of the observables.
Args:
steps (int): The number of steps to perform.
observables (List[Callable[[np.ndarray], float]]): A list of observables to measure.
sampling_frequency (int): The frequency at which to sample the state of the system and the observables.
Returns:
dict: A dictionary containing the sampled states of the system and the values of the observables.
"""
# Perform the warm-up steps
for _ in range(self.warm_up):
self.swendsen_wang_step()
# Perform the simulation steps
for i in range(steps):
self.swendsen_wang_step()
# Sample the state of the system and the observables
if i % sampling_frequency == 0:
if not self.snapshots:
# Initialize the dictionary with lists
self.snapshots = {'lattice': [self.lattice.copy()]}
for obs in observables:
self.snapshots[obs.name] = [obs.evaluate(self.lattice)]
else:
# Append to the existing lists
self.snapshots['lattice'].append(self.lattice.copy())
for obs in observables:
self.snapshots[obs.name].append(obs.evaluate(self.lattice))
# Convert lists to numpy arrays
for key in self.snapshots:
self.snapshots[key] = np.array(self.snapshots[key])
# Return the sampled states and observables
return self.snapshots
def save_snapshots(self, filename: str, metadata: dict = None):
"""
Save the snapshots of the system state and the observables to a file.
This function saves the snapshots of the system state and the observables to a compressed
numpy (.npz) file. Additional metadata can also be included in the file.
Args:
filename (str): The name of the file to save the snapshots to.
metadata (dict, optional): A dictionary of metadata to include in the file.
"""
# If metadata is provided, include it in the file
if metadata:
np.savez_compressed(f"{filename}.npz", **self.snapshots, **metadata)
else:
# Otherwise, just save the snapshots
np.savez_compressed(f"{filename}.npz", **self.snapshots)
if __name__ == "__main__":
import argparse
argparser = argparse.ArgumentParser()
argparser.add_argument("--size", type=int, default=16)
argparser.add_argument("--warm-up", type=int, default=1000)
argparser.add_argument("--steps", type=int, default=10000)
argparser.add_argument("--temp", type=float, default=2.0)
argparser.add_argument("--Jx", type=float, default=1.0)
argparser.add_argument("--Jy", type=float, default=1.0)
argparser.add_argument("--sampling-frequency", type=int, default=100)
argparser.add_argument("--filename", type=str, default="ising")
args = argparser.parse_args()
ising = IsingSwendsenWang(args.size, args.warm_up, args.temp, args.Jx, args.Jy)
results = ising.simulate(args.steps, [Energy(args.Jx, args.Jy), Magnetization()], args.sampling_frequency)
ising.save_snapshots(args.filename) | Python |
2D | lherron2/thermomaps-ising | thermomaps-root/ising/__init__.py | .py | 0 | 0 | null | Python |
2D | lherron2/thermomaps-ising | thermomaps-root/ising/base.py | .py | 3,147 | 84 | import numpy as np
import random
import sys
from typing import Callable, Dict, List, Type
from abc import ABC, abstractmethod
from data.trajectory import EnsembleIsingTrajectory
from data.generic import Summary
from ising.observables import Energy, Magnetization
from slurmflow.serializer import ObjectSerializer
import logging
logger = logging.getLogger(__name__)
logger.setLevel(logging.INFO)
logger.addHandler(logging.StreamHandler(sys.stdout))
class IsingModel:
def __init__(self, sampler: Type['Sampler'], size: int, warmup: int, temp: float, Jx: float = 1.0, Jy: float = 1.0):
"""
Initialize the base Ising model.
Args:
size (int): The size of the lattice.
warmup (int): The number of warm-up steps.
temp (float): The temperature of the system.
Jx (float, optional): The interaction energy along the x direction. Defaults to 1.0.
Jy (float, optional): The interaction energy along the y direction. Defaults to 1.0.
"""
self.size = size
self.lattice = np.random.choice([-1, 1], (size, size))
self.warmup = warmup
self.temp = temp
self.Jx = Jx
self.Jy = Jy
self.snapshots = []
sampler = sampler(self)
self.update = sampler.update
self.trajectory = EnsembleIsingTrajectory(
summary = Summary(name="IsingModel", size=size, temperature=temp, Jx=Jx, Jy=Jy, sampler=sampler.name),
state_variables = Summary(temperature=temp)
)
def simulate(self, steps: int, observables: List[Callable[[np.ndarray], float]], sampling_frequency: int):
"""
Simulate the Ising model.
Args:
steps (int): The number of steps to perform.
observables (List[Callable[[np.ndarray], float]]): A list of observables to measure.
sampling_frequency (int): The frequency at which to sample the state of the system and the observables.
"""
# Perform the warm-up steps
for _ in range(self.warmup):
self.lattice = self.update()
logger.debug(f"Finished warm-up steps.")
# Perform the simulation steps
for i in range(steps):
self.lattice = self.update()
# Sample the state of the system and the observables
if i % sampling_frequency == 0:
logger.debug(f"Adding frame {i} (shape = {self.lattice.shape}) to the trajectory.")
self.trajectory.add_frame(self.lattice)
# Compute the observables and add them to the trajectory
for obs in observables:
logger.debug(f"Computing observable {obs.name}.")
obs.evaluate(self.trajectory.coordinates)
self.trajectory.add_observable(obs)
return self.trajectory
def save(self, filename: str, overwrite: bool = False):
"""
Save the trajectory to a file.
Args:
filename (str): The name of the file to save the trajectory to.
"""
OS = ObjectSerializer(filename)
OS.serialize(self.trajectory, overwrite=overwrite) | Python |
2D | lherron2/thermomaps-ising | thermomaps-root/ising/observables.py | .py | 3,640 | 112 | import numpy as np
from abc import ABC, abstractmethod
from data.observables import Observable
import logging
logger = logging.getLogger(__name__)
logger.setLevel(logging.INFO)
class Energy(Observable):
"""
Class for calculating the energy of a lattice.
Energy is defined as the sum of the interaction energies between each spin and its neighbors.
This class inherits from the Observable class.
Attributes:
name (str): The name of the observable, "energy".
Jx (float): The interaction energy along the x direction.
Jy (float): The interaction energy along the y direction.
"""
def __init__(self, Jx: float = 1.0, Jy: float = 1.0, name: str = 'energy'):
"""
Initialize an Energy observable.
Args:
Jx (float, optional): The interaction energy along the x direction. Defaults to 1.0.
Jy (float, optional): The interaction energy along the y direction. Defaults to 1.0.
"""
super().__init__("energy")
self.Jx = Jx # Interaction energy along the x direction
self.Jy = Jy # Interaction energy along the y direction
def evaluate_frame(self, frame: np.ndarray) -> float:
energy = 0.0
size = len(frame)
# Iterate over each spin in the lattice
for i in range(size):
for j in range(size):
S = frame[i, j]
# Calculate the sum of the spins of the neighbors
neighbors_x = frame[(i+1)%size, j] + frame[(i-1)%size, j]
neighbors_y = frame[i, (j+1)%size] + frame[i, (j-1)%size]
# Add the interaction energy with the neighbors to the total energy
energy += -self.Jx * S * neighbors_x - self.Jy * S * neighbors_y
# Return the total energy, divided by 2 because each pair is counted twice
return energy / 2
def evaluate(self, time_series: np.ndarray) -> float:
"""
Calculate the energy of a lattice.
Args:
lattice (np.ndarray): The lattice of spins.
Returns:
float: The energy of the lattice.
"""
energies = []
for frame in time_series:
energies.append(self.evaluate_frame(frame))
self.quantity = np.array(energies)
return self.quantity
class Magnetization(Observable):
"""
Class for calculating the magnetization of a lattice.
Magnetization is defined as the mean value of the spins in the lattice.
This class inherits from the Observable class.
Attributes:
name (str): The name of the observable, "magnetization".
"""
def __init__(self):
"""
Initialize a Magnetization observable.
"""
super().__init__("magnetization")
def evaluate_frame(self, frame: np.ndarray) -> float:
"""
Calculate the magnetization of a lattice.
Args:
lattice (np.ndarray): The lattice of spins.
Returns:
float: The magnetization of the lattice.
"""
# Magnetization is the mean value of the spins
return abs(np.mean(frame))
def evaluate(self, time_series: np.ndarray) -> float:
"""
Calculate the magnetization of a lattice.
Args:
lattice (np.ndarray): The lattice of spins.
Returns:
float: The magnetization of the lattice.
"""
magnetizations = []
for frame in time_series:
magnetizations.append(self.evaluate_frame(frame))
self.quantity = np.array(magnetizations)
return self.quantity
| Python |
2D | lherron2/thermomaps-ising | thermomaps-root/tm/__init__.py | .py | 0 | 0 | null | Python |
2D | lherron2/thermomaps-ising | thermomaps-root/tm/core/FluctuationDataset.py | .py | 6,436 | 190 | import numpy as np
from inspect import signature
from scipy.optimize import curve_fit
import types
def safe_index(arr, idx):
if idx < len(arr):
return arr[idx]
else:
return arr[-1]
def linear_fit(x, a, b):
return x*a + b
class Fluctuation:
"""
A class for performing fluctuation analysis and fitting.
Args:
func (callable): The fitting function.
func_kwargs (dict): Additional keyword arguments for curve fitting.
"""
def __init__(self, func, **func_kwargs):
sig = signature(func)
self.func = func
self.free_params = len(sig.parameters) - 1
self.func_kwargs = func_kwargs
def filter_bounds(self, data, mult=None, cutoff=None):
"""
Filter the bounds of the data based on provided criteria.
Args:
data (numpy.ndarray): The data to be filtered.
mult (float, optional): Multiplicative factor for filtering. Defaults to None.
cutoff (float, optional): Cutoff value for filtering. Defaults to None.
Returns:
numpy.ndarray: The filtered data.
"""
mean, std = data.mean(0), data.std(0)
if mult is not None:
lb = mean - mult * std
ub = mean + mult * std
data_ = []
for x in data:
if mult is not None:
np.putmask(x, x > ub, ub)
np.putmask(x, x < lb, lb)
if cutoff is not None:
x[x < cutoff] = cutoff
data_.append(x)
data = np.stack(data_)
return data
def rmsd_traj(self, coords):
"""
Calculate the root mean square deviation (RMSD) for a trajectory.
Args:
coords (numpy.ndarray): The trajectory coordinates.
Returns:
numpy.ndarray: The RMSD values.
"""
return ((coords - coords.mean(0))**2).mean(0).sum(0)[None, :, :]
def rmsd_multitraj(self, coords_dict):
"""
Calculate the RMSD for multiple trajectories.
Args:
coords_dict (dict): A dictionary of trajectory coordinates.
Returns:
numpy.ndarray: The RMSD values.
"""
return np.concatenate([self.rmsd_traj(v) for k, v in coords_dict.items()], axis=0)
def param_from_rmsd(self, coords_dict, mult, cutoff):
"""
Calculate parameters from RMSD values.
Args:
coords_dict (dict): A dictionary of trajectory coordinates.
mult (float): Multiplicative factor for filtering.
cutoff (float): Cutoff value for filtering.
Returns:
numpy.ndarray: The calculated parameters.
"""
temps = np.array([float(k.split("_")[0]) for k in coords_dict.keys()])
fluctuations = self.rmsd_multitraj(coords_dict)
fluctuations_filt = self.filter_bounds(fluctuations, mult=mult, cutoff=cutoff)
params = np.ones_like(fluctuations_filt[0])[None, :].repeat(self.free_params, 0)
return temps, fluctuations_filt, params
def rmsd_fit(self, coords_dict, mult=None, cutoff=None):
"""
Fit a function to the RMSD data.
Args:
coords_dict (dict): A dictionary of trajectory coordinates.
mult (float, optional): Multiplicative factor for filtering. Defaults to None.
cutoff (float, optional): Cutoff value for filtering. Defaults to None.
Returns:
numpy.ndarray: The fitted parameters.
"""
self.temps, self.fluctuations, params = self.param_from_rmsd(coords_dict, mult, cutoff)
(_, xdims, ydims) = self.fluctuations.shape
for i in range(xdims):
for j in range(ydims):
self.popt, pcov = curve_fit(self.func,
self.temps.astype(float),
self.fluctuations[:, i, j],
**self.func_kwargs,
maxfev=10000
)
params[:, i, j] = self.popt
return params
class RNAFluctuationPrior:
"""
A class for computing fluctuation data and saving it.
Args:
mult_schedule (list): A list of multiplicative factors for filtering.
cutoff (float): Cutoff value for filtering.
"""
def __init__(self, mult_schedule, cutoff):
self.mult_schedule = mult_schedule
self.cutoff = cutoff
def compute_from_simulation_data(self, rvec_path, gvec_path, data_path, temps_path, iter, save):
"""
Compute fluctuation data from simulation data.
Args:
args (argparse.Namespace, optional): Command-line arguments. Defaults to None.
save (bool, optional): Whether to save the computed data. Defaults to False.
Returns:
numpy.ndarray: The computed data.
numpy.ndarray: The corresponding keys.
"""
rvecs = np.load(rvec_path, allow_pickle=True).item(0)
gvecs = np.load(gvec_path, allow_pickle=True).item(0)
linear_model = Fluctuation(linear_fit, bounds=([0, -np.inf], [np.inf, np.inf]))
params = linear_model.rmsd_fit(rvecs,
mult=safe_index(self.mult_schedule, int(iter)),
cutoff=self.cutoff)
self.params = params
data = []
keys = []
for i, (k, v) in enumerate(gvecs.items()):
v = v.astype(np.float32)
fluct_ch = linear_model.fluctuations[i][None, None, :, :]
fluct_ch = np.repeat(fluct_ch, v.shape[0], axis=0)
data.append(np.concatenate([v, fluct_ch], axis=1))
keys.append([k for _ in range(v.shape[0])])
data = np.concatenate(data, axis=0)
keys = np.concatenate(keys, axis=0)
if save:
np.save(data_path, data)
np.save(temps_path, keys)
return data, keys
@staticmethod
def load(data_path, key_path):
"""
Load data and keys from files.
Args:
data_path (str): Path to the data file.
key_path (str): Path to the keys file.
Returns:
numpy.ndarray: The loaded data.
numpy.ndarray: The loaded keys.
"""
return np.load(data_path), np.load(key_path)
| Python |
2D | lherron2/thermomaps-ising | thermomaps-root/tm/core/Directory.py | .py | 3,276 | 124 | import os
class Directory:
"""
Reads relevant paths from a YAML file defined for an experiment.
"""
def __init__(
self,
pdb: str,
expid: str,
iter: str,
identifier: str,
device: str,
num_devices: int,
**paths
):
"""
Initialize a Directory object with experiment-specific paths.
Args:
pdb (str): PDB identifier.
expid (str): Experiment identifier.
iter (str): Iteration identifier.
identifier (str): Identifier for the directory.
device (str): Device name.
num_devices (int): Number of devices.
**paths: Dictionary of paths loaded from a YAML file.
"""
self.device_ids = list(range(0, num_devices))
# Replacing wildcards in loaded YAML files
self.pdb = pdb
wildcards = {"PDBID": self.pdb, "EXPID": expid, "ITER": iter}
self.paths = self.replace_wildcards(paths, wildcards)
self.identifier = identifier
self.base_path = self.paths["experiment_path"]
self.model_path = os.path.join(self.base_path, self.paths["model_path"])
self.data_path = self.paths["dataset_path"]
self.temps_path = os.path.join(self.base_path, self.paths["temperature_path"])
self.fluct_path = os.path.join(self.base_path, self.paths["fluctuation_path"])
self.sample_path = os.path.join(self.base_path, self.paths["sample_path"])
self.device = device
os.makedirs(self.model_path, exist_ok=True)
os.makedirs(self.base_path, exist_ok=True)
os.makedirs(self.sample_path, exist_ok=True)
@staticmethod
def replace_wildcards(d, wildcard_d):
"""
Replace wildcards in dictionary values.
Args:
d (dict): Dictionary with values.
wildcard_d (dict): Dictionary with wildcard replacements.
Returns:
dict: Dictionary with wildcard-replaced values.
"""
for k_header, d_ in d.items():
for k, v in d_.items():
if isinstance(v, str):
for k_, v_ in wildcard_d.items():
v = v.replace(k_, v_)
d[k_header][k] = v
return d
def get_backbone_path(self):
"""
Get the model path.
Returns:
str: Model path.
"""
return self.model_path
def get_dataset_path(self):
"""
Get the dataset path.
Returns:
str: Dataset path.
"""
return self.data_path
def get_temps_path(self):
"""
Get the temperature path.
Returns:
str: Temperature path.
"""
return self.temps_path
def get_sample_path(self):
"""
Get the sample path.
Returns:
str: Sample path.
"""
return self.sample_path
def get_device(self):
"""
Get the device name.
Returns:
str: Device name.
"""
return self.device
def get_pdb(self):
"""
Get the PDB identifier.
Returns:
str: PDB identifier.
"""
return self.pdb
| Python |
2D | lherron2/thermomaps-ising | thermomaps-root/tm/core/backbone.py | .py | 7,574 | 237 | import torch.nn as nn
import torch
from torch.optim.lr_scheduler import MultiStepLR
import os
from tm.core.utils import Interpolater, default
import logging
logger = logging.getLogger(__name__)
logger.setLevel(logging.INFO)
class Backbone(nn.Module):
"""
Diffusion wrapper for instances of deep learning architectures.
Args:
model: The deep learning model to wrap.
data_shape: The shape of the input data.
target_shape: The shape of the target data.
num_dims: Number of dimensions.
lr: Learning rate for optimization.
optim: Optimization method (default is Adam).
scheduler: Learning rate scheduler (default is MultiStepLR).
Attributes:
device (str): The device used for computation (CPU or CUDA).
model: The deep learning model.
interp: Interpolater for data shapes.
expand_batch_to_dims: Tuple for expanding batch dimensions.
state: Internal state of the backbone.
start_epoch: Starting epoch for training.
optim: Optimization method.
scheduler: Learning rate scheduler.
Methods:
get_model_path(directory, epoch): Get the model path for saving.
save_state(directory, epoch): Save internal state of the backbone.
load_state(directory, epoch): Load internal state of the backbone.
load_model(directory, epoch): Load model, optimizer, and starting epoch from state dict.
"""
def __init__(
self,
model,
data_shape,
target_shape,
num_dims=3,
lr=1e-3,
optim=None,
scheduler=None,
interpolate=True,
):
super().__init__()
self.device = "cuda" if torch.cuda.is_available() else "cpu"
self.model = model.to(self.device)
data_shape = tuple(
[data_shape] * (num_dims - 2)
) # Ignore batch and channel dims
target_shape = tuple([target_shape] * (num_dims - 2))
self.interpolate = interpolate
if self.interpolate:
self.interp = Interpolater(data_shape, target_shape)
dim_vec = torch.ones(num_dims)
dim_vec[0] = -1
self.expand_batch_to_dims = tuple(dim_vec)
self.state = None
self.start_epoch = 0
optim_dict = {
"Adam": torch.optim.Adam(
self.model.parameters(),
lr=lr,
weight_decay=False,
betas=(0.9, 0.999),
amsgrad=True,
eps=1e-9,
)
}
self.optim = default(optim_dict["Adam"], optim)
scheduler_dict = {
"multistep": MultiStepLR(self.optim, milestones=[300], gamma=0.1),
}
self.scheduler = default(scheduler_dict["multistep"], scheduler)
@staticmethod
def get_model_path(model_dir, epoch, identifier='model'):
"""Get the model path for saving."""
return os.path.join(model_dir, f"{identifier}_{epoch}.pt")
def save_state(self, model_dir, epoch, identifier='model'):
"""
Save internal state of the backbone model.
Args:
directory: Directory where the state is saved.
epoch: Current training epoch.
Returns:
None
"""
states = {
"model": self.model.state_dict(),
"optim": self.optim.state_dict(),
"epoch": epoch,
}
os.makedirs(model_dir, exist_ok=True)
save_path = self.get_model_path(model_dir, epoch, identifier=identifier)
torch.save(states, save_path)
def load_state(self, model_dir, epoch, identifier='model', device=0):
"""
Load internal state of the backbone model.
Args:
directory: Directory where the state is saved.
epoch: Current training epoch.
Returns:
state_dict: Loaded state dictionary.
"""
state_dict = torch.load(
self.get_model_path(model_dir, epoch, identifier=identifier),
map_location=torch.device(device),
)
return state_dict
def load_model(self, model_dir, epoch, identifier='model', device=0):
"""
Load model, optimizer, and starting epoch from state dict.
Args:
directory: Directory where the state is saved.
epoch: Current training epoch.
Returns:
None
"""
state_dict = self.load_state(model_dir, epoch, identifier=identifier, device=device)
self.model.load_state_dict(state_dict["model"])
self.optim.load_state_dict(state_dict["optim"])
self.start_epoch = int(state_dict["epoch"]) + 1
class ConvBackbone(Backbone):
"""
Backbone with a forward method for Convolutional Networks.
Args:
model: The deep learning model to wrap.
data_shape: The shape of the input data.
target_shape: The shape of the target data.
num_dims: Number of dimensions.
lr: Learning rate for optimization.
optim: Optimization method (default is Adam).
eval_mode: Evaluation mode ('train' or 'sample').
self_condition: Whether to condition on itself during training (True or False).
scheduler: Learning rate scheduler (default is MultiStepLR).
Attributes:
eval_mode (str): Evaluation mode ('train' or 'sample').
self_condition (bool): Whether to condition on itself during training (True or False).
Methods:
get_self_condition(data, t): Get self-conditioning for training or sampling.
forward(batch, t): Forward pass of the ConvBackbone.
"""
def __init__(
self,
model,
data_shape,
target_shape,
num_dims=4,
lr=1e-3,
optim=None,
eval_mode="train",
self_condition=False,
scheduler=None,
interpolate=True
):
super().__init__(
model, data_shape, target_shape, num_dims, lr, optim, scheduler
)
self.eval_mode = eval_mode
self.self_condition = self_condition
def get_self_condition(self, data, t):
"""Get self-conditioning for training or sampling."""
if self.eval_mode == "train" and self.self_condition == True:
if torch.rand(1) < 0.5:
with torch.no_grad():
return self.model(data.to(self.device), t.to(self.device))
else:
return None
elif self.eval_mode == "sample" and self.self_condition == True:
return self.model(data.to(self.device), t.to(self.device))
else:
return None
def forward(self, batch, t):
"""Forward pass of the ConvBackbone."""
if self.interpolate:
upsampled = self.interp.to_target(batch)
else:
upsampled = batch
self_condition = self.get_self_condition(upsampled, t)
upsampled_out = self.model(
upsampled.to(self.device), t.to(self.device), x_self_cond=self_condition
)
if self.interpolate:
batch_out = self.interp.from_target(upsampled_out.to("cpu"))
else:
batch_out = upsampled_out.to("cpu")
return batch_out
class GraphBackbone(Backbone):
"""
Backbone with a forward method for Convolutional Networks.
"""
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
pass
def forward(self, batch, t):
"""Forward pass of the GraphBackbone."""
pass
| Python |
2D | lherron2/thermomaps-ising | thermomaps-root/tm/core/diffusion_model.py | .py | 17,506 | 530 | import torch
import os
import numpy as np
import logging
logger = logging.getLogger(__name__)
logger.setLevel(logging.INFO)
def temperature_density_rescaling(std_temp, ref_temp):
"""
Calculate temperature density rescaling factor.
Args:
std_temp (float): The standard temperature.
ref_temp (float): The reference temperature.
Returns:
float: The temperature density rescaling factor.
"""
return (std_temp / ref_temp).pow(0.5)
def identity(t, *args, **kwargs):
"""
Identity function.
Args:
t: Input tensor.
Returns:
t: Input tensor.
"""
return t
RESCALE_FUNCS = {
"density": temperature_density_rescaling,
"no_rescale": identity,
}
class DiffusionModel:
"""
Base class for diffusion models.
"""
def __init__(
self,
diffusion_process,
backbone,
loader,
prior,
pred_type,
rescale_func_name="no_rescale",
RESCALE_FUNCS=RESCALE_FUNCS,
**kwargs
):
"""
Initialize a DiffusionModel.
Args:
diffusion_process: The diffusion process.
backbone: The backbone model.
loader: Data loader.
pred_type: Type of prediction.
prior: Prior distribution.
control_ref (float): Control reference temperature.
rescale_func_name (str): Name of the rescaling function.
RESCALE_FUNCS (dict): Dictionary of rescaling functions.
"""
self.loader = loader
self.BB = backbone
self.DP = diffusion_process
self.pred_type = pred_type
self.rescale_func = RESCALE_FUNCS[rescale_func_name]
self.prior = prior
def noise_batch(self, b_t, t, prior, **prior_kwargs):
"""
Wrapper which calls applies the (marginal) transition kernel
of the forward noising process.
"""
return self.DP.forward_kernel(b_t, t, prior, **prior_kwargs)
def denoise_batch(self, b_t, t):
"""
Wrapper which calls applies the (marginal) transition kernel
of the reverse noising process.
"""
return self.DP.reverse_kernel(b_t, t, self.BB, self.pred_type)
def denoise_step(self, b_t, t, t_next, eta, **prior_kwargs):
"""
Wrapper which calls applies the (marginal) transition kernel
of the reverse noising process.
"""
b_t_next = self.DP.reverse_step(b_t, t, t_next, self.BB, self.pred_type, eta, self.prior, **prior_kwargs)
return b_t_next
def sample_times(self, num_times):
"""
Randomly sample times from the time-discretization of the
diffusion process.
"""
return torch.randint(
low=0, high=self.DP.num_diffusion_timesteps, size=(num_times,)
).long()
@staticmethod
def get_adjacent_times(times):
"""
Pairs t with t+1 for all times in the time-discretization
of the diffusion process.
"""
times_next = torch.cat((torch.Tensor([0]).long(), times[:-1]))
return list(zip(reversed(times), reversed(times_next)))
class DiffusionTrainer(DiffusionModel):
"""
Subclass of a DiffusionModel: A trainer defines a loss function and
performs backprop + optimizes model outputs.
"""
def __init__(
self,
diffusion_process,
backbone,
train_loader,
prior,
pred_type='noise',
model_dir=None,
test_loader = None,
optim=None,
scheduler=None,
rescale_func_name="density",
RESCALE_FUNCS=RESCALE_FUNCS,
device=0,
identifier="model"
):
"""
Initialize a DiffusionTrainer.
Args:
diffusion_process: The diffusion process.
backbone: The backbone model.
loader: Data loader.
pred_type: Type of prediction.
prior: Prior distribution.
optim: Optimizer.
scheduler: Learning rate scheduler.
rescale_func_name (str): Name of the rescaling function.
RESCALE_FUNCS (dict): Dictionary of rescaling functions.
"""
super().__init__(
diffusion_process,
backbone,
train_loader,
prior,
pred_type,
rescale_func_name,
RESCALE_FUNCS,
)
self.model_dir = model_dir
if self.model_dir:
os.makedirs(self.model_dir, exist_ok=True)
self.identifier = identifier
self.test_loader = test_loader
self.train_loader = train_loader
self.train_losses = []
self.test_losses = []
def loss_function(self, e, e_pred, weight, loss_type="l2"):
"""
Loss function can be the l1-norm, l2-norm, or the VLB (weighted l2-norm).
Args:
e: Actual data.
e_pred: Predicted data.
weight: Weight factor.
loss_type (str): Type of loss function.
Returns:
float: The loss value.
"""
sum_indices = tuple(list(range(1, self.loader.num_dims)))
def l1_loss(e, e_pred, weight):
return (e - e_pred).abs().sum(sum_indices)
def smooth_l1_loss(e, e_pred, weight):
return torch.nn.functional.smooth_l1_loss(e, e_pred, reduction='mean')
def l2_loss(e, e_pred, weight):
return (e - e_pred).pow(2).sum((1, 2, 3)).pow(0.5).mean()
def VLB_loss(e, e_pred, weight):
return (weight * ((e - e_pred).pow(2).sum(sum_indices)).pow(0.5)).mean()
def smooth_l1_loss(e, e_pred, weight):
return torch.nn.functional.smooth_l1_loss(e, e_pred)
loss_dict = {"l1": l1_loss, "l2": l2_loss, "VLB": VLB_loss, "smooth_l1": smooth_l1_loss}
return loss_dict[loss_type](e, e_pred, weight)
def train(
self,
num_epochs,
grad_accumulation_steps=1,
print_freq=None,
batch_size=128,
loss_type="l2",
):
"""
Trains a diffusion model.
Args:
num_epochs (int): Number of training epochs.
grad_accumulation_steps (int): Number of gradient accumulation steps.
print_freq (int): Frequency of printing training progress.
batch_size (int): Batch size.
loss_type (str): Type of loss function.
"""
train_loader = torch.utils.data.DataLoader(
self.train_loader,
batch_size=batch_size,
shuffle=True,
)
if self.test_loader:
test_loader = torch.utils.data.DataLoader(
self.test_loader,
batch_size=batch_size,
shuffle=True,
)
for epoch in range(num_epochs):
epoch_train_loss = []
epoch += self.BB.start_epoch
for i, (temperatures, b) in enumerate(train_loader, 0):
t = self.sample_times(b.size(0))
t_prev = t - 1
t_prev[t_prev == -1] = 0
weight = self.DP.compute_SNR(t_prev) - self.DP.compute_SNR(t)
# logging.debug(f"{b.shape=}")
target, output = self.train_step(b, t, self.prior,
batch_size=len(b), temperatures=temperatures, sample_type="from_data") # prior kwargs
loss = (self.loss_function(target, output, weight, loss_type=loss_type) / grad_accumulation_steps)
if i % grad_accumulation_steps == 0:
self.BB.optim.zero_grad()
epoch_train_loss.append(loss.detach().cpu().numpy())
loss.backward()
torch.nn.utils.clip_grad_norm_(self.BB.model.parameters(), 1.)
self.BB.optim.step()
if print_freq:
if i % print_freq == 0:
print(f"step: {i}, loss {loss.detach():.3f}")
if self.test_loader:
with torch.no_grad():
epoch_test_loss = []
for i, (temperatures, b) in enumerate(test_loader, 0):
t = self.sample_times(b.size(0))
t_prev = t - 1
t_prev[t_prev == -1] = 0
weight = self.DP.compute_SNR(t_prev) - self.DP.compute_SNR(t)
target, output = self.train_step(b, t, self.prior,
batch_size=len(b), temperatures=temperatures, sample_type="from_data")
loss = self.loss_function(target, output, weight, loss_type=loss_type)
epoch_test_loss.append(loss.detach().cpu().numpy())
self.train_losses.append(np.mean(epoch_train_loss))
if self.test_loader:
self.test_losses.append(np.mean(epoch_test_loss))
print(f"epoch: {epoch} | train loss: {self.train_losses[-1]:.3f} | test loss: {self.test_losses[-1]:.3f}")
else:
print(f"epoch: {epoch} | train loss: {self.train_losses[-1]:.3f}")
# if self.BB.scheduler:
# self.BB.scheduler.step()
if self.model_dir:
self.BB.save_state(self.model_dir, epoch, identifier=self.identifier)
def train_step(self, b, t, prior, **kwargs):
"""
Training step.
Args:
b: Input batch.
t: Sampled times.
prior: Prior distribution.
kwargs: Additional keyword arguments.
Returns:
Tuple: (noise, noise_pred)
"""
b_t, noise = self.noise_batch(b, t, prior, **kwargs)
b_0, noise_pred = self.denoise_batch(b_t, t)
if self.pred_type == "noise":
return noise, noise_pred
elif self.pred_type == "x0":
return b, b_0
class DiffusionSampler(DiffusionModel):
"""
Subclass of a DiffusionModel: A sampler generates samples from random noise.
"""
def __init__(
self,
diffusion_process,
backbone,
loader,
prior,
pred_type='noise',
sample_dir=None,
rescale_func_name="density",
RESCALE_FUNCS=RESCALE_FUNCS,
**kwargs
):
"""
Initialize a DiffusionSampler.
Args:
diffusion_process: The diffusion process.
backbone: The backbone model.
loader: Data loader.
pred_type: Type of prediction.
prior: Prior distribution.
rescale_func_name (str): Name of the rescaling function.
RESCALE_FUNCS (dict): Dictionary of rescaling functions.
"""
super().__init__(
diffusion_process,
backbone,
loader,
prior,
pred_type,
rescale_func_name,
RESCALE_FUNCS,
**kwargs
)
self.sample_dir = sample_dir
if self.sample_dir:
os.makedirs(self.sample_dir, exist_ok=True)
def sample_batch(self, **prior_kwargs):
"""
Sample a batch of data.
Args:
**prior_kwargs: Keyword arguments for sampling.
Returns:
Tensor: Sampled batch.
"""
xt = self.prior.sample(**prior_kwargs)
# stds = self.prior.fit_prior(**prior_kwargs)
time_pairs = self.get_adjacent_times(self.DP.times)
for t, t_next in time_pairs:
t = torch.Tensor.repeat(t, prior_kwargs['batch_size'])
t_next = torch.Tensor.repeat(t_next, prior_kwargs['batch_size'])
xt_next = self.denoise_step(xt, t, t_next, control=prior_kwargs['temperature'])
xt = xt_next
return xt
def save_batch(self, batch, save_prefix, temperature, save_idx):
"""
Save a batch of samples.
Args:
batch: Batch of samples.
save_prefix (str): Prefix for saving.
temperature: Temperature for saving.
save_idx (int): Index for saving.
"""
save_path = os.path.join(self.sample_dir, f"{temperature}K")
os.makedirs(save_path, exist_ok=True)
np.savez_compressed(
os.path.join(save_path, f"{save_prefix}_idx={save_idx}.npz"), traj=batch
)
def sample_loop(self, num_samples, batch_size, temperature, gamma=1, eta=1, save_prefix=None):
"""
Sampling loop.
Args:
num_samples (int): Number of samples to generate.
batch_size (int): Batch size.
save_prefix (str): Prefix for saving.
temperature: Temperature for saving.
n_ch: Number of channels.
"""
n_runs = max(num_samples // batch_size, 1)
if num_samples <= batch_size:
batch_size = num_samples
with torch.no_grad():
for save_idx in range(n_runs):
batch = self.sample_batch(eta=eta, gamma=gamma, batch_size=batch_size, temperature=temperature, sample_type="from_fit")
if self.sample_dir and save_prefix:
self.save_batch(batch, save_prefix, temperature, save_idx)
if save_idx == 0:
x = batch
else:
x = torch.cat((x, batch), 0)
return x
class SteeredDiffusionSampler(DiffusionSampler):
"""
A DiffusionModel consists of instances of a DiffusionProcess, Backbone,
and Loader objects.
"""
def __init__(
self,
diffusion_process,
backbone,
loader,
prior,
pred_type,
sample_dir=None,
rescale_func_name="no_rescale",
RESCALE_FUNCS=RESCALE_FUNCS,
**kwargs,
):
"""
Initialize a SteeredDiffusionSampler.
Args:
diffusion_process: The diffusion process.
backbone: The backbone model.
loader: Data loader.
pred_type: Type of prediction.
prior: Prior distribution.
rescale_func_name (str): Name of the rescaling function.
RESCALE_FUNCS (dict): Dictionary of rescaling functions.
kwargs: Additional keyword arguments.
"""
super().__init__(
diffusion_process,
backbone,
loader,
prior,
pred_type,
sample_dir,
rescale_func_name,
RESCALE_FUNCS,
**kwargs,
)
self.kwargs = kwargs
def denoise_step(self, b_t, t, t_next, eta, gamma, control_dict, **prior_kwargs):
"""
Wrapper which calls applies the (marginal) transition kernel
of the reverse noising process.
Wrapper to allow the alphas to be sampled and reshaped.
"""
# b_t_next = self.DP.reverse_step(b_t, t, t_next, self.BB, self.pred_type)
b_t_next = self.DP.reverse_step(b_t, t, t_next, self.BB, self.pred_type, eta, self.prior, **prior_kwargs)
for channel, channel_control in control_dict.items():
logger.debug(f"Setting channel {channel} to {channel_control}")
b_t_next[:, channel] = (1 - gamma) * b_t_next[:, channel] + gamma * channel_control
return b_t_next
@staticmethod
def build_channel_dict(batch_size, prior, temperature):
"""
Build a dictionary of the conditional values for each channel.
Args:
batch_size: The size of the batch.
prior: The prior object.
temperature: The temperature, can be a scalar or a vector.
Returns:
Dict: Dictionary of the conditional values for each channel.
"""
fluct_channels = prior.channels_info["fluctuation"]
num_fluct_channels = len(fluct_channels)
channel_slice = [batch_size] + [1] + list(prior.shape[1:]) # each channel is treated individually
channel_dict = {}
temperatures = torch.full((num_fluct_channels,), temperature)
for channel, temp in zip(fluct_channels, temperatures):
channel_dict[channel] = temp
# logging.debug(f"{channel_dict=}")
return channel_dict
def sample_batch(self, eta=1, gamma=0, batch_size=1000, temperature=1, **kwargs):
"""
Sample a batch of data.
Args:
**prior_kwargs: Keyword arguments for sampling.
Returns:
Tensor: Sampled batch.
"""
coord_channels = self.prior.channels_info["coordinate"]
num_coord_channels = len(coord_channels)
prior_formatted_temps = torch.Tensor([[temperature]*num_coord_channels]*batch_size)
logger.debug(f"{prior_formatted_temps}")
xt = self.prior.sample(batch_size=batch_size, temperatures=prior_formatted_temps)
# stds = self.prior.fit_prior(**prior_kwargs)
channel_control_dict = self.build_channel_dict(batch_size, self.prior, temperature)
time_pairs = self.get_adjacent_times(self.DP.times)
for t, t_next in time_pairs:
t = torch.Tensor.repeat(t, batch_size)
t_next = torch.Tensor.repeat(t_next, batch_size)
xt_next = self.denoise_step(xt, t, t_next, eta=eta, gamma=gamma, control_dict=channel_control_dict,
batch_size=batch_size, temperatures=prior_formatted_temps)
xt = xt_next
return xt
| Python |
2D | lherron2/thermomaps-ising | thermomaps-root/tm/core/diffusion_process.py | .py | 8,409 | 267 | import torch
from torch import vmap
import logging
logger = logging.getLogger(__name__)
logger.setLevel(logging.INFO)
def polynomial_noise(t, alpha_max, alpha_min, s=1e-5, **kwargs):
"""
Generate polynomial noise schedule used in Hoogeboom et. al.
Args:
t (torch.Tensor): Time steps.
alpha_max (float): Maximum alpha value.
alpha_min (float): Minimum alpha value.
s (float): Smoothing factor.
Returns:
torch.Tensor: Alpha schedule.
"""
T = t[-1]
alphas = (1 - 2 * s) * (1 - (t / T) ** 2) + s
a = alphas[1:] / alphas[:-1]
a[a**2 < 0.001] = 0.001
alpha_schedule = torch.cumprod(a, 0)
return alpha_schedule
def get_beta_schedule(beta_start, beta_end, num_diffusion_timesteps):
betas = np.linspace(beta_start, beta_end, num_diffusion_timesteps, dtype=np.float64)
return betas
def compute_alpha(beta, t):
beta = torch.cat([torch.zeros(1).to(beta.device), beta], dim=0)
a = (1 - beta).cumprod(dim=0).index_select(0, t).view(-1, 1, 1, 1)
return a
def linear_beta(t, beta_start, beta_end, **kwargs):
def compute_alpha(beta, t):
beta = torch.cat([torch.zeros(1).to(beta.device), beta], dim=0)
a = (1 - beta).cumprod(dim=0).index_select(0, t).view(-1, 1, 1, 1)
return a
betas = np.linspace(beta_start, beta_end, len(num_diffusion_timesteps), dtype=np.float64)
alphas = torch.Tensor([compute_alpha(betas, torch.Tensor([t]).long()) for beta, t in zip(betas, range(num_timesteps-1))])
return alphas.squeeze()
NOISE_FUNCS = {
"polynomial": polynomial_noise,
'linear_beta': linear_beta
}
class DiffusionProcess:
"""
Instantiates the noise parameterization, rescaling of noise distribution,
and timesteps for a diffusion process.
"""
def __init__(
self,
num_diffusion_timesteps,
noise_schedule,
alpha_max,
alpha_min,
beta_start,
beta_end,
NOISE_FUNCS,
):
"""
Initialize a DiffusionProcess.
Args:
num_diffusion_timesteps (int): Number of diffusion timesteps.
noise_schedule (str): Noise schedule type.
alpha_max (float): Maximum alpha value.
alpha_min (float): Minimum alpha value.
NOISE_FUNCS (dict): Dictionary of noise functions.
"""
self.num_diffusion_timesteps = num_diffusion_timesteps
self.times = torch.arange(num_diffusion_timesteps)
self.alphas = NOISE_FUNCS[noise_schedule](
t=torch.arange(num_diffusion_timesteps + 1), alpha_max=alpha_max, alpha_min=alpha_min,
beta_start=beta_start, beta_end=beta_end
)
class VPDiffusion(DiffusionProcess):
"""
Subclass of a DiffusionProcess: Performs a diffusion according to the VP-SDE.
"""
def __init__(
self,
num_diffusion_timesteps,
noise_schedule="polynomial",
alpha_max=20.0,
alpha_min=0.01,
beta_start=0.001,
beta_end=0.02,
NOISE_FUNCS=NOISE_FUNCS,
):
"""
Initialize a VPDiffusion process.
Args:
num_diffusion_timesteps (int): Number of diffusion timesteps.
noise_schedule (str): Noise schedule type.
alpha_max (float): Maximum alpha value.
alpha_min (float): Minimum alpha value.
NOISE_FUNCS (dict): Dictionary of noise functions.
"""
super().__init__(
num_diffusion_timesteps, noise_schedule, alpha_max, alpha_min, beta_start, beta_end, NOISE_FUNCS
)
self.bmul = vmap(torch.mul)
def get_alphas(self):
"""
Get alpha values.
Returns:
torch.Tensor: Alpha values.
"""
return self.alphas
def forward_kernel(self, x0, t, prior, **prior_kwargs):
"""
Marginal transition kernels of the forward process. q(x_t|x_0).
Args:
x0 (torch.Tensor): Initial data.
t (int): Time step.
prior: Prior distribution.
**prior_kwargs: Additional keyword arguments.
Returns:
tuple: Tuple containing x_t and noise.
"""
alphas_t = self.alphas[t]
noise = prior.sample(**prior_kwargs)
logger.debug(f"{noise.shape=}")
logger.debug(f"{x0.shape=}")
x_t = self.bmul(x0, alphas_t.sqrt()) + self.bmul(noise, (1 - alphas_t).sqrt())
return x_t, noise
def reverse_kernel(self, x_t, t, backbone, pred_type):
"""
Marginal transition kernels of the reverse process. p(x_0|x_t).
Args:
x_t (torch.Tensor): Data at time t.
t (int): Time step.
backbone: Backbone model.
pred_type (str): Type of prediction.
Returns:
tuple: Tuple containing x0_t and noise.
"""
alphas_t = self.alphas[t]
if pred_type == "noise":
noise = backbone(x_t, alphas_t)
noise_interp = self.bmul(noise, (1 - alphas_t).sqrt())
x0_t = self.bmul((x_t - noise_interp), 1 / alphas_t.sqrt())
elif pred_type == "x0":
x0_t = backbone(x_t, alphas_t)
x0_interp = self.bmul(x0_t, alphas_t.sqrt())
noise = self.bmul((x_t - x0_interp), 1 / (1 - alphas_t).sqrt())
else:
raise Exception("Please provide a valid prediction type: 'noise' or 'x0'")
return x0_t, noise
def reverse_step(self, x_t, t, t_next, backbone, pred_type, eta, prior, **prior_kwargs):
"""
Stepwise transition kernel of the reverse process p(x_t-1|x_t).
Args:
x_t (torch.Tensor): Data at time t.
t (int): Time step t.
t_next (int): Time step t_next.
backbone: Backbone model.
pred_type (str): Type of prediction.
Returns:
torch.Tensor: Data at time t_next.
"""
alphas_t_next = self.alphas[t_next]
alphas_t = self.alphas[t]
x0_t, noise = self.reverse_kernel(x_t, t, backbone, pred_type)
c1 = eta * ((1 - alphas_t / alphas_t_next) * (1 - alphas_t_next) / (1 - alphas_t)).sqrt()
c2 = ((1 - alphas_t_next) - c1**2).sqrt()
xt_next = self.bmul(alphas_t_next.sqrt(), x0_t) + self.bmul(c2, noise) + self.bmul(c1, prior.sample(**prior_kwargs))
return xt_next
def compute_SNR(self, t):
"""
Compute Signal-to-Noise Ratio (SNR) at a given time step.
Args:
t (int): Time step.
Returns:
torch.Tensor: SNR value.
"""
alpha_sq = self.alphas[t.long()].pow(2)
sigma_sq = 1 - alpha_sq
gamma_t = -(torch.log(alpha_sq) - torch.log(sigma_sq))
return torch.exp(-gamma_t)
class SteeredVPDiffusion(VPDiffusion):
"""
Subclass of VPDiffusion: VPDiffusion with steering control.
"""
def __init__(
self,
num_diffusion_timesteps,
noise_schedule="polynomial",
alpha_max=20.0,
alpha_min=0.01,
NOISE_FUNCS=NOISE_FUNCS,
):
"""
Initialize a SteeredVPDiffusion process.
Args:
num_diffusion_timesteps (int): Number of diffusion timesteps.
noise_schedule (str): Noise schedule type.
alpha_max (float): Maximum alpha value.
alpha_min (float): Minimum alpha value.
NOISE_FUNCS (dict): Dictionary of noise functions.
"""
super().__init__(
num_diffusion_timesteps, noise_schedule, alpha_max, alpha_min, NOISE_FUNCS
)
def reverse_step(self, x_t, t, t_next, backbone, pred_type):
"""
Stepwise transition kernel of the reverse process p(x_t-1|x_t) with steering control.
Args:
x_t (torch.Tensor): Data at time t.
t (int): Time step t.
t_next (int): Time step t_next.
backbone: Backbone model.
pred_type (str): Type of prediction.
Returns:
torch.Tensor: Data at time t_next.
"""
alphas_t_next = self.alphas[t_next]
x0_t, noise = self.reverse_kernel(x_t, t, backbone, pred_type)
xt_next = self.bmul(alphas_t_next.sqrt(), x0_t) + self.bmul(
(1 - alphas_t_next).sqrt(), noise
)
return xt_next
| Python |
2D | lherron2/thermomaps-ising | thermomaps-root/tm/core/prior.py | .py | 3,435 | 69 | import torch
import numpy as np
from typing import Any, Callable, Dict, List
import sys
import logging
logger = logging.getLogger(__name__)
logger.setLevel(logging.INFO)
logger.addHandler(logging.StreamHandler(sys.stdout))
class UnitNormalPrior:
def __init__(self, shape, channels_info):
self.channels_info = channels_info # Dictionary to define channel types
self.num_fluct_ch = len(self.channels_info['fluctuation'])
self.num_coord_ch = len(self.channels_info['coordinate'])
"""Initialize the Unit Normal Prior with the shape of the samples."""
self.shape = list(shape)[1:]
logger.debug(f"Initialized a Prior with shape {self.shape}.")
logger.debug(f"The first dimension of the supplied {shape=} must be the batch size.")
def sample(self, batch_size, *args, **kwargs):
"""Sample from a unit normal distribution."""
shape = [batch_size] + self.shape
# print(f"Sampling from a UnitNormalPrior with shape {shape}")
return torch.normal(mean=0, std=1, size=shape)
class GlobalEquilibriumHarmonicPrior(UnitNormalPrior):
def __init__(self, shape, channels_info):
"""Initialize GEHP with shape and channels information."""
super().__init__(shape, channels_info)
# self.channels_info = channels_info # Dictionary to define channel types
# self.num_fluct_ch = len(self.channels_info['fluctuation'])
# self.num_coord_ch = len(self.channels_info['coordinate'])
def sample(self, batch_size, temperatures, *args, **kwargs):
"""Sample from a distribution where variance is defined by temperatures."""
logger.debug(f"{temperatures=}")
temperatures = torch.Tensor(np.array(temperatures))
full_shape = [batch_size] + self.shape
coord_shape = [batch_size] + [self.num_coord_ch] + self.shape[1:]
fluct_shape = [batch_size] + [self.num_fluct_ch] + self.shape[1:]
logger.debug(f"{full_shape=}")
logger.debug(f"{coord_shape=}")
logger.debug(f"{fluct_shape=}")
logger.debug(f"{temperatures.shape=}")
samples = torch.empty(full_shape)
#assert (temperatures.shape[1] == self.num_coord_ch and
# (temperatures.shape[0] == 1 or temperatures.shape[0] == batch_size)), \
#f"{temperatures.shape=}. Expected (1,{self.num_coord_ch}) or ({batch_size}, {self.num_coord_ch})"
temps_for_each_channel_bool = temperatures.shape[1] == self.num_coord_ch
single_temp_provided_bool = temperatures.shape[0] == 1
temps_for_each_sample_in_batch_bool = temperatures.shape[0] == batch_size
if not temps_for_each_channel_bool and temps_for_each_sample_in_batch_bool:
temperatures = temperatures.unsqueeze(-1).unsqueeze(-1).expand(*coord_shape)
coord_variances = temperatures # expand along batch and coordinate dims
else:
coord_variances = temperatures.unsqueeze(-1).unsqueeze(-1).expand(*coord_shape) # expand along batch and coordinate dims
fluct_variances = torch.full((fluct_shape), 1)
variances = torch.cat((coord_variances, fluct_variances), dim=1)
for sample_idx, ch_variances in enumerate(variances):
logging.debug(f"{ch_variances.shape}")
samples[sample_idx] = torch.normal(mean=0., std=np.sqrt(ch_variances))
logger.debug(f"{samples.shape}")
return samples
| Python |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.