isodec 2.0.4__py3-none-win_arm64.whl

isodec/__init__.py

@@ -0,0 +1,15 @@
+"""IsoDec charge-state assignment and deconvolution."""
+
+from ._version import __version__
+from .config import IsoDecConfig
+from .c_interface import IsoDecWrapper
+from .fragment_matching import match_fragments
+from .runtime import IsoDecRuntime
+
+__all__ = [
+    "IsoDecConfig",
+    "IsoDecRuntime",
+    "IsoDecWrapper",
+    "match_fragments",
+    "__version__",
+]

isodec/__main__.py

@@ -0,0 +1,45 @@
+"""Command-line interface for IsoDec."""
+
+import argparse
+import sys
+from pathlib import Path
+
+if not __package__:
+    sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
+    __package__ = "isodec"
+
+from .runtime import IsoDecRuntime
+
+
+def build_parser():
+    parser = argparse.ArgumentParser(
+        prog="isodec",
+        description="Assign charge states and deconvolve isotopically resolved mass spectra.",
+    )
+    parser.add_argument("spectrum", type=Path, help="Input spectrum (TXT, DAT, CSV, NPZ, or a UniDec-supported format)")
+    parser.add_argument("-o", "--output", type=Path, help="Output TSV filename")
+    parser.add_argument("--centroided", action="store_true", help="Treat the input as centroid data")
+    parser.add_argument("--type", choices=("PEPTIDE", "RNA"), default="PEPTIDE", help="Analyte isotope model")
+    parser.add_argument("--quiet", action="store_true", help="Suppress progress output")
+    return parser
+
+
+def main(argv=None):
+    args = build_parser().parse_args(argv)
+    if not args.spectrum.is_file():
+        raise SystemExit(f"Spectrum does not exist: {args.spectrum}")
+
+    engine = IsoDecRuntime(verbose=not args.quiet)
+    engine.analyte_type = args.type
+    engine.process_file(
+        str(args.spectrum),
+        assume_centroided=args.centroided,
+        verbose=not args.quiet,
+    )
+    output = args.output or args.spectrum.with_name(f"{args.spectrum.stem}_isodec.tsv")
+    engine.pks.export_tsv(output, report_multiple_monoisos=engine.config.report_multiple_monoisos)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

isodec/_version.py

@@ -0,0 +1,3 @@
+"""Single source of truth for the package version."""
+
+__version__ = "2.0.4"

isodec/altdecon.py

