PPMS_Toolkit 0.2.1__py3-none-any.whl

ppms_toolkit/__init__.py

@@ -0,0 +1 @@
+# PPMS_Toolkit/__init__.py

ppms_toolkit/measurement/__init__.py

@@ -0,0 +1,17 @@
+# __init__.py
+
+# ruff: noqa
+# pylint: disable=unused-import
+
+from .base import Measurement
+from .heat_capacity import HeatCapacityMeasurement
+from .vsm import VSMMeasurement
+from .utils import merge_by_temp_diff, debye_model, debye_model_extended,einstein_model
+
+# When import with "from measurement import *",
+# * includes the following thing.
+# __all__ = ["Measurement",
+#            "HeatCapacityMeasurement",
+#            "merge_by_temp_diff",
+#            "debye_model",
+#            "debye_model_extended"]

ppms_toolkit/measurement/base.py

@@ -0,0 +1,74 @@
+'''
+This Module defined the abstracted base class [Measurement]. It serves as
+a backbone for its desecendent class, [HeatCapacityMeasurment],
+[Magnetism Measurement], etc.
+'''
+from abc import ABC, abstractmethod
+from typing import TYPE_CHECKING, Optional
+if TYPE_CHECKING:
+    from ppms_toolkit.sample import Sample  # Avoid Cylic-Import
+
+import pandas as pd
+
+
+class Measurement(ABC):
+    def __init__(self, 
+                 sample: "Sample", 
+                 comment: str = '',
+                 metadata: Optional[dict] = None,
+                 filepath: str | None = None, 
+                 raw_dataframe: pd.DataFrame | None = None,  # 允许直接传入
+                 processed_dataframe: pd.DataFrame | None = None):
+        self.filepath = filepath
+        self.sample = sample
+        self.comment = comment
+        self.metadata = metadata or {}
+
+        # 如果传入了 DataFrame，直接使用
+        if processed_dataframe is not None and raw_dataframe is not None:
+            self.raw_dataframe = raw_dataframe
+            self.dataframe = processed_dataframe
+        # 否则从文件加载
+        elif filepath is not None:
+            self.raw_dataframe, self.dataframe = self.load_data()
+        else:
+            raise ValueError("Must provide either 'filepath' or 'raw_dataframe'")
+
+    @property
+    def sample_name(self):
+        return self.sample.name if self.sample else "Unknown Sample"
+
+    def load_data(self):
+        assert self.filepath is not None
+        try:
+            with open(file=self.filepath, encoding='utf-8', errors="strict") as f:
+                content = f.readlines()
+        except UnicodeDecodeError:
+            with open(file=self.filepath, encoding='iso-8859-1') as f:
+                content = f.readlines()
+
+        # Data start after the Line [Data].
+        data_start_line = content.index('[Data]\n') + 1
+        data = content[data_start_line:]
+        splitted_data = [line.split(',') for line in data]
+
+        raw_df = pd.DataFrame(data=splitted_data[1:], columns=splitted_data[0])
+
+        df = self.process_data(raw_df, self.filepath)
+
+        return raw_df, df
+
+    '''
+    # Depracated function , Now Filepath is optional and unique check is depend on the sqlite
+
+    def __eq__(self, other):
+        from pathlib import Path
+        if not isinstance(other, Measurement):
+            return False
+        return Path(self.filepath).resolve() == Path(other.filepath).resolve()
+    '''
+
+    @abstractmethod
+    def process_data(self, raw_df, filepath) -> pd.DataFrame:
+        '''This Method have to be defined in the desendent class.'''
+        pass

ppms_toolkit/measurement/heat_capacity.py

