accord-rt 0.2__tar.gz

accord_rt-0.2/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2025 Nelson Sandoval Puente
+
+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.

accord_rt-0.2/PKG-INFO

@@ -0,0 +1,22 @@
+Metadata-Version: 2.4
+Name: accord-rt
+Version: 0.2
+Summary: accord: Calculator for TRS-398 calibration.
+Author: jonjon-el
+Requires-Python: >=3.8
+License-Expression: MIT
+Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: Intended Audience :: Healthcare Industry
+Classifier: Intended Audience :: Science/Research
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Scientific/Engineering :: Medical Science Apps.
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+License-File: LICENSE
+Requires-Dist: click>=8.0
+Requires-Dist: pylinac>=3.43.2,<4.0.0
+Requires-Dist: numpy
+Requires-Dist: scipy
+Project-URL: Homepage, https://github.com/jonjon-el/accord
+Project-URL: Issues, https://github.com/jonjon-el/accord/issues
+Project-URL: Source, https://github.com/jonjon-el/accord

accord_rt-0.2/accord/__init__.py

@@ -0,0 +1,2 @@
+"""accord: Calculator for TRS-398 calibration."""
+__version__ = "0.2"

accord_rt-0.2/accord/__main__.py

@@ -0,0 +1,7 @@
+import accord.interfaces.cli_click.commands
+
+def main():
+    """
+    CLI entry point.
+    """
+    accord.interfaces.cli_click.commands.cli()

accord_rt-0.2/accord/core/corrections.py

@@ -0,0 +1,82 @@
+from pylinac import ct
+from scipy import constants
+import numpy as np
+
+def calc_c_T(P_expected_value: float, T_ref: float, P_ref: float) -> float:
+    """
+    Calculate the sensitivity of temperature.
+
+    Args:
+        P_expected_value (float): The expected value of the measurand. (e.g., the expected pressure)
+        T_ref (float): The reference temperature.
+        P_ref (float): The reference pressure.
+    Returns:
+        float: The sensitivity of temperature.
+    """
+
+    # Check values
+    if P_expected_value <= 0:
+        raise ValueError("Expected value must be greater than zero.")
+    if P_ref <= 0:
+        raise ValueError("Reference pressure must be greater than zero.")
+    if T_ref <= -constants.zero_Celsius:
+        raise ValueError("Reference temperature must be greater than absolute zero.")
+    
+    # Calculate the sensitivity of temperature
+    c_T = abs( P_ref / ((constants.zero_Celsius + T_ref)*P_expected_value))
+    return c_T
+
+def calc_c_P(L_expected_value: float, T_expected_value: float, P_expected_value: float, T_ref: float, P_ref: float) -> float:
+    """
+    Calculate the sensitivity of pressure.
+
+    Args:
+        L_expected_value (float): The expected value of the measurand. (e.g., the expected crude lecture)
+        T_expected_value (float): The expected value of the measurand. (e.g., the expected temperature)
+        P_expected_value (float): The expected value of the measurand. (e.g., the expected pressure)
+        T_ref (float): The reference temperature.
+        P_ref (float): The reference pressure.
+    Returns:
+        float: The sensitivity of pressure.
+    """
+
+    # Check values
+    if T_expected_value <= -constants.zero_Celsius:
+        raise ValueError("Expected temperature must be greater than absolute zero.")
+    if P_expected_value <= 0:
+        raise ValueError("Expected value must be greater than zero.")
+    if P_ref <= 0:
+        raise ValueError("Reference pressure must be greater than zero.")
+    if T_ref <= -constants.zero_Celsius:
+        raise ValueError("Reference temperature must be greater than absolute zero.")
+    
+    # Calculate the sensitivity of pressure
+    c_P = abs(((constants.zero_Celsius + T_expected_value)*P_ref*L_expected_value) / ((constants.zero_Celsius + T_ref)*np.power(P_expected_value, 2)))
+    return c_P
+
+def calc_c_L(T_expected_value: float, P_expected_value: float, T_ref: float, P_ref: float) -> float:
+    """
+    Calculate the sensitivity of crude lecture.
+
+    Args:
+        T_expected_value (float): The expected value of the measurand. (e.g., the expected temperature)
+        P_expected_value (float): The expected value of the measurand. (e.g., the expected pressure)
+        T_ref (float): The reference temperature.
+        P_ref (float): The reference pressure.
+    Returns:
+        float: The sensitivity of crude lecture.
+    """
+
+    # Check values
+    if T_expected_value <= -constants.zero_Celsius:
+        raise ValueError("Expected temperature must be greater than absolute zero.")
+    if P_expected_value <= 0:
+        raise ValueError("Expected value must be greater than zero.")
+    if P_ref <= 0:
+        raise ValueError("Reference pressure must be greater than zero.")
+    if T_ref <= -constants.zero_Celsius:
+        raise ValueError("Reference temperature must be greater than absolute zero.")
+    
+    # Calculate the sensitivity of crude lecture
+    c_L = abs(((constants.zero_Celsius + T_expected_value)*P_ref) / ((constants.zero_Celsius + T_ref)*P_expected_value))
+    return c_L

