scietex.hal.vacuum-gauge 1.0.0__tar.gz

scietex_hal_vacuum_gauge-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Anton Bondarenko
+
+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.

scietex_hal_vacuum_gauge-1.0.0/PKG-INFO

@@ -0,0 +1,89 @@
+Metadata-Version: 2.4
+Name: scietex.hal.vacuum_gauge
+Version: 1.0.0
+Summary: Scietex Vacuum Gauge HAL package
+Author-email: Anton Bondarenko <bond.anton@gmail.com>
+License: MIT License
+        
+        Copyright (c) 2025 Anton Bondarenko
+        
+        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.
+Project-URL: Homepage, https://github.com/bond-anton/scietex.hal.vacuum_gauge
+Project-URL: Bug Tracker, https://github.com/bond-anton/scietex.hal.vacuum_gauge/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy<3.0.0,>=2.0.0
+Requires-Dist: scietex.hal.analog-sensor<2.0.0,>=1.0.0
+Requires-Dist: scietex.hal.serial<2.0.0,>=1.0.0
+Provides-Extra: dev
+Provides-Extra: test
+Requires-Dist: flake8; extra == "test"
+Requires-Dist: pytest; extra == "test"
+Requires-Dist: pytest-asyncio; extra == "test"
+Provides-Extra: lint
+Requires-Dist: pylint; extra == "lint"
+Dynamic: license-file
+
+# scietex.hal.vacuum_gauge
+
+`scietex.hal.vacuum_gauge` is a Python library for interfacing with and emulating vacuum gauges
+from various manufacturers, including Edwards, Leybold, and Erstevak. It provides a modular
+framework for converting analog voltage outputs to pressure readings and communicating with gauges
+over RS485 protocols. The library is designed for use in scientific and industrial applications,
+offering both client-side interaction with physical hardware and server-side emulation for testing
+and development.
+
+## Features
+- **Analog Gauge Support**: Convert voltage outputs to pressure readings (in millibars)
+  for Edwards (APG-M, APG-L), Leybold (TTR 101 N), and Erstevak (MTP4D, MTM9D) gauges using 
+  interpolation or exponential formulas.
+- **RS485 Communication**: Full support for Erstevak’s RS485 protocol (version 1),
+  including client-side control and server-side emulation.
+- **Modular Design**: Organized into subpackages (`base`, `edwards`, `leybold`, `erstevak`)
+  for easy extension to additional manufacturers or models.
+- **Atmospheric Adjustments**: Apply gas-specific correction factors to pressure calculations.
+- **Emulation**: Simulate Erstevak gauge behavior for testing without physical hardware.
+- **Backends**: Supports `pymodbus` and `pyserial` for flexible RS485 communication.
+
+## System Requirements
+
+- **Python**: 3.9 or higher.
+- **Operating Systems**: Compatible with **Linux** and **macOS**.
+
+## Installation
+
+To install the package, execute the following command in your terminal:
+
+```bash
+pip install scietex.hal.vacuum_gauge
+```
+
+## Contribution
+We welcome contributions to the project! Whether it's bug fixes, feature enhancements,
+or documentation improvements, your input is valuable. Please feel free to submit
+pull requests or open issues to discuss potential changes.
+
+## License
+
+This project is licensed under the MIT License. For more details, please refer
+to the `LICENSE` file included in the repository.

scietex_hal_vacuum_gauge-1.0.0/README.md

