syncmoss 0.4.0__tar.gz → 0.4.1__tar.gz

syncmoss-0.4.1/.github/workflows/_MacOS.yml

@@ -0,0 +1,451 @@
+name: _macOS (PyInstaller universal2 app)
+
+# Modelled on crispy's release workflow (github.com/mretegan/crispy):
+#   1. build the app natively on an Apple Silicon AND an Intel runner,
+#   2. fuse the two bundles into one universal2 SYNCmoss.app,
+#   3. sign it (Developer ID + hardened runtime), pack the DMG, notarize, staple.
+#
+# Signing and notarization run only when the Apple secrets are set (repository
+# Settings -> Secrets and variables -> Actions; release.yml forwards them).
+# Without them the job still ships a universal2 DMG, ad-hoc signed and not
+# notarized, named SYNCmoss-macOS-universal2.dmg. A notarized one is named
+# SYNCmoss-macOS-universal2-signed.dmg; _TagRelease.yml / _UploadRelease.yml
+# tell the two apart by that name.
+#
+#   APPLE_DEVELOPER_ID_APPLICATION_CERTIFICATE_BASE64
+#       the "Developer ID Application" certificate WITH its private key,
+#       exported from Keychain Access as .p12, then: base64 -i cert.p12 | pbcopy
+#   APPLE_DEVELOPER_ID_APPLICATION_CERTIFICATE_PASSWORD   password of that .p12
+#   APPLE_ID                             Apple Account e-mail of the developer
+#   APPLE_TEAM_ID                        10-character Team ID (developer.apple.com -> Membership)
+#   APPLE_APPLICATION_SPECIFIC_PASSWORD  app-specific password (account.apple.com -> Sign-In and Security)
+#   APPLE_KEYCHAIN_PASSWORD              optional: password of the throwaway CI keychain
+#                                        (a random one is used when unset)
+
+on:
+  workflow_call:
+    secrets:
+      APPLE_ID:
+        required: false
+      APPLE_TEAM_ID:
+        required: false
+      APPLE_DEVELOPER_ID_APPLICATION_CERTIFICATE_PASSWORD:
+        required: false
+      APPLE_DEVELOPER_ID_APPLICATION_CERTIFICATE_BASE64:
+        required: false
+      APPLE_KEYCHAIN_PASSWORD:
+        required: false
+      APPLE_APPLICATION_SPECIFIC_PASSWORD:
+        required: false
+
+jobs:
+  build:
+    name: Build macOS app (${{ matrix.arch }})
+    runs-on: ${{ matrix.runner }}
+    timeout-minutes: 60
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - runner: macos-15
+            arch: arm64
+          - runner: macos-15-intel
+            arch: x86_64
+    env:
+      MACOSX_DEPLOYMENT_TARGET: "11"
+      CFLAGS: "-mmacosx-version-min=11"
+      LDFLAGS: "-mmacosx-version-min=11"
+    steps:
+      - uses: actions/checkout@v6
+
+      - uses: actions/setup-python@v6
+        with:
+          python-version: "3.13"
+          cache: "pip"
+
+      - name: Check the runner architecture
+        run: |
+          MACHINE="$(python -c 'import platform; print(platform.machine())')"
+          echo "Python runs as ${MACHINE}"
+          if [ "${MACHINE}" != "${{ matrix.arch }}" ]; then
+            echo "::error::expected a ${{ matrix.arch }} runner, got ${MACHINE}"
+            exit 1
+          fi
+
+      - name: Download wheel artifact
+        uses: actions/download-artifact@v6
+        with:
+          name: wheels
+          path: wheels
+
+      # numba 0.62.x (llvmlite 0.45.x) is the last release with macOS x86_64
+      # wheels. The pin applies to BOTH architectures: the universal2 app holds
+      # one copy of the pure-Python code, so the two builds must resolve the
+      # same versions (checked again before the merge). --only-binary stops pip
+      # from quietly building an sdist on one architecture only.
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade pip setuptools wheel
+          python -m pip install --only-binary=:all: "numba==0.62.1" -r requirements.txt pyinstaller wheels/*.whl
+          python -m pip list --format=freeze
+
+      - name: Build the app
+        run: python bundle/macos_bundle.py --dist-dir bundle/MacOS/${{ matrix.arch }} --work-dir bundle/build/MacOS/${{ matrix.arch }}
+
+      # tar keeps the symlinks (Qt frameworks) and executable bits that
+      # upload-artifact would drop.
+      - name: Archive the app bundle
+        run: |
+          set -euo pipefail
+          DIST="bundle/MacOS/${{ matrix.arch }}"
+          APP_PATH=""
+          for candidate in "${DIST}/SYNCmoss.app" "${DIST}/SYNCmoss/SYNCmoss.app"; do
+            if [ -d "${candidate}" ]; then
+              APP_PATH="${candidate}"
+              break
+            fi
+          done
+          if [ -z "${APP_PATH}" ]; then
+            echo "::error::SYNCmoss.app not found in the ${{ matrix.arch }} build output"
+            find "${DIST}" -maxdepth 3 -print
+            exit 1
+          fi
+          echo "Executable architectures: $(lipo -archs "${APP_PATH}/Contents/MacOS/SYNCmoss")"
+          mkdir -p macos-artifact
+          tar -cpzf macos-artifact/SYNCmoss.app.tar.gz -C "$(dirname "${APP_PATH}")" SYNCmoss.app
+          python -m pip list --format=freeze > macos-artifact/pip-freeze.txt
+          echo "APP_PATH=${APP_PATH}" >> "${GITHUB_ENV}"
+
+      - name: Upload the app bundle
+        uses: actions/upload-artifact@v5
+        with:
+          name: macos-app-${{ matrix.arch }}
+          path: macos-artifact/
+          if-no-files-found: error
+          retention-days: 1
+
+      # Runs each architecture natively (the x86_64 slice is never exercised
+      # later). After archiving, so nothing the test writes reaches the artifact.
+      - name: Smoke-test the frozen app
+        run: |
+          "${APP_PATH}/Contents/MacOS/SYNCmoss" --test
+
+  universal2:
+    name: Merge, sign and notarize the universal2 app
+    needs: build
+    runs-on: macos-15
+    timeout-minutes: 90
+    steps:
+      - uses: actions/setup-python@v6
+        with:
+          python-version: "3.13"
+
+      - name: Download the arm64 app
+        uses: actions/download-artifact@v6
+        with:
+          name: macos-app-arm64
+          path: bundles/arm64
+
+      - name: Download the x86_64 app
+        uses: actions/download-artifact@v6
+        with:
+          name: macos-app-x86_64
+          path: bundles/x86_64
+
+      - name: Check both builds used the same packages
+        run: |
+          if ! diff -u bundles/arm64/pip-freeze.txt bundles/x86_64/pip-freeze.txt; then
+            echo "::error::arm64 and x86_64 resolved different package versions, so the universal2 app would mix them; pin the differing packages in the build job's install step"
+            exit 1
+          fi
+
+      - name: Extract the app bundles
+        run: |
+          set -euo pipefail
+          mkdir -p arm64 x86_64
+          tar -xpf bundles/arm64/SYNCmoss.app.tar.gz -C arm64
+          tar -xpf bundles/x86_64/SYNCmoss.app.tar.gz -C x86_64
+
+      # Adapted from crispy's package/merge-universal.py: walk both bundles,
+      # fuse every pair of thin Mach-O files with lipo, copy everything else
+      # (identical files, already-universal binaries, data files, symlinks),
+      # then require every Mach-O file of the result to carry both slices.
+      - name: Merge into a universal2 app
+        shell: python
+        run: |
+          import filecmp
+          import os
+          import shutil
+          import subprocess
+          import sys
+
+          ARM_APP = "arm64/SYNCmoss.app"
+          X86_APP = "x86_64/SYNCmoss.app"
+          OUT_APP = "dist/universal2/SYNCmoss.app"
+
+          THIN_MAGICS = {b"\xfe\xed\xfa\xce", b"\xfe\xed\xfa\xcf", b"\xce\xfa\xed\xfe", b"\xcf\xfa\xed\xfe"}
+          FAT_MAGICS = {b"\xca\xfe\xba\xbe", b"\xbe\xba\xfe\xca"}
+
+
+          def macho_kind(path):
+              """'thin', 'fat' or None, from the magic bytes: PyInstaller ships
+              extension-less Mach-O files. Java .class files share the fat magic,
+              but a real universal binary has only a few architectures."""
+              with open(path, "rb") as f:
+                  header = f.read(8)
+              if len(header) < 8:
+                  return None
+              if header[:4] in THIN_MAGICS:
+                  return "thin"
+              if header[:4] in FAT_MAGICS:
+                  byteorder = "big" if header[:4] == b"\xca\xfe\xba\xbe" else "little"
+                  return "fat" if int.from_bytes(header[4:8], byteorder) < 30 else None
+              return None
+
+
+          def collect(root):
+              """Relative path -> 'dir', 'symlink' or 'file' (symlinked dirs are not descended)."""
+              entries = {}
+              for current, dirnames, filenames in os.walk(root):
+                  for name in dirnames + filenames:
+                      path = os.path.join(current, name)
+                      if os.path.islink(path):
+                          kind = "symlink"
+                      elif os.path.isdir(path):
+                          kind = "dir"
+                      else:
+                          kind = "file"
+                      entries[os.path.relpath(path, root)] = kind
+              return entries
+
+
+          arm = collect(ARM_APP)
+          x86 = collect(X86_APP)
+          os.makedirs(OUT_APP)
+          single_arch = []
+          fused = 0
+
+          for rel in sorted(set(arm) | set(x86)):
+              arm_kind, x86_kind = arm.get(rel), x86.get(rel)
+              arm_path = os.path.join(ARM_APP, rel)
+              x86_path = os.path.join(X86_APP, rel)
+              out_path = os.path.join(OUT_APP, rel)
+
+              if "dir" in (arm_kind, x86_kind):
+                  os.makedirs(out_path, exist_ok=True)
+                  continue
+              os.makedirs(os.path.dirname(out_path), exist_ok=True)
+
+              if "symlink" in (arm_kind, x86_kind):
+                  if arm_kind == x86_kind and os.readlink(arm_path) != os.readlink(x86_path):
+                      print(f"WARNING: symlink target differs, using arm64: {rel}")
+                  os.symlink(os.readlink(arm_path if arm_kind == "symlink" else x86_path), out_path)
+                  continue
+
+              if arm_kind is None or x86_kind is None:
+                  present = arm_path if arm_kind else x86_path
+                  if macho_kind(present):
+                      single_arch.append(rel)
+                  else:
+                      print(f"WARNING: data file present in one build only: {rel}")
+                      shutil.copy2(present, out_path)
+                  continue
+
+              if filecmp.cmp(arm_path, x86_path, shallow=False):
+                  shutil.copy2(arm_path, out_path)
+                  continue
+
+              arm_macho, x86_macho = macho_kind(arm_path), macho_kind(x86_path)
+              if arm_macho == x86_macho == "thin":
+                  subprocess.run(["lipo", "-create", arm_path, x86_path, "-output", out_path], check=True)
+                  shutil.copymode(arm_path, out_path)
+                  fused += 1
+              elif "fat" in (arm_macho, x86_macho):
+                  # Already universal; the two copies differ only in their signature.
+                  shutil.copy2(arm_path if arm_macho == "fat" else x86_path, out_path)
+              elif arm_macho or x86_macho:
+                  single_arch.append(rel)
+              else:
+                  print(f"WARNING: data file differs, using arm64: {rel}")
+                  shutil.copy2(arm_path, out_path)
+
+          if single_arch:
+              sys.exit(
+                  "ERROR: these Mach-O binaries exist for one architecture only, so the "
+                  "app would crash on the other:\n" + "\n".join(f"  - {p}" for p in single_arch)
+              )
+
+          not_universal = []
+          checked = 0
+          for rel, kind in sorted(collect(OUT_APP).items()):
+              path = os.path.join(OUT_APP, rel)
+              if kind != "file" or not macho_kind(path):
+                  continue
+              checked += 1
+              archs = subprocess.run(["lipo", "-archs", path], capture_output=True, text=True).stdout.split()
+              if not {"arm64", "x86_64"} <= set(archs):
+                  not_universal.append(f"  - {rel}: {' '.join(archs) or 'unreadable'}")
+
+          print(f"Fused {fused} binaries, checked {checked} Mach-O files")
+          if not_universal:
+              sys.exit("ERROR: these binaries are not universal2:\n" + "\n".join(not_universal))
+          print(f"Universal2 app written to {OUT_APP}")
+
+      # The merge leaves the bundle's seal stale, so the app is always re-signed:
+      # with the Developer ID when the certificate secrets are set, otherwise
+      # ad-hoc (so macOS reports "unverified developer", not "damaged").
+      - name: Sign the app
+        id: sign
+        env:
+          CERTIFICATE_BASE64: ${{ secrets.APPLE_DEVELOPER_ID_APPLICATION_CERTIFICATE_BASE64 }}
+          CERTIFICATE_PASSWORD: ${{ secrets.APPLE_DEVELOPER_ID_APPLICATION_CERTIFICATE_PASSWORD }}
+          KEYCHAIN_PASSWORD: ${{ secrets.APPLE_KEYCHAIN_PASSWORD }}
+        run: |
+          set -euo pipefail
+          APP="dist/universal2/SYNCmoss.app"
+
+          # The hardened runtime needs these for the numba/llvmlite JIT (writable
+          # + executable memory) and for loading the bundled Python extensions.
+          ENTITLEMENTS="${RUNNER_TEMP}/entitlements.plist"
+          cat > "${ENTITLEMENTS}" <<'EOF'
+          <?xml version="1.0" encoding="UTF-8"?>
+          <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+          <plist version="1.0">
+          <dict>
+              <key>com.apple.security.cs.allow-jit</key>
+              <true/>
+              <key>com.apple.security.cs.allow-unsigned-executable-memory</key>
+              <true/>
+              <key>com.apple.security.cs.disable-library-validation</key>
+              <true/>
+          </dict>
+          </plist>
+          EOF
+
+          # Extended attributes would invalidate the signature.
+          xattr -cr "${APP}"
+
+          if [ -n "${CERTIFICATE_BASE64}" ] && [ -n "${CERTIFICATE_PASSWORD}" ]; then
+            KEYCHAIN_PATH="${RUNNER_TEMP}/signing.keychain-db"
+            CERTIFICATE_PATH="${RUNNER_TEMP}/certificate.p12"
+            if [ -z "${KEYCHAIN_PASSWORD}" ]; then
+              KEYCHAIN_PASSWORD="$(openssl rand -base64 24)"
+              echo "::add-mask::${KEYCHAIN_PASSWORD}"
+            fi
+
+            echo "Creating a temporary keychain and importing the certificate"
+            echo "${CERTIFICATE_BASE64}" | base64 --decode -o "${CERTIFICATE_PATH}"
+            security create-keychain -p "${KEYCHAIN_PASSWORD}" "${KEYCHAIN_PATH}"
+            security set-keychain-settings -lut 21600 "${KEYCHAIN_PATH}"
+            security unlock-keychain -p "${KEYCHAIN_PASSWORD}" "${KEYCHAIN_PATH}"
+            security import "${CERTIFICATE_PATH}" -P "${CERTIFICATE_PASSWORD}" -A -t cert -f pkcs12 -k "${KEYCHAIN_PATH}"
+            rm -f "${CERTIFICATE_PATH}"
+            security set-key-partition-list -S apple-tool:,apple:,codesign: -s -k "${KEYCHAIN_PASSWORD}" "${KEYCHAIN_PATH}" > /dev/null
+            security list-keychains -d user -s "${KEYCHAIN_PATH}"
+
+            IDENTITY="$(security find-identity -v -p codesigning "${KEYCHAIN_PATH}" | awk '/"Developer ID Application/ && !found { print $2; found = 1 }')"
+            if [ -z "${IDENTITY}" ]; then
+              echo "::error::the certificate holds no 'Developer ID Application' identity"
+              security find-identity -v -p codesigning "${KEYCHAIN_PATH}"
+              exit 1
+            fi
+
+            echo "Signing with the Developer ID (hardened runtime)"
+            codesign --force --deep --timestamp --options runtime \
+              --entitlements "${ENTITLEMENTS}" \
+              --keychain "${KEYCHAIN_PATH}" \
+              --sign "${IDENTITY}" \
+              "${APP}"
+            security delete-keychain "${KEYCHAIN_PATH}"
+            echo "developer_id=true" >> "${GITHUB_OUTPUT}"
+          else
+            echo "::warning::Apple certificate secrets are not set: the macOS DMG is ad-hoc signed and not notarized"
+            codesign --force --deep --sign - "${APP}"
+            echo "developer_id=false" >> "${GITHUB_OUTPUT}"
+          fi
+
+          codesign --verify --deep --strict --verbose=2 "${APP}"
+          echo "Universal executable architectures: $(lipo -archs "${APP}/Contents/MacOS/SYNCmoss")"
+
+      # On a copy, so files the test writes never reach the DMG. For a Developer
+      # ID build this runs under the hardened runtime, i.e. it also checks that
+      # the entitlements above are enough for numba.
+      - name: Smoke-test the signed universal2 app
+        run: |
+          set -euo pipefail
+          mkdir -p "${RUNNER_TEMP}/smoke"
+          ditto dist/universal2/SYNCmoss.app "${RUNNER_TEMP}/smoke/SYNCmoss.app"
+          "${RUNNER_TEMP}/smoke/SYNCmoss.app/Contents/MacOS/SYNCmoss" --test
+
+      - name: Create the DMG
+        run: |
+          set -euo pipefail
+          STAGING="${RUNNER_TEMP}/dmg"
+          mkdir -p "${STAGING}"
+          ditto dist/universal2/SYNCmoss.app "${STAGING}/SYNCmoss.app"
+          ln -s /Applications "${STAGING}/Applications"
+          # hdiutil is occasionally "Resource busy" on hosted runners: retry.
+          for attempt in 1 2 3; do
+            if hdiutil create -volname SYNCmoss -srcfolder "${STAGING}" -ov -format UDZO -imagekey zlib-level=9 dist/SYNCmoss.dmg; then
+              break
+            fi
+            if [ "${attempt}" -eq 3 ]; then
+              exit 1
+            fi
+            echo "hdiutil failed, retrying in 10 s"
+            sleep 10
+          done
+
+      - name: Notarize and staple the DMG
+        id: notarize
+        if: steps.sign.outputs.developer_id == 'true'
+        env:
+          APPLE_ID: ${{ secrets.APPLE_ID }}
+          APPLE_TEAM_ID: ${{ secrets.APPLE_TEAM_ID }}
+          APPLICATION_SPECIFIC_PASSWORD: ${{ secrets.APPLE_APPLICATION_SPECIFIC_PASSWORD }}
+        run: |
+          set -euo pipefail
+          if [ -z "${APPLE_ID}" ] || [ -z "${APPLE_TEAM_ID}" ] || [ -z "${APPLICATION_SPECIFIC_PASSWORD}" ]; then
+            echo "::warning::APPLE_ID / APPLE_TEAM_ID / APPLE_APPLICATION_SPECIFIC_PASSWORD are not set: the DMG is signed but not notarized, so Gatekeeper will still block it"
+            exit 0
+          fi
+          DMG="dist/SYNCmoss.dmg"
+
+          echo "Submitting ${DMG} for notarization"
+          RESULT="$(xcrun notarytool submit "${DMG}" \
+            --apple-id "${APPLE_ID}" --team-id "${APPLE_TEAM_ID}" --password "${APPLICATION_SPECIFIC_PASSWORD}" \
+            --wait --timeout 1h --output-format json)" || true
+          echo "${RESULT}"
+          SUBMISSION_ID="$(python -c 'import json, sys; print(json.loads(sys.argv[1]).get("id", ""))' "${RESULT}" 2> /dev/null || true)"
+          STATUS="$(python -c 'import json, sys; print(json.loads(sys.argv[1]).get("status", ""))' "${RESULT}" 2> /dev/null || true)"
+          if [ "${STATUS}" != "Accepted" ]; then
+            echo "::error::notarization did not succeed (status: '${STATUS:-none}')"
+            if [ -n "${SUBMISSION_ID}" ]; then
+              xcrun notarytool log "${SUBMISSION_ID}" \
+                --apple-id "${APPLE_ID}" --team-id "${APPLE_TEAM_ID}" --password "${APPLICATION_SPECIFIC_PASSWORD}" || true
+            fi
+            exit 1
+          fi
+
+          xcrun stapler staple "${DMG}"
+          xcrun stapler validate "${DMG}"
+          echo "notarized=true" >> "${GITHUB_OUTPUT}"
+
+      - name: Name the DMG
+        env:
+          NOTARIZED: ${{ steps.notarize.outputs.notarized }}
+        run: |
+          if [ "${NOTARIZED}" = "true" ]; then
+            mv dist/SYNCmoss.dmg dist/SYNCmoss-macOS-universal2-signed.dmg
+          else
+            mv dist/SYNCmoss.dmg dist/SYNCmoss-macOS-universal2.dmg
+          fi
+          ls -lh dist/*.dmg
+
+      - name: Upload the universal2 DMG
+        uses: actions/upload-artifact@v5
+        with:
+          name: macos-universal2
+          path: dist/SYNCmoss-macOS-universal2*.dmg
+          if-no-files-found: error
+          retention-days: 5

{syncmoss-0.4.0 → syncmoss-0.4.1}/PKG-INFO

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

{syncmoss-0.4.0 → syncmoss-0.4.1}/syncmoss/Library_window.py

@@ -119,7 +119,7 @@ def save_to_library_via_dialog(main_window):
 
 def open_library_model_dialog(main_window, parent_widget, insert_row, model_options=None):
     """Open internal Library browser with filters and detailed preview."""
-    library_dir = os.path.join(main_window.dir_path, 'Library')
+    library_dir = main_window.library_dir
     if not os.path.isdir(library_dir):
         main_window.set_status(f"Library folder not found: {library_dir}", "red")
         return

{syncmoss-0.4.0 → syncmoss-0.4.1}/syncmoss/instrumental_io.py

@@ -1258,40 +1258,39 @@ THEORY_FREE_FIELDS = ('theta_urad', 'B_s', 'dEQ', 'shift',
 # over (0.19-2.4 T across the published temperature series), i.e. T ~ 75.93 C by
 # the calibrated law.
 #
-# dEQ = -0.4056 +- 0.0030 mm/s comes from the 83-spectrum global fit. It is a
-# property of FeBO3, so it is a starting value, not a guess: the independent
-# laboratory measurement of Lyubutin et al. (2022) gives 2q = -0.3815 mm/s in
-# this parametrisation, 6 % away.
+# dEQ = -0.4216 +- 0.0038 mm/s (2026-09-29 global fit of the 83-spectrum ESRF
+# series: 123 parameters, shape chi2 1.317, and the independent intensity
+# cross-check agreeing to 0.91-1.05 across all nine temperatures).
 #
-# It read -0.3228 until the model was corrected in several places at once -- the
-# baseline constrained to a pure scale, ONE B_s per temperature instead of one
-# per spectrum, the Gaussian imperfection released, and f_LM changed from 0.70 to
-# 0.774. Several of those had been letting dEQ absorb an error that was not its
-# own. Because they moved together, this value is NOT attributable to any single
-# one of them -- and note that f_LM was changed on theoretical grounds, not
-# because it was measured to improve anything (see sms_study/test_flm_refine.py,
-# where the data prefer 0.55-0.65).
+# QUOTE THE ERROR AS +-0.03, NOT +-0.004. dEQ tracks how much freedom the model
+# is given rather than converging on a value: -0.3228, then -0.4056, then
+# -0.3900, now -0.4216, each time the source model changed. The +-0.0038 is the
+# covariance of one fit; the spread ACROSS defensible fits is ten times that. So
+# the laboratory value of Lyubutin et al. (2022), 2q = -0.3815 mm/s in this
+# parametrisation, is consistent with this one -- do not report a disagreement.
 #
-# mosaic_urad and gauss_fwhm are the two incoherent broadenings, both measured
-# by the same global fit (14.49 +- 0.11 urad and 0.1222 +- 0.0007 mm/s).
+# f_LM is the opposite and IS well determined: 0.7718, 0.7661, 0.7714, 0.7711
+# across those same four models. It is pinned by the width of the saturated core
+# (see the dynamical-saturation argument in sms_theory), which the model gets
+# right, while dEQ trades against whatever is absorbing line asymmetry.
 #
 # mosaic_urad starts at ZERO: the angle deviation is off by default (see
 # THEORY_PASSES), and setting_urad = 3 urad is applied regardless, so the source
-# is never completely unsmeared. f_LM is the nuclear amplitude scale; 0.774 is
-# both the Debye value and where the 83-spectrum profile puts it.
+# is never completely unsmeared. Released only at the rocking minimum, where the
+# 83-spectrum fit puts it at 20-28 urad (it is a property of one measurement's
+# setting, not a constant -- so this is a start, not a value).
 #
 # theta and B_s are the OPERATING POINT: spectrum 008 of the ESRF series
 # (T = 75.825 C, the angle the source is actually used at), refitted under these
 # very conventions -- setting_urad = 3, n_angle = 11 -- at chi2 = 0.97. Starting
 # a search at a guessed point instead is what the B_s scan exists to repair.
 #
-# dEQ, gauss_fwhm and f_LM come from the GLOBAL 83-spectrum fit, not from 008:
-# they are properties of the crystal and the instrument, and one spectrum
-# determines dEQ only to about half a sigma (008 alone prefers -0.24, the global
-# fit gives -0.3900 +- 0.0027).
-THEORY_START = {'theta_urad': 87.3, 'B_s': 0.7898, 'dEQ': -0.3900,
+# dEQ, gauss_fwhm and f_LM come from the GLOBAL fit, not from 008: they are
+# properties of the crystal and the instrument, and one spectrum determines dEQ
+# only to about +-0.04 (008 alone prefers -0.24).
+THEORY_START = {'theta_urad': 87.3, 'B_s': 0.7898, 'dEQ': -0.4216,
                 'shift': -0.2882, 'mosaic_urad': 0.0, 'dBs_rel_fwhm': 0.0,
-                'gauss_fwhm': 0.1303, 'f_LM': 0.7718}
+                'gauss_fwhm': 0.1303, 'f_LM': 0.7711}
 
 # Levenberg-Marquardt budget for the SCHEDULE passes. The final polish keeps
 # the full budget; the intermediate passes do not need it and each iteration is

{syncmoss-0.4.0 → syncmoss-0.4.1}/syncmoss/main.py

@@ -3,7 +3,7 @@ import sys
 import multiprocessing as mp
 from PySide6.QtWidgets import QApplication
 from syncmoss.syncmoss_main import PhysicsApp
-__VERSION__ = "0.4.0"
+__VERSION__ = "0.4.1"
 
 
 def _run_gui_smoke():

{syncmoss-0.4.0 → syncmoss-0.4.1}/syncmoss/model_io.py

@@ -570,7 +570,7 @@ def save_model_to_library(main_window, title, comment=None, metadata=None, notif
         main_window.set_status("Library title is empty", "orange")
         return False
 
-    library_dir = os.path.join(main_window.dir_path, 'Library')
+    library_dir = main_window.library_dir
     os.makedirs(library_dir, exist_ok=True)
     final_title, version_idx = compute_versioned_title_if_needed(library_dir, title)
     file_path = os.path.join(library_dir, f"{final_title}.mdl")

{syncmoss-0.4.0 → syncmoss-0.4.1}/syncmoss/sms_theory.py

@@ -1225,7 +1225,12 @@ PHYS_FIELDS = ('theta_urad', 'B_s', 'dEQ', 'shift', 'thickness_um',
                'gauss_fwhm', 'n_gauss', 'dT_mK')
 
 PHYS_DEFAULTS = {
-    'theta_urad': 70.0, 'B_s': 0.50, 'dEQ': -0.3228, 'shift': 0.0,
+    # dEQ and f_LM must match instrumental_io.THEORY_START, which is where they
+    # are documented. They were allowed to drift apart once (this dict kept
+    # -0.3228 for three revisions after the fitted value had moved) and nothing
+    # caught it, because every production call passes dEQ explicitly -- so the
+    # stale number only ever surfaces in a new caller that does not.
+    'theta_urad': 70.0, 'B_s': 0.50, 'dEQ': -0.4216, 'shift': 0.0,
     'thickness_um': DEFAULT_THICKNESS_UM, 'mosaic_urad': DEFAULT_MOSAIC_URAD,
     'setting_urad': DEFAULT_SETTING_URAD, 'phi_m_deg': 0.0,
     'f_LM': DEFAULT_F_LM, 'dBs_rel_fwhm': 0.0, 'n_angle': 11.0,

{syncmoss-0.4.0 → syncmoss-0.4.1}/syncmoss/supp_menu.py

@@ -580,13 +580,14 @@ def open_hamiltonian_helper(main_window):
 
 def export_library_pressed(main_window):
     """Export internal Library folder to a selected destination."""
+    # The Library dialogs open in the Library folder itself, not the work folder.
     destination = QFileDialog.getExistingDirectory(
-        main_window, "Select destination folder", main_window.workfolder or main_window.dir_path)
+        main_window, "Select destination folder", main_window.library_dir)
     if not destination:
         main_window.set_status("Export Library canceled", "orange")
         return
     try:
-        library_dir = os.path.join(main_window.dir_path, 'Library')
+        library_dir = main_window.library_dir
         target = export_library(library_dir, destination)
         main_window.set_status(f"Library exported to: {target}", "green")
     except Exception as e:
@@ -596,12 +597,12 @@ def export_library_pressed(main_window):
 def import_library_pressed(main_window):
     """Import .mdl files from selected folder into internal Library folder."""
     source = QFileDialog.getExistingDirectory(
-        main_window, "Select source folder", main_window.workfolder or main_window.dir_path)
+        main_window, "Select source folder", main_window.library_dir)
     if not source:
         main_window.set_status("Import Library canceled", "orange")
         return
     try:
-        library_dir = os.path.join(main_window.dir_path, 'Library')
+        library_dir = main_window.library_dir
         result = import_library(source, library_dir)
         if isinstance(result, dict):
             copied = int(result.get('copied', 0))