@@ -0,0 +1,166 @@
+'''
+This module define the [HeatCapacityMeasurment] instance,
+which is a descendant of [Measurement].
+
+Heat Capcity's experiment condition:
+[field_strength]
+'''
+
+from .base import Measurement
+from typing import TYPE_CHECKING, Optional
+if TYPE_CHECKING:
+    from ppms_toolkit.sample import Sample  # Avoid Cylic-Import
+
+
+import matplotlib.pyplot as plt
+import numpy as np
+import pandas as pd
+
+
+from .utils import merge_by_temp_diff, debye_model_extended, debye_model
+
+plt.rcParams['axes.grid'] = True  # Would like every plot to have grid
+
+
+class HeatCapacityMeasurement(Measurement):
+    def __init__(self,
+                 filepath: str,
+                 sample: "Sample",
+                 sample_mass: float = 1,
+                 field_strength: float = 0,
+                 comment: str = "",
+                 metadata=None
+                 ):
+        self.field_strength = field_strength
+        self.sample_mass = sample_mass
+        super().__init__(
+            filepath=filepath, 
+            sample=sample,
+            comment= comment,
+            metadata= metadata)
+        if sample:  # If sample is inputted, add this mesurement in the sample.
+            sample.add_measurement(self)
+
+    def __repr__(self):
+        return (f'HC exp, {self.sample_name} '
+                f'with {self.field_strength} '
+                f'Oe {self.comment}'
+                f'T-range {self.t_range}'
+                )
+    
+    def to_dict(self):
+        '''Return a dict for representation purpose'''
+
+        return {
+                "External field": getattr(self, "field_strength", None),
+                "Temp Range":     getattr(self, "t_range", None),
+                "instance": self
+        }
+
+    def process_data(self, raw_df, filepath) -> pd.DataFrame:
+        import re
+        # Remove the comment lines.
+        df = raw_df[raw_df['Comment ()'] == '']
+        
+        # Remove the error Code, fix the corrupted error code.
+        # Keep columns as an Index so we can access the `.str` accessor.
+        df.columns = df.columns.astype(str).str.replace('�', 'µ', regex=False)
+        # Convert all str into Floats
+
+        pattern = (     r'Time Stamp \(|'
+                r'Samp HC \(|'
+                r'Samp HC\/Temp \(|'
+                r'Sample Temp \(|'
+                r'Samp HC Err \(|'
+                r'Field \('
+                )
+
+
+        # Use Index.str.contains directly on the columns Index.
+        keys_to_keep = df.columns[df.columns.str.contains(pattern)]
+        df = df[keys_to_keep]
+        df = df.apply(pd.to_numeric, errors='coerce')
+        
+        df = merge_by_temp_diff(df=df,
+                                temp_col='Sample Temp (Kelvin)',
+                                tol=0.01)
+        
+        # Divide the Moment by sample_mass, if there's none 1 sample mass.
+        pattern = re.compile(r'^(Samp HC \(|Samp HC/Temp \(|Samp HC Err \()')
+        for col in df.columns:
+            if pattern.match(col):
+                df[col] = df[col] / self.sample_mass
+        
+        # Get the range of T
+        minimum = df['Sample Temp (Kelvin)'].min()
+        maximum = df['Sample Temp (Kelvin)'].max()
+        self.t_range = f'{minimum:.1f} ~ {maximum:.1f}'
+
+        return df
+
+    def plot(self, ax=None):
+        '''Create a standard plot of Heat Capacity Measurement'''
+        if ax is None:
+            fig, ax = plt.subplots(figsize=(6, 4))
+
+        cols = self.dataframe.columns
+        sample_T = cols[cols.str.contains(r'Sample Temp \(')][0]
+        sample_HC = cols[cols.str.contains(r'Samp HC \(')][0]
+     
+        # The first graph is a Samp HC v.s. T
+        ax.plot(self.dataframe[sample_T],
+                self.dataframe[sample_HC],
+                label=f'{self.field_strength} Oe',)
+        ax.set_xlabel(sample_T)
+        ax.set_ylabel(sample_HC)
+        ax.legend()
+
+        return ax
+
+    def background_subtraction(self,
+                               mask_func=lambda T: T > 0,
+                               model=debye_model, bounds=None, p0=None):
+        from scipy.optimize import curve_fit
+
+        T = self.dataframe['Sample Temp (Kelvin)']
+        HC = self.dataframe['Samp HC (µJ/K)']
+
+        mask = mask_func(T)
+        T_fit = T[mask]
+        HC_fit = HC[mask]
+
+        kwargs = {}
+        if bounds is not None:
+            kwargs['bounds'] = bounds
+        if p0 is not None:
+            kwargs['p0'] = p0
+
+        params, _ = curve_fit(model, T_fit, HC_fit, **kwargs)
+        phonon_background = model(T, *params)
+        subtracted = HC - phonon_background
+
+        fig, ax = plt.subplots()
+
+        ax.plot(T, HC, label='Heat Capacity')
+        ax.plot(T, phonon_background, label='Phonon Background')
+        ax.plot(T, subtracted, label='Subtracted.')
+        plt.title(f'{self.sample_name} Phonon Background Subtraction')
+        plt.legend()
+
+        return fig, ax, params, T, subtracted
+
+    def background_subtraction_debye(
+            self, mask_func=lambda T: (T > 5) & (T < 300),
+            bounds=([1, 0.0001],
+                    [500, 100])
+                    ):
+        return self.background_subtraction(
+            mask_func, debye_model, bounds)
+
+    def background_subtraction_debye_extended(
+            self, mask_func=lambda T: (T > 5) & (T < 300),
+            bounds=([1, 0.0001, -np.inf, -np.inf],
+                    [500, 100, np.inf, np.inf])
+                    ):
+        return self.background_subtraction(
+            mask_func, debye_model_extended, bounds)

ppms_toolkit/measurement/utils.py

@@ -0,0 +1,101 @@
+'''
+This module provide some useful util functions
+that might be used in general purpose
+'''
+import pandas as pd
+import numpy as np
+from scipy.integrate import quad
+
+def merge_by_temp_diff(df,
+                       temp_col='Sample Temp (Kelvin)',
+                       tol=0.01):
+
+    df_sorted = df.sort_values(by=temp_col).reset_index(drop=True)
+
+    temp_diffs = df_sorted[temp_col].diff().abs()
+
+    group_ids = (temp_diffs > tol).cumsum()
+
+    merged_df = df_sorted.groupby(group_ids).mean(numeric_only=True)
+
+    merged_df = merged_df.reset_index(drop=True)
+
+    return merged_df
+
+    '''
+        df_sorted = df.sort_values(by=temp_col).reset_index(drop=True)
+
+    groups = []
+    current_group = [0]
+
+    for i in range(1, len(df_sorted)):
+        t_curr = df_sorted.loc[i, temp_col]
+        t_prev = df_sorted.loc[current_group[-1], temp_col]
+        if abs(t_curr - t_prev) < tol:
+            current_group.append(i)
+        else:
+            groups.append(current_group)
+            current_group = [i]
+    groups.append(current_group)
+
+    merged_rows = []
+    for group in groups:
+        averaged = df_sorted.loc[group].mean(numeric_only=True)
+        merged_rows.append(averaged)
+    
+    '''
+
+
+# Debye Model for Phonon
+R = 8.314  # J/(mol·K)
+
+
+def debye_integral(x):
+    x = np.clip(x, 1e-10, 500)
+    ex = np.exp(x)
+    denom = (ex - 1)
+    return np.where(denom == 0, 0, x**4 * ex / denom**2)
+
+
+def debye_model(T, theta_D, scale=1.0):
+    T = np.array(T)
+    C = []
+
+    for t in T:
+        if t == 0:
+            C.append(0.0)
+        else:
+            x_max = min(500, theta_D / t)
+            integral, _ = quad(debye_integral, 0, x_max)
+            c = 9 * R * (t / theta_D)**3 * integral * scale
+            C.append(c)
+
+    return np.array(C)
+
+
+def einstein_model(T, theta_E, scale=1.0):
+    x = theta_E / T
+    return 3 * R * (x**2) * np.exp(x) / (np.exp(x) - 1)**2 * scale
+
+
+def debye_model_extended(T, theta_D, B, D, scale=1.0):
+    T = np.array(T)
+    C = []
+
+    for t in T:
+        if t == 0:
+            C.append(0.0)
+        else:
+            integral, _ = quad(debye_integral, 0, theta_D / t)
+            c = 9 * R * (t / theta_D)**3 * integral * scale
+            C.append(c)
+
+    return np.array(C) + B * T + D
+
+
+def gauss_with_step(x, A, x0, sigma, cL, cR):
+    step = np.where(x < x0, cL, cR)
+    return A * np.exp(-((x - x0)**2) / (2 * sigma**2)) + step
+
+def gauss(x, A, x0, sigma, c):
+    return A * np.exp(-(x-x0)**2/(2*sigma**2)) + c

