isodec 2.0.0b2__py3-none-win_amd64.whl

isodec/__init__.py

@@ -0,0 +1,8 @@
+"""IsoDec charge-state assignment and deconvolution."""
+
+from ._version import __version__
+from .config import IsoDecConfig
+from .c_interface import IsoDecWrapper
+from .runtime import IsoDecRuntime
+
+__all__ = ["IsoDecConfig", "IsoDecRuntime", "IsoDecWrapper", "__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.0b2"

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)

isodec/c_interface.py

@@ -0,0 +1,434 @@
+import ctypes
+from importlib import metadata
+import os
+import platform
+import sys
+from pathlib import Path
+
+import numpy as np
+
+if not __package__:
+    sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
+    __package__ = "isodec"
+
+from .match import MatchedPeak, MatchedCollection
+from .config import IsoDecConfig
+
+_system = platform.system()
+_library_names = {
+    "Windows": "isodeclib.dll",
+    "Linux": "isodeclib.so",
+    "Darwin": "isodeclib.dylib",
+}
+try:
+    dllname = _library_names[_system]
+except KeyError as error:
+    raise ImportError(f"IsoDec does not support {_system!r}") from error
+
+_package_dir = Path(__file__).resolve().parent
+_packaged_library_path = _package_dir / "bin" / dllname
+_source_library_path = _package_dir / dllname
+
+
+def _editable_library_path():
+    """Locate scikit-build's native install during an editable install."""
+    try:
+        candidate = Path(
+            metadata.distribution("isodec").locate_file(
+                Path("isodec") / "bin" / dllname
+            )
+        )
+    except metadata.PackageNotFoundError:
+        return None
+    return candidate if candidate.is_file() else None
+
+if _packaged_library_path.is_file():
+    default_dll_path = _packaged_library_path
+elif (_package_dir.parent / "pyproject.toml").is_file() and _source_library_path.is_file():
+    default_dll_path = _source_library_path
+elif _editable_library_path() is not None:
+    default_dll_path = _editable_library_path()
+else:
+    default_dll_path = _packaged_library_path
+
+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],
+    ]
+)
+
+isodist = ctypes.c_float * 64
+matchedinds = ctypes.c_int * 32
+
+
+# print(isodist)
+class MPStruct(ctypes.Structure):
+    _fields_ = [
+        ("mz", ctypes.c_float),
+        ("z", ctypes.c_int),
+        ("monoiso", ctypes.c_float),
+        ("peakmass", ctypes.c_float),
+        ("avgmass", ctypes.c_float),
+        ("area", ctypes.c_float),
+        ("peakint", ctypes.c_float),
+        ("matchedindsiso", ctypes.c_int * 64),
+        ("matchedindsexp", ctypes.c_int * 64),
+        ("isomz", isodist),
+        ("isodist", isodist),
+        ("isomass", isodist),
+        ("monoisos", ctypes.c_float * 16),
+        ("startindex", ctypes.c_int),
+        ("endindex", ctypes.c_int),
+        ("score", ctypes.c_float),
+        ("realisolength", ctypes.c_int),
+    ]
+
+
+class IDSettings(ctypes.Structure):
+    _fields_ = [
+        ("phaseres", ctypes.c_int),
+        ("verbose", ctypes.c_int),
+        ("peakwindow", ctypes.c_int),
+        ("peakthresh", ctypes.c_float),
+        ("minpeaks", ctypes.c_int),
+        ("css_thresh", ctypes.c_float),
+        ("matchtol", ctypes.c_float),
+        ("maxshift", ctypes.c_int),
+        ("mzwindow", ctypes.c_float * 2),
+        ("plusoneintwindow", ctypes.c_float * 2),
+        ("knockdown_rounds", ctypes.c_int),
+        ("min_score_diff", ctypes.c_float),
+        ("minareacovered", ctypes.c_float),
+        ("isolength", ctypes.c_int),
+        ("mass_diff_c", ctypes.c_double),
+        ("adductmass", ctypes.c_float),
+        ("minusoneaszero", ctypes.c_int),
+        ("isotopethreshold", ctypes.c_float),
+        ("datathreshold", ctypes.c_float),
+        ("zscore_threshold", ctypes.c_float),
+    ]
+
+
+class IDConfig(ctypes.Structure):
+    _fields_ = [
+        ("verbose", ctypes.c_int),
+        ("pres", ctypes.c_int),
+        ("maxz", ctypes.c_int),
+        ("elen", ctypes.c_int),
+        ("l1", ctypes.c_int),
+        ("l2", ctypes.c_int),
+        ("l3", ctypes.c_int),
+        ("l4", ctypes.c_int),
+        ("dlen", ctypes.c_int),
+    ]
+
+
+def config_to_settings(config):
+    # print(config)
+    settings = IDSettings()
+    settings.phaseres = int(config.phaseres)
+    settings.verbose = int(config.verbose)
+    settings.peakwindow = int(config.peakwindow)
+    settings.peakthresh = float(config.peakthresh)
+    settings.minpeaks = int(config.minpeaks)
+    settings.css_thresh = float(config.css_thresh)
+    settings.matchtol = float(config.matchtol)
+    settings.maxshift = int(config.maxshift)
+    settings.mzwindow = (config.mzwindowlb, config.mzwindowub)
+    settings.plusoneintwindow = (config.plusoneintwindowlb, config.plusoneintwindowub)
+    settings.knockdown_rounds = int(config.knockdown_rounds)
+    settings.min_score_diff = config.min_score_diff
+    settings.minareacovered = config.minareacovered
+    settings.isolength = 64
+    settings.mass_diff_c = config.mass_diff_c
+    settings.adductmass = config.adductmass
+    settings.minusoneaszero = config.minusoneaszero
+    settings.isotopethreshold = config.isotopethreshold
+    settings.datathreshold = config.datathreshold
+    settings.zscore_threshold = config.zscore_threshold
+    return settings
+
+
+class IsoDecWrapper:
+    def __init__(self, dllpath=None):
+        if dllpath is None:
+            dllpath = default_dll_path
+
+        dllpath = Path(dllpath).resolve()
+        if not dllpath.is_file():
+            raise ImportError(
+                f"IsoDec's native library is missing: {dllpath}. Reinstall "
+                "isodec using a compatible wheel, or build from source "
+                "with CMake and a native compiler."
+            )
+
+        modelpath = _package_dir / "modelparams"
+
+        self.modeldir = modelpath
+
+        self._dll_directory_handle = None
+        if _system == "Windows":
+            self._dll_directory_handle = os.add_dll_directory(str(dllpath.parent))
+        try:
+            self.c_lib = ctypes.CDLL(str(dllpath))
+        except OSError as error:
+            raise ImportError(f"Unable to load IsoDec's native library {dllpath}: {error}") from error
+
+        self.c_lib.encode.argtypes = [
+            ctypes.POINTER(ctypes.c_double),
+            ctypes.POINTER(ctypes.c_float),
+            ctypes.c_int,
+            ctypes.POINTER(ctypes.c_float),
+            IDConfig,
+            IDSettings,
+        ]
+        self.c_lib.encode.restype = ctypes.c_int
+
+        self.c_lib.predict_charge.argtypes = [
+            ctypes.POINTER(ctypes.c_double),
+            ctypes.POINTER(ctypes.c_float),
+            ctypes.c_int,
+            ctypes.c_char_p,  # Model path
+        ]
+        self.c_lib.predict_charge.restype = ctypes.c_int
+
+        self.c_lib.process_spectrum.argtypes = [
+            ctypes.POINTER(ctypes.c_double),
+            ctypes.POINTER(ctypes.c_float),
+            ctypes.c_int,
+            ctypes.c_char_p,
+            ctypes.POINTER(MPStruct),
+            IDSettings,
+            ctypes.c_char_p,
+        ]
+        self.c_lib.process_spectrum.restype = ctypes.c_int
+
+        self.c_lib.DefaultSettings.argtypes = []
+        self.c_lib.DefaultSettings.restype = IDSettings
+
+        self.modeldir = str(modelpath)
+        # self.modelpath = ctypes.c_char_p(
+        #     os.path.join(self.modeldir, "phase_model_8.bin").encode()
+        # )
+        # Create null pointer for model path
+        self.modelpath = None
+        self.config = IsoDecConfig()
+        # self.determine_model()
+
+    def encode(self, centroids, maxz=50, phaseres=8, config=None):
+        cmz = centroids[:, 0].astype(np.double)
+        cint = centroids[:, 1].astype(np.float32)
+        elen = maxz * phaseres
+        emat = np.zeros(elen).astype(np.float32)
+        idconf = IDConfig()
+        idconf.pres = phaseres
+        idconf.maxz = maxz
+        idconf.elen = elen
+
+        if config is not None:
+            self.config = config
+        settings = config_to_settings(self.config)
+
+        self.c_lib.encode(
+            cmz.ctypes.data_as(ctypes.POINTER(ctypes.c_double)),
+            cint.ctypes.data_as(ctypes.POINTER(ctypes.c_float)),
+            ctypes.c_int(len(cmz)),
+            emat.ctypes.data_as(ctypes.POINTER(ctypes.c_float)),
+            idconf,
+            settings,
+        )
+        # Convert emat to numpy
+        emat = np.ctypeslib.as_array(emat)
+        return emat
+
+    def predict_charge(self, centroids, config=None):
+
+        cmz = centroids[:, 0].astype(np.double)
+        cint = centroids[:, 1].astype(np.float32)
+        # charge = ctypes.c_int(0)
+        # self.modelpath = ctypes.c_char_p(None)
+
+        charge = self.c_lib.predict_charge(
+            cmz.ctypes.data_as(ctypes.POINTER(ctypes.c_double)),
+            cint.ctypes.data_as(ctypes.POINTER(ctypes.c_float)),
+            ctypes.c_int(len(cmz)),
+            self.modelpath,
+            # ctypes.byref(charge),
+        )
+        return charge
+
+    def process_spectrum(self, centroids, pks=None, config=None, input_type=None):
+
+        if input_type is None:
+            input_type = "Peptide"
+        type_c = ctypes.c_char_p(input_type.encode('utf-8'))
+
+        cmz = centroids[:, 0].astype(np.double)
+        cint = centroids[:, 1].astype(np.float32)
+        n = len(cmz)
+
+        if config is not None:
+            self.config = config
+        settings = config_to_settings(self.config)
+
+        elems = (MPStruct * n)()
+        matchedpeaks = ctypes.cast(elems, ctypes.POINTER(MPStruct))
+
+        nmatched = self.c_lib.process_spectrum(
+            cmz.ctypes.data_as(ctypes.POINTER(ctypes.c_double)),
+            cint.ctypes.data_as(ctypes.POINTER(ctypes.c_float)),
+            ctypes.c_int(n),
+            self.modelpath,
+            matchedpeaks,
+            settings,
+            type_c,
+        )
+
+        if pks is None:
+            pks = MatchedCollection()
+        for p in matchedpeaks[:nmatched]:
+            if p.z == 0:
+                continue
+
+            # Extract peak centroid data
+            startindex = p.startindex
+            endindex = p.endindex
+            if startindex < 0 or endindex < 0 or endindex <= startindex:
+                raise ValueError("Invalid start or end index in matched peak.")
+            pkcent = centroids[startindex:endindex + 1]
+
+            pk = MatchedPeak(p.z, p.mz, p.avgmass, centroids=pkcent, config=self.config)
+            pk.monoiso = p.monoiso
+            pk.peakmass = p.peakmass
+            pk.avgmass = p.avgmass
+
+            monoisos = np.array(p.monoisos)
+            monoisos = monoisos[monoisos > 0]
+            pk.monoisos = monoisos
+
+            if config is not None:
+                pk.scan = config.activescan
+                pk.ms_order = config.activescanorder
+                pk.rt = config.activescanrt
+
+            isodist = np.array(p.isodist)
+            isomz = np.array(p.isomz)
+            isomass = np.array(p.isomass)
+            b1 = isodist > np.amax(isodist) * 0.001
+            isodist = isodist[b1]
+            isomz = isomz[b1]
+            isomass = isomass[b1]
+            pk.matchedintensity = np.sum(isodist)
+            pk.peakint = p.peakint
+
+            # pk.isodist = calc_isotope_dist(p.monoiso, p.z)
+            pk.isodist = np.transpose((isomz, isodist))
+            # pk.isodist[:, 1] = p.peakint
+
+            pk.massdist = np.transpose((isomass, isodist))
+
+            pk.startindex = p.startindex
+            pk.endindex = p.endindex
+
+            pks.add_peak(pk)
+            pks.add_pk_to_masses(pk, config=self.config)
+        return pks
+
+    def determine_model(self, default=True):
+        if default:
+            self.modelpath = None
+        else:
+            print("Model Directory:", self.modeldir)
+            if self.config.phaseres == 4:
+                self.modelpath = ctypes.c_char_p(
+                    os.path.join(self.modeldir, "phase_model_4.bin").encode('utf-8')
+                )
+            elif self.config.phaseres == 8:
+
+                self.modelpath = ctypes.c_char_p(
+                    os.path.join(self.modeldir, "phase_model_8.bin").encode('utf-8')
+                )
+            else:
+                print("Invalid phase resolution.", self.config.phaseres)
+                raise ValueError("Invalid phase resolution.")
+
+            if self.config.verbose:
+                print(
+                    "Running C code with phaseres of:",
+                    self.config.phaseres,
+                )
+
+
+if __name__ == "__main__":
+    eng = IsoDecWrapper()
+    #
+    # eng.config.phaseres = 4
+    # eng.encode(example)
+    # print(eng.predict_charge(example))
+    # dat = eng.process_spectrum(example)
+    #
+    # print(dat)
+    filepath = "C:\\Data\\IsoNN\\test2.txt"
+    spectrum = np.loadtxt(filepath, skiprows=0)
+    pks = eng.process_spectrum(spectrum)
+    print(len(pks.peaks))
+
+    # Find peak with monoiso near 6396
+    for pk in pks.masses:
+        if 6395 < pk.monoiso < 6397:
+            print("Found Peak:", pk)
+            cplot(pk.decon_centroids, color="k", factor=1)
+            cplot(pk.massdist, color="k", factor=-1)
+            import matplotlib.pyplot as plt
+
+            colors = plt.rcParams['axes.prop_cycle'].by_key()['color']
+            for i, p in enumerate(pk.clusters):
+                print("  Subpeak:", p)
+                # if p.monoiso > 6396:
+                #     continue
+                cplot(p.decon_centroids, color=colors[i % len(colors)], factor=1)
+                cplot(p.massdist, color=colors[i % len(colors)], factor=-1)
+            plt.show()
+
+
+    exit()
+    # filepath = "C:\\Data\\IsoNN\\test2.txt"
+    filepath = "Z:\\Group Share\\JGP\\js8b05641_si_001\\etd_spectrum.txt"
+    spectrum = np.loadtxt(filepath, skiprows=0)
+    spectrum2 = datachop(spectrum, 891.195, 893.757)
+
+
+    e1 = eng.encode(spectrum2)
+    print("Encoded:", e1.shape)
+
+    # z = eng.predict_charge(spectrum2)
+    # print("Predicted Charge:", z)
+
+    # exit()
+    pks = eng.process_spectrum(spectrum2)
+    print(len(pks.peaks))
+    # exit()
+    plot_pks(pks, centroids=spectrum, show=True, title="C Interface")
+    plt.show()