sqil-core 0.0.1__py3-none-any.whl → 0.1.0__py3-none-any.whl

sqil_core/utils/_plot.py

@@ -0,0 +1,107 @@
+import numpy as np
+
+from ._const import _PARAM_METADATA
+from ._formatter import format_number
+from ._read import read_json
+
+
+def set_plot_style(plt):
+    """Sets the matplotlib plotting style to a SQIL curated one."""
+    style = {
+        "font.size": 20,
+        "xtick.labelsize": 18,  # X-axis tick labels
+        "ytick.labelsize": 18,  # Y-axis tick labels
+        "lines.linewidth": 2.5,  # Line width
+        "lines.marker": "o",
+        "lines.markersize": 7,  # Marker size
+        "lines.markeredgewidth": 1.5,  # Marker line width
+        "lines.markerfacecolor": "none",
+        "axes.grid": True,
+        "grid.linestyle": "--",
+        "xtick.major.size": 8,
+        "xtick.major.width": 1.5,
+        "ytick.major.size": 8,
+        "ytick.major.width": 1.5,
+        "figure.figsize": (20, 7),
+    }
+    return plt.rcParams.update(style)
+
+
+def reset_plot_style(plt):
+    """Resets the matplotlib plotting style to its default value."""
+    return plt.rcParams.update(plt.rcParamsDefault)
+
+
+def get_x_id_by_plot_dim(exp_id: str, plot_dim: str, sweep_param_id: str | None) -> str:
+    """Returns the param_id of the parameter that should be used as the x-axis."""
+    if exp_id == "CW_onetone" or exp_id == "pulsed_onetone":
+        if plot_dim == "1":
+            return sweep_param_id or "ro_freq"
+        return "ro_freq"
+    elif exp_id == "CW_twotone" or exp_id == "pulsed_twotone":
+        if plot_dim == "1":
+            return sweep_param_id or "qu_freq"
+        return "qu_freq"
+
+
+def build_title(title: str, path: str, params: list[str]) -> str:
+    """Build a plot title that includes the values of given parameters found in
+    the params_dict.json file, e.g. One tone with I = 0.5 mA.
+
+    Parameters
+    ----------
+    title : str
+        Title of the plot to which the parameters will be appended.
+
+    path: str
+        Path to the param_dict.json file.
+
+    params : List[str]
+        List of keys of parameters in the param_dict.json file.
+
+    Returns
+    -------
+    str
+        The original title followed by parameter values.
+    """
+    dic = read_json(f"{path}/param_dict.json")
+    title += " with "
+    for idx, param in enumerate(params):
+        if not (param in _PARAM_METADATA.keys()) or not (param in dic):
+            title += f"{param} = ? & "
+            continue
+        meta = _PARAM_METADATA[param]
+        value = format_number(dic[param], 3, meta["unit"])
+        title += f"${meta['symbol']} =${value} & "
+        if idx % 2 == 0 and idx != 0:
+            title += "\n"
+    return title[0:-3]
+
+
+def guess_plot_dimension(
+    f: np.ndarray, sweep: np.ndarray | list = [], threshold_2D=10
+) -> tuple[list["1", "1.5", "2"] | np.ndarray]:
+    """Guess if the plot should be a 1D line, a collection of 1D lines (1.5D),
+    or a 2D color plot.
+
+    Parameters
+    ----------
+    f : np.ndarray
+        Main variable, usually frequency
+    sweep : Union[np.ndarray, List], optional
+        Sweep variable, by default []
+    threshold_2D : int, optional
+        Threshold of sweeping parameters after which the data is considered, by default 10
+
+    Returns
+    -------
+    Tuple[Union['1', '1.5', '2'], np.ndarray]
+        The plot dimension ('1', '1.5' or '2') and the vector that should be used as the x
+        axis in the plot.
+    """
+    if len(sweep) > threshold_2D:
+        return "2"
+    elif len(f.shape) == 2 and len(sweep.shape) == 1:
+        return "1.5"
+    else:
+        return "1"

sqil_core/utils/{read.py → _read.py}

