lcmodel-wrapper 0.1.0__tar.gz

lcmodel_wrapper-0.1.0/PKG-INFO

@@ -0,0 +1,62 @@
+Metadata-Version: 2.4
+Name: lcmodel_wrapper
+Version: 0.1.0
+Summary: Python wrapper for LCModel MRS fitting
+Author-email: Julian Merkofer <j.p.merkofer@tue.nl>
+License: MIT
+Project-URL: Homepage, https://github.com/yourusername/PyLCModel
+Project-URL: Repository, https://github.com/yourusername/PyLCModel
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: numpy>=1.22
+Requires-Dist: scipy>=1.10
+Requires-Dist: fsl_mrs>=2.1.0
+
+# PyLCModel
+
+**PyLCModel** is a Python wrapper designed to streamline the use of LCModel for least-squares spectral fitting in MRS. It takes the complexity out of setting up LCModel by automating control file generation, handling data conversions, and managing execution (with support for both single and multi-core processing).
+
+---
+
+## Features
+
+- **Easy Setup:** Quickly run LCModel with minimal code.
+- **Automated Control Files:** Dynamically generates and adjusts LCModel control files to suit your data.
+- **Multiprocessing Support:** Leverage multiple cores to accelerate batch processing.
+- **Data Conversion:** Seamlessly converts to .raw for execution. (Coming soon: conversion to .basis)
+- **Robust Output Parsing:** Extracts metabolite concentrations and CRLBs from LCModel output.
+
+---
+
+## Installation
+
+### From Source
+```bash
+git clone https://github.com/julianmer/PyLCModel.git
+cd PyLCModel
+pip install -e .
+```
+
+### From PyPI *(once published)*
+```bash
+pip install lcmodel
+```
+
+---
+
+## Getting Started
+
+```python
+from lcmodel_wrapper import LCModel
+
+# Initialize the LCModel wrapper with your basis set
+lcmodel = LCModel(path2basis='/path/to/your/basis_set.basis')
+
+# Assuming `data` is your MRS data in the frequency domain as a NumPy array
+# Fit the data using LCModel
+concentrations, crlbs = lcmodel(data)
+
+# Print results
+print("Fitted Metabolite Concentrations:", concentrations)
+print("CRLBs:", crlbs)
+```

lcmodel_wrapper-0.1.0/README.md

@@ -0,0 +1,48 @@
+# PyLCModel
+
+**PyLCModel** is a Python wrapper designed to streamline the use of LCModel for least-squares spectral fitting in MRS. It takes the complexity out of setting up LCModel by automating control file generation, handling data conversions, and managing execution (with support for both single and multi-core processing).
+
+---
+
+## Features
+
+- **Easy Setup:** Quickly run LCModel with minimal code.
+- **Automated Control Files:** Dynamically generates and adjusts LCModel control files to suit your data.
+- **Multiprocessing Support:** Leverage multiple cores to accelerate batch processing.
+- **Data Conversion:** Seamlessly converts to .raw for execution. (Coming soon: conversion to .basis)
+- **Robust Output Parsing:** Extracts metabolite concentrations and CRLBs from LCModel output.
+
+---
+
+## Installation
+
+### From Source
+```bash
+git clone https://github.com/julianmer/PyLCModel.git
+cd PyLCModel
+pip install -e .
+```
+
+### From PyPI *(once published)*
+```bash
+pip install lcmodel
+```
+
+---
+
+## Getting Started
+
+```python
+from lcmodel_wrapper import LCModel
+
+# Initialize the LCModel wrapper with your basis set
+lcmodel = LCModel(path2basis='/path/to/your/basis_set.basis')
+
+# Assuming `data` is your MRS data in the frequency domain as a NumPy array
+# Fit the data using LCModel
+concentrations, crlbs = lcmodel(data)
+
+# Print results
+print("Fitted Metabolite Concentrations:", concentrations)
+print("CRLBs:", crlbs)
+```

lcmodel_wrapper-0.1.0/pyproject.toml