accord_rt-0.2/accord/core/customSim.py

@@ -0,0 +1,12 @@
+from pylinac.core.image_generator.simulators import Simulator
+
+class iViewGTImage(Simulator):
+    pixel_size = 0.40
+    shape = (1024, 1024)
+
+def test():
+    obj0 = iViewGTImage()
+
+if __name__=="__main__":
+    print("Running as main...")
+    test()

accord_rt-0.2/accord/core/metrology.py

@@ -0,0 +1,73 @@
+import numpy as np
+import functools
+
+def calc_U (u: float, k: float) -> float:
+    """
+    Calculate the combined uncertainty.
+
+    Args:
+        u (float): The combined standard uncertainty.
+        k (float): The coverage factor.
+
+    Returns:
+        float: The combined uncertainty.
+    """
+    return u * k
+
+def calc_u_c (*u_i) -> float:
+    """
+    Calculate the combined standard uncertainty.
+
+    Args:
+        *u_i (float): Variable number of standard uncertainties.
+    Returns:
+        float: The combined standard uncertainty.
+    """
+    return functools.reduce(np.hypot, u_i)
+
+def calc_u_A (*measurand_values) -> float:
+    """
+    Calculate Type A standard uncertainty.
+
+    Args:
+        *measurand_values (float): Variable number of the mean values for each series.
+    Returns:
+        float: The Type A uncertainty.
+    """
+
+    n = len(measurand_values)
+
+    # Calculate the sample standard deviation. (n-1 Bessel's correction)
+    std_dev = np.std(measurand_values, ddof=1)
+
+    # Calculate the standard uncertainty of the mean
+    u_A = std_dev / np.sqrt(n)
+
+    return u_A
+
+def calc_u_B(error_value: float, distribution: str, k: float|None = None) -> float:
+    """
+    Calculate Type B standard uncertainty.
+
+    Args:
+        error_value (float): The value of the error.
+        distribution (str): The type of uncertainty. ("rectangular" , "triangular", "normal" distributions are supported)
+        k (float): The coverage factor for normal distribution. (ignored for other distributions)
+    Returns:
+        float: The standard uncertainty.
+    """
+    
+    if distribution == "rectangular":
+        u_B = error_value / np.sqrt(3)
+    elif distribution == "triangular":
+        u_B = error_value / np.sqrt(6)
+    elif distribution == "normal":
+        if k is None:
+            raise ValueError("Coverage factor 'k' is required for normal distribution.")
+        if k <= 0:
+            raise ValueError("Coverage factor 'k' must be a positive number.")
+        u_B = error_value / k
+    else:
+        raise ValueError("Unsupported distribution type. Supported types are: 'rectangular', 'triangular', 'normal'.")
+    
+    return u_B

accord_rt-0.2/accord/core/nel_aux.py

