quantalyze 0.1.0__py3-none-any.whl

quantalyze/__init__.py

@@ -0,0 +1,4 @@
+# This file makes the directory a package.
+from .core import *
+from .transport import *
+from .thermometry import *

quantalyze/core/__init__.py

@@ -0,0 +1,4 @@
+from .fitting import Fit, fit
+from .symmetrize import symmetrize, antisymmetrize
+from .smoothing import bin, window, savgol_filter
+from .differentiation import backward_difference, forward_difference, central_difference, derivative

quantalyze/core/differentiation.py

@@ -0,0 +1,71 @@
+def forward_difference(df, x_column, y_column):
+    """
+    Calculate the forward difference of a given DataFrame.
+
+    Parameters:
+    df (pandas.DataFrame): The DataFrame containing the data.
+    x_column (str): The name of the column representing the x-values.
+    y_column (str): The name of the column representing the y-values.
+
+    Returns:
+    pandas.Series: A Series containing the forward differences of the y-values with respect to the x-values.
+    """
+    forward_diff = df[y_column].diff().shift(-1) / df[x_column].diff().shift(-1)
+    return forward_diff
+
+
+def backward_difference(df, x_column, y_column):
+    """
+    Calculate the backward difference of a DataFrame column.
+
+    Parameters:
+    df (pandas.DataFrame): The DataFrame containing the data.
+    x_column (str): The name of the column to use as the x-values.
+    y_column (str): The name of the column to use as the y-values.
+
+    Returns:
+    pandas.Series: The backward difference of the y_column with respect to the x_column.
+    """
+    backward_diff = df[y_column].diff() / df[x_column].diff()
+    return backward_diff
+
+
+def central_difference(df, x_column, y_column):
+    """
+    Calculate the central difference for a given DataFrame.
+
+    The central difference is computed as the average of the forward difference
+    and the backward difference for the specified columns.
+
+    Parameters:
+    df (pandas.DataFrame): The input DataFrame containing the data.
+    x_column (str): The name of the column representing the x-values.
+    y_column (str): The name of the column representing the y-values.
+
+    Returns:
+    pandas.Series: A Series containing the central difference values.
+    """
+    forward_diff = forward_difference(df, x_column, y_column)
+    backward_diff = backward_difference(df, x_column, y_column)
+    central_diff = (forward_diff + backward_diff) / 2
+    return central_diff
+
+
+
+def derivative(df, x_column, y_column):
+    """
+    Calculate the derivative of the y_column with respect to the x_column.
+
+    This method computes the numerical derivative of a given y_column with respect to an x_column
+    in a pandas DataFrame using central difference method.
+
+    Parameters:
+    df (pandas.DataFrame): The input DataFrame containing the data.
+    x_column (str): The name of the column representing the x-axis.
+    y_column (str): The name of the column representing the y-axis.
+
+    Returns:
+    pandas.Series: A Series with the derivative values.
+    """
+    return central_difference(df, x_column, y_column)
+    

quantalyze/core/fitting.py