ppms_toolkit/measurement/vsm.py

@@ -0,0 +1,328 @@
+'''
+This module define the [VSM_Measurement] instance,
+which is a descendant of [Measurement].
+
+VSM experiment condition:
+[Sample Orientation]
+'''
+
+from .base import Measurement
+from typing import TYPE_CHECKING
+
+import numpy as np
+import pandas as pd
+import matplotlib.pyplot as plt
+from scipy.signal import savgol_filter, detrend
+from scipy.optimize import curve_fit
+from scipy.interpolate import interp1d #,PchipInterpolator,UnivariateSpline
+
+from .utils import gauss
+
+if TYPE_CHECKING:
+    from ppms_toolkit.sample import Sample  # Avoid Cylic-Import
+
+
+class VSMMeasurement(Measurement):
+    def __init__(self,
+                    mode: str,
+                    sample: 'Sample',
+                    filepath: str | None = None,
+                    raw_dataframe: pd.DataFrame | None = None,  # 新增
+                    processed_dataframe: pd.DataFrame | None = None,  # 新增
+                    comment: str = "",
+                    metadata: dict | None =None
+                 ):
+        self.mode = mode
+        self.const_temp = None
+        self.const_field = None
+        self.condition = None
+        super().__init__(
+            filepath=filepath, 
+            sample=sample, 
+            comment=comment, 
+            metadata=metadata,
+            raw_dataframe=raw_dataframe,
+            processed_dataframe=processed_dataframe)
+        
+        if metadata:
+            self.const_field = metadata.get('const_field')
+            self.const_temp = metadata.get('const_temp') or metadata.get('const_temperature')
+            self.condition = metadata.get('condition') 
+
+        sample.add_measurement(self)
+
+    @property
+    def mode(self):
+        return self._mode
+
+    @mode.setter
+    def mode(self, value):
+        if value not in ("MH", "MT"):
+            raise ValueError("Mode can only be 'MH' or 'MT'")
+        self._mode = value
+
+    def to_dict(self):
+        '''Return a dict for representation purpose'''
+        return {
+                "mode":      getattr(self, "mode", None),
+                #"orientation":getattr(self, "sample_orientation", None),
+                "const temp": getattr(self, "const_temp", None),
+                "const field": getattr(self, "const_field", None),
+                "instance": self
+        }
+    
+    def process_data(self, raw_df, filepath) -> pd.DataFrame:      
+        import re
+
+        pattern = (     
+                r'^Temperature \(|'
+                r'Magnetic Field \(|'
+                r'Moment \(|'
+                r'M. Std. Err. \('
+                )
+     
+        cols = raw_df.columns
+        keys_to_keep = cols[cols.str.contains(pattern)]
+        df = raw_df[keys_to_keep].apply(pd.to_numeric, errors='coerce')
+
+
+        # Divide the Moment by, if there's none 1 sample mass.
+        for col in df.columns:
+            if re.match(r'Moment',col):
+                df[col] = df[col] / self.sample.mass
+
+        if self.mode == 'MT':
+            self.const_field = np.average(df.filter(regex='Magnetic Field')).round().astype(int)
+            for col in df.columns:
+                if re.match(r'Moment',col):
+                    df['chi'] = df[col] / self.const_field
+            if re.search(r'ZFC', filepath):
+                self.condition = 'ZFC'
+            elif re.search(r'FC', filepath):
+                self.condition = 'FC'
+            else:
+                self.condition = 'Unknown Condition'
+
+        else:
+            self.const_temp = np.average(df.filter(regex='^Temperature')).round(1)
+
+        return df
+    
+    
+    def __repr__(self):
+        if self.mode == 'MT':
+            return (f'{self.mode} on {self.sample_name} '
+                    f'with {self.sample.orientation or "Unknown"} orientation '
+                    f'at {self.const_field}Oe')
+        else:
+            return (f'{self.mode} on {self.sample_name} '
+                    f'with {self.sample.orientation or "Unknown"} orientation '
+                    f'at {self.const_temp}K')
+        
+    def plot(self, mid=None, ax=None, susceptibility=True, legend: str|list = 'Exp Setting' ):
+
+        if ax is None:
+            fig, ax = plt.subplots()
+
+        label: str|None = None
+        if legend == 'Exp Setting':
+            if self.mode == 'MH':
+                label = f'{mid if mid else ""} {self.const_temp:.0f}K' 
+            elif self.mode == "MT":
+                label = f'{self.const_field}Oe {self.condition} {self.sample.orientation or "Unknown Ori"} {mid if mid else ""}' 
+        elif legend == 'Sample Name':
+            label = f'{self.sample.name}'
+        elif type(legend) is list:
+            label = " ".join(str(getattr(self, l)) for l in legend)
+        else:
+            raise ValueError("Legend Mode is not set")
+
+
+        df = self.dataframe
+
+        regex = '^Moment'
+        ax.set_ylabel('Moment (emu / gram)')
+        if self.mode == 'MT':
+            if susceptibility:
+                regex = 'chi'
+                ax.set_ylabel('Susceptibility (emu)')
+            ax.plot(df.filter(regex='^Temperature'), df.filter(regex=regex).squeeze(), label = label)
+            ax.set_xlabel('Temperature(K)')
+        elif self.mode == 'MH':
+            ax.plot(df.filter(regex='Magnetic Field'), df.filter(regex=regex).squeeze(), label = label)
+            ax.set_xlabel('Magnetic Field(Oe)')
+        else:
+            print('Ah oh, something went wrong. Check if measurement.mode is "MH" or "MT".')
+        
+        #ax.set_ylabel('Susceptibility (emu)')
+        ax.set_title(f'{self.sample.name} {self.mode} {self.sample.orientation if self.sample.orientation else ""}')
+        ax.legend()
+
+        return ax
+
+
+    def fit_MH(self, fit_window = [0,70000], window_length=101, p0=None):
+        """
+        from M(H) curve, do dM/dH gussian fit, to extract:
+        - x0_fit: Peak Position (Oe)
+        - FWHM : Full Width Half Maximum (Oe)
+        also return fig, ax
+        """
+
+        fig, ax = plt.subplots(1,2, figsize=(16,5))
+
+        df = self.dataframe
+
+        field_col = "Magnetic Field (Oe)"
+        moment_col = "Moment (emu)"
+
+        mask_field = (df[field_col] > fit_window[0]) & (df[field_col] < fit_window[1])
+        this_df = df.loc[mask_field].copy()
+
+        if this_df.empty:
+            raise ValueError("fit_MH: No datapoint in desired fit_window")
+
+        # Transform into Numpy Array
+        ExtField = this_df[field_col].to_numpy()
+        Moment   = this_df[moment_col].to_numpy()
+
+        dMdH = np.gradient(Moment, ExtField)
+
+        dMdH_detrended = detrend(dMdH)
+        base_y = dMdH - dMdH_detrended
+
+        if window_length >= len(dMdH_detrended):
+            # 选一个最大可能的奇数窗
+            window_length = max(3, len(dMdH_detrended) // 2 * 2 + 1)
+        dMdH_detrended_filtered = savgol_filter(dMdH_detrended, window_length, polyorder=3)
+
+        mask = (dMdH > 0)
+        x_fit = ExtField[mask]
+        y_fit = dMdH_detrended_filtered[mask]
+
+        # 3) 给出初始猜测 p0
+        if p0 is None:
+            A0     = y_fit.max() - y_fit.min()    # 峰高
+            max_idx = int(np.argmax(y_fit))
+            x00    = float(x_fit[max_idx])      # 峰位
+            sigma0 = (x_fit.max() - x_fit.min())/6  # 大致半宽
+            c0     = y_fit.min()                   # 底线
+            p0 = [A0, x00, sigma0, c0]
+
+        # 4) 拟合
+        popt, pcov = curve_fit(gauss, x_fit, y_fit, p0=p0)
+        A_fit, x0_fit, sigma_fit, c_fit = popt
+        sigma_fit = abs(sigma_fit)
+        FWHM = 2 * np.sqrt(2 * np.log(2)) * sigma_fit
+
+        ax[0].scatter(ExtField, dMdH_detrended_filtered, s=1, label= 'Detrended Filtered Data')
+        ax[0].plot(ExtField, gauss(ExtField, *popt), '-', lw=2, label='Guassian fit',color='g')
+        ax[0].axvline(x0_fit, color='r', ls='--', label=f'Peak @ {x0_fit:.0f} Oe, FWHM = {FWHM}')
+        ax[0].legend()
+        
+        ax[1].scatter(ExtField, dMdH, s=1, label = 'OG Data')
+        ax[1].plot(ExtField, gauss(ExtField, *popt)+base_y, '-', lw=2, label='Guassian fit',color='r')
+        ax[1].legend()
+        
+        fig.suptitle(f'dMdH, T = {self.const_temp}')
+
+        return fig, ax, x0_fit, FWHM 
+        
+
+
+    def fit_MT(self, 
+               fit_func, 
+               fit_window:list, 
+               p0=None,
+               detrended:bool = True,
+               smooth_window:int = 101,
+               deriv_smooth_window:int = 31
+               ):
+
+        field = self.const_field
+        this_df = self.dataframe
+        
+        chi = this_df['chi']
+        Temp = this_df['Temperature (K)']
+
+        # --- 1. 等间距插值 & 平滑 χ(T) -----------------------------------
+        f_interp = interp1d(
+            Temp,
+            chi,
+            kind="linear",
+            bounds_error=False,
+            fill_value="extrapolate")# type: ignore[arg-type]
+
+        # 生成等间距 T_new
+        T_new = np.linspace(np.min(Temp), np.max(Temp), 2000)
+        chi_resampled = f_interp(T_new)
+
+        # 窗口必须是奇数且 < 数据长度
+        smooth_window = min(smooth_window, len(T_new) // 2 * 2 + 1)
+        chi_smooth = savgol_filter(chi_resampled, window_length=smooth_window, polyorder=3)
+
+        # Take gradient
+        dchidT = np.gradient(chi_smooth, T_new)
+
+        mask = np.isfinite(dchidT) 
+        dchidT_clean = dchidT[mask]
+        T_new_clean = T_new[mask]
+
+        # --- 3. 去趋势 & 再平滑 -------------------------------------------
+        if detrended:
+            dchidT_trend_removed = detrend(dchidT_clean)
+        else:
+            dchidT_trend_removed = dchidT_clean.copy()
+
+        base_y = dchidT_clean - dchidT_trend_removed
+        deriv_smooth_window = min(deriv_smooth_window,
+                              len(dchidT_trend_removed) // 2 * 2 + 1)
+        dchidT_detrended_filtered = savgol_filter(dchidT_trend_removed, deriv_smooth_window, 3)
+
+        
+        left, right = fit_window
+        mask = (T_new_clean > left) & (T_new_clean<right)
+        x_fit = T_new_clean[mask]
+        y_fit = dchidT_detrended_filtered[mask]
+
+            # --- 5. 初始猜测 p0（如果未给） -----------------------------------
+        if p0 is None:
+            A0 = float(y_fit.max() - y_fit.min())
+            # 粗略峰位：拟合区内最大值
+            x00 = float(x_fit[np.argmax(y_fit)])
+            sigma0 = float((x_fit.max() - x_fit.min()) / 6)
+            c0 = float(y_fit.min())
+            p0 = [A0, x00, sigma0, c0]
+
+        # 4) 拟合
+        popt, pcov = curve_fit(fit_func, x_fit, y_fit, p0=p0)
+
+        A_fit, x0_fit, sigma_fit, c_fit = popt
+
+        FWHM = 2 * np.sqrt(2 * np.log(2)) * sigma_fit
+
+        # 5) 作图验证
+        fig, ax = plt.subplots(1,2,figsize=(12,5))
+
+        ax[0].plot(T_new_clean, dchidT_detrended_filtered, '.', ms=3, alpha=0.5, label='data')
+        ax[0].plot(x_fit, y_fit, '.', ms=5, label='fit region')
+        ax[0].plot(T_new_clean, fit_func(T_new_clean, *popt), '-', lw=2, label='Guassian fit')
+        ax[0].axvline(x0_fit, color='r', ls='--', label=f'Peak @ {x0_fit:.2f} T, FWHM = {FWHM:.3f}')
+        ax[0].set_title(f'Field = {field} Oe')
+        ax[0].set_xlabel('Temperature(K)')
+        ax[0].set_ylabel('dChidT (emu/K)')
+        ax[0].legend()
+
+        ax[1].scatter(T_new_clean, dchidT_clean,s=1, label='original')
+        ax[1].plot(T_new_clean, base_y, label='linear background')
+        ax[1].scatter(T_new_clean,dchidT_trend_removed, label='Detrended',s=1)
+        ax[1].scatter(T_new_clean,dchidT_detrended_filtered, label='Detrended+Filtered',s=1)
+        ax[1].set_xlabel('Temperature (K)')
+        ax[1].set_ylabel('dchi/dT (emu/K)')
+        ax[1].legend()
+
+        plt.grid(True, linestyle='--', alpha=0.6, which='major') 
+
+        return fig, ax, x0_fit, FWHM
+
+    

ppms_toolkit/sample.py

@@ -0,0 +1,347 @@
+'''
+
+'''
+
+import pickle
+import os
+from datetime import date
+from multiprocessing import Pool, set_start_method
+
+import pandas as pd
+import matplotlib.pyplot as plt
+
+from .measurement import Measurement,VSMMeasurement,HeatCapacityMeasurement
+
+
+class Sample:
+    '''
+    This modules defined each sample, their properties
+    and their supported functions.
+
+    The Samples should contains serveal Measurement and could
+    be save into a .pickel file and reload some time again.
+
+
+    Parameters
+    ----------
+    name : str
+        Name of the sample.
+    id   : float, optional
+        Assign a unique id to the sample.
+    orientation : str
+        either "In Plane" or "Out of Plane"
+    mass : float, optional
+        Mass of the sample, unit is mg.
+    make_date: str
+        make date of the sample, in "%Y-%m-%d" format.
+
+    Attributes
+    ----------
+    measurements: list
+        a list of measurements assigned to this sample.
+     All the parameters.
+    '''
+    def __init__(self, name: str,
+                 id: float | None = None,
+                 orientation: str | None = None,
+                 mass: float | None = None,
+                 make_date: str | None = None):
+        self.name = name
+        self.orientation = orientation
+        self.id = id
+        self.mass = mass  # milligram
+        self.make_date = \
+            date.fromisoformat(make_date) if make_date else None
+        self._measurements = []
+        # in Sample.__init__
+        self.phase_points = pd.DataFrame(columns=["source", "temp", "field", "fwhm"])
+
+
+    @property
+    def measurements(self) -> tuple[pd.DataFrame, pd.DataFrame]:
+        '''Represent the measurement list as dataframes'''
+        df_vsm = self.measurements_vsm
+        df_hc = self.measurements_hc
+        return df_vsm, df_hc
+    
+    # deprecated function
+    # @property
+    # def show_measurements(self):
+    #     df_vsm = self.measurements_vsm
+    #     df_hc = self.measurements_hc
+    #     if df_hc.empty:
+    #         print("There's no HC measurements bind to this sample.")
+    #     else:
+    #         print("#### HeatCapacity Measurements List")
+    #         print(df_hc)
+
+    #     if df_vsm.empty:
+    #         print("There's no VSM measurements bind to this sample.")
+    #     else:
+    #         print("#### VSM Measurements List")
+    #         print(df_vsm)
+        
+    @property
+    def measurements_vsm(self):
+        return self.get_measurements_vsm()
+
+    def get_measurements_vsm(self, mode=None):
+        '''Represent the measurement list as pd.Dataframe'''
+
+        measurements = (
+            m for m in self._measurements
+            if isinstance(m, VSMMeasurement)
+            and (mode is None or m.mode == mode)
+        )
+        df = pd.DataFrame(m.to_dict() for m in measurements)
+
+        if df.empty:
+            return df
+
+        # 决定排序规则
+        sort_key = 'const temp' if mode == 'MH' else 'const field'
+
+        return df.sort_values(sort_key)
+
+    @property
+    def measurements_hc(self):
+        '''Represent the measurement list as pd.Dataframe'''
+        hc_rows = []
+        for m in self._measurements:
+            if isinstance(m, HeatCapacityMeasurement):
+                hc_rows.append(m.to_dict())
+        df_hc =pd.DataFrame(hc_rows)
+        return df_hc
+        
+    def set_make_date(self, make_date: str):
+        self.make_date = date.fromisoformat(make_date)
+
+    def add_measurement(self, m: Measurement):
+        if m not in self._measurements:
+            print(f'{m} (added)')
+            self._measurements.append(m)
+            m.sample = self  # double-linked with the measurement
+        else:
+            print(f'The Measurment [{m}] \n'
+                  f'is already exist in sample [{self}] ')
+
+    def save(self):
+        with open(f'{self.name}'
+                  f'({self.make_date if self.make_date else "Unknown MakeTime"}).pkl', "wb") as f:
+            pickle.dump(self, f)
+
+    @staticmethod
+    def load(filepath):
+        with open(filepath, "rb") as f:
+            return pickle.load(f)
+
+    def _vsm_measurement_reader(self, args):
+
+        path, orientation = args
+        if 'MT' in path:
+            mode =  'MT'
+        elif 'MH' in path:
+            mode =  'MH'
+        else:
+            raise ValueError(f'Mode is not contained in filename of {path}')
+    
+        m=VSMMeasurement(filepath=path, 
+                         sample=self, 
+                         mode=mode)
+
+        return m
+
+
+    def add_vsm_measurements_by_folder(self, folder_path, paralelle=False):
+
+        """
+        bind multiple vsm measurement by folder name
+        """
+        if os.name != "posix":
+            set_start_method("spawn", force=True)
+
+        if 'IP' in folder_path:
+            orientation = "In Plane"
+        elif 'OOP' in folder_path:
+            orientation = "Out of Plane"
+        else:
+            raise ValueError(f'Orientation is not contained in folderpath {folder_path}')
+        
+        arg_list = [(folder_path + p, orientation) for p in os.listdir(folder_path)]
+
+        if paralelle:
+            with Pool() as pool: 
+                measurements = pool.map(self._vsm_measurement_reader, arg_list)
+
+            for m in measurements:
+                self.add_measurement(m)
+        else:
+            for args in arg_list:
+                m = self._vsm_measurement_reader(args)
+                self.add_measurement(m)
+
+
+    def __repr__(self):
+        date = self.make_date if self.make_date else "Unknwon Date"
+        return (f'id: {self.id}, '
+                f'{self.name}, '
+                f'{self.mass}mg, '
+                f'made in {date}.')
+    
+
+    def add_phase_point(self, source, x, y, fwhm):
+        self.phase_points.loc[len(self.phase_points)] = [source, x, y, fwhm]
+
+    def plot_phase_diagram(self,
+                           ax=None,
+                           mh_fwhm_cut=5000,
+                           mt_fwhm_cut=10,
+                           xlim=None,
+                           ylim=None,
+                           title=None,
+                           savepath=None,
+                           dpi=300):
+        """
+        Plot phase diagram using notebook-like style.
+
+        phase_points columns:
+        - source: 'MH' or 'MT'
+        - x, y
+        - fwhm
+        """
+        if ax is None:
+            _, ax = plt.subplots()
+
+        df = self.phase_points.copy()
+        if df.empty:
+            raise ValueError("phase_points is empty")
+
+        df["source"] = df["source"].astype(str).str.upper()
+        df = df[df["source"].isin(["MH", "MT"])]
+
+        for col in ("temp", "field", "fwhm"):
+            df[col] = pd.to_numeric(df[col], errors="coerce")
+        df = df.dropna(subset=["temp", "field", "fwhm"])
+
+        def plot_with_err(sub_df, *, err_axis, color, marker, label):
+            if sub_df.empty:
+                return
+
+            err = sub_df["fwhm"].values / 2.0
+            kwargs = dict(
+                fmt=marker,
+                color=color,
+                ecolor="gray",
+                capsize=5,
+                elinewidth=1.5,
+                alpha=0.8,
+                linestyle="none",
+                label=label,
+            )
+            if err_axis == "y":
+                ax.errorbar(
+                    x=sub_df["temp"].values,
+                    y=sub_df["field"].values,
+                    yerr=err,
+                    **kwargs
+                )
+            else:
+                ax.errorbar(
+                    x=sub_df["temp"].values,
+                    y=sub_df["field"].values,
+                    xerr=err,
+                    **kwargs
+                )
+
+        # MH: x=Temp, y=PeakField, yerr=FWHM/2
+        df_mh = df[df["source"] == "MH"]
+        wide_mh = df_mh["fwhm"] > mh_fwhm_cut
+        narrow_mh = ~wide_mh
+        plot_with_err(
+            df_mh[narrow_mh],
+            err_axis="y",
+            color="tab:green",
+            marker="s",
+            label=f"MH - reliable, width <= {mh_fwhm_cut / 1000:g} kOe",
+        )
+        plot_with_err(
+            df_mh[wide_mh],
+            err_axis="y",
+            color="tab:red",
+            marker="s",
+            label=f"MH - less reliable, width > {mh_fwhm_cut / 1000:g} kOe",
+        )
+
+        # MT: x=PeakTemp, y=Field, xerr=FWHM/2
+        df_mt = df[df["source"] == "MT"]
+        wide_mt = df_mt["fwhm"] > mt_fwhm_cut
+        narrow_mt = ~wide_mt
+        plot_with_err(
+            df_mt[narrow_mt],
+            err_axis="x",
+            color="tab:green",
+            marker="^",
+            label=f"MT - reliable, width <= {mt_fwhm_cut:g} K",
+        )
+        plot_with_err(
+            df_mt[wide_mt],
+            err_axis="x",
+            color="tab:red",
+            marker="^",
+            label=f"MT - less reliable, width > {mt_fwhm_cut:g} K",
+        )
+
+        ax.set_xlabel("Temperature (K)")
+        ax.set_ylabel("Magnetic Field (Oe)")
+        ax.grid(True, linestyle="--", alpha=0.6, which="major")
+        ax.legend()
+
+        if title:
+            ax.set_title(title)
+        else:
+            ax.set_title(f"{self.name} {self.orientation} Phase Diagram")
+        if xlim:
+            ax.set_xlim(xlim)
+        if ylim:
+            ax.set_ylim(ylim)
+
+        plt.tight_layout()
+        if savepath:
+            plt.savefig(savepath, dpi=dpi)
+
+        return ax
+
+
+    ## This function is not quite useful.
+    def plot_vsm(self, mode, ax=None, field=None, temperature=None, condition=None, susceptibility=True, legend: str|list='Exp Setting'):
+
+        if not ax:
+            fig ,ax = plt.subplots()
+
+        df = self.measurements_vsm
+        if mode=='MH':
+            df = self.measurements_vsm.sort_values('const temp')
+
+        if mode:
+            mask_mode = df['mode'] == mode
+        else:
+            mask_mode = True
+        
+        if field:
+            mask_field = df['const field'] == field
+        else:
+            mask_field = True
+        
+        if temperature:
+            mask_temp = df['const temp'] == temperature
+        else:
+            mask_temp = True
+
+
+        df_filtered = df[mask_field & mask_mode & mask_temp]
+        for index, row in df_filtered.iterrows():
+                if condition:
+                    if row['instance'].condition == condition:
+                        row['instance'].plot(ax=ax, susceptibility=susceptibility, legend=legend)
+                else:
+                        row['instance'].plot(ax=ax, susceptibility=susceptibility, legend=legend)

ppms_toolkit-0.2.1.dist-info/METADATA

@@ -0,0 +1,296 @@
+Metadata-Version: 2.4
+Name: PPMS_Toolkit
+Version: 0.2.1
+Summary: Toolkit for PPMS data processing
+Author-email: Yunxiao LIU <yunxiao.liu@tum.de>
+License: MIT License
+        
+        Copyright (c) 2025 Yunxiao Liu
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+License-File: LICENSE
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.9
+Requires-Dist: matplotlib>=3.4.0
+Requires-Dist: numpy>=1.21.0
+Requires-Dist: pandas>=1.3.0
+Requires-Dist: scipy>=1.7.0
+Provides-Extra: gui
+Requires-Dist: pyarrow>=10.0.0; extra == 'gui'
+Requires-Dist: pyside6; extra == 'gui'
+Description-Content-Type: text/markdown
+
+# PPMS Toolkit
+
+> ⚠️ **Development Notice**
+>
+> This project is currently under active development and primarily developed and tested on **macOS**.
+> It is a **pure Python** application built with **Qt (PySide6)**, so it should be *cross-platform* in principle.
+> However, minor GUI display issues may occur on **Windows** or **Linux** systems.
+
+<div align="center">
+
+[![Python](https://img.shields.io/badge/Python-3.9+-blue.svg)](https://www.python.org/downloads/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![PySide6](https://img.shields.io/badge/GUI-PySide6-green.svg)](https://doc.qt.io/qtforpython/)
+
+*A  Python toolkit for PPMS (Physical Property Measurement System) data analysis*
+
+[Features](#-features) • [Installation](#-installation) • [Quick Start](#-quick-start) • [Documentation](#-documentation)
+
+</div>
+
+---
+
+## 📖 Overview
+
+![Easy plot with Measurement List](screenshots/plot_window.png)
+
+**PPMS Toolkit** is a modern, user-friendly application designed for researchers working with Quantum Design's Physical Property Measurement System (PPMS). It provides both a powerful **GUI application** and a flexible **Python library** for:
+
+- 📂 **Data Management**: Import, organize, and manage PPMS `.dat` files with SQLite database
+- 📊 **Interactive Plotting**: Visualize VSM ~~and Heat Capacity measurements~~ with Matplotlib
+- ~~🔬 **Advanced Analysis**: Curie temperature fitting, background subtraction, susceptibility analysis~~
+- 💾 **Efficient Storage**: Parquet-based file format for fast data loading and minimal disk usage
+- 🎨 **Cross-Platform**: Built with PySide6 (Qt6) for cross-platform compatibility
+
+---
+
+## ✨ Features
+
+### 🖥️ GUI Application
+
+- **Sample Management**
+  - Create and edit sample metadata (name, mass, orientation, chemical formula)
+  - Track multiple measurements per sample
+  - Delete samples and associated data files
+
+- **Measurement Management**
+  - Batch import of `.dat` files from PPMS
+  - Support for VSM (Vibrating Sample Magnetometer) measurements:
+    - **MH mode**: Magnetization vs. Field
+    - **MT mode**: Magnetization vs. Temperature
+  - ~~Support for Heat Capacity measurements~~
+  - Automatic deduplication based on file content hash
+
+- **Interactive Plotting**
+  - Plot multiple measurements with customizable legends
+  - Click-to-hide curves for easy comparison
+  - Switch between susceptibility (χ) and moment views
+  - Zoom, pan, and export plots
+
+- **Data Filtering**
+  - Multi-column filtering in measurement tables
+  - Filter by sample, mode, field, temperature, or condition
+
+---
+
+## 🚀 Installation
+
+### Option 1: Conda Environment (Recommended)
+
+```bash
+# Clone the repository
+git clone https://github.com/AlbertRyu/PPMS_ToolKit.git
+cd PPMS_ToolKit
+
+# Create and activate conda environment
+conda env create -f environment.yml
+conda activate ppms_toolkit
+
+# Install the package in development mode
+pip install -e ".[gui]"
+
+# Launch the GUI
+ppms-toolkit
+```
+
+### Option 2: pip + venv
+
+```bash
+# Clone the repository
+git clone https://github.com/AlbertRyu/PPMS_ToolKit.git
+cd PPMS_ToolKit
+
+# Create virtual environment
+python -m venv venv
+source venv/bin/activate  # On Windows: venv\Scripts\activate
+
+# Install with GUI support
+pip install -e ".[gui]"
+
+# Launch the GUI
+ppms-toolkit
+```
+---
+
+## 🎯 Quick Start
+
+### GUI Workflow
+
+1. **Launch Application**
+   ```bash
+   ppms-toolkit
+   ```
+
+2. **Select/Create Project**
+   - Choose an existing project folder or create a new one
+   - All data will be stored in this folder
+
+3. **Add Samples**
+   - Navigate to "Samples" tab
+   - Click "Add Sample" and enter metadata (name, mass, orientation)
+
+4. **Import Measurements**
+   - Go to "Plots" tab
+   - Click "Add Measurement"
+   - Select multiple `.dat` files (batch import supported)
+   - Choose the sample and measurement mode (MH/MT)
+
+   #### 📁 File Naming for MT Mode
+   
+   The toolkit automatically detects measurement conditions from filenames:
+   
+   | Filename Contains | Detected Condition |
+   |-------------------|-------------------|
+   | `ZFC` (case-insensitive) | Zero Field Cooling |
+   | `FC` (case-insensitive) | Field Cooling |
+   | Neither | Unknown Condition |
+   
+   **Examples:**
+   ```bash
+   ✅ sample_ZFC_100Oe.dat  → Condition: ZFC
+   ✅ data_FC.dat           → Condition: FC
+   ⚠️ measurement.dat       → Condition: Unknown
+
+5. **Visualize Data**
+   - Select measurements from the table
+   - Click "Plot" to visualize
+   - Use legend to toggle curves
+   - Toggle χ/Moment view with checkbox
+
+---
+
+## 📊 Supported Measurement Types
+
+### VSM (Vibrating Sample Magnetometer)
+
+| Mode | Description | Analysis Tools |
+|------|-------------|----------------|
+| **MH** | Magnetization vs. Field | ~~`fit_MH()` - Coercivity extraction～～~~ |
+| **MT** | Magnetization vs. Temperature | ~~`fit_MT()` - Curie temperature fitting~~|
+
+---
+
+## 🗂️ Project Structure
+
+```
+PPMS_ToolKit/
+├── src/
+│   ├── ppms_toolkit/              # Core library
+│   │   ├── sample.py              # Sample class
+│   │   └── measurement/
+│   │       ├── base.py            # Base Measurement class
+│   │       ├── vsm.py             # VSM analysis
+│   │       └── heat_capacity.py   # Heat Capacity analysis
+│   │
+│   ├── ppms_toolkit_gui/          # GUI application
+│   │   ├── app.py                 # Entry point
+│   │   ├── main_window.py         # Main window
+│   │   ├── controller/            # MVC controllers
+│   │   ├── widgets/               # Qt widgets
+│   │   └── dialogs/               # Dialog windows
+│   │
+│   └── infrastructure/
+│       └── db/
+│           └── db.py              # SQLite database wrapper
+│
+├── examples/
+│   └── code_example.ipynb         # Jupyter notebook examples
+│
+├── pyproject.toml                 # Project metadata & dependencies
+├── environment.yml                # Conda environment specification
+└── README.md                      # This file
+```
+
+---
+
+## 🔧 Dependencies
+
+### Core Dependencies
+- **numpy** ≥ 1.21 - Numerical computing
+- **pandas** ≥ 1.3 - Data manipulation
+- **scipy** ≥ 1.7 - Scientific computing
+- **matplotlib** ≥ 3.4 - Plotting
+
+### GUI Dependencies (Optional)
+- **PySide6** ≥ 6.4 - Qt6 GUI framework
+- **pyarrow** ≥ 10.0 - Parquet file I/O
+
+### Development Dependencies
+- **ipykernel** - Jupyter notebook support
+- **IPython** - Enhanced interactive shell
+
+---
+
+## 📚 Documentation
+
+### Database Structure
+
+The toolkit uses SQLite for data management with two main tables:
+
+**`samples`**
+- `id`, `name`, `mass`, `chemical`, `orientation`, `created_at`, `notes`
+
+**`measurements`**
+- `id`, `sample_id` (FK), `measurement_type`, `mode`
+- `const_field`, `const_temperature`
+- `original_filepath`, `data_filepath`, `processed_data_filepath`
+- `content_hash` (for deduplication)
+- `extra_parameters` (JSON), `comment`, `created_at`
+---
+
+## 📄 License
+
+This project is licensed under the **MIT License**.
+
+You are free to use, modify, and distribute this software, provided that:
+- You include the original copyright notice and license text in any copies
+- You do not hold the author liable for any damages
+
+See [LICENSE](LICENSE) file for full details.
+
+---
+
+## 🙏 Acknowledgments
+
+- Built with [PySide6](https://doc.qt.io/qtforpython/) (Qt for Python)
+- Data storage powered by [Apache Arrow](https://arrow.apache.org/) (Parquet format)
+- Scientific computing with [NumPy](https://numpy.org/), [SciPy](https://scipy.org/), and [pandas](https://pandas.pydata.org/)
+
+---
+
+<div align="center">
+
+**[⬆ Back to Top](#ppms-toolkit)**
+
+Made with ❤️ for the research community
+
+</div>

ppms_toolkit-0.2.1.dist-info/RECORD

@@ -0,0 +1,12 @@
+ppms_toolkit/__init__.py,sha256=3flGSBZtv-_MCc6sgIaV6NeDZpKZwxEBLx827DFDUjw,27
+ppms_toolkit/sample.py,sha256=1eWdPbTXqo020UBxNUG9lbPd7jzqPuiy9g0BxZCTuFg,10471
+ppms_toolkit/measurement/__init__.py,sha256=Q-bhd43pE2QAhjdvo6SY6e6IUeYkykZA8EnXuk53hWM,512
+ppms_toolkit/measurement/base.py,sha256=IxxRhWz12T79mdWbyHgGlaxtsit1WimNylSLEpxtm6Y,2624
+ppms_toolkit/measurement/heat_capacity.py,sha256=HFE6-O-xZ3BH-mjA5TgWeSP0rxr76l72Vlpf33mHY7c,5481
+ppms_toolkit/measurement/utils.py,sha256=xzrRJJMZe6KQiGI-q45Vq8s7hOwrJRJKQFmrYhxyFKQ,2477
+ppms_toolkit/measurement/vsm.py,sha256=JrHCjbb3io-gFQ9g2G-fTTCzeOgVc5qGP3GOP-RuUbs,11712
+ppms_toolkit-0.2.1.dist-info/METADATA,sha256=EXg3lV9iXmmmArDfC1wPJtKYWFzi0opR76HrxPCZ-_M,9636
+ppms_toolkit-0.2.1.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+ppms_toolkit-0.2.1.dist-info/entry_points.txt,sha256=CN_9LJUB_mHCyNLeVjJdqq0-uxxf4TC5ffg5ujOhQsc,59
+ppms_toolkit-0.2.1.dist-info/licenses/LICENSE,sha256=akBODBkAxof09O6zf-agbJKnBVlFvdfduN9GdHss0Qs,1068
+ppms_toolkit-0.2.1.dist-info/RECORD,,

ppms_toolkit-0.2.1.dist-info/WHEEL

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

ppms_toolkit-0.2.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+ppms-toolkit = ppms_toolkit_gui.app:main

ppms_toolkit-0.2.1.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Yunxiao Liu
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.