@@ -0,0 +1,43 @@
+# scietex.hal.vacuum_gauge
+
+`scietex.hal.vacuum_gauge` is a Python library for interfacing with and emulating vacuum gauges
+from various manufacturers, including Edwards, Leybold, and Erstevak. It provides a modular
+framework for converting analog voltage outputs to pressure readings and communicating with gauges
+over RS485 protocols. The library is designed for use in scientific and industrial applications,
+offering both client-side interaction with physical hardware and server-side emulation for testing
+and development.
+
+## Features
+- **Analog Gauge Support**: Convert voltage outputs to pressure readings (in millibars)
+  for Edwards (APG-M, APG-L), Leybold (TTR 101 N), and Erstevak (MTP4D, MTM9D) gauges using 
+  interpolation or exponential formulas.
+- **RS485 Communication**: Full support for Erstevak’s RS485 protocol (version 1),
+  including client-side control and server-side emulation.
+- **Modular Design**: Organized into subpackages (`base`, `edwards`, `leybold`, `erstevak`)
+  for easy extension to additional manufacturers or models.
+- **Atmospheric Adjustments**: Apply gas-specific correction factors to pressure calculations.
+- **Emulation**: Simulate Erstevak gauge behavior for testing without physical hardware.
+- **Backends**: Supports `pymodbus` and `pyserial` for flexible RS485 communication.
+
+## System Requirements
+
+- **Python**: 3.9 or higher.
+- **Operating Systems**: Compatible with **Linux** and **macOS**.
+
+## Installation
+
+To install the package, execute the following command in your terminal:
+
+```bash
+pip install scietex.hal.vacuum_gauge
+```
+
+## Contribution
+We welcome contributions to the project! Whether it's bug fixes, feature enhancements,
+or documentation improvements, your input is valuable. Please feel free to submit
+pull requests or open issues to discuss potential changes.
+
+## License
+
+This project is licensed under the MIT License. For more details, please refer
+to the `LICENSE` file included in the repository.

scietex_hal_vacuum_gauge-1.0.0/pyproject.toml

@@ -0,0 +1,53 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "scietex.hal.vacuum_gauge"
+dynamic = ["version"]
+description = "Scietex Vacuum Gauge HAL package"
+authors = [
+  { name = "Anton Bondarenko", email = "bond.anton@gmail.com" },
+]
+license = { file = "LICENSE" }
+readme = "README.md"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+]
+requires-python = ">=3.9"
+dependencies = [
+    "numpy >= 2.0.0, < 3.0.0",
+    "scietex.hal.analog-sensor >= 1.0.0, < 2.0.0",
+    "scietex.hal.serial >= 1.0.0, < 2.0.0",
+]
+
+[project.urls]
+"Homepage" = "https://github.com/bond-anton/scietex.hal.vacuum_gauge"
+"Bug Tracker" = "https://github.com/bond-anton/scietex.hal.vacuum_gauge/issues"
+
+[project.optional-dependencies]
+dev = []
+test = ["flake8", "pytest", "pytest-asyncio"]
+lint = ["pylint"]
+
+[tool.setuptools.dynamic]
+version = {attr = "scietex.hal.vacuum_gauge.version.__version__"}
+
+[tool.setuptools.package-data]
+"scietex.hal.vacuum_gauge" = ["py.typed"]
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.black]
+line-length = 100
+
+[tool.mypy]
+python_version = "3.9"
+
+[tool.pytest.ini_options]
+pythonpath = [
+  "src"
+]

scietex_hal_vacuum_gauge-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

scietex_hal_vacuum_gauge-1.0.0/src/scietex/hal/vacuum_gauge/__init__.py

@@ -0,0 +1,15 @@
+"""
+Vacuum Gauge Package.
+
+This package provides a modular framework for interfacing with vacuum gauges over serial
+communication protocols, such as RS485, within the `scietex.hal` ecosystem. It supports both
+client-side interaction with physical vacuum gauges and server-side emulation for testing and
+development. The package is designed to be extensible, allowing for the addition of support for
+different gauge manufacturers and models through subpackages.
+
+Currently, the package includes support for Erstevak vacuum gauges via the `erstevak` subpackage,
+which implements the Erstevak RS485 protocol (version 1). Future expansions may include additional
+manufacturers or protocol versions.
+"""
+
+from .version import __version__

scietex_hal_vacuum_gauge-1.0.0/src/scietex/hal/vacuum_gauge/base/__init__.py

@@ -0,0 +1,25 @@
+"""
+Base Vacuum Gauge Subpackage.
+
+This subpackage provides foundational classes and utilities for working with analog vacuum gauges.
+It includes abstract and concrete implementations for converting analog voltage outputs to pressure
+readings in millibars (mbar), supporting various atmospheric gases and customizable gauge
+parameters. These components serve as building blocks for specific gauge implementations
+(e.g., in the `edwards` subpackage).
+
+Classes:
+    Atmosphere: An enumeration of supported atmospheric gases for pressure conversion adjustments.
+    ExponentialVacuumGauge: An abstract base class for vacuum gauges with exponential output.
+    InterpolationVacuumGauge: A class for vacuum gauges using linear interpolation based on
+        calibration data.
+
+Modules:
+    atmosphere: Defines the `Atmosphere` enumeration for gas type handling.
+    analog: Contains the core vacuum gauge classes `ExponentialVacuumGauge` and
+        `InterpolationVacuumGauge`.
+"""
+
+from .atmosphere import Atmosphere
+from .analog import ExponentialVacuumGauge, InterpolationVacuumGauge
+
+__all__ = ["Atmosphere", "ExponentialVacuumGauge", "InterpolationVacuumGauge"]