@@ -0,0 +1,90 @@
+from scipy.optimize import curve_fit
+from inspect import signature
+
+
+class Fit:
+    
+    def __init__(self, func, popt, pcov):
+        self.func = func
+        self.popt = popt
+        self.pcov = pcov
+
+
+    def evaluate(self, x):
+        """
+        Evaluate the fitted function at given data points.
+
+        Parameters:
+        x : array-like
+            The input data points where the function should be evaluated.
+
+        Returns:
+        array-like
+            The evaluated values of the fitted function at the given data points.
+        """
+        return self.func(x, *self.popt)
+
+
+    def plot(self, ax, x, **kwargs):
+        """
+        Plot the evaluated function on the given axes.
+
+        Parameters:
+        ax (matplotlib.axes.Axes): The axes on which to plot.
+        x (array-like): The x values to evaluate the function.
+        **kwargs: Additional keyword arguments to pass to the plot function.
+
+        Returns:
+        None
+        """
+        ax.plot(x, self.evaluate(x), **kwargs)
+
+
+def fit(func, df, x_column, y_column, x_min=None, x_max=None, y_min=None, y_max=None, p0=None):
+    """
+    Fits a given function to data in a DataFrame within an optional x and y range.
+    
+    Parameters:
+    func (callable): The function to fit to the data. It should take x data as the first argument and parameters to fit as subsequent arguments.
+    df (pandas.DataFrame): The input DataFrame containing the data.
+    x_column (str): The name of the column in the DataFrame to use as the x data.
+    y_column (str): The name of the column in the DataFrame to use as the y data.
+    x_min (float, optional): The minimum value of x to include in the fitting. Defaults to None.
+    x_max (float, optional): The maximum value of x to include in the fitting. Defaults to None.
+    y_min (float, optional): The minimum value of y to include in the fitting. Defaults to None.
+    y_max (float, optional): The maximum value of y to include in the fitting. Defaults to None.
+    p0 (array-like, optional): Initial guess for the parameters. Defaults to None.
+    
+    Returns:
+    Fit: An instance of the Fit class containing the fitted function and parameters.
+    """
+    # Filter the dataframe based on x_min and x_max
+    if x_min is not None:
+        df = df[df[x_column] >= x_min]
+    if x_max is not None:
+        df = df[df[x_column] <= x_max]
+    
+    # Filter the dataframe based on y_min and y_max
+    if y_min is not None:
+        df = df[df[y_column] >= y_min]
+    if y_max is not None:
+        df = df[df[y_column] <= y_max]
+    
+    # Extract x and y data
+    x_data = df[x_column].values
+    y_data = df[y_column].values
+    
+    # Check if there is data to fit
+    if len(x_data) == 0 or len(y_data) == 0:
+        raise RuntimeError("No data in the specified x or y range to fit.")
+    
+    # Check if p0 is provided and has the correct length
+    if p0 is not None:
+        num_params = len(signature(func).parameters) - 1  # Subtract 1 for the x parameter
+        if len(p0) != num_params:
+            raise ValueError(f"Initial guess p0 must have length {num_params}, but got {len(p0)}.")
+    
+    # Perform curve fitting
+    popt, pcov = curve_fit(func, x_data, y_data, p0=p0)
+    
+    return Fit(func=func, popt=popt, pcov=pcov)

quantalyze/core/smoothing.py

@@ -0,0 +1,71 @@
+import pandas as pd
+import numpy as np
+from scipy.signal import savgol_filter as scipy_savgol_filter
+
+
+
+
+
+def bin(dfs, column, minimum, maximum, width):
+    """
+    Bin the data in the specified column of the DataFrame(s) into equal-width bins and compute the mean of each bin.
+
+    Parameters:
+    dfs (pandas.DataFrame or list of pandas.DataFrame): The input DataFrame(s) containing the data to be binned.
+    column (str): The name of the column in the DataFrame(s) to be binned.
+    minimum (float): The minimum value of the range to be binned.
+    maximum (float): The maximum value of the range to be binned.
+    width (float): The width of each bin.
+
+    Returns:
+    pandas.DataFrame: A DataFrame containing the mean values of each bin, with the bin midpoints as the values in the specified column.
+    """
+    def bin_single_df(df):
+        bin_edges = np.arange(minimum - width / 2, maximum + width / 2 + width, width)
+        bin_midpoints = (bin_edges[1:] + bin_edges[:-1]) / 2
+        df['bin'] = pd.cut(df[column], bins=bin_edges, include_lowest=True)
+        binned = df.groupby('bin').agg('mean').reset_index()
+        binned[column] = bin_midpoints
+        binned = binned.drop('bin', axis=1)
+        return binned
+
+    if isinstance(dfs, list):
+        combined_df = pd.concat(dfs, ignore_index=True)
+        return bin_single_df(combined_df)
+    else:
+        return bin_single_df(dfs)
+
+
+
+def window(df, column, window_size=5, window_type='triang'):
+    """
+    Apply a rolling window smoothing to a specified column in a DataFrame.
+
+    Parameters:
+    df (pandas.DataFrame): The input DataFrame containing the data.
+    column (str): The name of the column to which the rolling window smoothing will be applied.
+    window_size (int, optional): The size of the rolling window. Default is 5.
+    window_type (str, optional): The type of window to use. Default is 'triang'.
+
+    Returns:
+    pandas.Series: A Series with the smoothed values.
+    """
+    return df[column].rolling(window=window_size, win_type=window_type, center=True).mean()
+
+
+def savgol_filter(df, column, window_size=5, order=2):
+    """
+    Apply a Savitzky-Golay filter to a specified column in a DataFrame.
+
+    Parameters:
+    df (pandas.DataFrame): The input DataFrame containing the data.
+    column (str): The name of the column to which the Savitzky-Golay filter will be applied.
+    window_size (int, optional): The size of the window. Default is 5.
+    order (int, optional): The order of the polynomial used to fit the samples. Default is 2.
+
+    Returns:
+    pandas.Series: A Series with the smoothed values.
+    """
+    return pd.Series(scipy_savgol_filter(df[column], window_size, order), index=df.index)
+	
+