@@ -0,0 +1,201 @@
+import importlib.resources
+import pathlib
+import shutil
+
+import pylinac.calibration.trs398
+import tomllib
+
+# This file contains auxiliary functions for the NEL calibration process.
+
+# Copy sample files.
+def copy_sample_files(path: pathlib.Path, file_class: str):
+    configTraversable_list = list()
+    if file_class == "config":
+        configTraversable_list.append(importlib.resources.files("accord").joinpath("sampleFiles/config.toml"))
+    elif file_class == "calibration":
+        configTraversable_list.append(importlib.resources.files("accord").joinpath("sampleFiles/calibration.toml"))
+        # TODO: make file_class a list of paths to work with the three preliminary.csv original files.
+    elif file_class == "preliminary":
+        configTraversable_list.append(importlib.resources.files("accord").joinpath("sampleFiles/preliminary_0.csv"))
+        configTraversable_list.append(importlib.resources.files("accord").joinpath("sampleFiles/preliminary_1.csv"))
+        configTraversable_list.append(importlib.resources.files("accord").joinpath("sampleFiles/preliminary_2.csv"))
+    elif file_class == "devices":
+        configTraversable_list.append(importlib.resources.files("accord").joinpath("sampleFiles/devices.toml"))
+    else:
+        raise ValueError("Invalid file type. Please choose 'config', 'calibration', 'preliminary', or 'devices'.")
+
+    try:
+        for configTraversable in configTraversable_list:
+            with importlib.resources.as_file(configTraversable) as configPath:
+                shutil.copy(configPath, path)
+                print(f"File copied.")
+    except FileNotFoundError:
+        raise ValueError(f"Sample file not found in {configPath}.")
+    except PermissionError:
+        raise ValueError(f"Permission denied when copying file.")
+    except shutil.SameFileError:
+        raise ValueError(f"Source and destination represents the same file.")
+    except OSError as e:
+        raise ValueError(f"Error copying file: {e.strerror}.")
+
+# Load a TOML file
+def load_toml_file(path: pathlib.Path) -> dict[str, object]:
+    with open(path, "rb") as f:
+        return tomllib.load(f)
+
+# Get a nested value in a dictionary
+def get_nested(dictObj, *keys, default=None):
+    for key in keys:
+        if isinstance(dictObj, dict):
+            dictObj = dictObj.get(key)
+        else:
+            return default
+    return dictObj if dictObj is not None else default
+
+# Validate option helper.
+def resolve_option2(cli_value, config, key_path):
+    keys = key_path.split(".")
+    value = cli_value or get_nested(config, *keys)
+
+    # if value is None:
+    #     raise ValueError(f"Missing required option: --{keys[-1]} or '{key_path}' in config.")
+    return value
+
+# Example calibration data structure used in the calibration file.
+calibration_data = {
+    "chamber":"30013",
+    "clinical_pdd_zref": 66.5,
+    "energy": 6,
+    "fff": False,
+    "institution": "Your institution here",
+    "k_elec": 1.000,
+    "m_opposite": [25.64, 25.65, 25.65],
+    "m_reference": [25.65, 25.66, 25.65],
+    "m_reduced": [25.64, 25.63, 25.63],
+    "measurement_date": "2025-05-16",
+    "mu": 200,
+    "n_dw": 5.443,
+    "physicist": "Person realizing the calibration",
+    "press": 100.65839,
+    "setup": "SSD",
+    "temp": 22.1,
+    "tissue_correction": 1.0,
+    "tpr2010": 0.573573574,
+    "unit": "Unit employed",
+    "voltage_reduced": -150,
+    "voltage_reference": -300,
+    "notes": "Sample note."
+}
+
+def GetBaseTypes(config_quantities: dict) -> dict:
+    """
+    Get the base types of the quantities from the config file.
+    """
+    baseTypes = dict()
+    for key in config_quantities:
+        baseTypes[key] = config_quantities[key]["baseType"]
+    return baseTypes
+
+def Row2Measurement(row: dict, baseTypes: dict) -> dict:
+    """
+    Convert a row from the CSV file into a measurement dictionary.
+    """
+    measurement = dict()
+    for key in row:
+        if baseTypes[key] == "int":
+            measurement[key] = int(row[key])
+        elif baseTypes[key] == "float":
+            measurement[key] = float(row[key])
+
+    return measurement
+
+def Row2Measurement2(row: dict, quantities: dict) -> dict:
+    """
+    Convert a dictionary containing a row from the CSV file to a dictionary containing the same values but with the correct base types.
+    Base types are obtained from the quantities dictionary in the json file.
+    """
+    measurement = dict()
+    for key in row:
+        if quantities[key]["baseType"] == "int":
+            measurement[key] = int(row[key])
+        elif quantities[key]["baseType"] == "float":
+            measurement[key] = float(row[key])
+        elif quantities[key]["baseType"] == "str":
+            measurement[key] = row[key]
+        elif quantities[key]["baseType"] == "bool":
+            measurement[key] = row[key].lower() in ("true")
+
+    return measurement
+
+def ConvertMeasurement(rawMeasurement: dict, oldUnits: dict, newUnits: dict) -> dict:
+    """
+    Converts raw measurement in old units to new units.
+    """
+    measurement = rawMeasurement.copy()
+    for key in rawMeasurement:
+        if oldUnits[key] != newUnits[key]:
+            if key == "T":
+                # measurement[key] = trs398.convert_temperature(rawMeasurement[key], oldUnits[key], newUnits[key])
+                if oldUnits[key] == "°F":
+                    measurement[key] = pylinac.calibration.trs398.fahrenheit2celsius(rawMeasurement[key])
+                elif oldUnits[key] == "K":
+                    measurement[key] = rawMeasurement[key] + 273
+            elif key == "P":
+                # measurement[key] = trs398.convert_pressure(rawMeasurement[key], oldUnits[key], newUnits[key])
+                if oldUnits[key] == "mbar":
+                    measurement[key] = pylinac.calibration.trs398.mbar2kPa(rawMeasurement[key])
+                elif oldUnits[key] == "mmHg":
+                    measurement[key] = pylinac.calibration.trs398.mmHg2kPa(rawMeasurement[key])
+            # elif key == "m":
+            #     measurement[key] = trs398.convert_charge(rawMeasurement[key], oldUnits[key], newUnits[key])
+            # elif key == "k_TP":
+            #     measurement[key] = trs398.convert_temperature_pressure_correction_factor(rawMeasurement["T"], rawMeasurement["P"], oldUnits["T"], oldUnits["P"], newUnits["T"], newUnits["P"])
+            # elif key == "m_corrected":
+            #     measurement[key] = trs398.convert_charge(rawMeasurement[key], oldUnits[key], newUnits[key])
+    return measurement
+
+def Convert_measurement_to_pylinac_units(measurement: dict, oldUnits: dict) -> dict:
+    converted_measurement = measurement.copy()
+    for key in converted_measurement:
+        if key == "T":
+            if oldUnits[key] == "°F":
+                converted_measurement[key] = pylinac.calibration.trs398.fahrenheit2celsius(converted_measurement[key])
+            elif oldUnits[key] == "°C":
+                pass
+            else:
+                raise ValueError(f"Invalid temperature unit: {oldUnits[key]}")
+        elif key == "P":
+            if oldUnits[key] == "mbar":
+                converted_measurement[key] = pylinac.calibration.trs398.mbar2kPa(converted_measurement[key])
+            elif oldUnits[key] == "mmHg":
+                converted_measurement[key] = pylinac.calibration.trs398.mmHg2kPa(converted_measurement[key])
+            elif oldUnits[key] == "kPa":
+                pass
+            else:
+                raise ValueError(f"Invalid pressure unit: {oldUnits[key]}")
+            
+    return converted_measurement
+
+def FindAverage(numberList: list) -> float:
+    acum = 0
+    for number in numberList:
+        acum = acum + number
+    # DEBUG: FAIL. With empty value .csv input files.
+    return acum / len(numberList)
+
+def FindStdDev(numberList: list) -> float:
+    average = FindAverage(numberList)
+    acum = 0
+    for number in numberList:
+        acum = acum + (number - average) ** 2
+    return (acum / (len(numberList)-1)) ** 0.5
+
+def FindExpectedValue(numberList: list) -> float:
+    return FindAverage(numberList)
+
+def main():
+    return 0
+
+if __name__ == "__main__":
+    errorCode = main()
+    print(f"Program terminated with errorCode: {errorCode}")