scietex_hal_vacuum_gauge-1.0.0/src/scietex/hal/vacuum_gauge/base/analog.py

@@ -0,0 +1,273 @@
+"""
+Analog Vacuum Gauge Module.
+
+This module provides functionality for working with analog vacuum gauges, converting analog
+output voltage to pressure readings in millibar (mbar) units. It supports various atmospheric
+gases and allows customization of the gauge model and atmosphere.
+
+Classes:
+    - ExponentialVacuumGauge: An abstract base class for handling analog vacuum gauge operations
+      with exponential output, including voltage-to-pressure conversion. This class is intended
+      to be inherited by subclasses that implement specific gauge models.
+    - InterpolationVacuumGauge: A class for handling analog vacuum gauges using linear interpolation
+      based on calibration data, converting voltage to pressure with atmospheric gas adjustments.
+
+Key Features:
+    - Supports multiple atmospheric gases with customizable conversion factors.
+    - Converts analog voltage readings to pressure values in millibars (mbar).
+    - Configurable gauge model, voltage range, pressure range, and atmosphere for accurate
+      calculations.
+    - Offers both exponential and interpolation-based conversion methods.
+"""
+
+from typing import Union, Optional
+import numpy as np
+from numpy.typing import NDArray
+
+from scietex.hal.analog_sensor import AnalogSensorInterface, LinearInterpolatorSensor
+from .atmosphere import Atmosphere
+
+
+# pylint: disable=too-few-public-methods
+class ExponentialVacuumGauge(AnalogSensorInterface):
+    """
+    An abstract base class for handling analog vacuum gauges with exponential output.
+
+    This class provides a foundation for converting analog output voltage from a vacuum gauge into
+    pressure readings in millibars (mbar) using an exponential relationship.
+    It supports customization for different atmospheric gases and gauge-specific parameters.
+    Subclasses should override `convert_voltage` to implement model-specific conversion logic.
+
+    Attributes:
+        model_name (str): The model identifier of the vacuum gauge.
+        offset_voltage (float): Voltage offset used in the pressure calculation.
+        scale (float): Scaling factor for the voltage difference in the exponential pressure
+            conversion.
+        v_min (float): Minimum voltage threshold; inputs below this are clamped to `p_min`.
+        v_max (float): Maximum voltage threshold; inputs above this are clamped to `p_max`.
+        p_min (float): Minimum pressure output in mbar before atmospheric scaling (e.g., 5e-5).
+        p_max (float): Maximum pressure output in mbar before atmospheric scaling (e.g., 1.5e3).
+        atmosphere (Atmosphere): The atmospheric gas used for calculations.
+        atmosphere_factor (dict[Atmosphere, float]): A dictionary mapping atmospheric gases to
+            their respective conversion factors. Defaults to 1.0 for all supported gases.
+
+    Methods:
+        convert_voltage(voltage: Union[float, NDArray[np.float64]])
+            -> Union[float, NDArray[np.float64]]:
+            Converts analog output voltage to pressure (mbar) based on the gauge model and
+            atmosphere.
+    """
+
+    atmosphere_factor = {
+        Atmosphere.AIR: 1.0,
+        Atmosphere.AR: 1.0,
+        Atmosphere.CO: 1.0,
+        Atmosphere.CO2: 1.0,
+        Atmosphere.H2: 1.0,
+        Atmosphere.HE: 1.0,
+        Atmosphere.N2: 1.0,
+        Atmosphere.O2: 1.0,
+        Atmosphere.NE: 1.0,
+        Atmosphere.KR: 1.0,
+        Atmosphere.XE: 1.0,
+    }
+
+    # pylint: disable=too-many-arguments,too-many-positional-arguments
+    def __init__(
+        self,
+        model_name: str,
+        offset_voltage: float = 5.0,
+        scale: float = 1.0,
+        v_min: float = 0.0,
+        v_max: float = 10.0,
+        p_min: float = 5e-5,
+        p_max: float = 1.5e3,
+        atmosphere: Optional[Union[str, Atmosphere]] = None,
+    ):
+        """
+        Initializes the ExponentialVacuumGauge instance.
+
+        Args:
+            model_name (str): The model identifier of the vacuum gauge.
+            offset_voltage (float, optional): Voltage offset for the pressure calculation.
+                Defaults to 5.0.
+            scale (float, optional): Scaling factor for the voltage difference in the exponential
+                pressure conversion. Defaults to 1.0.
+            v_min (float, optional): Minimum voltage threshold; inputs below this are clamped to
+                `p_min`. Defaults to 0.0.
+            v_max (float, optional): Maximum voltage threshold; inputs above this are clamped to
+                `p_max`. Defaults to 10.0.
+            p_min (float, optional): Minimum pressure output in mbar before atmospheric scaling.
+                Defaults to 5e-5.
+            p_max (float, optional): Maximum pressure output in mbar before atmospheric scaling.
+                Defaults to 1.5e3.
+            atmosphere (Optional[Union[str, Atmosphere]], optional): The atmospheric gas used for
+                calculations, either as an `Atmosphere` member or its string value (e.g., "Air").
+                Defaults to `Atmosphere.AIR` if not provided.
+        """
+        super().__init__(model_name)
+        self.offset_voltage: float = offset_voltage
+        self.scale: float = scale
+        self.v_min: float = v_min
+        self.v_max: float = v_max
+        self.p_min: float = p_min
+        self.p_max: float = p_max
+        self.atmosphere: Atmosphere
+        if isinstance(atmosphere, str):
+            self.atmosphere = Atmosphere.from_string(atmosphere)
+        else:
+            self.atmosphere = atmosphere if atmosphere is not None else Atmosphere.AIR
+
+    def convert_voltage(
+        self, voltage: Union[float, NDArray[np.float64]]
+    ) -> Union[float, NDArray[np.float64]]:
+        """
+        Converts analog output voltage to pressure (mbar).
+
+        This method calculates pressure in millibars (mbar) from analog voltage using an
+        exponential formula: `pressure = 10 ** ((voltage - offset_voltage) / scale)`.
+        Voltages below `v_min` or above `v_max` are clamped to `p_min` or `p_max`, respectively.
+        The entire pressure result, including clamps, is then scaled by the atmospheric gas factor.
+        This is a basic implementation and should be overridden in subclasses for model-specific
+        conversion logic.
+
+        Args:
+            voltage (Union[float, NDArray[np.float64]]): The analog output voltage(s) from the
+                vacuum gauge. Can be a single float or a NumPy array.
+
+        Returns:
+            Union[float, NDArray[np.float64]]: The calculated pressure in millibars (mbar),
+                matching the input type (float or array).
+        """
+        voltage_array = np.asarray(voltage)
+        clamped_voltage = np.clip(voltage_array, self.v_min, self.v_max)
+        pressure = np.where(
+            clamped_voltage == self.v_min,
+            self.p_min,
+            np.where(
+                clamped_voltage == self.v_max,
+                self.p_max,
+                10 ** ((clamped_voltage - self.offset_voltage) / self.scale),
+            ),
+        )
+        pressure *= self.atmosphere_factor[self.atmosphere]
+        return pressure if isinstance(voltage, np.ndarray) else float(pressure)
+
+
+# pylint: disable=too-few-public-methods
+class InterpolationVacuumGauge(LinearInterpolatorSensor):
+    """
+    A class for handling analog vacuum gauges using linear interpolation based on calibration data.
+
+    This class extends `LinearInterpolatorSensor` to convert analog output voltage from a vacuum
+    gauge into pressure readings in millibars (mbar) using linear interpolation over provided
+    calibration data. It supports atmospheric gas adjustments and enforces voltage and pressure
+    limits. It is designed for vacuum gauges where pressure is mapped directly from voltage via
+    calibration points (e.g., Edwards APG-M or APG-L).
+
+    Attributes:
+        model_name (str): The model identifier of the vacuum gauge.
+        data (NDArray[np.float64]): 2D array with shape (n, 2) containing voltage (column 0) and
+            pressure (column 1) calibration points.
+        v_min (float): Minimum voltage threshold; inputs below this are clamped to `p_min`.
+        v_max (float): Maximum voltage threshold; inputs above this are clamped to `p_max`.
+        p_min (float): Minimum pressure output in mbar before atmospheric scaling (e.g., 1e-6).
+        p_max (float): Maximum pressure output in mbar before atmospheric scaling (e.g., 1000).
+        atmosphere (Atmosphere): The atmospheric gas used for calculations.
+        atmosphere_factor (dict[Atmosphere, float]): A dictionary mapping atmospheric gases to
+            their respective conversion factors. Defaults to 1.0 for all supported gases.
+
+    Methods:
+        convert_voltage(voltage: Union[float, NDArray[np.float64]])
+            -> Union[float, NDArray[np.float64]]:
+            Converts analog output voltage to pressure (mbar) using linear interpolation, adjusted
+            by atmospheric gas factor, with clamping at specified limits.
+    """
+
+    atmosphere_factor = {
+        Atmosphere.AIR: 1.0,
+        Atmosphere.AR: 1.0,
+        Atmosphere.CO: 1.0,
+        Atmosphere.CO2: 1.0,
+        Atmosphere.H2: 1.0,
+        Atmosphere.HE: 1.0,
+        Atmosphere.N2: 1.0,
+        Atmosphere.O2: 1.0,
+        Atmosphere.NE: 1.0,
+        Atmosphere.KR: 1.0,
+        Atmosphere.XE: 1.0,
+    }
+
+    # pylint: disable=too-many-arguments,too-many-positional-arguments
+    def __init__(
+        self,
+        model_name: str,
+        data: NDArray[np.float64],
+        v_min: float = 0.0,
+        v_max: float = 10.0,
+        p_min: float = 1e-6,
+        p_max: float = 1000.0,
+        atmosphere: Optional[Union[str, Atmosphere]] = None,
+        extrapolate: Optional[bool] = None,
+    ):
+        """
+        Initializes the InterpolationVacuumGauge instance.
+
+        Args:
+            model_name (str): The model identifier of the vacuum gauge.
+            data (NDArray[np.float64]): 2D array with shape (n, 2) containing voltage (column 0)
+                and pressure (column 1) calibration points.
+            v_min (float, optional): Minimum voltage threshold; inputs below this are clamped to
+                `p_min`. Defaults to 0.0.
+            v_max (float, optional): Maximum voltage threshold; inputs above this are clamped to
+                `p_max`. Defaults to 10.0.
+            p_min (float, optional): Minimum pressure output in mbar before atmospheric scaling.
+                Defaults to 1e-6.
+            p_max (float, optional): Maximum pressure output in mbar before atmospheric scaling.
+                Defaults to 1000.0.
+            atmosphere (Optional[Union[str, Atmosphere]], optional): The atmospheric gas used for
+                calculations, either as an `Atmosphere` member or its string value (e.g., "Air").
+                Defaults to `Atmosphere.AIR` if not provided.
+            extrapolate (Optional[bool], optional): Whether to extrapolate beyond the calibration
+                data. Defaults to None (uses `LinearInterpolatorSensor` default behavior).
+        """
+        super().__init__(model_name, data, extrapolate=extrapolate)
+        self.v_min: float = v_min
+        self.v_max: float = v_max
+        self.p_min: float = p_min
+        self.p_max: float = p_max
+        self.atmosphere: Atmosphere
+        if isinstance(atmosphere, str):
+            self.atmosphere = Atmosphere.from_string(atmosphere)
+        else:
+            self.atmosphere = atmosphere if atmosphere is not None else Atmosphere.AIR
+
+    def convert_voltage(
+        self, voltage: Union[float, NDArray[np.float64]]
+    ) -> Union[float, NDArray[np.float64]]:
+        """
+        Converts analog output voltage to pressure (mbar) using linear interpolation.
+
+        This method uses linear interpolation from the provided calibration data to compute
+        pressure, clamps the result to `p_min` or `p_max` if the input voltage is outside `v_min`
+        or `v_max`, and then scales the entire pressure result (including clamps) by the
+        atmospheric gas factor.
+
+        Args:
+            voltage (Union[float, NDArray[np.float64]]): The analog output voltage(s) from the
+                vacuum gauge. Can be a single float or a NumPy array.
+
+        Returns:
+            Union[float, NDArray[np.float64]]: The calculated pressure in millibars (mbar),
+                matching the input type (float or array).
+        """
+        voltage_array = np.asarray(voltage)
+        clamped_voltage = np.clip(voltage_array, self.v_min, self.v_max)
+        interpolated_pressure = super().convert_voltage(clamped_voltage)
+        pressure = np.where(
+            clamped_voltage == self.v_min,
+            self.p_min,
+            np.where(clamped_voltage == self.v_max, self.p_max, interpolated_pressure),
+        )
+        pressure *= self.atmosphere_factor[self.atmosphere]
+        return pressure if isinstance(voltage, np.ndarray) else float(pressure)