@@ -0,0 +1,31 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "lcmodel_wrapper"
+version = "0.1.0"
+description = "Python wrapper for LCModel MRS fitting"
+readme = "README.md"
+requires-python = ">=3.8"
+license = { text = "MIT" }
+
+authors = [
+  { name = "Julian Merkofer", email = "j.p.merkofer@tue.nl" }
+]
+
+dependencies = [
+  "numpy>=1.22",
+  "scipy>=1.10",
+  "fsl_mrs>=2.1.0"
+]
+
+[project.urls]
+Homepage = "https://github.com/yourusername/PyLCModel"
+Repository = "https://github.com/yourusername/PyLCModel"
+
+[tool.setuptools]
+package-dir = {"" = "src"}
+
+[tool.setuptools.packages.find]
+where = ["src"]

lcmodel_wrapper-0.1.0/setup.cfg

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

lcmodel_wrapper-0.1.0/src/lcmodel_wrapper/__init__.py

@@ -0,0 +1 @@
+from .lcmodel_wrapper import PyLCModel

lcmodel_wrapper-0.1.0/src/lcmodel_wrapper/lcmodel_wrapper.py

@@ -0,0 +1,460 @@
+####################################################################################################
+#                                        lcmodel_wrapper.py                                        #
+####################################################################################################
+#                                                                                                  #
+# Authors: J. P. Merkofer (j.p.merkofer@tue.nl)                                                    #
+#                                                                                                  #
+# Created: 20/06/24                                                                                #
+#                                                                                                  #
+# Purpose: Python wrapper for the LCModel optimization framework for least-squares fitting         #
+#          of spectra.                                                                             #
+#                                                                                                  #
+####################################################################################################
+
+
+#*************#
+#   imports   #
+#*************#
+import multiprocessing
+import numpy as np
+import os
+import platform
+import re
+import shutil
+import subprocess
+import time
+
+from fsl_mrs.utils import mrs_io
+
+from scipy.optimize import minimize
+
+
+
+#**************************************************************************************************#
+#                                           Class LCModel                                          #
+#**************************************************************************************************#
+#                                                                                                  #
+# The framework wrapper for the LCModel fitting tool.                                              #
+#                                                                                                  #
+#**************************************************************************************************#
+class LCModel():
+    def __init__(self, path2basis, control=None, multiprocessing=False, ppmlim=(0.5, 4.2),
+                 conj=True, ignore='default', save_path='', path2exec=None, sample_points=None,
+                 bandwidth=None, **kwargs):
+
+        self.basisFSL = mrs_io.read_basis(path2basis)
+        self.control = control
+        self.multiprocessing = multiprocessing
+        self.save_path = save_path
+        self.conj = conj
+        if sample_points is None: self.sample_points = self.basisFSL.original_points
+        else: self.sample_points = sample_points
+        if bandwidth is None: self.bandwidth = self.basisFSL.original_bw
+        else: self.bandwidth = bandwidth
+
+        if path2exec is None:   # infer path to LCModel executable (and os system)
+            print(f'Warning -- path2exec not specified, trying to use internal binaries...')
+            print(f'           It is recommended to provide an own executable for LCModel!')
+            if os.name == 'nt':
+                self.path2exec = (os.path.dirname(os.path.realpath(__file__)) + os.sep + 'lcmodel'
+                                  + os.sep + 'executables' + os.sep + 'win' + os.sep + 'win10'
+                                  + os.sep + 'LCModel.exe')
+                if platform.release() != '10':   # warning if not win10
+                    print(f'Warning -- LCModel binaries are for Windows 10, but you are using '
+                          f'{platform.release()}!')
+            elif os.name == 'posix':
+                if platform.system() == 'Darwin':
+                    self.path2exec = (f'{os.path.dirname(os.path.realpath(__file__))}'
+                                      f'/lcmodel/executables/mac/lcmodel')
+                    os.chmod(self.path2exec, 0o755)  # make executable
+                elif platform.system() == 'Linux':
+                    self.path2exec = (f'{os.path.dirname(os.path.realpath(__file__))}'
+                                      f'/lcmodel/executables/linux/lcmodel')
+                    os.chmod(self.path2exec, 0o755)  # make executable
+        else: self.path2exec = path2exec
+
+        # ignore metabolites
+        if isinstance(ignore, str):
+            if ignore.lower() == 'default': ignore = ['Lip13a', 'Lip13b', 'Lip09', 'Lip20',
+                                                      'MM09', 'MM12', 'MM14', 'MM17', 'MM20',
+                                                      '-CrCH2', 'CrCH2']
+            elif ignore.lower() == 'none': ignore = []
+            else: raise ValueError('Unknown preset string... Please use one of the predefined '
+                                   'or provide a list of metabolite names!')
+        elif not isinstance(ignore, list):
+            raise ValueError('Ignore must be a list of metabolite names or a string!')
+
+        # TODO: convert basis to LCModel format (if necessary)
+        if not path2basis.lower().endswith('.basis'):
+            raise ValueError('Basis file must be in .basis format! (For now... Sorry!)')
+
+        # parse control file
+        if control is not None:
+            control = open(control, 'r').read()
+            self.control = control.split('\n')
+
+            # overwrite basis
+            for i, line in enumerate(self.control):
+                if line.startswith('filbas='):
+                    if not line[1:-1].split(os.sep)[-1] == path2basis.split(os.sep)[-1]:
+                        print(f'Warning -- overwriting filbas in control file with'
+                              f' {os.path.abspath(path2basis)}')
+                    self.control[i] = f"filbas='{os.path.abspath(path2basis)}'"
+
+            # adjust ppm limits
+            for i, line in enumerate(self.control):
+                if line.startswith('ppmst='):
+                    if not line.split('=')[1] == str(ppmlim[1]):   # warning if limits aren't equal
+                        print(f'Warning -- overwriting ppmst in control file with {ppmlim[1]}')
+                    self.control[i] = f'ppmst={ppmlim[1]}'
+                if line.startswith('ppmend='):
+                    if not line.split('=')[1] == str(ppmlim[0]):   # warning if limits aren't equal
+                        print(f'Warning -- overwriting ppmend in control file with {ppmlim[0]}')
+                    self.control[i] = f'ppmend={ppmlim[0]}'
+
+            # overwrite ignore metabolites
+            for i, line in enumerate(self.control):
+                if line.startswith('nomit='):
+                    if not line.split('=')[1] == str(len(ignore)):   # warning if ignore isn't equal
+                        print(f'Warning -- overwriting nomit in control file with '
+                              f'{len(ignore)} for {ignore}...')
+                    self.control[i] = f'nomit={len(ignore)}'
+                    for j, met in enumerate(ignore):
+                        self.control.insert(i+j+1, f'chomit({j+1})=\'{met}\'')
+                    break
+
+        else:
+            lines = []
+            lines.append(f"$LCMODL")
+            lines.append(f"nunfil={self.sample_points}")  # data points
+            lines.append(f"deltat={1. / self.bandwidth}")  # dwell time
+            lines.append(f"hzpppm={self.basisFSL.cf}")  # field strength in MHz
+            lines.append(f"ppmst={ppmlim[1]}")
+            lines.append(f"ppmend={ppmlim[0]}")
+
+            lines.append(f"dows=F")   # 'T' <-> do water scaling
+            lines.append(f"neach=99")   # number of metabolites to plot fit individually
+
+            lines.append(f"filbas='{os.path.abspath(path2basis)}'")
+
+            lines.append(f"filraw='example.raw'")
+            lines.append(f"filps='example.ps'")
+            lines.append(f"filcoo='example.coord'")
+            lines.append(f"filh2o='example.h2o'")
+
+            lines.append(f"lcoord=9")  # 0 <-> surpress creation of coord file, 9 <-> don't surpress
+            lines.append(f"nomit={len(ignore)}")
+            for i, met in enumerate(ignore):
+                lines.append(f"chomit({i+1})=\'{met}\'")
+            lines.append(f"namrel='Cr+PCr'")
+
+            # lines.append(f"nratio=0")   # number of soft constraints (default 12, see manual)
+            # lines.append(f"sddegz=6")   # 6 <-> eddy current correction
+            # lines.append(f"dkntmn=0.5")   # limit knot spacing of baseline (max 1/3 of ppm range)
+            lines.append(f"$END")
+
+            self.control = lines
+
+
+    #**********************#
+    #   forward function   #
+    #**********************#
+    def __call__(self, *args, **kwargs):
+        return self.forward(*args, **kwargs)
+
+
+    #*************************#
+    #   optimal referencing   #
+    #*************************#
+    def optimalReference(self, t, t_hat):
+        w = np.ones(t.shape[0])
+        for i in range(t.shape[0]):
+            def err(w):
+                w = np.clip(w, 0, None)
+                return np.abs(t[i] - w * t_hat[i]).mean()
+
+            w[i] = minimize(err, w[i], bounds=[(0, None)]).x
+        return w[..., np.newaxis]
+
+
+    #****************************#
+    #   loss on concentrations   #
+    #****************************#
+    def concsLoss(self, t, t_hat, type='ae'):
+        t = t[:, :self.basisFSL.n_metabs]
+        t_hat = t_hat[:, :self.basisFSL.n_metabs]
+
+        if type == 'ae':  # absolute error
+            return np.abs(t - t_hat)
+        else:
+            raise ValueError('Unknown loss type... Please use one of the predefined!')
+
+
+    #*********************#
+    #   input to output   #
+    #*********************#
+    def forward(self, x, x_ref=None, frac=None, x0=None):
+        assert x0 is None, 'Initial values not supported... (please set x0=None)'
+
+        theta = self.lcmodel_minimize(x, x_ref, frac)
+        return theta
+
+
+    #*********************#
+    #   LCModel fitting   #
+    #*********************#
+    def lcmodel_minimize(self, x, x_ref=None, frac=None):
+        thetas, crlbs = [], []
+        x = x[:, 0] + 1j * x[:, 1]
+        fids = np.fft.ifft(x, axis=-1)   # to time domain
+        if self.conj:
+            fids = np.conjugate(fids)   # conjugate if necessary
+            if x_ref is not None: x_ref = np.conjugate(x_ref)
+
+        # create temporary directory
+        if self.save_path == '' or self.save_path is None:
+            path = os.getcwd() + os.sep + 'tmp' + os.sep
+        else:
+            path = os.getcwd() + os.sep + self.save_path + os.sep
+        if not os.path.exists(path): os.makedirs(path)
+
+        # run
+        if self.multiprocessing:   # multi threading
+            tasks = [(fids[i], x_ref, frac, i, path) for i in range(fids.shape[0])]
+            with multiprocessing.Pool(None) as pool:
+                thetas, crlbs = zip(*pool.starmap(self.lcm_forward, tasks))
+
+        else:  # loop
+            for i, fid in enumerate(fids):
+                theta, crlb = self.lcm_forward(fid, x_ref, frac, i, path)
+                thetas.append(theta)
+                crlbs.append(crlb)
+
+        # remove temporary folder
+        if self.save_path == '' or self.save_path is None:
+            shutil.rmtree(path, ignore_errors=True)
+        else:
+            # ... or save control file to save path
+            with open(f'{path + os.sep}control', 'w') as file:
+                file.write('\n'.join(self.control))
+
+        return np.array(thetas), np.array(crlbs)
+
+
+    #************************#
+    #   write to .raw file   #
+    #************************#
+    def to_raw(self, fid, file_path, header=" $NMID\n  id='', fmtdat='(2E15.6)'\n $END\n"):
+        with open(file_path, 'w') as file:
+            file.write(header)
+            for num in fid:
+                file.write(f"  {num.real: .6E} {num.imag: .6E}\n")
+
+
+    #*************************#
+    #   read from .raw file   #
+    #*************************#
+    def from_raw(self, path):
+        with open(path, 'r') as f:
+            lines = f.readlines()
+            for i, line in enumerate(lines):
+                if line.split()[0] == '$END': break
+            fid = [complex(float(line.split()[0]),
+                           float(line.split()[1])) for line in lines[i+1:]]
+        return np.array(fid)
+
+
+    #*************************#
+    #   run LCModel wrapper   #
+    #*************************#
+    def lcm_forward(self, fid, h2o=None, frac=None, idx=0, path=os.getcwd() + os.sep + 'tmp' + os.sep):
+        # transform to a .raw file
+        assert fid.shape[0] == self.sample_points, \
+            'Number of points in FID does not match sample points!'
+        self.to_raw(fid, f'{path + os.sep}temp{idx}.raw')
+
+        # transform to a .h2o file
+        if h2o is not None:
+            self.to_raw(h2o[idx], f'{path + os.sep}temp{idx}.h2o')
+
+            # write control file
+            for i, line in enumerate(self.control):
+                if line.startswith('dows='): self.control[i] = 'dows=T'
+
+        # tissue correction
+        if frac is not None:
+            wconc = (43300 * frac[idx]['GM'] + 35880 * frac[idx]['WM'] + 
+                     55556 * frac[idx]['CSF']) / (1 - frac[idx]['CSF'])
+
+            # write control file
+            for i, line in enumerate(self.control):
+                if line.startswith('wconc='): self.control[i] = f'wconc={int(wconc)}'
+
+        # run LCModel
+        self.initiate(f'{path + os.sep}temp{idx}.raw')
+
+        # wait for .coord file
+        while not os.path.exists(f'{path + os.sep}temp{idx}.coord'): time.sleep(1e-3)   # 1ms
+
+        # read .coord file
+        metabs, concs, crlbs, tcr = self.read_LCModel_coord(f'{path}temp{idx}.coord',
+                                                            meta=False)
+        # sort concentrations by basis names
+        concs = [concs[metabs.index(met)] if met in metabs else 0.0
+                 for met in self.basisFSL._names]
+        crlbs = [crlbs[metabs.index(met)] if met in metabs else 999.0
+                 for met in self.basisFSL._names]
+        return concs, crlbs
+
+
+    #******************************#
+    #   initiate routine on .raw   #
+    #******************************#
+    def initiate(self, file_path):
+        # write control file
+        for i, line in enumerate(self.control):
+            if line.startswith('filraw='): self.control[i] = f'filraw=\'{file_path}\''
+            if line.startswith('filps='): self.control[i] = f'filps=\'{file_path[:-4]}.ps\''
+            if line.startswith('filcoo='): self.control[i] = f'filcoo=\'{file_path[:-4]}.coord\''
+            if line.startswith('filh2o='): self.control[i] = f'filh2o=\'{file_path[:-4]}.h2o\''
+
+        msg = '\n'.join(self.control)
+        msg = msg.encode('utf-8')
+
+        # run LCModel
+        proc = subprocess.Popen(
+            [self.path2exec, ],
+            shell=True,
+            stdin=subprocess.PIPE,
+            stdout=subprocess.PIPE,
+        )
+        stdout_value, stderr_value = proc.communicate(msg)
+
+        # error handling
+        if not (stdout_value == b'' or stdout_value is None): print(stdout_value)
+        if not (stderr_value == b'' or stderr_value is None): print(stderr_value)
+
+
+    #**************************#
+    #   setter for save path   #
+    #**************************#
+    def set_save_path(self, path):
+        self.save_path = path
+
+    #*****************************#
+    #   load LCModel coord data   #
+    #*****************************#
+    def read_LCModel_coord(self, path, coord=True, meta=True):
+        metabs, concs, crlbs, tcr = [], [], [], []
+        fwhm, snr, shift, phase = None, None, None, None
+
+        # go through file and extract all info
+        with open(path, 'r') as file:
+            concReader = 0
+            miscReader = 0
+
+            for line in file:
+                if 'lines in following concentration table' in line:
+                    concReader = int(line.split(' lines')[0])
+                elif concReader > 0:  # read concentration table
+                    concReader -= 1
+                    values = line.split()
+
+                    # check if in header of table
+                    if values[0] == 'Conc.':
+                        continue
+                    else:
+                        try:  # sometimes the fields are fused together with '+'
+                            m = values[3]
+                            c = float(values[2])
+                        except:
+                            if 'E+' in values[2]:  # catch scientific notation
+                                c = values[2].split('E+')
+                                m = str(c[1].split('+')[1:])
+                                c = float(c[0] + 'e+' + c[1].split('+')[0])
+                            else:
+                                if len(values[2].split('+')) > 1:
+                                    m = str(values[2].split('+')[1:])
+                                    c = float(values[2].split('+')[0])
+                                elif len(values[2].split('-')) > 1:
+                                    m = str(values[2].split('-')[1:])
+                                    c = float(values[2].split('-')[0])
+                                else:
+                                    raise ValueError(f'Could not parse {values}')
+
+                        # append to data
+                        metabs.append(m)
+                        concs.append(float(values[0]))
+                        crlbs.append(int(values[1][:-1]))
+                        tcr.append(c)
+                        continue
+
+                if 'lines in following misc. output table' in line:
+                    miscReader = int(line.split(' lines')[0])
+                elif miscReader > 0:  # read misc. output table
+                    miscReader -= 1
+                    values = line.split()
+
+                    # extract info
+                    if 'FWHM' in values:
+                        fwhm = float(values[2])
+                        snr = float(values[-1].split('=')[-1])
+                    elif 'shift' in values:
+                        if values[3] == 'ppm':
+                            shift = float(values[2][1:])  # negative fuses with '='
+                        else:
+                            shift = float(values[3])
+                    elif 'Ph' in values:
+                        phase = float(values[1])
+
+        if coord and meta:
+            return metabs, concs, crlbs, tcr, fwhm, snr, shift, phase
+        elif coord:
+            return metabs, concs, crlbs, tcr
+        elif meta:
+            return fwhm, snr, shift, phase
+
+
+    #**************************************#
+    #   load LCModel fit from coord data   #
+    #**************************************#
+    def read_LCModel_fit(self, path):
+        # Source: https://gist.github.com/alexcraven/3db2c09f14ec489a31df81dc7b5a0f9c
+
+        series_type = None
+        series_data = {}
+
+        with open(path) as f:
+            vals = []
+
+            for line in f:
+                prev_series_type = series_type
+                if re.match(".*[0-9]+ points on ppm-axis = NY.*", line):
+                    series_type = "ppm"
+                elif re.match(".*NY phased data points follow.*", line):
+                    series_type = "data"
+                elif re.match(".*NY points of the fit to the data follow.*", line):
+                    series_type = "completeFit"
+                    # completeFit implies baseline+fit
+                elif re.match(".*NY background values follow.*", line):
+                    series_type = "baseline"
+                elif re.match(".*lines in following.*", line):
+                    series_type = None
+                elif re.match("[ ]+[a-zA-Z0-9]+[ ]+Conc. = [-+.E0-9]+$", line):
+                    series_type = None
+
+                if prev_series_type != series_type:  # start/end of chunk...
+                    if len(vals) > 0:
+                        series_data[prev_series_type] = np.array(vals)
+                        vals = []
+                else:
+                    if series_type:
+                        for x in re.finditer(r"([-+.E0-9]+)[ \t]*", line):
+                            v = x.group(1)
+                            try:
+                                v = float(v)
+                                vals.append(v)
+                            except ValueError:
+                                print("Error parsing line: %s" % (line,))
+                                print(v)
+        return series_data