quantalyze/core/symmetrize.py

@@ -0,0 +1,54 @@
+import pandas as pd
+from .smoothing import bin
+
+
+
+def symmetrize(dfs, x_column, y_column, minimum, maximum, step):
+    """
+    Symmetrizes the given dataframes by combining them, filtering based on the x_column values,
+    and then averaging the y_column values with their reversed counterparts.
+
+    Parameters:
+    dfs (list of pd.DataFrame): List of dataframes to be symmetrized.
+    x_column (str): The name of the column to be used for filtering and sorting.
+    y_column (str): The name of the column to be symmetrized.
+    minimum (float): The minimum value for filtering the x_column.
+    maximum (float): The maximum value for filtering the x_column.
+    step (float): The step size for binning the x_column values.
+
+    Returns:
+    pd.DataFrame: A new dataframe with symmetrized y_column values.
+    """
+    dfs = [df[(df[x_column] >= minimum) & (df[x_column] <= maximum)] for df in dfs]
+    combined = pd.concat(dfs)
+    combined = combined.sort_values(by=x_column)
+    combined = bin(combined, x_column, -maximum, maximum, step)
+    new_df = pd.DataFrame(data={x_column: combined[x_column], 'a': combined[y_column], 'b': combined[y_column].values[::-1]})
+    new_df[y_column] = (new_df["a"]+new_df["b"])/2
+    new_df = new_df.drop(columns=['a', 'b'])
+    return new_df
+
+
+def antisymmetrize(dfs, x_column, y_column, minimum, maximum, step):
+    """
+    Antisymmetrizes the given dataframes by reflecting the y-values around the x-axis.
+
+    Parameters:
+    dfs (list of pd.DataFrame): List of dataframes to be antisymmetrized.
+    x_column (str): The name of the column representing the x-axis.
+    y_column (str): The name of the column representing the y-axis.
+    minimum (float): The minimum value of the x-axis range to consider.
+    maximum (float): The maximum value of the x-axis range to consider.
+    step (float): The step size for binning the x-axis values.
+
+    Returns:
+    pd.DataFrame: A new dataframe with antisymmetrized y-values.
+    """
+    dfs = [df[(df[x_column] >= minimum) & (df[x_column] <= maximum)] for df in dfs]
+    combined = pd.concat(dfs)
+    combined = combined.sort_values(by=x_column)
+    combined = bin(combined, x_column, -maximum, maximum, step)
+    new_df = pd.DataFrame(data={x_column: combined[x_column], 'a': combined[y_column], 'b': combined[y_column].values[::-1]})
+    new_df[y_column] = (new_df["a"]-new_df["b"])/2
+    new_df = new_df.drop(columns=['a', 'b'])
+    return new_df

quantalyze/plotting.py

@@ -0,0 +1,52 @@
+import matplotlib.pyplot as plt
+
+
+
+def _set_ticks_inwards(fig):
+    """
+    Set the direction of ticks on the axes to inwards.
+    
+    Parameters:
+    fig (matplotlib.figure.Figure): The figure to modify.
+    
+    Returns:
+    matplotlib.figure.Figure: The modified figure.
+    """
+    for ax in fig.axes:
+        ax.tick_params(direction='in')
+    
+    return fig
+
+
+
+def nature_single_column(fig):
+    """
+    Adjusts the size and tick orientation of a matplotlib figure to match the 
+    single-column format typically used in Nature journal publications.
+    Parameters:
+    fig (matplotlib.figure.Figure): The figure to be adjusted.
+    Returns:
+    matplotlib.figure.Figure: The adjusted figure.
+    """
+
+    fig.set_size_inches(3.5, 2.5)
+
+    _set_ticks_inwards(fig)
+
+    return fig
+
+
+def nature_double_column(fig):
+    """
+    Adjusts the size of the given figure to fit a double column format for Nature journal.
+    Parameters:
+    fig (matplotlib.figure.Figure): The figure to be adjusted.
+    Returns:
+    matplotlib.figure.Figure: The adjusted figure with the new size.
+    """
+
+    fig.set_size_inches(7.2, 4.5)
+
+    _set_ticks_inwards(fig)
+
+    return fig

quantalyze/thermometry.py