scietex_hal_vacuum_gauge-1.0.0/src/scietex/hal/vacuum_gauge/base/atmosphere.py

@@ -0,0 +1,74 @@
+"""
+Atmosphere Enum Module.
+
+This module defines the `Atmosphere` enumeration, which represents the supported atmospheric gases
+for vacuum gauge calculations. These gases are used to adjust pressure readings based on the
+specific gas being measured. The enumeration supports initialization from string values for
+compatibility with stored or serialized data.
+
+Classes:
+    - Atmosphere: An enumeration of supported atmospheric gases with string values and a method
+      to convert from strings.
+
+Methods:
+    - from_string: Converts a string representation of a gas to the corresponding `Atmosphere`
+        member.
+"""
+
+from enum import Enum
+
+
+class Atmosphere(Enum):
+    """
+    Enumeration of supported atmospheric gases for vacuum gauge calculations.
+
+    Members:
+        AIR: Represents air, with value "Air".
+        AR: Represents argon, with value "Ar".
+        CO: Represents carbon monoxide, with value "CO".
+        CO2: Represents carbon dioxide, with value "CO2".
+        H2: Represents hydrogen, with value "H2".
+        HE: Represents helium, with value "He".
+        N2: Represents nitrogen, with value "N2".
+        O2: Represents oxygen, with value "O2".
+        NE: Represents neon, with value "Ne".
+        KR: Represents krypton, with value "Kr".
+        XE: Represents xenon, with value "Xe".
+
+    Methods:
+        from_string(cls, value: str) -> 'Atmosphere':
+            Class method to convert a string to an `Atmosphere` member.
+    """
+
+    AIR = "Air"
+    AR = "Ar"
+    CO = "CO"
+    CO2 = "CO2"
+    H2 = "H2"
+    HE = "He"
+    N2 = "N2"
+    O2 = "O2"
+    NE = "Ne"
+    KR = "Kr"
+    XE = "Xe"
+
+    @classmethod
+    def from_string(cls, value: str) -> "Atmosphere":
+        """
+        Converts a string representation of a gas to the corresponding `Atmosphere` member.
+
+        Args:
+            value (str): The string representation of the gas (e.g., "Air", "H2", "Ne").
+
+        Returns:
+            Atmosphere: The corresponding `Atmosphere` member.
+
+        Raises:
+            ValueError: If the string does not match any supported gas value.
+        """
+        for member in cls:
+            if member.value == value:
+                return member
+        raise ValueError(
+            f"Unknown atmosphere gas: {value}. Supported values are: {[m.value for m in cls]}"
+        )

scietex_hal_vacuum_gauge-1.0.0/src/scietex/hal/vacuum_gauge/edwards/__init__.py

@@ -0,0 +1,20 @@
+"""
+Edwards Vacuum Gauge Subpackage.
+
+This subpackage provides implementations of analog vacuum gauges specific to Edwards models.
+It includes classes for converting analog voltage outputs to pressure readings in millibars (mbar)
+using calibration data and atmospheric gas adjustments. The classes are designed for use with
+Edwards APG-M and APG-L vacuum gauges, leveraging interpolation-based conversion methods.
+
+Classes:
+    APGMGauge: A vacuum gauge class for the Edwards APG-M model, using linear interpolation.
+    APGLGauge: A vacuum gauge class for the Edwards APG-L model, using linear interpolation.
+
+Modules:
+    analog: Contains the implementation of Edwards-specific vacuum gauge classes.
+    calibration_data: Provides calibration data arrays for Edwards APG-M and APG-L models.
+"""
+
+from .analog import APGMGauge, APGLGauge
+
+__all__ = ["APGMGauge", "APGLGauge"]