@@ -1,156 +1,179 @@
-import json
-import os
-
-import h5py
-import numpy as np
-
-from .const import PARAM_METADATA
-
-
-def extract_h5_data(
-    path: str, keys: list[str] | None = None
-) -> dict | tuple[np.ndarray, ...]:
-    """Extract data at the given keys from an HDF5 file. If no keys are
-    given (None) returns the data field of the object.
-
-    Parameters
-    ----------
-    path : str
-        path to the HDF5 file or a folder in which is contained a data.ddh5 file
-    keys : None or List, optional
-        list of keys to extract from file['data'], by default None
-
-    Returns
-    -------
-    Dict or Tuple[np.ndarray, ...]
-        The full data dictionary if keys = None.
-        The tuple with the requested keys otherwise.
-
-    Example
-    -------
-        Extract the data object from the dataset:
-        >>> data = extract_h5_data(path)
-        Extracting only 'amp' and 'phase' from the dataset:
-        >>> amp, phase = extract_h5_data(path, ['amp', 'phase'])
-        Extracting only 'phase':
-        >>> phase, = extract_h5_data(path, ['phase'])
-    """
-    # If the path is to a folder open /data.ddh5
-    if os.path.isdir(path):
-        path = os.path.join(path, "data.ddh5")
-
-    with h5py.File(path, "r") as h5file:
-        data = h5file["data"]
-        data_keys = data.keys()
-        # Extract only the requested keys
-        if bool(keys) and (len(keys) > 0):
-            res = []
-            for key in keys:
-                key = str(key)
-                if (not bool(key)) | (key not in data_keys):
-                    res.append([])
-                    continue
-                res.append(np.array(data[key][:]))
-            return tuple(res)
-        # Extract the whole data dictionary
-        return _h5_to_dict(data)
-
-
-def _h5_to_dict(obj) -> dict:
-    """Convert h5 data into a dictionary"""
-    data_dict = {}
-    for key in obj.keys():
-        item = obj[key]
-        if isinstance(item, h5py.Dataset):
-            data_dict[key] = item[:]
-        elif isinstance(item, h5py.Group):
-            data_dict[key] = extract_h5_data(item)
-    return data_dict
-
-
-def read_json(path: str) -> dict:
-    """Reads a json file and returns the data as a dictionary."""
-    with open(path) as f:
-        dictionary = json.load(f)
-    return dictionary
-
-
-class ParamInfo:
-    """Parameter information for items of param_dict
-
-    Attributes:
-        id (str): param_dict key
-        value (any): the value of the parameter
-        name (str): full name of the parameter (e.g. Readout frequency)
-        symbol (str): symbol of the parameter in Latex notation (e.g. f_{RO})
-        unit (str): base unit of measurement (e.g. Hz)
-        scale (int): the scale that should be generally applied to raw data (e.g. 1e-9 to take raw Hz to GHz)
-    """
-
-    def __init__(self, id, value):
-        self.id = id
-        self.value = value
-        if id in PARAM_METADATA:
-            meta = PARAM_METADATA[id]
-        else:
-            meta = {}
-        self.name = meta["name"] if "name" in meta else id
-        self.symbol = meta["symbol"] if "symbol" in meta else id
-        self.unit = meta["unit"] if "unit" in meta else ""
-        self.scale = meta["scale"] if "scale" in meta else 1
-
-    def to_dict(self):
-        """Convert ParamInfo to a dictionary."""
-        return {
-            "id": self.id,
-            "value": self.value,
-            "name": self.name,
-            "symbol": self.symbol,
-            "unit": self.unit,
-            "scale": self.scale,
-        }
-
-    def __str__(self):
-        """Return a JSON-formatted string of the object."""
-        return json.dumps(self.to_dict())
-
-    def __eq__(self, other):
-        if isinstance(other, ParamInfo):
-            return (self.id == other.id) & (self.value == other.value)
-        if isinstance(other, (int, float, complex, str)):
-            return self.value == other
-        return False
-
-
-ParamDict = dict[str, ParamInfo | dict[str, ParamInfo]]
-
-
-def _enrich_param_dict(param_dict: dict) -> ParamDict:
-    """Add metadata to param_dict entries."""
-    res = {}
-    for key, value in param_dict.items():
-        if isinstance(value, dict):
-            # Recursive step for nested dictionaries
-            res[key] = _enrich_param_dict(value)
-        else:
-            res[key] = ParamInfo(key, value)
-    return res
-
-
-def read_param_dict(path: str) -> ParamDict:
-    """Read param_dict and include additional information for each entry.
-
-    Parameters
-    ----------
-    path : str
-        Path to the file or a folder in which is contained a param_dict.json file
-
-    Returns
-    -------
-    ParamDict
-        The param_dict with additional metadata
-    """
-    # If the path is to a folder open /param_dict.json
-    if os.path.isdir(path):
-        path = os.path.join(path, "param_dict.json")
-    return _enrich_param_dict(read_json(path))
+import json
+import os
+
+import h5py
+import numpy as np
+
+from ._const import _EXP_UNIT_MAP, _PARAM_METADATA
+
+
+def extract_h5_data(
+    path: str, keys: list[str] | None = None
+) -> dict | tuple[np.ndarray, ...]:
+    """Extract data at the given keys from an HDF5 file. If no keys are
+    given (None) returns the data field of the object.
+
+    Parameters
+    ----------
+    path : str
+        path to the HDF5 file or a folder in which is contained a data.ddh5 file
+    keys : None or List, optional
+        list of keys to extract from file['data'], by default None
+
+    Returns
+    -------
+    Dict or Tuple[np.ndarray, ...]
+        The full data dictionary if keys = None.
+        The tuple with the requested keys otherwise.
+
+    Example
+    -------
+        Extract the data object from the dataset:
+        >>> data = extract_h5_data(path)
+        Extracting only 'amp' and 'phase' from the dataset:
+        >>> amp, phase = extract_h5_data(path, ['amp', 'phase'])
+        Extracting only 'phase':
+        >>> phase, = extract_h5_data(path, ['phase'])
+    """
+    # If the path is to a folder open /data.ddh5
+    if os.path.isdir(path):
+        path = os.path.join(path, "data.ddh5")
+
+    with h5py.File(path, "r") as h5file:
+        data = h5file["data"]
+        data_keys = data.keys()
+        # Extract only the requested keys
+        if bool(keys) and (len(keys) > 0):
+            res = []
+            for key in keys:
+                key = str(key)
+                if (not bool(key)) | (key not in data_keys):
+                    res.append([])
+                    continue
+                res.append(np.array(data[key][:]))
+            return tuple(res)
+        # Extract the whole data dictionary
+        return _h5_to_dict(data)
+
+
+def _h5_to_dict(obj) -> dict:
+    """Convert h5 data into a dictionary"""
+    data_dict = {}
+    for key in obj.keys():
+        item = obj[key]
+        if isinstance(item, h5py.Dataset):
+            data_dict[key] = item[:]
+        elif isinstance(item, h5py.Group):
+            data_dict[key] = extract_h5_data(item)
+    return data_dict
+
+
+def read_json(path: str) -> dict:
+    """Reads a json file and returns the data as a dictionary."""
+    with open(path) as f:
+        dictionary = json.load(f)
+    return dictionary
+
+
+class ParamInfo:
+    """Parameter information for items of param_dict
+
+    Attributes:
+        id (str): param_dict key
+        value (any): the value of the parameter
+        name (str): full name of the parameter (e.g. Readout frequency)
+        symbol (str): symbol of the parameter in Latex notation (e.g. f_{RO})
+        unit (str): base unit of measurement (e.g. Hz)
+        scale (int): the scale that should be generally applied to raw data (e.g. 1e-9 to take raw Hz to GHz)
+    """
+
+    def __init__(self, id, value):
+        self.id = id
+        self.value = value
+        if id in _PARAM_METADATA:
+            meta = _PARAM_METADATA[id]
+        else:
+            meta = {}
+        self.name = meta["name"] if "name" in meta else id
+        self.symbol = meta["symbol"] if "symbol" in meta else id
+        self.unit = meta["unit"] if "unit" in meta else ""
+        self.scale = meta["scale"] if "scale" in meta else 1
+
+    def get_name_and_unit(self):
+        res = self.name
+        if self.unit != "":
+            exponent = -(int(f"{self.scale:.0e}".split("e")[1]) // 3) * 3
+            unit = f" [{_EXP_UNIT_MAP[exponent]}{self.unit}]"
+            res += unit
+        return res
+
+    def to_dict(self):
+        """Convert ParamInfo to a dictionary."""
+        return {
+            "id": self.id,
+            "value": self.value,
+            "name": self.name,
+            "symbol": self.symbol,
+            "unit": self.unit,
+            "scale": self.scale,
+        }
+
+    def __str__(self):
+        """Return a JSON-formatted string of the object."""
+        return json.dumps(self.to_dict())
+
+    def __eq__(self, other):
+        if isinstance(other, ParamInfo):
+            return (self.id == other.id) & (self.value == other.value)
+        if isinstance(other, (int, float, complex, str)):
+            return self.value == other
+        return False
+
+    def __bool__(self):
+        return bool(self.id)
+
+
+ParamDict = dict[str, ParamInfo | dict[str, ParamInfo]]
+
+
+def _enrich_param_dict(param_dict: dict) -> ParamDict:
+    """Add metadata to param_dict entries."""
+    res = {}
+    for key, value in param_dict.items():
+        if isinstance(value, dict):
+            # Recursive step for nested dictionaries
+            res[key] = _enrich_param_dict(value)
+        else:
+            res[key] = ParamInfo(key, value)
+    return res
+
+
+def read_param_dict(path: str) -> ParamDict:
+    """Read param_dict and include additional information for each entry.
+
+    Parameters
+    ----------
+    path : str
+        Path to the file or a folder in which is contained a param_dict.json file
+
+    Returns
+    -------
+    ParamDict
+        The param_dict with additional metadata
+    """
+    # If the path is to a folder open /param_dict.json
+    if os.path.isdir(path):
+        path = os.path.join(path, "param_dict.json")
+    return _enrich_param_dict(read_json(path))
+
+
+def get_sweep_param(path: str, exp_id: str):
+    params = read_param_dict(path)
+    sweep_id = params[exp_id]["sweep"].value
+    if sweep_id:
+        return params[sweep_id]
+    return ParamInfo("", "")
+
+
+def get_measurement_id(path):
+    return os.path.basename(path)[0:5]

sqil_core/utils/_utils.py

@@ -0,0 +1,17 @@
+import inspect
+
+
+def _count_function_parameters(func):
+    sig = inspect.signature(func)
+    return len(
+        [
+            param
+            for param in sig.parameters.values()
+            if param.default == inspect.Parameter.empty
+            and param.kind
+            in (
+                inspect.Parameter.POSITIONAL_OR_KEYWORD,
+                inspect.Parameter.POSITIONAL_ONLY,
+            )
+        ]
+    )

{sqil_core-0.0.1.dist-info → sqil_core-0.1.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.3
 Name: sqil-core
-Version: 0.0.1
+Version: 0.1.0
 Summary: The codebase of the SQIL group in EPFL
 Author: Andrea Duina
 Requires-Python: >=3.10,<4.0
@@ -11,10 +11,11 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Requires-Dist: h5py (>=3.12.1,<4.0.0)
 Requires-Dist: isort (==5.9.3)
+Requires-Dist: lmfit (>=1.3.2,<2.0.0)
 Requires-Dist: matplotlib (>=3.9.3,<4.0.0)
-Requires-Dist: numpy (>=2.2.0,<3.0.0)
+Requires-Dist: numpy (>=2.2.3,<3.0.0)
 Requires-Dist: scipy (>=1.14.1,<2.0.0)
-Requires-Dist: seaborn (>=0.13.2,<0.14.0)
+Requires-Dist: tabulate (>=0.9.0,<0.10.0)
 Description-Content-Type: text/markdown
 
 # For users
@@ -38,34 +39,44 @@ path = 'path to your data folder'
 mag, phase, freq = sqil.extract_h5_data(path, ['mag_dB', 'phase', 'ro_freq'])
 ```
 
+## Documentation
+You can find the documentation for this package [here](https://sqil-epfl.github.io/sqil-core/)
+
 # For developers
 
 ## Development
 
 1. **Install poetry if you haven't already**
+
 ```bash
 $ pip install poetry
+$ pip install poetry-plugin-shell
 ```
 
 2. **Install the required packages using poetry**
+
 ```bash
 $ poetry install
 ```
 
 3. **Install the pre-commit hooks**
-If you are on windows you need to install git ([https://git-scm.com/downloads](here)) and add it to your windows PATH.
-After the installation open a new terminal.
+   If you are on windows you need to install git ([https://git-scm.com/downloads](here)) and add it to your windows PATH.
+   After the installation open a new terminal.
+
 ```bash
 $ poetry run pre-commit install
 ```
+
 This will check if your python files are formatted correctly when you try to commit.
 If that's not the case the commit will be canceled and the files will be automatically formatted.
 Then you'll have to add and commit again the new files.
 
 4. **Start the virtual environment**
+
 ```bash
 $ poetry shell
 ```
+
 To exit the virtual environment just use `exit`
 
 #### Test your changes
@@ -91,7 +102,11 @@ $ poetry run build
 $ pip install PATH_TO_SQIL_CORE_FOLDER/dist/SQIL_CORE-VERSION.whl
 ```
 
-If you're using a jupyter notebook remember to restart the kernel
+If you're testing a new function remember to import it in the folder's `__init__.py` file.
+
+
+If you're using a jupyter notebook remember to restart the kernel.
+
 
 ## Build
 
@@ -99,6 +114,16 @@ If you're using a jupyter notebook remember to restart the kernel
 $ poetry run build
 ```
 
+## Publish
+
+To publish version X.X.X run the commands below. This will trigger a GitHub action that deploys to release to PyPi (pip) and GitHub.
+Remember also to change the version number in the `pyproject.toml` file.
+
+```bash
+$ git tag vX.X.X
+$ git push origin vX.X.X
+```
+
 ## Docs
 
 Serve docs

sqil_core-0.1.0.dist-info/RECORD

@@ -0,0 +1,19 @@
+sqil_core/__init__.py,sha256=6CsaaYqp3DKoQLNiOzVix_VeHqUo0Bl3ugpnyBVs19E,193
+sqil_core/config.py,sha256=x7nNdIGJh_2jU6_WuyZ_VjjwkcvibAK-Rc-k0yePUFA,166
+sqil_core/fit/__init__.py,sha256=q_dqH77DsYrpJUWm9sm7T4d2k2uQsLbVLgrQaE25-Fw,320
+sqil_core/fit/_core.py,sha256=izbn9Lh_5Gk3ywc9GXKbRbGEQrBniIkaatfuPMI-HmM,36003
+sqil_core/fit/_fit.py,sha256=dy4Vshoy8jcuof0ROxxG4h5oiwTFy2593eEHDRRobqE,25183
+sqil_core/fit/_models.py,sha256=eoIbAvtmusoUn_LN9tIe4PemRV4HXhPDkl75AxVbFRw,3034
+sqil_core/resonator/__init__.py,sha256=LFq30-1r6cVNRnNYfiqlzIhLJa0yHNeZ_tHPcSJej_Q,210
+sqil_core/resonator/_resonator.py,sha256=rjcUqDvglKK00M5zIqVXukNrZFMscOZZIG2YBn13BjE,29198
+sqil_core/utils/__init__.py,sha256=xdefhf8GUpGPKuGEhuP3He3067nPcD3CRP-5CJrH6Gk,1363
+sqil_core/utils/_analysis.py,sha256=qhipdYvxWR3P886us_gF8dBQZGzGJme8-5AT1YxBaKo,9982
+sqil_core/utils/_const.py,sha256=H58XFwq7_pX6M7kapBPbeky8Ck-GGE66fzkNe2e3GW0,1217
+sqil_core/utils/_formatter.py,sha256=F7JRPyU_pYymRD7G1iNVYiZS3D1ccuD9AYZWYg3SiW4,5750
+sqil_core/utils/_plot.py,sha256=ABmt-e7wfqynnU2P9584EqMkmwhGqJItlgFctZQzOp4,3442
+sqil_core/utils/_read.py,sha256=K0IjnUhkbCuf_wbKn_0fRP86bNGYj3dEbFXzQi9lOoU,5421
+sqil_core/utils/_utils.py,sha256=BMelbGLbjBh0Mu-Cb86bkoKXcGAABVZ7UkBZs68JzUA,420
+sqil_core-0.1.0.dist-info/METADATA,sha256=U0gtbLDys5_rSBQ5Y0ifCtBYMMgNd7IATqGcpjL49xM,3000
+sqil_core-0.1.0.dist-info/WHEEL,sha256=7dDg4QLnNKTvwIDR9Ac8jJaAmBC_owJrckbC0jjThyA,88
+sqil_core-0.1.0.dist-info/entry_points.txt,sha256=mnYKe0NKDcT5Py_8cL44TgcbLVOUS-CxmGBMEcsbGAQ,95
+sqil_core-0.1.0.dist-info/RECORD,,

{sqil_core-0.0.1.dist-info → sqil_core-0.1.0.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 1.9.1
+Generator: poetry-core 2.1.0
 Root-Is-Purelib: true
 Tag: py3-none-any

{sqil_core-0.0.1.dist-info → sqil_core-0.1.0.dist-info}/entry_points.txt

@@ -1,5 +1,5 @@
 [console_scripts]
 build=scripts:build
 docs-build=scripts:docs_build
-docs-serve=scripts:docs_serve
+docs-dev=scripts:docs_dev
 

sqil_core/utils/analysis.py

@@ -1,68 +0,0 @@
-import numpy as np
-
-
-def remove_offset(data: np.ndarray, avg: int = 3) -> np.ndarray:
-    """Removes the initial offset from a data matrix or vector by subtracting
-    the average of the first `avg` points. After applying this function,
-    the first point of each column of the data will be shifted to (about) 0.
-
-    Parameters
-    ----------
-    data : np.ndarray
-        Input data, either a 1D vector or a 2D matrix
-    avg : int, optional
-        The number of initial points to average when calculating
-        the offset, by default 3
-
-    Returns
-    -------
-    np.ndarray
-       The input data with the offset removed
-    """
-    is1D = len(data.shape) == 1
-    if is1D:
-        return data - np.mean(data[0:avg])
-    return data - np.mean(data[:, 0:avg], axis=1).reshape(data.shape[0], 1)
-
-
-def estimate_linear_background(x: np.ndarray, data: np.ndarray, points_cut=0.1) -> list:
-    is1D = len(data.shape) == 1
-    points = data.shape[0] if is1D else data.shape[1]
-    cut = int(points * points_cut)
-
-    # Consider just the cut points
-    x_data = x[0:cut] if is1D else x[0:cut, :]
-    X = np.vstack([np.ones_like(x_data), x_data]).T
-    y_data = data[0:cut] if is1D else data[0:cut, :]
-
-    # Linear fit
-    coefficients, residuals, _, _ = np.linalg.lstsq(
-        X, y_data if is1D else y_data.T, rcond=None
-    )
-
-    return coefficients
-
-
-def remove_linear_background(
-    x: np.ndarray, data: np.ndarray, points_cut=0.1
-) -> np.ndarray:
-    """Removes a linear background from the input data (e.g. the phase background
-    of a spectroscopy).
-
-
-    Parameters
-    ----------
-    data : np.ndarray
-        Input data. Can be a 1D vector or a 2D matrix.
-
-    Returns
-    -------
-    np.ndarray
-        The input data with the linear background removed. The shape of the
-        returned array matches the input `data`.
-    """
-    coefficients = estimate_linear_background(x, data, points_cut)
-
-    # Remove background over the whole array
-    X = np.vstack([np.ones_like(x), x]).T
-    return data - (X @ coefficients).T