lcmodel_wrapper-0.1.0/src/lcmodel_wrapper.egg-info/PKG-INFO

@@ -0,0 +1,62 @@
+Metadata-Version: 2.4
+Name: lcmodel_wrapper
+Version: 0.1.0
+Summary: Python wrapper for LCModel MRS fitting
+Author-email: Julian Merkofer <j.p.merkofer@tue.nl>
+License: MIT
+Project-URL: Homepage, https://github.com/yourusername/PyLCModel
+Project-URL: Repository, https://github.com/yourusername/PyLCModel
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: numpy>=1.22
+Requires-Dist: scipy>=1.10
+Requires-Dist: fsl_mrs>=2.1.0
+
+# PyLCModel
+
+**PyLCModel** is a Python wrapper designed to streamline the use of LCModel for least-squares spectral fitting in MRS. It takes the complexity out of setting up LCModel by automating control file generation, handling data conversions, and managing execution (with support for both single and multi-core processing).
+
+---
+
+## Features
+
+- **Easy Setup:** Quickly run LCModel with minimal code.
+- **Automated Control Files:** Dynamically generates and adjusts LCModel control files to suit your data.
+- **Multiprocessing Support:** Leverage multiple cores to accelerate batch processing.
+- **Data Conversion:** Seamlessly converts to .raw for execution. (Coming soon: conversion to .basis)
+- **Robust Output Parsing:** Extracts metabolite concentrations and CRLBs from LCModel output.
+
+---
+
+## Installation
+
+### From Source
+```bash
+git clone https://github.com/julianmer/PyLCModel.git
+cd PyLCModel
+pip install -e .
+```
+
+### From PyPI *(once published)*
+```bash
+pip install lcmodel
+```
+
+---
+
+## Getting Started
+
+```python
+from lcmodel_wrapper import LCModel
+
+# Initialize the LCModel wrapper with your basis set
+lcmodel = LCModel(path2basis='/path/to/your/basis_set.basis')
+
+# Assuming `data` is your MRS data in the frequency domain as a NumPy array
+# Fit the data using LCModel
+concentrations, crlbs = lcmodel(data)
+
+# Print results
+print("Fitted Metabolite Concentrations:", concentrations)
+print("CRLBs:", crlbs)
+```