@@ -0,0 +1,58 @@
+import numpy as np
+from numpy.polynomial.chebyshev import Chebyshev
+
+
+class ChebychevFit:
+
+    def __init__(self, cheb_fit_R_to_T, cheb_fit_T_to_R):
+        self.cheb_fit_R_to_T = cheb_fit_R_to_T
+        self.cheb_fit_T_to_R = cheb_fit_T_to_R
+
+
+    def resistance_to_temperature(self, resistance):
+        """
+        Convert resistance to temperature using the Chebyshev fit.
+        Parameters:
+            resistance (float): Resistance in ohms.
+        Returns:
+            float: Temperature in Kelvin.
+        """
+        log_R = np.log10(resistance)
+        log_T = self.cheb_fit_R_to_T(log_R)
+        return 10**log_T
+    
+
+    def temperature_to_resistance(self, temperature):
+        """
+        Convert temperature to resistance using the Chebyshev fit.
+        Parameters:
+            temperature (float): Temperature in Kelvin.
+        Returns:
+            float: Resistance in ohms.
+        """
+        log_T = np.log10(temperature)
+        log_R = self.cheb_fit_T_to_R(log_T)
+        return 10**log_R
+
+
+def fit_chebyshev_polynomial(df, resistance_column='resistance', temperature_column='temperature', order=7):
+    """
+    Fits Chebyshev polynomials to log-log data for resistance vs. temperature.
+    
+    Parameters:
+        df (pandas.DataFrame): DataFrame containing 'resistance' and 'temperature' columns.
+        resistance_column (str): Name of the column containing resistance data.
+        temperature_column (str): Name of the column containing temperature data.
+        order (int): Order of the Chebyshev polynomial.
+    
+    Returns:
+        tuple: (Chebyshev object for R->T, Chebyshev object for T->R)
+    """
+    log_R = np.log10(df[resistance_column])
+    log_T = np.log10(df[temperature_column])
+    
+    cheb_fit_R_to_T = Chebyshev.fit(log_R, log_T, order)
+    cheb_fit_T_to_R = Chebyshev.fit(log_T, log_R, order)
+    
+    return ChebychevFit(cheb_fit_R_to_T, cheb_fit_T_to_R)
+

quantalyze/transport.py

@@ -0,0 +1,108 @@
+
+
+
+def calculate_resistance(df, voltage, current):
+    """
+    Calculate the electrical resistance using voltage and current.
+
+    Parameters:
+    df (pandas.DataFrame): The dataframe containing the data.
+    voltage (str): The name of the column in the dataframe that contains the voltage values.
+    current (str or float): The name of the column in the dataframe that contains the current values if it's a string,
+                            or a constant current value if it's a float.
+
+    Returns:
+    pandas.Series: A series containing the calculated resistance values.
+    """
+    if isinstance(current, str):
+        resistance = df[voltage] / df[current]
+    else:
+        resistance = df[voltage] / current
+    return resistance
+ 
+
+def calculate_resistivity(df, length=None, width=None, thickness=None, resistance=None, voltage=None, current=None, geometric_factor=None):
+    """
+    Calculate the electrical resistivity using either resistance or voltage and current, along with length, width, and thickness,
+    or a provided geometric factor.
+    
+    Parameters:
+    df (pandas.DataFrame): The dataframe containing the data.
+    resistance (str, optional): The name of the column in the dataframe that contains the resistance values.
+    voltage (str, optional): The name of the column in the dataframe that contains the voltage values.
+    current (str or float, optional): The name of the column in the dataframe that contains the current values if it's a string,
+                                      or a constant current value if it's a float.
+    length (float, optional): The length of the material.
+    width (float, optional): The width of the material.
+    thickness (float, optional): The thickness of the material.
+    geometric_factor (float, optional): The pre-calculated geometric factor (width * thickness / length).
+    
+    Returns:
+    pandas.Series: A series containing the calculated resistivity values.
+    """
+    if resistance is None:
+        if voltage is not None and current is not None:
+            resistance = calculate_resistance(df, voltage, current)
+        else:
+            raise ValueError("Either resistance or both voltage and current must be provided.")
+    else:
+        resistance = df[resistance]
+    
+    if geometric_factor is None:
+        if length is not None and width is not None and thickness is not None:
+            geometric_factor = (width * thickness) / length
+        else:
+            raise ValueError("Either geometric_factor or all of length, width, and thickness must be provided.")
+    
+    resistivity = resistance * geometric_factor
+    return resistivity
+
+
+def calculate_hall_resistance(df, hall_voltage, current):
+    """
+    Calculate the Hall resistance using the Hall voltage and current.
+
+    Parameters:
+    df (pandas.DataFrame): The dataframe containing the data.
+    hall_voltage (str): The name of the column in the dataframe that contains the Hall voltage values.
+    current (str or float): The name of the column in the dataframe that contains the current values if it's a string,
+                            or a constant current value if it's a float.
+
+    Returns:
+    pandas.Series: A series containing the calculated Hall resistance values.
+    """
+    if isinstance(current, str):
+        hall_resistance = df[hall_voltage] / df[current]
+    else:
+        hall_resistance = df[hall_voltage] / current
+    return hall_resistance
+
+
+def calculate_hall_resistivity(df, hall_resistance=None, hall_voltage=None, current=None, thickness=None):
+    """
+    Calculate the Hall resistivity using either Hall resistance or Hall voltage and current, along with thickness.
+
+    Parameters:
+    df (pandas.DataFrame): The dataframe containing the data.
+    hall_resistance (str, optional): The name of the column in the dataframe that contains the Hall resistance values.
+    hall_voltage (str, optional): The name of the column in the dataframe that contains the Hall voltage values.
+    current (str or float, optional): The name of the column in the dataframe that contains the current values if it's a string,
+                                      or a constant current value if it's a float.
+    thickness (float, optional): The thickness of the material.
+
+    Returns:
+    pandas.Series: A series containing the calculated Hall resistivity values.
+    """
+    if hall_resistance is None:
+        if hall_voltage is not None and current is not None:
+            hall_resistance = calculate_hall_resistance(df, hall_voltage, current)
+        else:
+            raise ValueError("Either hall_resistance or both hall_voltage and current must be provided.")
+    else:
+        hall_resistance = df[hall_resistance]
+    
+    if thickness is None:
+        raise ValueError("Thickness must be provided.")
+    
+    hall_resistivity = hall_resistance * thickness
+    return hall_resistivity

