syncmoss 0.2.0__tar.gz → 0.2.2__tar.gz

{syncmoss-0.2.0 → syncmoss-0.2.2}/.gitignore

@@ -139,3 +139,13 @@ bundle/Windows/
 syncmoss/*.mdl
 syncmoss/*.png
 syncmoss/*.svg
+
+# Deprecated original minimiser, kept locally for reference / equivalence checks
+# (the active implementation is now the optimized minimi_lib.py).
+syncmoss/minimi_lib_old.py
+
+# minimi_lib optimization: local-only test tooling and notes (depend on the
+# git-ignored minimi_lib_old.py; kept out of the tracked repo).
+verify_minimi.py
+bench_coldstart.py
+minimi_optimization_notes.txt

{syncmoss-0.2.0/syncmoss.egg-info → syncmoss-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: syncmoss
-Version: 0.2.0
+Version: 0.2.2
 Summary: SYNCmoss — Mössbauer spectroscopy analysis application
 Author: Sergey Yaroslavtsev
 License: MIT

{syncmoss-0.2.0 → syncmoss-0.2.2}/bundle/MacOS.spec

@@ -2,30 +2,49 @@
 from PyInstaller.utils.hooks import collect_data_files, collect_submodules
 import os
 
-# Hidden imports
-hiddenimports = collect_submodules('scipy')
-hiddenimports += collect_submodules('PySide6')
-hiddenimports += collect_submodules('numba')
+# ── Hidden imports ──────────────────────────────────────────────
+# numba/llvmlite/scipy do a lot of dynamic importing, so collect their submodules
+# (this keeps core modules like scipy._cyutility that the hooks miss). The big
+# unused scipy subpackages are pruned again via scipy_excludes below; numba's own
+# test-suite is filtered out (not needed at runtime, and it emits a wall of
+# "hidden import not found" warnings for its CUDA tests).
+hiddenimports = collect_submodules('numba', filter=lambda name: 'tests' not in name)
 hiddenimports += collect_submodules('llvmlite')
+hiddenimports += collect_submodules('scipy')
+# Only the Qt modules SYNCmoss actually uses. We deliberately do NOT
+# collect_submodules('PySide6'): that drags in the QtQuick / QtQml / Qt3D /
+# WebEngine frameworks (100+ MB) the app never uses. The PySide6 PyInstaller
+# hook bundles the Qt frameworks/plugins matching just these imports. This
+# matters most on macOS, where the build is universal2 (two architectures) and
+# UPX is not applied.
+hiddenimports += ['PySide6.QtCore', 'PySide6.QtGui', 'PySide6.QtWidgets']
 # GUI smoke driver lives in tests/syncmoss_test.py; bundling it lets the frozen
 # binary self-test via `SYNCmoss --test` (see syncmoss/main.py).
 hiddenimports += ['syncmoss_test']
 
-scipy_data = collect_data_files('scipy')
+# llvmlite carries native data/bitcode that must be collected.
 llvmlite_data = collect_data_files('llvmlite')
+# On macOS, missing platform input context plugins can lead to non-editable
+# QLineEdit/QTable widgets in frozen apps. Bundle these explicitly.
+qt_plugin_data = collect_data_files(
+    'PySide6',
+    includes=[
+        'Qt/plugins/platforms/*',
+        'Qt/plugins/platforminputcontexts/*',
+        'Qt/plugins/styles/*',
+    ],
+)
 
 syncmoss_dir = os.path.abspath(os.path.join(SPECPATH, '..', 'syncmoss'))
 project_dir  = os.path.abspath(os.path.join(SPECPATH, '..'))
 tests_dir    = os.path.abspath(os.path.join(SPECPATH, '..', 'tests'))
 
-datas = scipy_data + llvmlite_data
+# Application resources (icons/, parameters/, themes, etc.) are copied into the
+# app bundle by macos_bundle.py after the build.
+datas = llvmlite_data + qt_plugin_data
 
-# SYNCmoss only uses PySide6.QtWidgets / QtGui / QtCore. Excluding the large,
-# unused Qt frameworks (WebEngine, Quick/QML, 3D, Multimedia, Charts, ...) keeps
-# excludes win over collect_submodules above, so they are pruned from the bundle.
-# This matters most on macOS, where the build is universal2 (two architectures)
-# and UPX compression is not applied. The CI "--test" smoke run guards against
-# accidentally excluding something the app actually needs.
+# Unused-Qt Python module excludes (belt-and-suspenders, since PySide6 is no
+# longer force-collected). The CI "--test" smoke run guards against over-excluding.
 qt_excludes = [
     'PySide6.QtWebEngineCore', 'PySide6.QtWebEngineWidgets', 'PySide6.QtWebEngineQuick',
     'PySide6.QtWebChannel', 'PySide6.QtWebSockets', 'PySide6.QtWebView',
@@ -42,6 +61,15 @@ qt_excludes = [
     'PySide6.QtUiTools', 'PySide6.QtNetworkAuth', 'PySide6.QtRemoteObjects',
     'PySide6.QtTextToSpeech', 'PySide6.QtScxml', 'PySide6.QtStateMachine',
 ]
+# scipy is only used for scipy.linalg.eig; exclude the big unused subpackages.
+# (linalg, _lib, special and sparse are kept: scipy.linalg's import chain may
+# touch special/sparse.)
+scipy_excludes = [
+    'scipy.stats', 'scipy.optimize', 'scipy.spatial', 'scipy.interpolate',
+    'scipy.integrate', 'scipy.fft', 'scipy.fftpack', 'scipy.ndimage',
+    'scipy.signal', 'scipy.io', 'scipy.cluster', 'scipy.odr',
+    'scipy.datasets', 'scipy.misc',
+]
 # pytest is only used by the source test-suite; it must not be pulled into the
 # frozen binary (the smoke driver imports it lazily / guarded).
 other_excludes = ['tkinter', 'PyQt5', 'PyQt6', 'PySide2', 'pytest', '_pytest', 'pluggy']
@@ -53,7 +81,9 @@ a = Analysis(
     pathex=[project_dir, tests_dir],
     hooksconfig={
         'matplotlib': {
-            'backends': 'all',
+            # Only the backends SYNCmoss uses (Qt for the GUI, Agg/SVG/PDF for
+            # saving). 'all' pulls every backend incl. the tk one.
+            'backends': ['Agg', 'QtAgg', 'SVG', 'PDF'],
         },
     },
     binaries=[],
@@ -61,7 +91,7 @@ a = Analysis(
     hiddenimports=hiddenimports,
     hookspath=[],
     runtime_hooks=[],
-    excludes=qt_excludes + other_excludes,
+    excludes=qt_excludes + scipy_excludes + other_excludes,
     cipher=block_cipher,
     noarchive=False,
 )
@@ -76,9 +106,9 @@ exe_gui = EXE(
     name='SYNCmoss',
     debug=False,
     bootloader_ignore_signals=False,
-    strip=True,
+    strip=False,
     upx=False,
-    console=True,
+    console=False,
 )
 
 coll = COLLECT(
@@ -86,7 +116,7 @@ coll = COLLECT(
     a.binaries,
     a.zipfiles,
     a.datas,
-    strip=True,
+    strip=False,
     upx=False,
     upx_exclude=[],
     name='SYNCmoss',

{syncmoss-0.2.0 → syncmoss-0.2.2}/bundle/Windows.spec

@@ -3,26 +3,35 @@ from PyInstaller.utils.hooks import collect_data_files, collect_submodules
 import os
 
 # ── Hidden imports ──────────────────────────────────────────────
-hiddenimports = collect_submodules('scipy')
-hiddenimports += collect_submodules('PySide6')
-# Ensure numba and llvmlite submodules are included in the frozen app
-hiddenimports += collect_submodules('numba')
+# numba/llvmlite/scipy do a lot of dynamic importing, so collect their submodules
+# (this keeps core modules like scipy._cyutility that the hooks miss). The big
+# unused scipy subpackages are pruned again via scipy_excludes below; numba's own
+# test-suite is filtered out (not needed at runtime, and it emits a wall of
+# "hidden import not found" warnings for its CUDA tests).
+hiddenimports = collect_submodules('numba', filter=lambda name: 'tests' not in name)
 hiddenimports += collect_submodules('llvmlite')
+hiddenimports += collect_submodules('scipy')
+# Only the Qt modules SYNCmoss actually uses. We deliberately do NOT
+# collect_submodules('PySide6'): that drags in the QtQuick / QtQml / Qt3D /
+# WebEngine frameworks (100+ MB) the app never uses. The PySide6 PyInstaller
+# hook bundles the Qt frameworks/plugins matching just these imports.
+hiddenimports += ['PySide6.QtCore', 'PySide6.QtGui', 'PySide6.QtWidgets']
 # GUI smoke driver lives in tests/syncmoss_test.py; bundling it lets the frozen
 # binary self-test via `SYNCmoss --test` (see syncmoss/main.py).
 hiddenimports += ['syncmoss_test']
-scipy_data = collect_data_files('scipy')
-# llvmlite carries native data/bitcode that should be collected
+
+# scipy is only needed for scipy.linalg.eig (the import-time "dummy" in
+# models.py); scipy_excludes below drops the big unused subpackages.
+# llvmlite carries native data/bitcode that must be collected.
 llvmlite_data = collect_data_files('llvmlite')
 
 syncmoss_dir = os.path.abspath(os.path.join(SPECPATH, '..', 'syncmoss'))
 project_dir  = os.path.abspath(os.path.join(SPECPATH, '..'))
 tests_dir    = os.path.abspath(os.path.join(SPECPATH, '..', 'tests'))
 
-# Only Python library data (scipy, etc.) goes through PyInstaller.
-# Application resources (icons/, parameters/, themes, etc.) are copied
-# next to the .exe by bundle.py after the build.
-datas = scipy_data + llvmlite_data
+# Application resources (icons/, parameters/, themes, etc.) are copied next to
+# the .exe by bundle.py after the build.
+datas = llvmlite_data
 
 # SYNCmoss only uses PySide6.QtWidgets / QtGui / QtCore. Excluding the large,
 # unused Qt frameworks keeps the bundle small; excludes win over the
@@ -44,6 +53,15 @@ qt_excludes = [
     'PySide6.QtUiTools', 'PySide6.QtNetworkAuth', 'PySide6.QtRemoteObjects',
     'PySide6.QtTextToSpeech', 'PySide6.QtScxml', 'PySide6.QtStateMachine',
 ]
+# scipy is only used for scipy.linalg.eig; exclude the big unused subpackages.
+# (linalg, _lib, special and sparse are kept: scipy.linalg's import chain may
+# touch special/sparse.)
+scipy_excludes = [
+    'scipy.stats', 'scipy.optimize', 'scipy.spatial', 'scipy.interpolate',
+    'scipy.integrate', 'scipy.fft', 'scipy.fftpack', 'scipy.ndimage',
+    'scipy.signal', 'scipy.io', 'scipy.cluster', 'scipy.odr',
+    'scipy.datasets', 'scipy.misc',
+]
 # pytest is only used by the source test-suite; it must not be pulled into the
 # frozen binary (the smoke driver imports it lazily / guarded).
 other_excludes = ['tkinter', 'PyQt5', 'PyQt6', 'PySide2', 'pytest', '_pytest', 'pluggy']
@@ -55,7 +73,9 @@ a = Analysis(
     pathex=[project_dir, tests_dir],
     hooksconfig={
         'matplotlib': {
-            'backends': 'all',
+            # Only the backends SYNCmoss uses (Qt for the GUI, Agg/SVG/PDF for
+            # saving). 'all' pulls every backend incl. the tk one.
+            'backends': ['Agg', 'QtAgg', 'SVG', 'PDF'],
         },
     },
     binaries=[],
@@ -63,7 +83,7 @@ a = Analysis(
     hiddenimports=hiddenimports,
     hookspath=[],
     runtime_hooks=[],
-    excludes=qt_excludes + other_excludes,
+    excludes=qt_excludes + scipy_excludes + other_excludes,
     cipher=block_cipher,
     noarchive=False,
 )

{syncmoss-0.2.0 → syncmoss-0.2.2}/bundle/bundle.py

@@ -66,7 +66,6 @@ def copy_resources():
         # from syncmoss/
         os.path.join(syncmoss_DIR, "theme_dark.json"),
         os.path.join(syncmoss_DIR, "theme_light.json"),
-        os.path.join(syncmoss_DIR, "Calibration.dat"),
         # from repo root
         os.path.join(ROOT_DIR, "COPYING.txt"),
         os.path.join(ROOT_DIR, "NOTICE.txt"),
@@ -117,7 +116,7 @@ def verify():
         "parameters/INSint.txt",
         "theme_dark.json",
         "theme_light.json",
-        "Calibration.dat",
+        "parameters/Calibration.dat",
         "COPYING.txt",
         "NOTICE.txt",
         "LICENSE",

{syncmoss-0.2.0 → syncmoss-0.2.2}/bundle/macos_bundle.py

@@ -69,7 +69,6 @@ def copy_resources(app_dir: str):
     root_files = [
         os.path.join(SYNCMOSS_DIR, "theme_dark.json"),
         os.path.join(SYNCMOSS_DIR, "theme_light.json"),
-        os.path.join(SYNCMOSS_DIR, "Calibration.dat"),
         os.path.join(ROOT_DIR, "COPYING.txt"),
         os.path.join(ROOT_DIR, "NOTICE.txt"),
         os.path.join(ROOT_DIR, "LICENSE"),
@@ -113,6 +112,7 @@ def verify(app_dir: str):
         "Contents/MacOS/icons/CheckBox.png",
         "Contents/MacOS/parameters/Be.txt",
         "Contents/MacOS/parameters/KB.txt",
+        "Contents/MacOS/parameters/Calibration.dat",
         "Contents/MacOS/theme_dark.json",
         "Contents/MacOS/theme_light.json",
     ]

{syncmoss-0.2.0 → syncmoss-0.2.2}/pyproject.toml

@@ -58,6 +58,8 @@ syncmoss = [
     "icons/*.ico",
     "icons/*.svg",
     "parameters/*.txt",
+    "parameters/*.dat",
+    "parameters/*.png",
     "*.json",
     "*.dat",
 ]

{syncmoss-0.2.0 → syncmoss-0.2.2}/syncmoss/Calibration.py

@@ -31,6 +31,7 @@ import syncmoss.minimi_lib as mi
 import syncmoss.models as m5
 import multiprocessing as mp
 import matplotlib.pyplot as plt
+import os
 import platform
 import re
 import time
@@ -541,7 +542,7 @@ def Calibration(dir_path, Cal_file, pool, VVV, INS, JN, x0, MulCo, Vel_start = 1
             model = ['Sextet', 'Sextet', 'Doublet']
 
             try:
-                Be_param = np.genfromtxt(str(dir_path) + str('\\\\parameters\\\\Be.txt')*(platform.system() == 'Windows') + str('/parameters/Be.txt')*(platform.system() != 'Windows'), delimiter='\t', skip_footer=0)
+                Be_param = np.genfromtxt(os.path.join(dir_path, 'Be.txt'), delimiter='\t', skip_footer=0)
                 print('file was read')
             except:
                 Be_param = np.array([0.057, 0.066, -0.261, 0.098, 0.375, 0.772, 1])
@@ -742,7 +743,7 @@ def Calibration(dir_path, Cal_file, pool, VVV, INS, JN, x0, MulCo, Vel_start = 1
 
         ax.text(len(xn2)/2, max(id[0]) + 10 * np.sqrt(max(id[0])), str('lin ')*(method==1) + str('sin ')*(method==0) + str(n1) + str(' ') + str(n2), color='r', fontsize=8, horizontalalignment='center')
 
-        fig.savefig('calibr.png', bbox_inches='tight')
+        fig.savefig(os.path.join(dir_path, 'calibr.png'), bbox_inches='tight')
         plt.close()
 
         print('Shift due to instrumental function ', INS_shift)

{syncmoss-0.2.0 → syncmoss-0.2.2}/syncmoss/fitting_io.py

@@ -14,7 +14,11 @@ from syncmoss.constants import number_of_baseline_parameters, numco
 from syncmoss.model_io import mod_len_def as mod_len_def_full, read_model as read_model_full
 from syncmoss.models_positions import mod_pos
 from syncmoss.spectrum_io import load_spectrum
-from syncmoss.instrumental_io import resolve_sms_instrumental_for_file
+from syncmoss.instrumental_io import (
+    resolve_instrumental_for_file,
+    compute_norm,
+    same_method_params,
+)
 
 
 
@@ -296,62 +300,95 @@ def fit_single_spectrum(app, spectrum_file, pool, background=None, sequence_para
             print(f"[Fitting] X range: {A[0]:.2f} to {A[-1]:.2f}")
             print(f"[Fitting] Y range: {B.min():.2f} to {B.max():.2f}")
         
-        # Determine fitting method
-        if app.MS_fit.isChecked():
-            VVV = 1  # MS method
-            experimental_method = 1
-        elif app.SMS_fit.isChecked():
-            VVV = 3  # SMS method
-            experimental_method = 3
-        else:
+        # A method checkbox must be selected (it is the fallback when a spectrum
+        # carries no .dat instrumental metadata)
+        if not app.MS_fit.isChecked() and not app.SMS_fit.isChecked():
             return {
                 'success': False,
                 'message': 'No fitting method selected (MS or SMS)'
             }
-        
-        # Get instrumental function parameters
+
+        # Resolve instrumental parameters per spectrum. Each spectrum may be CMS
+        # or SMS depending on its own .dat metadata (#@GCMS vs #@INSexp/#@INSint)
+        # when the "use instrumental function from .dat file" option is enabled;
+        # otherwise the UI-selected method with the internal values is used.
         JN = int(app.JN0)
-        
-        if VVV == 1:  # MS method
-            # CMS method with MulCoCMS
-            INS = float(app.L0.text())
-            x0_val = 0.0
-            MulCo_val = app.MulCoCMS
-            
-            # Calculate normalization integral
-            pNorm = np.array([float(0)] * number_of_baseline_parameters)
-            pNorm[0] = 1
-            Norm = m5.TI(np.array([float(1000)]), pNorm, [], JN, pool, 0.0, MulCo_val, INS, [0], [0], Met=1)[0]
-            print('Normalization integral equal to', Norm)
-            
+        use_dat_metadata = bool(getattr(app, 'use_dat_instrumental_metadata', True))
+        files_for_ins = list(spectrum_files) if is_simultaneous else [spectrum_file]
+
+        method_params_list = []
+        for ins_file in files_for_ins:
+            mp_i = resolve_instrumental_for_file(app, ins_file, use_dat_metadata=use_dat_metadata)
+            mp_i['Norm'] = compute_norm(pool, JN, mp_i)
+            print('Normalization integral equal to', mp_i['Norm'])
+            method_params_list.append(mp_i)
+        mp0 = method_params_list[0]
+
+        note_lines = [mp_i['note'] for mp_i in method_params_list]
+        if len({mp_i['method'] for mp_i in method_params_list}) > 1:
+            note_lines.insert(0, "Mixed-method simultaneous fit: CMS and SMS spectra are fitted together.")
+        instrumental_note = '\n'.join(note_lines)
+        print(f"[Fitting] {instrumental_note}")
+
+        if is_simultaneous:
+            # Split model at Nbaseline boundaries
+            model_separate = []
+            startM = 0
+            for i in range(len(model)):
+                if model[i] == 'Nbaseline':
+                    model_separate.append(model[startM:i])
+                    startM = i + 1
+            model_separate.append(model[startM:])
+
+            # Calculate parameter indices for each spectrum
+            begining_spc = [0]
+            start_cont_par = number_of_baseline_parameters
+            param_names_full = app.params_table.get_parameter_names()
+            for i in range(1, len(param_names_full)):
+                param_names = param_names_full[i]
+                if len(param_names) > 0 and param_names[0] == 'Ns':  # Start of new spectrum
+                    begining_spc.append(start_cont_par)
+                for j in range(len(param_names)):
+                    if param_names[j] != '':
+                        start_cont_par += 1
+
+            print(f"[Fitting] Simultaneous - model_separate: {model_separate}")
+            print(f"[Fitting] Simultaneous - begining_spc: {begining_spc}")
+
+            # Per-section slices of the Distri/Cor expression lists (used after the
+            # fit to rebuild each section's sub-spectra for plotting)
+            distr_bounds = np.cumsum([0] + [ms.count('Distr') for ms in model_separate])
+            corr_bounds = np.cumsum([0] + [ms.count('Corr') for ms in model_separate])
+
+            def section_parameters(p_full, idx):
+                if idx < len(begining_spc) - 1:
+                    return p_full[begining_spc[idx]:begining_spc[idx + 1]]
+                return p_full[begining_spc[idx]:]
+
+        uniform_method = all(same_method_params(mp0, mp_i) for mp_i in method_params_list[1:])
+
+        if not is_simultaneous or uniform_method:
+            # Uniform instrumental settings: a single TI call over the whole model
+            # (TI splits Nbaseline sections internally) — the original code path.
             def func(x, p):
-                return m5.TI(x, p, model, JN, pool, 0.0, MulCo_val, INS, Distri, Cor, Met=1, Norm=Norm)
-        
-        elif VVV == 3:  # SMS method
-            # SMS method: optionally read INS metadata from .dat, otherwise fallback to global files
-            if is_simultaneous:
-                selected_files = app.parse_process_path()
-                spectrum_for_ins = selected_files[0] if selected_files else spectrum_file
-            else:
-                spectrum_for_ins = spectrum_file
-
-            use_dat_metadata = bool(getattr(app, 'use_dat_instrumental_metadata', True))
-            INS, MulCo_val, x0_val, instrumental_note = resolve_sms_instrumental_for_file(
-                app,
-                spectrum_for_ins,
-                use_dat_metadata=use_dat_metadata,
-            )
-            print(f"[Fitting] {instrumental_note}")
-            
-            # Calculate normalization integral
-            pNorm = np.array([float(0)] * number_of_baseline_parameters)
-            pNorm[0] = 1
-            Norm = m5.TI(np.array([float(1000)]), pNorm, [], JN, pool, x0_val, MulCo_val, INS, [0], [0])[0]
-            print('Normalization integral equal to', Norm)
-            
+                return m5.TI(x, p, model, JN, pool, mp0['x0'], mp0['MulCo'], mp0['INS'],
+                             Distri, Cor, Met=mp0['Met'], Norm=mp0['Norm'])
+        else:
+            # Dedicated per-section instrumental parameters (e.g. mixing CMS and
+            # SMS): TI receives one value per section as lists. The full model and
+            # full p are still passed, so cross-spectrum links and Distr/Cor p[i]
+            # references resolve exactly as in the uniform path — no per-section
+            # bookkeeping leaks into this module.
+            x0_list = [mp_i['x0'] for mp_i in method_params_list]
+            mulco_list = [mp_i['MulCo'] for mp_i in method_params_list]
+            ins_list = [mp_i['INS'] for mp_i in method_params_list]
+            met_list = [mp_i['Met'] for mp_i in method_params_list]
+            norm_list = [mp_i['Norm'] for mp_i in method_params_list]
+
             def func(x, p):
-                return m5.TI(x, p, model, JN, pool, x0_val, MulCo_val, INS, Distri, Cor, Norm=Norm)
-        
+                return m5.TI(x, p, model, JN, pool, x0_list, mulco_list, ins_list,
+                             Distri, Cor, Met=met_list, Norm=norm_list)
+
         # Set up bounds and fixed parameters
         # For now, use unbounded optimization
         bounds = np.array([[-np.inf] * len(p), [np.inf] * len(p)], dtype=float)
@@ -480,56 +517,28 @@ def fit_single_spectrum(app, spectrum_file, pool, background=None, sequence_para
         SPC_f = func(A, p)
         
         # For simultaneous fitting, we need to separate results for each spectrum
+        # (model_separate and begining_spc were computed before the minimization)
         if is_simultaneous:
-            # Separate model and parameters for each spectrum
-            model_separate = []
-            startM = 0
-            for i in range(len(model)):
-                if model[i] == 'Nbaseline':
-                    model_separate.append(model[startM:i])
-                    startM = i + 1
-            model_separate.append(model[startM:])
-            
-            # Calculate parameter indices for each spectrum
-            begining_spc = [0]
-            start_cont_par = number_of_baseline_parameters
-            param_names_full = app.params_table.get_parameter_names()
-            for i in range(1, len(param_names_full)):
-                param_names = param_names_full[i]
-                if len(param_names) > 0 and param_names[0] == 'Ns':  # Start of new spectrum
-                    begining_spc.append(start_cont_par)
-                for j in range(len(param_names)):
-                    if param_names[j] != '':
-                        start_cont_par += 1
-            
-            print(f"[Fitting] Simultaneous - model_separate: {model_separate}")
-            print(f"[Fitting] Simultaneous - begining_spc: {begining_spc}")
-            
             # Substitute Distri and Cor parameter values ONCE using full model and full p
             # This ensures constrained parameters are correctly substituted
             Distri_substituted = np.copy(Distri)
             Cor_substituted = np.copy(Cor)
             if len(Distri) > 0 or len(Cor) > 0:
                 _, _, Distri_substituted, Cor_substituted, _, _ = create_subspectra(app, model, Distri, Cor, p)
-            
-            # Calculate fitted spectrum for each section separately
-            # Use model_separate (without Nbaseline) and parameter subset for each
+
+            # Calculate fitted spectrum for each section separately, each with the
+            # instrumental parameters resolved for that section's spectrum
             SPC_f_list = []
             for NumSpc in range(number_of_spectra):
-                # Get parameters for this spectrum
-                if NumSpc < len(begining_spc) - 1:
-                    p_separate = p[begining_spc[NumSpc]:begining_spc[NumSpc + 1]]
-                else:
-                    p_separate = p[begining_spc[NumSpc]:]
-                
-                # Calculate spectrum using model_separate and p_separate
-                # Use pre-substituted Distri and Cor
-                model_for_spectrum = model_separate[NumSpc]
-                if VVV == 1:  # MS method
-                    SPC_f_separate = m5.TI(A_list[NumSpc], p_separate, model_for_spectrum, JN, pool, 0.0, MulCo_val, INS, Distri_substituted, Cor_substituted, Met=1, Norm=Norm)
-                elif VVV == 3:  # SMS method
-                    SPC_f_separate = m5.TI(A_list[NumSpc], p_separate, model_for_spectrum, JN, pool, x0_val, MulCo_val, INS, Distri_substituted, Cor_substituted, Norm=Norm)
-                
+                p_separate = section_parameters(p, NumSpc)
+                mp_i = method_params_list[NumSpc]
+                d_slice = list(Distri_substituted[distr_bounds[NumSpc]:distr_bounds[NumSpc + 1]])
+                c_slice = list(Cor_substituted[corr_bounds[NumSpc]:corr_bounds[NumSpc + 1]])
+                SPC_f_separate = m5.TI(A_list[NumSpc], p_separate, model_separate[NumSpc], JN, pool,
+                                       mp_i['x0'], mp_i['MulCo'], mp_i['INS'],
+                                       d_slice if len(d_slice) > 0 else [0],
+                                       c_slice if len(c_slice) > 0 else [0],
+                                       Met=mp_i['Met'], Norm=mp_i['Norm'])
                 SPC_f_list.append(SPC_f_separate)
             
             # Now calculate subspectra for plotting
@@ -547,15 +556,12 @@ def fit_single_spectrum(app, spectrum_file, pool, background=None, sequence_para
             Cor_work = np.copy(Cor)
             
             for NumSpc in range(number_of_spectra):
-                # Get parameters for this spectrum
-                if NumSpc < len(begining_spc) - 1:
-                    p_separate = p[begining_spc[NumSpc]:begining_spc[NumSpc + 1]]
-                else:
-                    p_separate = p[begining_spc[NumSpc]:]
-                
+                p_separate = section_parameters(p, NumSpc)
+                mp_i = method_params_list[NumSpc]
+
                 # Calculate subspectra
                 Ps, Psm, Distri_t, Cor_t, Di, Co = create_subspectra(app, model_separate[NumSpc], Distri_work, Cor_work, p_separate)
-                
+
                 FS = []
                 FS_pos = []
                 for i in range(len(Ps)):
@@ -563,16 +569,13 @@ def fit_single_spectrum(app, spectrum_file, pool, background=None, sequence_para
                     DiSt = sum([Psm[j].count('Distr') for j in range(i)])
                     CoEn = CoSt + Psm[i].count('Corr')
                     DiEn = DiSt + Psm[i].count('Distr')
-                    
-                    if VVV == 1:  # MS method
-                        subspectrum = m5.TI(A_list[NumSpc], Ps[i], Psm[i], JN, pool, 0.0, MulCo_val, INS, 
-                                           Distri_t[DiSt:DiEn], Cor_t[CoSt:CoEn], Met=1, Norm=Norm)
-                        positions = mod_pos(Ps[i], Psm[i], INS, Met=1)
-                    elif VVV == 3:  # SMS method
-                        subspectrum = m5.TI(A_list[NumSpc], Ps[i], Psm[i], JN, pool, x0_val, MulCo_val, INS,
-                                           Distri_t[DiSt:DiEn], Cor_t[CoSt:CoEn], Norm=Norm)
-                        positions = mod_pos(Ps[i], Psm[i], INS)
-                    
+
+                    subspectrum = m5.TI(A_list[NumSpc], Ps[i], Psm[i], JN, pool,
+                                        mp_i['x0'], mp_i['MulCo'], mp_i['INS'],
+                                        Distri_t[DiSt:DiEn], Cor_t[CoSt:CoEn],
+                                        Met=mp_i['Met'], Norm=mp_i['Norm'])
+                    positions = mod_pos(Ps[i], Psm[i], mp_i['INS'], Met=mp_i['Met'])
+
                     FS.append(subspectrum)
                     FS_pos.append(positions)
                 
@@ -623,16 +626,12 @@ def fit_single_spectrum(app, spectrum_file, pool, background=None, sequence_para
                 CoEn = CoSt + Psm[i].count('Corr')
                 DiEn = DiSt + Psm[i].count('Distr')
                 print(Ps[i], Psm[i])
-                if VVV == 1:  # MS method
-                    subspectrum = m5.TI(A, Ps[i], Psm[i], JN, pool, 0.0, MulCo_val, INS, 
-                                       Distri_t[DiSt:DiEn], Cor_t[CoSt:CoEn], Met=1, Norm=Norm)
-                    # Calculate positions for this subspectrum
-                    positions = mod_pos(Ps[i], Psm[i], INS, Met=1)
-                elif VVV == 3:  # SMS method
-                    subspectrum = m5.TI(A, Ps[i], Psm[i], JN, pool, x0_val, MulCo_val, INS,
-                                       Distri_t[DiSt:DiEn], Cor_t[CoSt:CoEn], Norm=Norm)
-                    # Calculate positions for this subspectrum
-                    positions = mod_pos(Ps[i], Psm[i], INS)
+                subspectrum = m5.TI(A, Ps[i], Psm[i], JN, pool,
+                                    mp0['x0'], mp0['MulCo'], mp0['INS'],
+                                    Distri_t[DiSt:DiEn], Cor_t[CoSt:CoEn],
+                                    Met=mp0['Met'], Norm=mp0['Norm'])
+                # Calculate positions for this subspectrum
+                positions = mod_pos(Ps[i], Psm[i], mp0['INS'], Met=mp0['Met'])
                 FS.append(subspectrum)
                 FS_pos.append(positions)