@@ -0,0 +1,127 @@
+import numpy as np
+import matplotlib.pyplot as plt
+import sys
+from pathlib import Path
+
+if not __package__:
+    sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
+    __package__ = "isodec"
+
+from . import tools as ud
+
+example = np.array(
+    [
+        [5.66785531e02, 1.47770838e06],
+        [5.67057354e02, 1.54980838e06],
+        [5.67507468e02, 5.21600520e07],
+        [5.67708173e02, 8.35557760e07],
+        [5.67908401e02, 7.28264240e07],
+        [5.68060254e02, 1.87337225e06],
+        [5.68108674e02, 4.35435520e07],
+        [5.68239256e02, 3.88155375e06],
+        [5.68309390e02, 2.05468060e07],
+        [5.68509951e02, 7.18109250e06],
+        [5.68707871e02, 2.30373500e06],
+        [5.69150563e02, 1.57598062e06],
+        [5.69243121e02, 1.96390440e07],
+        [5.69334393e02, 6.82677120e07],
+        [5.69425337e02, 1.22867432e08],
+        [5.69516492e02, 1.45702336e08],
+        [5.69607541e02, 1.20801936e08],
+        [5.69698595e02, 1.06786072e08],
+        [5.69789906e02, 6.56232960e07],
+        [5.69881208e02, 3.41013880e07],
+        [5.69972168e02, 1.70930360e07],
+        [5.70063432e02, 9.17621100e06],
+        [5.70699369e02, 1.96462650e06],
+    ]
+)
+
+import numpy as np
+from scipy import signal
+
+MAX_CHARGE = 50
+
+
+def gen_thrash_arrays(centroids, startpad=10):
+    max_mz = centroids[-1, 0]
+    min_mz = centroids[0, 0]
+
+    additional = 4 - (max_mz - min_mz)
+    if additional < 0:
+        additional = 0
+    else:
+        max_mz += additional / 2
+        min_mz -= additional / 2
+
+    num_l = int((max_mz - min_mz) * MAX_CHARGE * 8)
+
+    intx = np.linspace(min_mz, max_mz, num_l)
+    if len(intx) <= 1:
+        return None, None, None, None, None, None
+
+    linear_data = ud.lintegrate(centroids, intx, fastmode=True)
+    if len(linear_data) <= 1:
+        return None, None, None, None, None, None
+
+    corry = signal.fftconvolve(linear_data[:, 1], linear_data[:, 1][::-1], mode='same')
+    maxposition = np.argmax(corry)
+    ac = corry[maxposition + startpad:]
+
+
+    acx = intx - intx[0]
+    acx = 1 / acx[startpad:len(ac) + startpad]
+
+    fft = np.fft.fft(linear_data[:, 1])
+    fft = np.abs(fft)
+    fft = fft[startpad:len(ac) + startpad]
+
+    fftx = np.fft.fftfreq(len(linear_data[:, 1]), d=(linear_data[1, 0] - linear_data[0, 0]))
+    fftx = fftx[startpad:len(ac) + startpad]
+    b1 = fftx < MAX_CHARGE
+    fft = fft[b1]
+    fftx = fftx[b1]
+
+    fft /= np.max(fft)
+    ac2 = ud.lintegrate(np.transpose([acx, ac]), fftx)
+
+
+    acx, ac = ac2[:, 0], ac2[:, 1]
+    ac /= np.max(ac)
+    mul = ac * fft
+    return linear_data, ac, fft, mul, fftx, acx
+
+def thrash_predict(centroids):
+    linear_data, ac, fft, mul, fftx, acx = gen_thrash_arrays(centroids)
+    if linear_data is None or len(mul) == 0:
+        return 0
+    maxpos = np.argmax(mul)
+
+    charge = acx[maxpos]
+    return round(charge)
+
+
+if __name__ == "__main__":
+    example = np.loadtxt("Z:\\Group Share\\JGP\\MockData\\mockdata_centroids.csv", delimiter=",")
+    example = ud.datachop(example, 326,327)
+    for i in range(len(example)):
+        plt.plot([example[i, 0], example[i, 0]], [0, example[i, 1]], color="black")
+    plt.show()
+
+
+
+    raw_data = example
+    charge_state = thrash_predict(raw_data)
+    print(charge_state)
+
+    linear_data, ac, fft, mul, fftx, acx = gen_thrash_arrays(raw_data)
+
+    plt.subplot(121)
+    plt.plot(linear_data[:, 0], linear_data[:, 1])
+    plt.subplot(122)
+    plt.plot(acx, mul, label="Mul")
+    plt.plot(acx, ac-1, label="AC")
+    plt.plot(fftx, fft-2, label="FFT")
+    plt.legend()
+    plt.show()
+

isodec/bin_to_header.py

@@ -0,0 +1,56 @@
+"""Convert a PyTorch model to a binary file and C header."""
+
+from pathlib import Path
+
+import torch
+
+
+def pth_to_bin(pth_file, bin_file):
+    """Flatten a PyTorch state dictionary into a raw float32 binary file."""
+    pth_file = Path(pth_file)
+    bin_file = Path(bin_file)
+
+    state_dict = torch.load(pth_file, map_location="cpu", weights_only=True)
+    weights = torch.cat([tensor.flatten() for tensor in state_dict.values()])
+    weights.detach().cpu().numpy().tofile(bin_file)
+
+
+def bin_to_header(bin_file, header_file, varname="model_weights"):
+    """Write the bytes from ``bin_file`` to a C array in ``header_file``."""
+    bin_file = Path(bin_file)
+    header_file = Path(header_file)
+    data = bin_file.read_bytes()
+    guard = f"{varname.upper()}_H"
+
+    with header_file.open("w", encoding="ascii", newline="\n") as outfile:
+        outfile.write(f"#ifndef {guard}\n")
+        outfile.write(f"#define {guard}\n\n")
+        outfile.write(f"// Generated from {bin_file.name}\n")
+        outfile.write(f"static const unsigned char {varname}[] = {{\n")
+
+        for start in range(0, len(data), 12):
+            chunk = data[start:start + 12]
+            values = ", ".join(f"0x{byte:02x}" for byte in chunk)
+            if start + 12 < len(data):
+                values += ","
+            outfile.write(f"  {values}\n")
+
+        outfile.write("};\n")
+        outfile.write(f"static const unsigned int {varname}_len = {len(data)};\n\n")
+        outfile.write(f"#endif // {guard}\n")
+
+
+if __name__ == "__main__":
+    isodec_dir = Path(__file__).resolve().parent
+
+    model_dir = isodec_dir / "modelparams"
+    input_pth = model_dir / "phase_model_8.pth"
+    output_bin = model_dir / "phase_model_8.bin"
+    output_header = isodec_dir / "src_cmake" / "phase_model_8.h"
+    variable_name = "phase_model_8_bin"
+
+    pth_to_bin(input_pth, output_bin)
+    print("Wrote binary model:", output_bin)
+
+    bin_to_header(output_bin, output_header, variable_name)
+    print("Wrote C header:", output_header)