quantalyze-0.1.0.dist-info/METADATA

@@ -0,0 +1,15 @@
+Metadata-Version: 2.4
+Name: quantalyze
+Version: 0.1.0
+Summary: Add your description here
+Requires-Python: >=3.9
+Requires-Dist: matplotlib>=3.9.4
+Requires-Dist: numpy>=2.0.2
+Requires-Dist: pandas>=2.2.3
+Requires-Dist: pytest>=8.3.5
+Requires-Dist: scipy>=1.13.1
+Description-Content-Type: text/markdown
+
+# Quantalyze
+
+Utilities for analyzing data.

quantalyze-0.1.0.dist-info/RECORD

@@ -0,0 +1,14 @@
+quantalyze/__init__.py,sha256=3USGRwzlSkskP6c7CcsBI98x8kxmg4awtE9__sPpvFU,117
+quantalyze/plotting.py,sha256=SlimI-IoUyZaUiFQB64GsICiR1fCgFLm9OTYF9Em1C4,1221
+quantalyze/thermometry.py,sha256=O3-f4o98dgDE4A8pbYgYz-IKaGYRfjWeZdjUA-hEzlw,1971
+quantalyze/transport.py,sha256=5zTAhjQnCeygFhh5Sl2tW6r3asB2PdeQqOfwvGM1x_c,4978
+quantalyze/core/__init__.py,sha256=-J7Z3wnRyO8V8v05Nis0fCG2S9wF2c-YXT14ex52mTo,234
+quantalyze/core/differentiation.py,sha256=XtOQaTwZoXl0jiKfq3cqR44q_daYsh03w6r-eolGTNg,2591
+quantalyze/core/fft.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+quantalyze/core/fitting.py,sha256=7iVmukOzaA8WhQ2UOqSZdAtWO9-ntTLZsNavoX-Sr0g,3348
+quantalyze/core/interpolation.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+quantalyze/core/smoothing.py,sha256=0Z0Pd5S0FyhmysrHmYnXj_UJI2Fj5HnHnCeJCI5GLuE,2781
+quantalyze/core/symmetrize.py,sha256=KRXwAkkBrULV1rTyYVgPFAhbdYD4wZFaM2GSlaKDFt0,2488
+quantalyze-0.1.0.dist-info/METADATA,sha256=ZLx6GGXh9UQd6YPVD8XFIIHDYsvL3C0YQ81DiXxn968,344
+quantalyze-0.1.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+quantalyze-0.1.0.dist-info/RECORD,,

quantalyze-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.27.0
+Root-Is-Purelib: true
+Tag: py3-none-any