lcmodel_wrapper-0.1.0/src/lcmodel_wrapper.egg-info/SOURCES.txt

@@ -0,0 +1,10 @@
+README.md
+pyproject.toml
+src/lcmodel_wrapper/__init__.py
+src/lcmodel_wrapper/lcmodel_wrapper.py
+src/lcmodel_wrapper.egg-info/PKG-INFO
+src/lcmodel_wrapper.egg-info/SOURCES.txt
+src/lcmodel_wrapper.egg-info/dependency_links.txt
+src/lcmodel_wrapper.egg-info/requires.txt
+src/lcmodel_wrapper.egg-info/top_level.txt
+tests/test_lcm.py

lcmodel_wrapper-0.1.0/src/lcmodel_wrapper.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

lcmodel_wrapper-0.1.0/src/lcmodel_wrapper.egg-info/requires.txt

@@ -0,0 +1,3 @@
+numpy>=1.22
+scipy>=1.10
+fsl_mrs>=2.1.0

lcmodel_wrapper-0.1.0/src/lcmodel_wrapper.egg-info/top_level.txt

@@ -0,0 +1 @@
+lcmodel_wrapper

lcmodel_wrapper-0.1.0/tests/test_lcm.py

@@ -0,0 +1,136 @@
+####################################################################################################
+#                                           test_lcm.py                                            #
+####################################################################################################
+#                                                                                                  #
+# Authors: J. P. Merkofer (j.p.merkofer@tue.nl)                                                    #
+#                                                                                                  #
+# Created: 20/06/24                                                                                #
+#                                                                                                  #
+# Purpose: Tests the PyLCModel class by fitting MRS data from the ISMRM 2016 fitting challenge.    #
+#                                                                                                  #
+####################################################################################################
+
+
+#*************#
+#   imports   #
+#*************#
+import sys
+
+import numpy as np
+import pandas as pd
+
+from fsl_mrs.utils import mrs_io
+
+from pathlib import Path
+
+# own
+from lcmodel_wrapper import LCModel
+
+
+#*************#
+#   loading   #
+#*************#
+def load_EXCEL_conc(path2conc: Path):
+    """
+    Load a list of concentrations from an EXCEL file (ISMRM 2016 fitting challenge).
+    Returns a sorted dict of metabolite -> concentration
+    """
+    truth = {"Ace": 0.0}  # initialize, Ace is only partially present
+
+    df = pd.read_excel(str(path2conc), header=17)
+    for i, met in enumerate(df["Metabolites"]):
+        if not isinstance(met, str):
+            break
+        truth[met] = df["concentration"].iloc[i]
+
+    # rename MMBL to Mac if present
+    if "MMBL" in truth:
+        truth["Mac"] = truth.pop("MMBL")
+    return dict(sorted(truth.items()))
+
+
+#*************#
+#   imports   #
+#*************#
+def main():
+
+    repo_root = Path(__file__).resolve().parents[1]
+    example_data = repo_root / "example_data"
+
+    config = {
+        "path2basis": example_data / "press3T_30ms.BASIS",
+        "path2concs": example_data / "ground_truth",
+        "path2data": example_data / "datasets_JMRUI_WS",
+        "path2water": example_data / "datasets_JMRUI_nWS",
+        "path2save": None,
+        "test_size": 10,
+        "sample_points": 2048,
+    }
+
+    # quick existence checks
+    if not config["path2basis"].exists():
+        raise FileNotFoundError(
+            f"Basis file not found: {config['path2basis']}\n"
+            "Make sure example_data contains your BASIS file or update path."
+        )
+
+    if not config["path2concs"].is_dir():
+        raise FileNotFoundError(
+            f"Concentration folder not found: {config['path2concs']}"
+        )
+
+    if not config["path2data"].is_dir():
+        raise FileNotFoundError(f"Data folder not found: {config['path2data']}")
+
+    # initialize model
+    lcm = PyLCModel(str(config["path2basis"]), sample_points=config["sample_points"])
+
+    # load ground truth concentration files
+    conc_files = sorted([p for p in (Path(config["path2concs"])).iterdir() if p.suffix in (".xlsx", ".xls")])[: config["test_size"]]
+    if len(conc_files) == 0:
+        raise RuntimeError("No concentration excel files found in path2concs")
+
+    concs_list = [load_EXCEL_conc(p) for p in conc_files]
+
+    # align to basis names
+    try:
+        basis_names = lcm.basisFSL._names
+        n_metabs = lcm.basisFSL.n_metabs
+    except Exception as e:
+        raise AttributeError("Could not access basisFSL._names or n_metabs from LCM object") from e
+
+    concs_aligned = [[c.get(met, 0.0) for met in basis_names] for c in concs_list]
+    concs = np.array(concs_aligned)[:, :n_metabs]
+
+    # load data
+    data_files = sorted([p for p in Path(config["path2data"]).iterdir() if p.is_file()])[: config["test_size"]]
+    if len(data_files) == 0:
+        raise RuntimeError("No data files found in path2data")
+
+    data = np.array([mrs_io.read_FID(str(p)).mrs().FID for p in data_files])
+
+    # load water if available
+    water = None
+    if config.get("path2water") and Path(config["path2water"]).is_dir():
+        water_files = sorted(list(Path(config["path2water"]).iterdir()))[: config["test_size"]]
+        if len(water_files) > 0:
+            water = np.array([mrs_io.read_FID(str(p)).mrs().FID for p in water_files])
+
+    # to frequency domain (stack real and imaginary part)
+    data = np.fft.fft(data, axis=-1)
+    data = np.stack((data.real, data.imag), axis=1)
+
+    # fit
+    lcm.set_save_path(config["path2save"])
+    thetas, uncs = lcm(data, water)  # data in freq. domain, shape (batch, 2, sample_points)
+
+    # loss: if water not provided, apply optimalReference
+    if water is None:
+        thetas = lcm.optimalReference(concs, thetas) * thetas
+
+    loss = lcm.concsLoss(concs, thetas, type="ae")
+    print("MAE:", float(loss.mean()))
+
+
+if __name__ == "__main__":
+    main()