diff --git a/CHANGELOG.md b/CHANGELOG.md index 13fb96a..511e431 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,5 +1,10 @@ # Changelog +# 1.6.1 + +- Small fixes to the noise interfaces and resistance functions. +- Documentation updates: added a tutorial on custom dipole interactions + interface fixes and typing. + # 1.6.0 - Extended the `Stack` models allowing for non-symmetric coupling between devices. diff --git a/cmtj/models/general_sb.py b/cmtj/models/general_sb.py index 50978d4..03b68a0 100644 --- a/cmtj/models/general_sb.py +++ b/cmtj/models/general_sb.py @@ -861,8 +861,32 @@ def _compute_numerical_inverse(self, A_matrix): A_inv_np = np.linalg.inv(A_np) return sym.Matrix(A_inv_np) - @lru_cache(maxsize=1000) # noqa: B019 def _compute_A_and_V_matrices(self, n, Vdc_ex_variable, H, frequency): + A_matrix = sym.zeros(2 * n, 2 * n) + V_matrix = sym.zeros(2 * n, 1) + U = self.create_energy(H=H, volumetric=False) + omega = sym.Symbol(r"\omega") if frequency is None else 2 * sym.pi * frequency + for i, layer in enumerate(self.layers): + rhs = layer.rhs_spherical_llg(U / layer.thickness, osc=True) + alpha_factor = 1 + layer.alpha**2 + V_matrix[2 * i] = sym.diff(rhs[0] * alpha_factor, Vdc_ex_variable) + V_matrix[2 * i + 1] = sym.diff(rhs[1] * alpha_factor, Vdc_ex_variable) + theta, phi = layer.get_coord_sym() + fn_theta = (omega * sym.I * theta - rhs[0]) * alpha_factor + fn_phi = (omega * sym.I * phi - rhs[1]) * alpha_factor + # the functions are only valid for that row i (theta) and i + 1 (phi) + # so we only need to compute the derivatives for the other layers + # for the other layers, the derivatives are zero + for j, layer_j in enumerate(self.layers): + theta_, phi_ = layer_j.get_coord_sym() + A_matrix[2 * i, 2 * j] = sym.diff(fn_theta, theta_) + A_matrix[2 * i, 2 * j + 1] = sym.diff(fn_theta, phi_) + A_matrix[2 * i + 1, 2 * j] = sym.diff(fn_phi, theta_) + A_matrix[2 * i + 1, 2 * j + 1] = sym.diff(fn_phi, phi_) + return A_matrix, V_matrix + + @lru_cache(maxsize=1000) # noqa: B019 + def _compute_A_and_V_matrices_old(self, n, Vdc_ex_variable, H, frequency): A_matrix = sym.zeros(2 * n, 2 * n) V_matrix = sym.zeros(2 * n, 1) U = self.create_energy(H=H, volumetric=False) diff --git a/cmtj/reservoir/__init__.pyi b/cmtj/reservoir/__init__.pyi index 5f75dd0..ddf382e 100644 --- a/cmtj/reservoir/__init__.pyi +++ b/cmtj/reservoir/__init__.pyi @@ -159,5 +159,14 @@ def computeDipoleInteractionNoumra( ... def nullDipoleInteraction(r1: cmtj.CVector, r2: cmtj.CVector, layer1: cmtj.Layer, layer2: cmtj.Layer) -> cmtj.CVector: - """Compute null dipole interaction between two junctions.""" + """Compute null dipole interaction between two junctions. + This is a placeholder function that returns a zero vector. + + :param r1: Position vector of the first junction + :param r2: Position vector of the second junction + :param layer1: Magnetic layer of the first junction + :param layer2: Magnetic layer of the second junction + + :return: Zero vector + """ ... diff --git a/cmtj/utils/parallel.py b/cmtj/utils/parallel.py index ffeeeae..ef55dfc 100644 --- a/cmtj/utils/parallel.py +++ b/cmtj/utils/parallel.py @@ -5,7 +5,9 @@ from multiprocess import Pool from tqdm import tqdm -__all__ = ["distribute"] +from ..models.general_sb import LayerDynamic + +__all__ = ["distribute", "parallel_vsd_sb_model"] def distribute( @@ -47,3 +49,37 @@ def func_wrapper(iterable): iterable, output = result indx = indexes[iterables.index(iterable)] yield indx, output + + +def parallel_vsd_sb_model( + simulation_fn: Callable, + frequencies: list[float], + Hvecs: list[list[float]], + layers: list[LayerDynamic], + J1: list[float] = None, + J2: list[float] = None, + iDMI: list[float] = None, + n_cores: int = None, +): + """ + Parallelise the VSD SB model. + :param simulation_fn: function to be distributed. + This function must take a tuple of arguments, where the first argument is the + frequency, then Hvectors, the list of layers and finally the list of J1 and J2 values. + :param frequencies: list of frequencies + :param Hvecs: list of Hvectors in cartesian coordinates + :param layers: list of layers + :param J1: list of J1 values + :param J2: list of J2 values + :param n_cores: number of cores to use. + :returns: list of simulation_fn outputs for each frequency + """ + if J1 is None: + J1 = [0] * (len(layers) - 1) + if J2 is None: + J2 = [0] * (len(layers) - 1) + if iDMI is None: + iDMI = [0] * (len(layers) - 1) + args = [(f, Hvecs, *layers, J1, J2, iDMI) for f in frequencies] + with Pool(processes=n_cores) as pool: + return list(tqdm(pool.imap(simulation_fn, args), total=len(frequencies))) diff --git a/cmtj/utils/resistance.py b/cmtj/utils/resistance.py index 94c3fff..1c16f4b 100644 --- a/cmtj/utils/resistance.py +++ b/cmtj/utils/resistance.py @@ -1,4 +1,5 @@ -from typing import Union +from functools import lru_cache +from typing import Callable, Union import numpy as np import sympy as sym @@ -8,10 +9,9 @@ EPS = np.finfo("float64").resolution -def compute_sd( - dynamic_r: np.ndarray, dynamic_i: np.ndarray, integration_step: float -) -> np.ndarray: +def compute_sd(dynamic_r: np.ndarray, dynamic_i: np.ndarray, integration_step: float) -> np.ndarray: """Computes the SD voltage. + :param dynamic_r: magnetoresistance from log :param dynamic_i: excitation current :param integration_step: integration paramemter from run_simulation @@ -31,11 +31,21 @@ def compute_resistance( m: Union[list[float], np.ndarray], l: list[float], w: list[float], -): +) -> tuple[list[float], list[float]]: """Computes the resistance of the system. + If you want to compute the resistance for an entire time series, pass m as a 3D array with shape [number_of_layers, 3, T], where T is the time component. [number_of_layers, 3, T] where T is the time component. + + :param Rx0: resistance offset in longitudinal direction + :param Ry0: resistance offset in transverse direction + :param AMR: anisotropic magnetoresistance + :param AHE: anomalous Hall effect + :param SMR: spin Hall magnetoresistance + :param m: magnetisation of the layers. Shape [number_of_layers, 3, T] + :param l: length of the layers + :param w: width of the layers """ number_of_layers = len(Rx0) if not isinstance(m, np.ndarray): @@ -51,15 +61,11 @@ def compute_resistance( for i in range(number_of_layers): w_l = w[i] / l[i] SxAll[i] = Rx0[i] + (AMR[i] * m[i, 0] ** 2 + SMR[i] * m[i, 1] ** 2) - SyAll[i] = ( - Ry0[i] - + 0.5 * AHE[i] * m[i, 2] - + (w_l) * (SMR[i] - AMR[i]) * m[i, 0] * m[i, 1] - ) + SyAll[i] = Ry0[i] + 0.5 * AHE[i] * m[i, 2] + (w_l) * (SMR[i] - AMR[i]) * m[i, 0] * m[i, 1] return SxAll, SyAll -def compute_gmr(Rp: float, Rap: float, m1: np.ndarray, m2: np.ndarray): +def compute_gmr(Rp: float, Rap: float, m1: np.ndarray, m2: np.ndarray) -> np.ndarray: """Computes the GMR using parallel and antiparallel resistance. :param Rp: parallel resistance :param Rap: antiparallel resistance @@ -68,7 +74,7 @@ def compute_gmr(Rp: float, Rap: float, m1: np.ndarray, m2: np.ndarray): return Rp + 0.5 * (Rap - Rp) * (1 - np.sum(m1 * m2, axis=0)) -def calculate_magnetoresistance(Rp: float, Rap: float, m: np.ndarray): +def calculate_magnetoresistance(Rp: float, Rap: float, m: np.ndarray) -> np.ndarray: """Computes the magnetoresistance using parallel and antiparallel resistance. :param Rp: parallel resistance :param Rap: antiparallel resistance @@ -77,10 +83,7 @@ def calculate_magnetoresistance(Rp: float, Rap: float, m: np.ndarray): if not isinstance(m, np.ndarray): m = np.asarray(m) if m.shape[0] != 2: - raise ValueError( - "The magnetoresistance can only be computed for 2 layers" - f". Current shape {m.shape}" - ) + raise ValueError("The magnetoresistance can only be computed for 2 layers" f". Current shape {m.shape}") return Rp + 0.5 * (Rap - Rp) * np.sum(m[0] * m[1], axis=0) @@ -93,7 +96,7 @@ def calculate_resistance_parallel( m: list[float], l: list[float], w: list[float], -): +) -> tuple[np.ndarray, np.ndarray]: """Calculates the resistance of the system in parallel. If you want to compute the resistance for an entire time series, pass m as a 3D array. [number_of_layers, 3, T] where T is the time component. @@ -124,7 +127,7 @@ def calculate_resistance_series( m: list[float], l: list[float], w: list[float], -): +) -> tuple[np.ndarray, np.ndarray]: """Calculates the resistance of the system in series. If you want to compute the resistance for an entire time series, pass m as a 3D array. [number_of_layers, 3, T] where T is the time component. @@ -153,7 +156,7 @@ def angular_calculate_resistance_gmr( phi_1: np.ndarray, theta_2: np.ndarray, phi_2: np.ndarray, -): +) -> np.ndarray: """Computes the GMR using parallel and antiparallel resistance. :param Rp: parallel resistance :param Rap: antiparallel resistance @@ -179,23 +182,163 @@ def angular_calculate_resistance_gmr( return compute_gmr(Rp, Rap, m1, m2) +@lru_cache(maxsize=5) +def Rxx_symbolic(id: int, AMR: float, SMR: float) -> tuple[float, sym.Symbol, sym.Symbol, sym.Matrix]: + """Compute the Rxx resistance for a given layer. + :param id: layer id + :param AMR: anisotropic magnetoresistance + :param SMR: spin Hall magnetoresistance + """ + theta1 = sym.Symbol(r"\theta_" + str(id)) + phi1 = sym.Symbol(r"\phi_" + str(id)) + m = sym.Matrix( + [ + sym.sin(theta1) * sym.cos(phi1), + sym.sin(theta1) * sym.sin(phi1), + sym.cos(theta1), + ] + ) + return AMR * m[0] ** 2 + SMR * m[1] ** 2, theta1, phi1, m + + +@lru_cache(maxsize=5) +def Rxy_symbolic( + id: int, AMR: float, SMR: float, AHE: float, w_l: float +) -> tuple[float, sym.Symbol, sym.Symbol, sym.Matrix]: + """Compute the Rxy resistance for a given layer. + :param id: layer id + :param AMR: anisotropic magnetoresistance + :param SMR: spin Hall magnetoresistance + :param AHE: anomalous Hall effect + :param w_l: width to length ratio + """ + theta1 = sym.Symbol(r"\theta_" + str(id)) + phi1 = sym.Symbol(r"\phi_" + str(id)) + m = sym.Matrix( + [ + sym.sin(theta1) * sym.cos(phi1), + sym.sin(theta1) * sym.sin(phi1), + sym.cos(theta1), + ] + ) + return (0.5 * AHE * m[-1]) + w_l * (SMR - AMR) * m[0] * m[1], theta1, phi1, m + + def calculate_linearised_resistance( GMR: float, AMR: list[float], SMR: list[float], -): +) -> tuple[float, float, float, sym.Symbol, sym.Symbol, sym.Symbol, sym.Symbol]: """ Compute the resistance of the two FM bilayer system from the linearised angles. + :param GMR: GMR :param AMR: AMR :param SMR: SMR - :param stationary_angles: stationary angles [t1, p1, t2, p2] - :param linearised_angles: linearised angles [dt1, dp1, dt2, dp2] """ + + Rxx1, theta1, phi1, m1 = Rxx_symbolic(1, AMR[0], SMR[0]) + Rxx2, theta2, phi2, m2 = Rxx_symbolic(2, AMR[1], SMR[1]) + GMR_resistance = GMR * (1 - (m1.dot(m2))) / 2.0 + return Rxx1, Rxx2, GMR_resistance, theta1, phi1, theta2, phi2 + + +def Rxx_parallel_bilayer_expr() -> ( + tuple[ + Callable[ + [ + float, + float, + float, + float, + float, + float, + float, + float, + float, + float, + float, + float, + float, + float, + ], + float, + ], + Callable[ + [ + float, + float, + float, + float, + float, + float, + float, + float, + float, + float, + float, + float, + float, + float, + ], + float, + ], + ] +): + """Get the symbolic expressions for the parallel and linearised resistance of a bilayer system. + + Signals: + - GMR: GMR + - AMR1: AMR of layer 1 + - SMR1: SMR of layer 1 + - AMR2: AMR of layer 2 + - SMR2: SMR of layer 2 + - stationary angles: [t1, p1, t2, p2] + - linearised angles: [dt1, dp1, dt2, dp2] + + Function signatures + - Rlin_func: linearised resistance function + f(GMR, AMR1, SMR1, AMR2, SMR2, [t1, p1, t2, p2], [dt1, dp1, dt2, dp2]) + - R_func: series resistance function + f(GMR, AMR1, SMR1, AMR2, SMR2, [t1, p1, t2, p2]) + + :returns: linearised and parallel resistance functions + """ + AMR_1 = sym.Symbol(r"\mathrm{AMR}_1") + SMR_1 = sym.Symbol(r"\mathrm{SMR}_1") + AMR_2 = sym.Symbol(r"\mathrm{AMR}_2") + SMR_2 = sym.Symbol(r"\mathrm{SMR}_2") + GMR_s = sym.Symbol(r"\mathrm{GMR}") + R_1, t1, p1, m1 = Rxx_symbolic(1, AMR_1, SMR_1) + R_2, t2, p2, m2 = Rxx_symbolic(2, AMR_2, SMR_2) + gmr_term = GMR_s * (1 - m1.dot(m2)) / 2 + + Rparallel = gmr_term + (R_1 * R_2) / (R_1 + R_2 + EPS) + linearised_terms = sym.symbols(r"\partial\theta_1, \partial\phi_1, \partial\theta_2, \partial\phi_2") + dRdtheta1 = sym.diff(Rparallel, t1) * linearised_terms[0] + dRdphi1 = sym.diff(Rparallel, p1) * linearised_terms[1] + dRdtheta2 = sym.diff(Rparallel, t2) * linearised_terms[2] + dRdphi2 = sym.diff(Rparallel, p2) * linearised_terms[3] + + linearised_R = dRdtheta1 + dRdtheta2 + dRdphi1 + dRdphi2 + + Rlin_func = sym.lambdify( + [GMR_s, AMR_1, SMR_1, AMR_2, SMR_2, [t1, p1, t2, p2], linearised_terms], + linearised_R, + ) + R_func = sym.lambdify([GMR_s, AMR_1, SMR_1, AMR_2, SMR_2, [t1, p1, t2, p2]], Rparallel) + + return Rlin_func, R_func + + +def GMR_expr() -> Callable[[float, float, float, float], float]: + """Get the symbolic expression for the GMR. + + :returns: GMR function: Callable[[theta1, phi1, theta2, phi2], float] + """ + GMR_s = sym.Symbol(r"\mathrm{GMR}") theta1 = sym.Symbol(r"\theta_1") phi1 = sym.Symbol(r"\phi_1") - theta2 = sym.Symbol(r"\theta_2") - phi2 = sym.Symbol(r"\phi_2") m1 = sym.Matrix( [ sym.sin(theta1) * sym.cos(phi1), @@ -203,18 +346,119 @@ def calculate_linearised_resistance( sym.cos(theta1), ] ) + theta2 = sym.Symbol(r"\theta_2") + phi2 = sym.Symbol(r"\phi_2") m2 = sym.Matrix( [ sym.sin(theta2) * sym.cos(phi2), - -sym.sin(theta2) * sym.sin(phi2), + sym.sin(theta2) * sym.sin(phi2), sym.cos(theta2), ] ) - GMR_resistance = GMR * (1 - (m1.dot(m2))) / 2.0 + Rf = GMR_s * (1 - m1.dot(m2)) / 2 + dRdt1 = sym.diff(Rf, theta1) + dRdp1 = sym.diff(Rf, phi1) + dRdt2 = sym.diff(Rf, theta2) + dRdp2 = sym.diff(Rf, phi2) + linearised_terms = sym.symbols(r"\partial\theta_1, \partial\phi_1, \partial\theta_2, \partial\phi_2") + dRf = ( + dRdt1 * linearised_terms[0] + + dRdp1 * linearised_terms[1] + + dRdt2 * linearised_terms[2] + + dRdp2 * linearised_terms[3] + ) - Rxx1 = AMR[0] * m1[0] ** 2 + SMR[0] * m1[1] ** 2 - Rxx2 = AMR[1] * m2[0] ** 2 + SMR[1] * m2[1] ** 2 - return Rxx1, Rxx2, GMR_resistance, theta1, phi1, theta2, phi2 + Rf_func = sym.lambdify([GMR_s, [theta1, phi1, theta2, phi2]], Rf) + dRf_func = sym.lambdify([GMR_s, [theta1, phi1, theta2, phi2], linearised_terms], dRf) + return Rf_func, dRf_func + + +def Rxx_series_bilayer_expr() -> ( + tuple[ + Callable[ + [ + float, + float, + float, + float, + float, + float, + float, + float, + float, + float, + float, + float, + float, + float, + ], + float, + ], + Callable[ + [ + float, + float, + float, + float, + float, + float, + float, + float, + float, + float, + float, + float, + float, + float, + ], + float, + ], + ] +): + """Get the symbolic expressions for the series and linearised resistance of a bilayer system. + + Signals: + - GMR: GMR + - AMR1: AMR of layer 1 + - SMR1: SMR of layer 1 + - AMR2: AMR of layer 2 + - SMR2: SMR of layer 2 + - stationary angles: [t1, p1, t2, p2] + - linearised angles: [dt1, dp1, dt2, dp2] + + Function signatures + - Rlin_func: linearised resistance function + f(GMR, AMR1, SMR1, AMR2, SMR2, [t1, p1, t2, p2], [dt1, dp1, dt2, dp2]) + - R_func: series resistance function + f(GMR, AMR1, SMR1, AMR2, SMR2, [t1, p1, t2, p2]) + + :returns: linearised and series resistance functions + """ + AMR_1 = sym.Symbol(r"\mathrm{AMR}_1") + SMR_1 = sym.Symbol(r"\mathrm{SMR}_1") + AMR_2 = sym.Symbol(r"\mathrm{AMR}_2") + SMR_2 = sym.Symbol(r"\mathrm{SMR}_2") + GMR_s = sym.Symbol(r"\mathrm{GMR}") + R_1, t1, p1, m1 = Rxx_symbolic(1, AMR_1, SMR_1) + R_2, t2, p2, m2 = Rxx_symbolic(2, AMR_2, SMR_2) + gmr_term = GMR_s * (1 - m1.dot(m2)) / 2 + + Rseries = gmr_term + R_1 + R_2 + linearised_terms = sym.symbols(r"\partial\theta_1, \partial\phi_1, \partial\theta_2, \partial\phi_2") + dRdtheta1 = sym.diff(Rseries, t1) * linearised_terms[0] + dRdphi1 = sym.diff(Rseries, p1) * linearised_terms[1] + dRdtheta2 = sym.diff(Rseries, t2) * linearised_terms[2] + dRdphi2 = sym.diff(Rseries, p2) * linearised_terms[3] + + linearised_R = dRdtheta1 + dRdtheta2 + dRdphi1 + dRdphi2 + + Rlin_func = sym.lambdify( + [GMR_s, AMR_1, SMR_1, AMR_2, SMR_2, [t1, p1, t2, p2], linearised_terms], + linearised_R, + ) + R_func = sym.lambdify([GMR_s, AMR_1, SMR_1, AMR_2, SMR_2, [t1, p1, t2, p2]], Rseries) + + return Rlin_func, R_func def calculate_linearised_resistance_parallel( @@ -226,6 +470,7 @@ def calculate_linearised_resistance_parallel( ): """ Compute the parallel resistance of the two FM bilayer system from the linearised angles. + :param GMR: GMR :param AMR: AMR :param SMR: SMR @@ -236,19 +481,20 @@ def calculate_linearised_resistance_parallel( t02, p02 = stationary_angles[2:] dt1, dp1 = linearised_angles[:2] dt2, dp2 = linearised_angles[2:] - Rxx1, Rxx2, GMR_resistance, theta1, phi1, theta2, phi2 = ( - calculate_linearised_resistance(GMR, AMR, SMR) - ) + Rxx1, Rxx2, GMR_resistance, theta1, phi1, theta2, phi2 = calculate_linearised_resistance(GMR, AMR, SMR) Rparallel = GMR_resistance if any(AMR) or any(SMR): Rparallel += (Rxx1 * Rxx2) / (Rxx1 + Rxx2 + EPS) + elif GMR == 0: + return 0, 0 dRparallel = ( sym.diff(Rparallel, theta1) * dt1 + sym.diff(Rparallel, phi1) * dp1 + sym.diff(Rparallel, theta2) * dt2 + sym.diff(Rparallel, phi2) * dp2 ) - + if isinstance(dRparallel, (list, np.ndarray)): + dRparallel = dRparallel[0] dRparallel = dRparallel.subs( { theta1: t01, @@ -274,7 +520,7 @@ def calculate_linearised_resistance_series( SMR: list[float], stationary_angles: list[float], linearised_angles: list[float], -): +) -> tuple[float, float]: """ Compute the resistance of the two FM bilayer system from the linearised angles. :param GMR: GMR @@ -287,9 +533,7 @@ def calculate_linearised_resistance_series( t02, p02 = stationary_angles[2:] dt1, dp1 = linearised_angles[:2] dt2, dp2 = linearised_angles[2:] - Rxx1, Rxx2, GMR_resistance, theta1, phi1, theta2, phi2 = ( - calculate_linearised_resistance(GMR, AMR, SMR) - ) + Rxx1, Rxx2, GMR_resistance, theta1, phi1, theta2, phi2 = calculate_linearised_resistance(GMR, AMR, SMR) Rseries = GMR_resistance + Rxx1 + Rxx2 dRseries = ( sym.diff(Rseries, theta1) * dt1 diff --git a/core/cvector.hpp b/core/cvector.hpp index 301a207..90271e1 100644 --- a/core/cvector.hpp +++ b/core/cvector.hpp @@ -212,6 +212,11 @@ template class CVector { ss << "[x:" << this->x << ", y:" << this->y << ", z:" << this->z << "]"; return ss.str(); } + + static CVector fromSpherical(T theta, T phi, T r = 1.0) { + return CVector(r * sin(theta) * cos(phi), r * sin(theta) * sin(phi), + r * cos(theta)); + } }; #endif // CORE_CVECTOR_HPP_ diff --git a/core/junction.hpp b/core/junction.hpp index cab2ca1..2b3dfe3 100644 --- a/core/junction.hpp +++ b/core/junction.hpp @@ -922,6 +922,14 @@ template class Junction { if (this->layerNo == 0) { throw std::invalid_argument("Passed a zero length Layer vector!"); } + // verify that all layers have unique ids + std::unordered_set _ids; + for (const auto &layer : this->layers) { + if (_ids.find(layer.id) != _ids.end()) { + throw std::invalid_argument("Layers must have unique ids!"); + } + _ids.insert(layer.id); + } } explicit Junction(const std::vector> &layersToSet, T Rp, T Rap) : Junction(layersToSet) { diff --git a/core/noise.hpp b/core/noise.hpp index 689f447..cba0397 100644 --- a/core/noise.hpp +++ b/core/noise.hpp @@ -134,7 +134,7 @@ template class OneFNoise { } }; -std::mt19937 generator(std::random_device{}()); +// std::mt19937 generator(std::random_device{}()); template class BufferedAlphaNoise : public NullTicker { protected: std::vector> bufferWhite, bufferColoured; @@ -148,6 +148,7 @@ template class BufferedAlphaNoise : public NullTicker { inv; // configs for forward and inverse real fft unsigned int internalCounter = 0; unsigned int refills = 0; + std::mt19937 generator; public: /** @@ -160,7 +161,7 @@ template class BufferedAlphaNoise : public NullTicker { */ BufferedAlphaNoise(unsigned int bufferSize, T alpha, T std, T scale) : bufferSize(bufferSize), alpha(alpha), scale(scale) { - + this->generator = std::mt19937(std::random_device{}()); this->bufferColoured.resize(2 * bufferSize); this->bufferWhite.resize(2 * bufferSize); this->result.resize(bufferSize); diff --git a/docs/api/core.md b/docs/api/core.md index f7992cf..8d42ec8 100644 --- a/docs/api/core.md +++ b/docs/api/core.md @@ -1 +1 @@ -::: cmtj +::: cmtj.core diff --git a/docs/api/reservoir.md b/docs/api/reservoir.md new file mode 100644 index 0000000..38ab234 --- /dev/null +++ b/docs/api/reservoir.md @@ -0,0 +1 @@ +::: cmtj.reservoir diff --git a/docs/index.md b/docs/index.md index c87648d..a073cd2 100644 --- a/docs/index.md +++ b/docs/index.md @@ -6,7 +6,7 @@ [![pages-build-deployment](https://github.com/LemurPwned/cmtj/actions/workflows/pages/pages-build-deployment/badge.svg?branch=gh-pages)](https://github.com/LemurPwned/cmtj/actions/workflows/pages/pages-build-deployment) [![Version](https://img.shields.io/pypi/v/cmtj)](https://pypi.org/project/cmtj/) [![License](https://img.shields.io/pypi/l/cmtj.svg)](https://github.com/LemurPwned/cmtj/blob/master/LICENSE) -[![Streamlit](https://static.streamlit.io/badges/streamlit_badge_black_white.svg)](http://cmtj-simulations.streamlit.app/) +[![Streamlit](https://static.streamlit.io/badges/streamlit_badge_black_white.svg)](https://cmtj-app.streamlit.app/spectrum) ![Downloads](https://img.shields.io/pypi/dm/cmtj.svg) ## Table of contents @@ -14,6 +14,7 @@ - [CMTJ](#cmtj) - [Table of contents](#table-of-contents) - [Short description](#short-description) + - [What can you simulate?](#what-can-you-simulate) - [Web GUI](#web-gui) - [Quickstart](#quickstart) - [Installation :rocket:](#installation-rocket) @@ -34,9 +35,47 @@ The `cmtj` name may be misleading -- the MTJ (Magnetic Tunnel Junctions) are not The library allows for macromagnetic simulation of various multilayer spintronic structures. The package uses C++ implementation of (s)LLGS (stochastic Landau-Lifschitz-Gilbert-Slonczewski) equation with various field contributions included for instance: anisotropy, interlayer exchange coupling, demagnetisation, dipole fields etc. It is also possible to connect devices in parallel or in series to have electrically coupled arrays. +### What can you simulate? + +Below is a brief list of examples (it's not exhaustive! Check the docs for more). + +**Magnetic devices:** + +- Magnetic Tunnel Junctions + - Voltage-Driven Magnetic Tunnel Junctions + - Spin-Torque Oscillators + - VCMA sensors and devices + - Magnetic Tunnel Junction Arrays +- SOT devices + - Current-Driven SOT +- Advanced device coupling +- Reservoirs (dipole coupling) +- Electrically coupled MTJs +- Base equations + - Landau-Lifshitz-Gilbert-Slonczewski equation + - Stochastic Landau-Lifshitz-Gilbert-Slonczewski equation + - Landau-Lifshitz-Gilbert-Bloch equation +- Domain wall motion + +**Experimental methods:** + +Some of the experimental methods available: + +- PIMM +- Spin-Diode +- CIMS +- R(H), M(H) + ## Web GUI -Check out the [streamlit hosted demo here](http://cmtj-simulations.streamlit.app/). You can simulate PIMM spectra and Spin-Diode spectra there. Let us know if you have any issues with the demo. +Check out the [streamlit hosted demo here](https://cmtj-app.streamlit.app/spectrum). +You can simulate: + +- PIMM spectra and Spin-Diode spectra +- Try some optimization fitting +- Fit multi-domain or multi-level M(H) or R(H) loops in [Domain mode](https://cmtj-app.streamlit.app) + +Let us know if you have any issues with the demo. ## Quickstart diff --git a/docs/tutorials/SBModel.ipynb b/docs/tutorials/SBModel.ipynb index 6cb6ef1..4770bd8 100644 --- a/docs/tutorials/SBModel.ipynb +++ b/docs/tutorials/SBModel.ipynb @@ -15,14 +15,16 @@ }, { "cell_type": "code", - "execution_count": 45, + "execution_count": 1, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 50/50 [00:27<00:00, 1.80it/s]\n" + "/opt/homebrew/Caskroom/miniforge/base/envs/.cmtj/lib/python3.9/site-packages/scipy/__init__.py:138: UserWarning: A NumPy version >=1.16.5 and <1.23.0 is required for this version of SciPy (detected version 1.26.4)\n", + " warnings.warn(f\"A NumPy version >={np_minversion} and <{np_maxversion} is required for this version of \"\n", + "100%|██████████| 50/50 [00:26<00:00, 1.86it/s]\n" ] } ], @@ -88,17 +90,19 @@ }, { "cell_type": "code", - "execution_count": 43, + "execution_count": 2, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] }, - "metadata": {}, + "metadata": { + "needs_background": "light" + }, "output_type": "display_data" } ], @@ -165,14 +169,14 @@ }, { "cell_type": "code", - "execution_count": 141, + "execution_count": 3, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 50/50 [00:14<00:00, 3.36it/s]\n" + "100%|██████████| 50/50 [00:14<00:00, 3.53it/s]\n" ] } ], @@ -249,12 +253,12 @@ }, { "cell_type": "code", - "execution_count": 142, + "execution_count": 4, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -340,7 +344,14 @@ "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 30/30 [00:21<00:00, 1.42it/s]\n" + " 0%| | 0/30 [00:00" ] @@ -505,6 +516,167 @@ " ax2.set_ylabel(\"angle (deg)\")\n", " fig.tight_layout()" ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Voltage FMR \n", + "\n", + "The dynamic model can be used to compute the voltage FMR. This is done by computing the linearised resistance of the system and then using the voltage drop across the system to compute the frequency shift.\n", + "\n", + "We need both the stationary and linearised angles to compute the linearised resistance, so we find the energy minimum first, and then compute the linearisation using standard Jacobian method. \n", + "\n", + "We will also use parallelisation to speed up the computation which normally can be pretty slow." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 18/18 [08:02<00:00, 26.78s/it]\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "from collections import defaultdict\n", + "from cmtj.utils.parallel import parallel_vsd_sb_model\n", + "from cmtj.models import LayerDynamic, VectorObj, Solver\n", + "from cmtj.utils import mu0, FieldScan\n", + "\n", + "\n", + "def process_frequency(args):\n", + " # this is a fixed function, so we can use it in parallel\n", + " f, Hvecs, layerA, layerB, J1, J2, _ = args\n", + " data = defaultdict(list)\n", + " current_position = [\n", + " np.deg2rad(90),\n", + " np.deg2rad(0.1),\n", + " np.deg2rad(90),\n", + " np.deg2rad(0.1),\n", + " ]\n", + " for H in Hvecs:\n", + " solver = Solver(\n", + " layers=[layerA, layerB],\n", + " J1=J1,\n", + " J2=J2,\n", + " H=VectorObj.from_cartesian(*H),\n", + " )\n", + " current_position = solver.adam_gradient_descent(\n", + " init_position=current_position, max_steps=1e6\n", + " )\n", + " res = solver.linearised_N_spin_diode(\n", + " H=H,\n", + " frequency=f * 1e9,\n", + " Vdc_ex_variable=LayerDynamic.get_Vp_symbol(),\n", + " Vdc_ex_value=1e6,\n", + " zero_pos=current_position,\n", + " phase_shift=0,\n", + " cache_var=\"H\",\n", + " )\n", + " data[\"lineshape\"].append(res)\n", + " data[\"pos\"].append(current_position)\n", + " return data\n", + "\n", + "\n", + "Ms1 = 1.0 / mu0\n", + "Ms2 = 1.2 / mu0\n", + "alpha = 1e-3\n", + "tpar = 0.2\n", + "tperp = -0.2\n", + "layerA = LayerDynamic(\n", + " _id=0,\n", + " thickness=1e-9,\n", + " Kv=VectorObj(np.deg2rad(0.0), np.deg2rad(0), 1e1),\n", + " Ks=3e4,\n", + " Ms=Ms1,\n", + " alpha=alpha,\n", + " torque_par=tpar,\n", + " torque_perp=tperp,\n", + ")\n", + "layerB = LayerDynamic(\n", + " _id=1,\n", + " thickness=1.3e-9,\n", + " Kv=VectorObj(np.deg2rad(0.0), np.deg2rad(0), 1e4),\n", + " Ks=1e1,\n", + " Ms=Ms2,\n", + " alpha=alpha,\n", + " torque_par=-tpar,\n", + " torque_perp=-tperp,\n", + ")\n", + "hmin = 200e3\n", + "N = 70\n", + "Hscan, Hvecs = FieldScan.amplitude_scan(\n", + " start=-hmin, stop=hmin, steps=N, theta=89, phi=0.1, back=False\n", + ")\n", + "fmax = 18\n", + "fspace = np.arange(0, fmax, 1)\n", + "spin_diode_data = parallel_vsd_sb_model(\n", + " process_frequency,\n", + " frequencies=fspace,\n", + " layers=[layerA, layerB],\n", + " Hvecs=Hvecs,\n", + " J1=[1e-4],\n", + " J2=[0.0],\n", + " n_cores=4,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "from cmtj.utils.resistance import Rxx_parallel_bilayer_expr\n", + "\n", + "GMR = 0.1\n", + "SMR = 0.01\n", + "AMR = 0.1\n", + "Vdc = 1\n", + "Rlin_func, R_func = Rxx_parallel_bilayer_expr()\n", + "with plt.style.context([\"science\", \"nature\"]):\n", + " fig, ax = plt.subplots(dpi=200)\n", + " for findx, fdata in enumerate(spin_diode_data):\n", + " V = []\n", + " for linearised, stationary in zip(fdata[\"lineshape\"], fdata[\"pos\"]):\n", + " Rparallel = R_func(GMR, AMR, SMR, AMR, SMR, stationary)\n", + " dRparallel = Rlin_func(GMR, AMR, SMR, AMR, SMR, stationary, linearised)\n", + " Vline = (Vdc / Rparallel) * dRparallel\n", + " V.append(Vline)\n", + " V = np.asarray(V)\n", + " V = (V - V.min()) / (V.max() - V.min()) / 2\n", + " ax.plot(Hscan / 1e3, V + findx, color=\"gray\")\n", + " ax.scatter(\n", + " Hvals,\n", + " result_dictionary[\"frequency\"],\n", + " color=\"crimson\",\n", + " label=r\"f\",\n", + " )\n", + " ax.set_xlabel(\"H (kA/m)\")\n", + " ax.set_ylabel(\"V (a.u.)\")\n", + " ax.set_title(\"Voltage FMR\")\n", + " ax.set_xlim(-hmin / 1e3, hmin / 1e3)\n", + " ax.set_ylim(-0.1, fmax)" + ] } ], "metadata": { diff --git a/docs/tutorials/interactions.ipynb b/docs/tutorials/interactions.ipynb new file mode 100644 index 0000000..af63237 --- /dev/null +++ b/docs/tutorials/interactions.ipynb @@ -0,0 +1,257 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Group interactions \n", + "\n", + "\n", + "## Introduction\n", + "In this tutorial, we will explore the interaction between any number of junctions. \n", + "We will limit ourselves to the interaction between two junctions, but the code can be easily extended to more junctions.\n", + "\n", + "We will use the `GroupInteraction` class to simulate the interaction between the junctions.\n", + "It allows us to define the interaction between the junctions based on the distance between the junctions. \n", + "\n", + "For documentation, see the [API reference](https://lemurpwned.github.io/cmtj/latest/api/reservoir.html#cmtj.reservoir.GroupInteraction).\n", + "\n", + "## Interaction functions\n", + "There are three available interaction functions:\n", + "\n", + "1. `nullDipoleInteraction`: This is the default interaction function. It does not take into account the interaction between the junctions.\n", + "2. `computeDipoleInteraction`: Simulates dipole interactions, see [1] for more details.\n", + "3. `computeDipoleInteractionNoumra`: Similar to 2., also dipole interactions, see [2] for more details.\n", + "\n", + "[1] Kanao et al., *Reservoir Computing on Spin-Torque Oscillator Array* (2019), https://link.aps.org/doi/10.1103/PhysRevApplied.12.024052 \n", + "\n", + "[2] Nomura et al., *Reservoir computing with dipole-coupled nanomagnets* (2019), https://iopscience.iop.org/article/10.7567/1347-4065/ab2406 \n", + "\n", + "\n", + "\n", + "## Experiment \n", + "\n", + "The experiment we will simulate is a two-junction system with a current flowing only through the first junction.\n", + "What we want to see is some oscillation in the second junction that is induced by the current flowing through the first junction and the interaction between the junctions.\n", + "\n", + "The coordinate matrix is defined as a list of position vectors, where each position vector represents the position of a junction with respect to (0, 0, 0) origin." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/opt/homebrew/Caskroom/miniforge/base/envs/.cmtj/lib/python3.9/site-packages/scipy/__init__.py:138: UserWarning: A NumPy version >=1.16.5 and <1.23.0 is required for this version of SciPy (detected version 1.26.4)\n", + " warnings.warn(f\"A NumPy version >={np_minversion} and <{np_maxversion} is required for this version of \"\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "from cmtj.reservoir import (\n", + " GroupInteraction,\n", + " nullDipoleInteraction,\n", + " computeDipoleInteraction,\n", + ")\n", + "\n", + "from cmtj import *\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "from scipy.fft import fftfreq, fft\n", + "\n", + "\n", + "import matplotlib.pyplot as plt\n", + "\n", + "BETA = 0.1\n", + "\n", + "fontsize = 5\n", + "\n", + "def create_junction(Ms, Ku):\n", + " damping = 1e-2\n", + " surface = np.pi * 50e-9 * 50e-9\n", + " thickness = 3e-9\n", + " spinPolarisation = 0.54\n", + " SLP = spinPolarisation**2\n", + " spinPolarisation = 1\n", + " demag = [CVector(0, 0, 0), CVector(0, 0, 0), CVector(0, 0, 1)]\n", + " # generate a random start position for the magnetization\n", + " start_m = CVector(\n", + " np.random.uniform(-1, 1), np.random.uniform(-1, 1), np.random.uniform(-1, 1)\n", + " )\n", + " start_m.normalize()\n", + " start_m = CVector(0, 0, 1)\n", + " layer = Layer.createSTTLayer(\n", + " \"free\",\n", + " start_m,\n", + " CVector(1.0, 0.0, 0.0),\n", + " Ms,\n", + " thickness,\n", + " surface,\n", + " demag,\n", + " damping,\n", + " SLP,\n", + " BETA,\n", + " spinPolarisation,\n", + " )\n", + " layer.setReferenceLayer(CVector(1, 0.0, 0))\n", + " layer.setAnisotropyDriver(constantDriver(Ku))\n", + " return Junction(\n", + " [layer],\n", + " 100,\n", + " 200,\n", + " )\n", + "\n", + "\n", + "int_time = 1e-13\n", + "Ms = 1.2\n", + "Ku = 1e2\n", + "m1 = create_junction(Ms, Ku)\n", + "m2 = create_junction(\n", + " Ms, Ku * (1 + 0.5)\n", + ") # we slightly modify the anisotropy of the second junction, so they are not identical\n", + "jdc = constantDriver(-7e11)\n", + "m1.setLayerCurrentDriver(\"free\", jdc)\n", + "m1.setLayerExternalFieldDriver(\"all\", AxialDriver(0, 0, 10e3))\n", + "m2.setLayerExternalFieldDriver(\"all\", AxialDriver(0, 0, 10e3))\n", + "coordinate_matrix = [\n", + " CVector(0, 0, 0),\n", + " CVector(\n", + " 200e-9, 0, 0\n", + " ), # we place the second junction 200 nm away from the first junction in the x direction\n", + "]\n", + "\n", + "\n", + "def customDipoleInteraction(\n", + " r1: CVector, r2: CVector, layer1: Layer, layer2: Layer\n", + ") -> CVector:\n", + " dist: CVector = np.power((r1 - r2).length(), 3) * (layer2.Ms / layer1.Ms) * 0.01\n", + " return CVector(dist, 0, 0)\n", + "\n", + "\n", + "colors = [\"crimson\", \"navy\"]\n", + "linestyles = [\"-\", \"--\"]\n", + "fstrs = [\"null\", \"Kanao\", \"custom\"]\n", + "lcolors = [\"crimson\", \"navy\", \"forestgreen\"]\n", + "fns = [nullDipoleInteraction, computeDipoleInteraction, customDipoleInteraction]\n", + "with plt.style.context([\"science\", \"nature\"]):\n", + " w, h = plt.figaspect(len(fns) / 3)\n", + " fig, axs = plt.subplots(len(fns), 3, dpi=300, figsize=(w, h))\n", + " for fi, (fn, fstr) in enumerate(zip(fns, fstrs)):\n", + " gi = GroupInteraction(coordinate_matrix, [m1, m2])\n", + "\n", + " gi.setInteractionFunction(fn)\n", + " gi.runSimulation(30e-9, int_time, int_time)\n", + " c_is = []\n", + " plot_time = 1\n", + " tm_wait = 10\n", + " for i in range(len(coordinate_matrix)):\n", + " log = gi.getLog(i)\n", + " tm = np.asarray(log[\"time\"]) * 1e9\n", + " R = np.asarray(log[\"R\"])\n", + " des_tm = tm.max() - plot_time\n", + " N = np.argwhere(tm > des_tm).ravel().min()\n", + " axs[fi, 0].plot(tm[N:], R[N:], label=f\"Junction {i}\", color=colors[i])\n", + " # compute fft of R\n", + "\n", + " idx = np.argwhere(tm > tm_wait).ravel()\n", + " # print(idx)\n", + " R = R[idx]\n", + " fft_R = fft(R)\n", + " freq = fftfreq(len(R), int_time)\n", + " fft_R = np.abs(fft_R)\n", + " fft_R = fft_R[: len(fft_R) // 2]\n", + " freq = freq[: len(freq) // 2]\n", + " axs[fi, 1].plot(freq, fft_R, label=f\"Junction {i}\", color=colors[i])\n", + " for kl, l in enumerate(\"xyz\"):\n", + " m_l = np.asarray(log[f\"free_m{l}\"])\n", + " axs[fi, 2].plot(\n", + " tm[N:],\n", + " m_l[N:],\n", + " label=f\"Junction {i} {l}\",\n", + " color=lcolors[kl],\n", + " linestyle=linestyles[i],\n", + " linewidth=0.3,\n", + " )\n", + " axs[fi, 0].set_xlabel(\"Time [ns]\", fontsize=fontsize)\n", + " axs[fi, -1].set_xlabel(\"Time [ns]\", fontsize=fontsize)\n", + " axs[fi, 0].set_ylabel(\"Resistance [Ohm]\", fontsize=fontsize)\n", + " axs[fi, 1].legend(fontsize=fontsize)\n", + " axs[fi, 1].set_xlabel(\"Frequency [GHz]\", fontsize=fontsize)\n", + " axs[fi, 1].set_ylabel(\"Amplitude\", fontsize=fontsize)\n", + " axs[fi, 2].set_ylabel(\"Magnetization\", fontsize=fontsize)\n", + " axs[fi, 1].set_xscale(\"log\")\n", + " axs[fi, 1].set_yscale(\"log\")\n", + "\n", + " axs[fi, 0].set_title(\"Resistance\", fontsize=fontsize)\n", + " axs[fi, 1].set_title(f\"Dipole interaction: {fstr}\", fontsize=fontsize)\n", + " axs[fi, 2].set_title(\"(solid: $m_1$, dashed: $m_2$)\", fontsize=fontsize)\n", + " fig.subplots_adjust(hspace=0.85)\n", + " fig.tight_layout()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Conclusions\n", + "\n", + "In the first row, we see null dipole interaction (no dipole interaction), and as expected, the resistance is of the second junction is constant.\n", + "\n", + "In the second row, we see the dipole interaction computed by Kanao et al. (2019), and we see that the resistance of the second junction oscillates, even though the current is only flowing through the first junction.\n", + "\n", + "For the third row, we defined a simple function that computes the interaction based on the distance between the junctions:\n", + "```python\n", + "def customDipoleInteraction(\n", + " r1: CVector, r2: CVector, layer1: Layer, layer2: Layer\n", + ") -> CVector:\n", + " dist: CVector = np.power((r1 - r2).length(), 3) * (layer2.Ms / layer1.Ms) * 0.01\n", + " return CVector(dist, 0, 0)\n", + "```\n", + "The interaction definition is quite simple, and flexible.\n", + "\n", + "We just need to remember that interaction should return a CVector, and that the interaction is defined for each pair of junctions.\n", + "In this case, the interaction is asymmetric because:\n", + "\n", + "1. We have the 3rd power of the distance in the formula.\n", + "2. We have a scalar factor that depends on whether we are computing the impact of the first junction on the second or the second on the first, (layer1.Ms / layer2.Ms) will differ depending on that." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": ".cmtj", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.6" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/docs/tutorials/simpler_harmonics.ipynb b/docs/tutorials/simpler_harmonics.ipynb new file mode 100644 index 0000000..16b58f0 --- /dev/null +++ b/docs/tutorials/simpler_harmonics.ipynb @@ -0,0 +1,442 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Simple harmonic Hall voltage detection\n", + "\n", + "In this tutorial, we will simulate the harmonic Hall voltage detection of a single junction.\n", + "\n", + "This notebook also shows how to parallelize the simulation using multiprocessing for faster simulations." + ] + }, + { + "cell_type": "code", + "execution_count": 71, + "metadata": { + "id": "3C51CWWNVkj9" + }, + "outputs": [], + "source": [ + "from cmtj import CVector, Layer, Junction, AxialDriver, NullDriver\n", + "from cmtj.utils.resistance import calculate_resistance_parallel\n", + "from cmtj import constantDriver, sineDriver\n", + "from collections import defaultdict\n", + "from cmtj.utils import Filters\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import cmtj\n", + "import math\n", + "\n", + "\n", + "OeToAm = 79.57747\n", + "\n", + "\n", + "Rx0 = 304.306 # @param {type: \"number\"}\n", + "Ry0 = 1.008 # @param {type: \"number\"}\n", + "SMR = -0.464 # @param {type: \"number\"}\n", + "AMR = -0.053 # @param {type: \"number\"}\n", + "AHE = -5.71 # @param {type: \"number\"}\n", + "w = 3e-5 # @param {type: \"number\"}\n", + "l = 2e-5 # @param {type: \"number\"}\n", + "INT_STEP = 1e-13 # @param {type: \"number\"}\n", + "HMIN = 250e3 # @param {type: \"number\"}\n", + "HMAX = 830e3 # @param {type: \"number\"}\n", + "HSTEPS = 100 # @param {type: \"number\"}\n", + "\n", + "\n", + "def compute_vsd1(stime, resistance, frequency, tstart=2e-9):\n", + " \"\"\"Time\"\"\"\n", + " stime = np.asarray(stime)\n", + " indx = np.argwhere(stime >= tstart).ravel()\n", + " Rx = np.asarray(resistance)[indx]\n", + " avg_res = np.mean(Rx)\n", + " current = np.sqrt(1 / avg_res) * np.sin(2 * np.pi * frequency * stime[indx])\n", + " return np.mean(current * Rx)\n", + "\n", + "\n", + "def compute_vsd2(dynamicR, integration_step, dynamicI):\n", + " \"\"\"Pymag\"\"\"\n", + " SD = -dynamicI * dynamicR\n", + " fs = 1.0 / integration_step\n", + " SD_dc = Filters.butter_lowpass_filter(SD, cutoff=10e6, fs=fs, order=3)\n", + " return np.mean(SD_dc)\n", + "\n", + "\n", + "def simulate_lorentz(Ms, Ku, frequency, orient, alpha=1e-4, Irf=0.5e-3):\n", + " demagTensor = [\n", + " CVector(0.0, 0.0, 0.0),\n", + " CVector(0.0, 0.0, 0.0),\n", + " CVector(0.0, 0.0, 1.0),\n", + " ]\n", + " thickness = 1.45e-9\n", + " l1 = Layer(\n", + " id=\"free\",\n", + " mag=CVector(0.0, 0.0, 1.0),\n", + " anis=CVector(0, 0.0, 1.0),\n", + " Ms=Ms,\n", + " thickness=thickness,\n", + " cellSurface=0,\n", + " demagTensor=demagTensor,\n", + " damping=alpha,\n", + " )\n", + " junction = Junction([l1])\n", + "\n", + " junction.setLayerAnisotropyDriver(\"free\", constantDriver(Ku))\n", + "\n", + " HoeAmpl = 5000 # A/m\n", + " Hspace = np.linspace(HMIN, HMAX, num=HSTEPS)\n", + " theta = np.deg2rad(91)\n", + " if orient == \"4p\":\n", + " phideg = 0\n", + " elif orient == \"2p\":\n", + " phideg = 45\n", + " else:\n", + " raise ValueError(\"Unknown orient\")\n", + " phi = np.deg2rad(phideg)\n", + " Hsweep = np.zeros((Hspace.shape[0]))\n", + " for i, H in enumerate(Hspace):\n", + " junction.clearLog()\n", + " HDriver = AxialDriver(\n", + " constantDriver(H * math.sin(theta) * math.cos(phi)),\n", + " constantDriver(H * math.sin(theta) * math.sin(phi)),\n", + " constantDriver(H * math.cos(theta)),\n", + " )\n", + "\n", + " HoeDriver = AxialDriver(\n", + " NullDriver(),\n", + " NullDriver(),\n", + " sineDriver(0, -HoeAmpl, frequency, 0),\n", + " )\n", + " junction.setLayerExternalFieldDriver(\"all\", HDriver)\n", + " junction.setLayerOerstedFieldDriver(\"all\", HoeDriver)\n", + " junction.runSimulation(40e-9, INT_STEP, INT_STEP, solverMode=cmtj.RK4)\n", + "\n", + " log = junction.getLog()\n", + " m = np.asarray(\n", + " [\n", + " [log[f\"{str_}_mx\"], log[f\"{str_}_my\"], log[f\"{str_}_mz\"]]\n", + " for str_ in [\"free\"]\n", + " ]\n", + " )\n", + " dynamicRx, dynamicRy = calculate_resistance_parallel(\n", + " Rx0=[Rx0],\n", + " Ry0=[Ry0],\n", + " AMR=[AMR],\n", + " AHE=[AHE],\n", + " SMR=[SMR],\n", + " m=m,\n", + " l=[l],\n", + " w=[w],\n", + " )\n", + " dynamicR = dynamicRx if orient == \"4p\" else dynamicRy\n", + " dynamicI = Irf * np.sin(2 * math.pi * frequency * np.asarray(log[\"time\"]))\n", + " vmix = compute_vsd2(dynamicR, INT_STEP, dynamicI)\n", + " Hsweep[i] = vmix\n", + " return Hspace, Hsweep\n", + "\n", + "\n", + "def simulate_lorentz_freq_scan(Ms, Ku, Hvalue, orient, alpha=1e-4, Irf=0.5e-3):\n", + " demagTensor = [\n", + " CVector(0.0, 0.0, 0.0),\n", + " CVector(0.0, 0.0, 0.0),\n", + " CVector(0.0, 0.0, 1.0),\n", + " ]\n", + " thickness = 1.45e-9\n", + " l1 = Layer(\n", + " id=\"free\",\n", + " mag=CVector(0.0, 0.0, 1.0),\n", + " anis=CVector(0, 0.0, 1.0),\n", + " Ms=Ms,\n", + " thickness=thickness,\n", + " cellSurface=0,\n", + " demagTensor=demagTensor,\n", + " damping=alpha,\n", + " )\n", + " junction = Junction([l1])\n", + "\n", + " junction.setLayerAnisotropyDriver(\"free\", constantDriver(Ku))\n", + "\n", + " HoeAmpl = 5000 # A/m\n", + " theta = np.deg2rad(91)\n", + " if orient == \"4p\":\n", + " phideg = 0\n", + " elif orient == \"2p\":\n", + " phideg = 45\n", + " else:\n", + " raise ValueError(\"Unknown orient\")\n", + " phi = np.deg2rad(phideg)\n", + " fspace = np.arange(2, 18, 0.1) * 1e9\n", + " fsweep = np.zeros((fspace.shape[0]))\n", + " for i, f in enumerate(fspace):\n", + " junction.clearLog()\n", + " HDriver = AxialDriver(\n", + " constantDriver(Hvalue * math.sin(theta) * math.cos(phi)),\n", + " constantDriver(Hvalue * math.sin(theta) * math.sin(phi)),\n", + " constantDriver(Hvalue * math.cos(theta)),\n", + " )\n", + "\n", + " HoeDriver = AxialDriver(\n", + " NullDriver(),\n", + " NullDriver(),\n", + " sineDriver(0, -HoeAmpl, f, 0),\n", + " )\n", + " junction.setLayerExternalFieldDriver(\"all\", HDriver)\n", + " junction.setLayerOerstedFieldDriver(\"all\", HoeDriver)\n", + " junction.runSimulation(40e-9, INT_STEP, INT_STEP, solverMode=cmtj.RK4)\n", + "\n", + " log = junction.getLog()\n", + " m = np.asarray(\n", + " [\n", + " [log[f\"{str_}_mx\"], log[f\"{str_}_my\"], log[f\"{str_}_mz\"]]\n", + " for str_ in [\"free\"]\n", + " ]\n", + " )\n", + " dynamicRx, dynamicRy = calculate_resistance_parallel(\n", + " Rx0=[Rx0],\n", + " Ry0=[Ry0],\n", + " AMR=[AMR],\n", + " AHE=[AHE],\n", + " SMR=[SMR],\n", + " m=m,\n", + " l=[l],\n", + " w=[w],\n", + " )\n", + " dynamicR = dynamicRx if orient == \"4p\" else dynamicRy\n", + " dynamicI = Irf * np.sin(2 * math.pi * f * np.asarray(log[\"time\"]))\n", + " vmix = compute_vsd2(dynamicR, INT_STEP, dynamicI)\n", + " fsweep[i] = vmix\n", + " return fspace, fsweep" + ] + }, + { + "cell_type": "code", + "execution_count": 72, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 10/10 [01:56<00:00, 11.62s/it]\n" + ] + } + ], + "source": [ + "from tqdm import tqdm\n", + "import multiprocess as mp\n", + "from functools import partial\n", + "\n", + "\n", + "def process_h(h, orient, irf, Ms, Ku, alpha):\n", + " fscan, fsweep = simulate_lorentz_freq_scan(\n", + " Ms, Ku, h, orient=orient, alpha=alpha, Irf=irf\n", + " )\n", + " if orient == \"2p\":\n", + " fsweep -= fsweep.max()\n", + " return fscan, fsweep\n", + "\n", + "\n", + "data = defaultdict(list)\n", + "hscans = []\n", + "vscans = []\n", + "\n", + "hscan = np.arange(150, 650, 50) * 1e3\n", + "alpha = 30e-3 # @param {type: \"number\"}\n", + "Ms = 0.525 # @param {type: \"number\"}\n", + "Ku = 1.54e5 # @param {type: \"number\"}\n", + "orient = \"2p\"\n", + "irf = 0.4e-3\n", + "with mp.Pool() as pool:\n", + " process_func = partial(process_h, orient=orient, irf=irf, Ms=Ms, Ku=Ku, alpha=alpha)\n", + " results = list(tqdm(pool.imap(process_func, hscan), total=len(hscan)))\n", + "\n", + "for fscan, fsweep in results:\n", + " data[f\"{orient}\"].append(fsweep)\n", + " data[f\"{orient}-freq\"].append(fscan)" + ] + }, + { + "cell_type": "code", + "execution_count": 73, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# import scienceplots\n", + "\n", + "with plt.style.context([\"nature\"]):\n", + " fig, ax = plt.subplots(dpi=300)\n", + "\n", + " colors = plt.get_cmap(\"rainbow\")(np.linspace(0, 1, len(hscan)))\n", + " for i, h in enumerate(hscan):\n", + " ax.plot(\n", + " np.asarray(data[f\"{orient}-freq\"][i]) / 1e9,\n", + " np.asarray(data[orient][i]) * 1e6,\n", + " alpha=1,\n", + " linestyle=\"--\", \n", + " label=f\"{h/1e3:.2f} kA/m\" if orient == \"4p\" else None,\n", + " color=colors[i],\n", + " linewidth=1,\n", + " )\n", + " # ax.set_xlim([300, 630])\n", + " ax.set_ylabel(r\"$V_\\mathrm{DC} (\\mathrm{\\mu V})$\")\n", + " ax.set_xlabel(\"f (GHz)\")\n", + "\n", + " # add a colorbar\n", + " norm = plt.Normalize(min(hscan) / 1e3, max(hscan) / 1e3)\n", + " sm = plt.cm.ScalarMappable(cmap=\"rainbow\", norm=norm)\n", + " sm.set_array([])\n", + " cbar = fig.colorbar(sm, ax=ax, label=\"H (kA/m)\")\n", + " cbar.ax.set_ylabel(\"H (kA/m)\", rotation=90, labelpad=10)\n", + "\n", + " fig.align_ylabels([ax])\n", + " # fig.legend()\n", + " # fig.tight_layout()" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "rFBpkJCGWiYb", + "outputId": "a22fb62e-d731-4f40-8987-b24fd9fef040" + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 4/4 [01:34<00:00, 23.69s/it]\n", + "100%|██████████| 4/4 [01:35<00:00, 23.78s/it]\n" + ] + } + ], + "source": [ + "from tqdm import tqdm\n", + "\n", + "data = defaultdict(list)\n", + "hscans = []\n", + "vscans = []\n", + "fmin = 12 # @param {type: \"number\"}\n", + "fmax = 17 # @param {type: \"number\"}\n", + "fscan = [9, 12, 17, 22]\n", + "alpha = 30e-3 # @param {type: \"number\"}\n", + "Ms = 0.525 # @param {type: \"number\"}\n", + "Ku = 1.54e5 # @param {type: \"number\"}\n", + "for orient, irf in zip((\"4p\", \"2p\"), (0.75e-3, 0.4e-3)):\n", + " for f in tqdm(fscan):\n", + " hscan, vscan = simulate_lorentz(\n", + " Ms, Ku, f * 1e9, orient=orient, alpha=alpha, Irf=irf\n", + " )\n", + " if orient == \"2p\":\n", + " vscan -= vscan.max()\n", + " data[f\"{orient}\"].append(vscan)\n", + " data[f\"{orient}-field\"].append(hscan)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 764 + }, + "id": "cQsuEyfBV88k", + "outputId": "ad703e46-f5e0-4e92-8774-4739fd7d6b3a" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# import scienceplots\n", + "\n", + "with plt.style.context([\"nature\"]):\n", + " fig, ax = plt.subplots(2, 1, dpi=300, sharex=\"col\")\n", + " colors = plt.get_cmap(\"rainbow\")(np.linspace(0, 1, len(fscan)))\n", + " for j, orient in enumerate((\"4p\", \"2p\")):\n", + " for i, f in enumerate(fscan):\n", + " ax[j].plot(\n", + " np.asarray(data[f\"{orient}-field\"][i]) / 1e3,\n", + " np.asarray(data[orient][i]) * 1e6,\n", + " alpha=1,\n", + " linestyle=\"--\",\n", + " label=f\"{f} GHz\" if orient == \"4p\" else None,\n", + " color=colors[i],\n", + " linewidth=1,\n", + " )\n", + " # ax[j].set_xlim([300, 630])\n", + " ax[j].set_ylabel(r\"$V_\\mathrm{DC} (\\mathrm{\\mu V})$\")\n", + "\n", + " ax[1].set_xlabel(\"H (kA/m)\")\n", + " # ax[1].legend()\n", + " import matplotlib.transforms as mtransforms\n", + "\n", + " # ax[0].legend()\n", + " for label, ax_ in zip([\"(a)\", \"(b)\"], ax.flatten()):\n", + " trans = mtransforms.ScaledTranslation(10 / 72, -5 / 72, fig.dpi_scale_trans)\n", + " ax_.text(\n", + " 0.0,\n", + " 1.0,\n", + " label,\n", + " transform=ax_.transAxes + trans,\n", + " fontsize=\"medium\",\n", + " verticalalignment=\"top\",\n", + " bbox=dict(facecolor=\"none\", edgecolor=\"none\", pad=3.0),\n", + " )\n", + " fig.subplots_adjust(hspace=0)\n", + " fig.align_ylabels()\n", + " fig.legend()\n", + " fig.tight_layout()" + ] + } + ], + "metadata": { + "colab": { + "provenance": [] + }, + "kernelspec": { + "display_name": "Python 3", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.6" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/mkdocs.yml b/mkdocs.yml index 20f4540..bf25d94 100644 --- a/mkdocs.yml +++ b/mkdocs.yml @@ -46,10 +46,13 @@ nav: - Stack: api/stack.md - Noise: api/noise.md - LLGB: api/llgb.md + - Group interactions: api/reservoir.md - Examples: - Library introduction: tutorials/CMTJBindingsTutorial.ipynb - Trajectories: tutorials/trajectory.ipynb - Smit-Beljers: tutorials/SBModel.ipynb + - Interactions: tutorials/interactions.ipynb + - Simple Harmonic Hall voltage detection: tutorials/simpler_harmonics.ipynb theme: icon: diff --git a/python/cmtj.cpp b/python/cmtj.cpp index 7b12417..6a68fa0 100644 --- a/python/cmtj.cpp +++ b/python/cmtj.cpp @@ -119,7 +119,8 @@ PYBIND11_MODULE(cmtj, m) { [](const DVector& v, const int key) { return v[key]; }) .def("__len__", [](const DVector& v) { return 3; }) .def("__str__", py::overload_cast<>(&DVector::toString)) - .def("__repr__", py::overload_cast<>(&DVector::toString)); + .def("__repr__", py::overload_cast<>(&DVector::toString)) + .def_static("fromSpherical", &DVector::fromSpherical, "theta"_a, "phi"_a, "r"_a = 1.0); py::implicitly_convertible, DVector>(); py::implicitly_convertible, DVector>(); @@ -240,7 +241,7 @@ PYBIND11_MODULE(cmtj, m) { .def_readonly("cellSurface", &DLayer::cellSurface) .def_readonly("demagTensor", &DLayer::demagTensor) // noise - .def("setAlphaNoise", &DLayer::setAlphaNoise) + .def("setAlphaNoise", &DLayer::setAlphaNoise, "alpha"_a, "std"_a, "scale"_a, "axis"_a = Axis::all) .def("setOneFNoise", &DLayer::setOneFNoise) // getters .def("getId", &DLayer::getId) diff --git a/setup.py b/setup.py index b665255..da73f37 100644 --- a/setup.py +++ b/setup.py @@ -6,7 +6,7 @@ from setuptools import Extension, find_namespace_packages, setup from setuptools.command.build_ext import build_ext -__version__ = "1.6.2" +__version__ = "1.6.3" """ As per https://github.com/pybind/python_example diff --git a/tests/test_sanity.py b/tests/test_sanity.py new file mode 100644 index 0000000..e91dd41 --- /dev/null +++ b/tests/test_sanity.py @@ -0,0 +1,39 @@ +import pytest + +from cmtj import Layer, Junction, CVector + + +def test_throws_error_if_layers_have_duplicate_ids(): + demag = [CVector(0, 0, 0), CVector(0, 0, 0), CVector(0, 0, 1)] + alpha = 0.005 + surface = 0 + + layers = [ + Layer( + "free", + mag=CVector(0, 0, 1), + anis=CVector(0, 0, 1), + Ms=1.65, + thickness=3e-9, + cellSurface=surface, + demagTensor=demag, + damping=alpha, + ), + Layer( + "free", + mag=CVector(0, 0, 1), + anis=CVector(0, 1.0, 0), + Ms=1.65, + thickness=3e-9, + cellSurface=surface, + demagTensor=demag, + damping=alpha, + ), + ] + with pytest.raises(ValueError, match="Layers must have unique ids!"): + Junction(layers) + + +def test_throws_if_no_layers_are_passed(): + with pytest.raises(ValueError, match="Passed a zero length Layer vector!"): + Junction([]) diff --git a/view/simulation_fns.py b/view/simulation_fns.py index 07f8bf7..28de75c 100644 --- a/view/simulation_fns.py +++ b/view/simulation_fns.py @@ -1,7 +1,11 @@ from collections import defaultdict from itertools import groupby from typing import List +from venv import create +from colorama import init + +from new_sb import LayerDynamic import numpy as np import streamlit as st @@ -45,7 +49,9 @@ def create_single_layer(id_: str) -> tuple: ] demag_sum = nxx + nyy + nzz if abs(demag_sum - 1.0) > 1e-5: - st.warning(f"Warning: Demagnetization tensor components should sum to 1.0 (Layer {id_})") + st.warning( + f"Warning: Demagnetization tensor components should sum to 1.0 (Layer {id_})" + ) Kdir = FieldScan.angle2vector( theta=st.session_state[f"theta_K{id_}"], phi=st.session_state[f"phi_K{id_}"] ) @@ -74,6 +80,27 @@ def create_single_layer(id_: str) -> tuple: return layer, rp +def create_sb_layer(id_: str) -> tuple[LayerDynamic, list[float]]: + nxx = st.session_state[f"Nxx{id_}"] + nyy = st.session_state[f"Nyy{id_}"] + nzz = st.session_state[f"Nzz{id_}"] + Ks = st.session_state[f"Ks{id_}"] + Kv = st.session_state[f"Kv{id_}"] + kphi = st.session_state[f"phi_K{id_}"] + demag = VectorObj.from_cartesian(nxx, nyy, nzz) + layer = LayerDynamic( + _id=int(id_), + thickness=st.session_state[f"thickness{id_}"] * 1e-9, + Kv=VectorObj(np.deg2rad(0.0), np.deg2rad(kphi), Kv), + Ks=Ks, + Ms=st.session_state[f"Ms{id_}"] / mu0, + demagTensor=demag, + damping=st.session_state[f"alpha{id_}"], + ) + ktheta = 90 if Kv > Ks else 0 # if Kv is smaller than Ks, assume in plane + return layer, [np.deg2rad(ktheta), np.deg2rad(kphi)] + + def get_axis_cvector(axis: str): if axis == "x": return CVector(1, 0, 0) @@ -131,12 +158,68 @@ def prepare_simulation(): j = Junction(layers=layers) for jvals in range(N - 1): J = st.session_state[f"J{jvals}"] * 1e-6 # rescale GUI units + J2 = st.session_state[f"J2{jvals}"] * 1e-6 # rescale GUI units l1_name = layers[jvals].id l2_name = layers[jvals + 1].id j.setIECDriver(l1_name, l2_name, ScalarDriver.getConstantDriver(J)) + j.setQuadIECDriver(l2_name, l1_name, ScalarDriver.getConstantDriver(J2)) return j, rparams +def prepare_sb_simulation() -> tuple: + layers = [] + init_pos = [] + N = st.session_state["N"] + for i in range(N): + layer, init_pos_i = create_sb_layer(i) + layers.append(layer) + init_pos.append(init_pos_i) + Js = [] + Js2 = [] + for jvals in range(N - 1): + J = st.session_state[f"J{jvals}"] * 1e-6 # rescale GUI units + J2 = st.session_state[f"J2{jvals}"] * 1e-6 # rescale GUI units + Js.append(J) + Js2.append(J2) + return layers, init_pos, Js, Js2 + + +def get_spectrum_sb_data(H_axis, Hmin, Hmax, Hsteps, run_vsd: bool = False): + layers, init_pos, Js, Js2 = prepare_sb_simulation() + + htheta, hphi = get_axis_angles(H_axis) + hmin, hmax = min([Hmin, Hmax]), max([Hmin, Hmax]) # fix user input + _, Hvecs = FieldScan.amplitude_scan(hmin, hmax, Hsteps, htheta, hphi) + force_single_layer = not any(Js) and not any(Js2) + all_sb_data = defaultdict(list) + for H in Hvecs: + Hvec = VectorObj.from_cartesian(*H) + solver = Solver(layers=layers, J1=Js, J2=Js2, H=Hvec) + eq, frequencies = solver.solve( + init_position=init_pos, + perturbation=1e-4, + force_single_layer=force_single_layer, + ) + for freq in frequencies: + all_sb_data["Hmag"].append(Hvec.mag / 1e3) + all_sb_data["frequency"].append(freq) + + if run_vsd: + res = solver.linearised_N_spin_diode( + H=Hvec, + frequency=freq * 1e9, + Vdc_ex_variable=LayerDynamic.get_Vp_symbol(), + Vdc_ex_value=st.session_state["Hoe_mag"] * 1e3, + zero_pos=eq.tolist(), + phase_shift=0, + cache_var="H", + ) + + all_sb_data["pos"].append(eq.tolist()) + init_pos = eq.tolist() + return all_sb_data + + # @st.cache_data def get_pimm_data( H_axis, diff --git a/view/streamlit_app.py b/view/streamlit_app.py index 65e5606..e60b148 100644 --- a/view/streamlit_app.py +++ b/view/streamlit_app.py @@ -47,7 +47,8 @@ def import_session_state(file): mime="application/json", type="primary", help="Export the current session state to a JSON file. " - "You can use this to save your current settings and load them later or ""share them with others.", + "You can use this to save your current settings and load them later or " + "share them with others.", ) st.file_uploader( @@ -173,6 +174,16 @@ def import_session_state(file): format="%.3f", help="Interlayer exchange coupling constant", ) + + st.number_input( + f"$J_2$ ({j+1}<-->{j+2}) (uJ/m^2)", + min_value=GENERIC_BOUNDS["J"][0], + max_value=GENERIC_BOUNDS["J"][1], + value=0.0, + key=f"J2{j}", + format="%.4f", + help="Biquadratic interlayer exchange coupling constant", + ) with st.expander("Simulation & control parameters"): st.selectbox( "H axis", options=["x", "y", "z", "xy", "xz", "yz"], key="H_axis", index=0