accord_rt-0.2/accord/formats/fileFormats.json

@@ -0,0 +1,67 @@
+{
+    "input_preliminary": {
+        "type:": "csv",
+        "description": "Preliminary input file with raw readings of the electrometer and the temperature and pressure values.",
+        "column_delimiter": ";",
+        "columns": {
+            "index": {
+                "name": "Index",
+                "unit": "",
+                "description": "Index"
+            },
+            "T": {
+                "name": "T",
+                "unit": "°C",
+                "description": "Temperature"
+            },
+            "P": {
+                "name": "P",
+                "unit": "kPa",
+                "description": "Pressure"
+            },
+            "m": {
+                "name": "m",
+                "unit": "nC",
+                "description": "Raw reading of the electrometer"
+            }
+        }
+    }
+    ,
+    "output_preliminary": {
+        "type:": "csv",
+        "description": "Preliminary output file with corrected readings of the electrometer and the correction factor for temperature and pressure.",
+        "column_delimiter": ";",
+        "columns": {
+            "index": {
+                "name": "Index",
+                "unit": "",
+                "description": "Index"
+            },
+            "T": {
+                "name": "T",
+                "unit": "°C",
+                "description": "Temperature"
+            },
+            "P": {
+                "name": "P",
+                "unit": "kPa",
+                "description": "Pressure"
+            },
+            "m": {
+                "name": "m",
+                "unit": "nC",
+                "description": "Raw reading of the electrometer"
+            },
+            "k_TP": {
+                "name": "k_TP",
+                "unit": "",
+                "description": "Correction factor for temperature and pressure"
+            },
+            "m_corrected": {
+                "name": "m_corrected",
+                "unit": "nC",
+                "description": "Corrected reading of electrometer"
+            }
+        }
+    }
+}

accord_rt-0.2/accord/formats/quantities.json

@@ -0,0 +1,22 @@
+{
+  "index": {
+    "description": "Index of the quantity",
+    "unit": null,
+    "baseType": "int"
+  },
+  "T": {
+    "description": "Temperature",
+    "unit": "K",
+    "baseType": "float"
+  },
+  "P": {
+    "description": "Pressure",
+    "unit": "Pa",
+    "baseType": "float"
+  },
+  "m": {
+    "description": "Electrometer reading",
+    "unit": "nC",
+    "baseType": "float"
+  }
+}