synth-cryo-em 0.1.0__tar.gz

synth_cryo_em-0.1.0/PKG-INFO

@@ -0,0 +1,66 @@
+Metadata-Version: 2.4
+Name: synth-cryo-em
+Version: 0.1.0
+Summary: Synthetic Cryo-EM map generator from PDB models
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: numpy
+Requires-Dist: mrcfile
+Requires-Dist: gemmi
+Requires-Dist: scipy
+Requires-Dist: click
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Provides-Extra: docs
+Requires-Dist: mkdocs; extra == "docs"
+Requires-Dist: mkdocs-material; extra == "docs"
+Requires-Dist: mkdocstrings[python]; extra == "docs"
+
+# synth-cryo-em
+
+[![Tests](https://github.com/elkins/synth-cryo-em/actions/workflows/test.yml/badge.svg)](https://github.com/elkins/synth-cryo-em/actions/workflows/test.yml)
+[![Documentation](https://img.shields.io/badge/docs-latest-blue)](https://elkins.github.io/synth-cryo-em/)
+
+A lightweight Pythonic utility to convert atomic models (PDB/CIF) into synthetic 3D Cryo-EM maps with realistic noise, CTF effects, and varying resolutions.
+
+## 🌟 Features
+- **Voxelize** atomic models with accurate resolution simulation.
+- **Simulate Physics:** Apply Contrast Transfer Functions (CTF) and envelope functions.
+- **Noise Modeling:** Add adjustable Gaussian noise to simulate low-SNR experimental data.
+- **Standard Format:** Export results to MRC files compatible with RELION, ChimeraX, and other tools.
+
+## 🚀 Quick Start
+
+### Installation
+```bash
+pip install synth-cryo-em
+```
+
+### Basic Generation
+```bash
+synth-cryo-em structure.pdb output.mrc --resolution 4.0
+```
+
+### Realistic Simulation
+```bash
+synth-cryo-em structure.pdb output.mrc --resolution 3.5 --apply-physics --snr 5
+```
+
+## 📚 Documentation
+For detailed guides and API reference, visit the [Documentation Site](https://elkins.github.io/synth-cryo-em/).
+
+## 🛠️ Development
+To install for development and documentation:
+```bash
+pip install -e ".[test,docs]"
+```
+
+Run tests:
+```bash
+pytest tests/
+```
+
+Build docs locally:
+```bash
+mkdocs serve
+```

synth_cryo_em-0.1.0/README.md

@@ -0,0 +1,48 @@
+# synth-cryo-em
+
+[![Tests](https://github.com/elkins/synth-cryo-em/actions/workflows/test.yml/badge.svg)](https://github.com/elkins/synth-cryo-em/actions/workflows/test.yml)
+[![Documentation](https://img.shields.io/badge/docs-latest-blue)](https://elkins.github.io/synth-cryo-em/)
+
+A lightweight Pythonic utility to convert atomic models (PDB/CIF) into synthetic 3D Cryo-EM maps with realistic noise, CTF effects, and varying resolutions.
+
+## 🌟 Features
+- **Voxelize** atomic models with accurate resolution simulation.
+- **Simulate Physics:** Apply Contrast Transfer Functions (CTF) and envelope functions.
+- **Noise Modeling:** Add adjustable Gaussian noise to simulate low-SNR experimental data.
+- **Standard Format:** Export results to MRC files compatible with RELION, ChimeraX, and other tools.
+
+## 🚀 Quick Start
+
+### Installation
+```bash
+pip install synth-cryo-em
+```
+
+### Basic Generation
+```bash
+synth-cryo-em structure.pdb output.mrc --resolution 4.0
+```
+
+### Realistic Simulation
+```bash
+synth-cryo-em structure.pdb output.mrc --resolution 3.5 --apply-physics --snr 5
+```
+
+## 📚 Documentation
+For detailed guides and API reference, visit the [Documentation Site](https://elkins.github.io/synth-cryo-em/).
+
+## 🛠️ Development
+To install for development and documentation:
+```bash
+pip install -e ".[test,docs]"
+```
+
+Run tests:
+```bash
+pytest tests/
+```
+
+Build docs locally:
+```bash
+mkdocs serve
+```

synth_cryo_em-0.1.0/pyproject.toml

@@ -0,0 +1,28 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "synth-cryo-em"
+version = "0.1.0"
+description = "Synthetic Cryo-EM map generator from PDB models"
+readme = "README.md"
+requires-python = ">=3.9"
+dependencies = [
+    "numpy",
+    "mrcfile",
+    "gemmi",
+    "scipy",
+    "click",
+]
+
+[project.optional-dependencies]
+test = ["pytest"]
+docs = ["mkdocs", "mkdocs-material", "mkdocstrings[python]"]
+
+[project.scripts]
+synth-cryo-em = "synth_cryo_em.cli:main"
+synth-cryo-em-validate = "synth_cryo_em.validate:main"
+
+[tool.setuptools.packages.find]
+where = ["src"]

synth_cryo_em-0.1.0/setup.cfg

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

synth_cryo_em-0.1.0/src/synth_cryo_em/cli.py

@@ -0,0 +1,43 @@
+import click
+from .core import generate_density_map, add_gaussian_noise, save_mrc, apply_ctf
+import numpy as np
+
+@click.command()
+@click.argument('input_path', type=click.Path(exists=True))
+@click.argument('output_path', type=click.Path())
+@click.option('--resolution', '-r', default=4.0, help='Resolution in Angstroms')
+@click.option('--spacing', '-s', default=None, type=float, help='Grid spacing in Angstroms')
+@click.option('--snr', default=None, type=float, help='Signal-to-noise ratio')
+@click.option('--defocus', default=2.0, help='Defocus in micrometers')
+@click.option('--voltage', default=300.0, help='Acceleration voltage in kV')
+@click.option('--cs', default=2.7, help='Spherical aberration in mm')
+@click.option('--bfactor', default=0.0, help='Envelope B-factor')
+@click.option('--bfactors/--no-bfactors', default=False, help='Use atomic B-factors for local resolution')
+@click.option('--apply-physics/--no-physics', default=False, help='Apply CTF effects')
+def main(input_path, output_path, resolution, spacing, snr, defocus, voltage, cs, bfactor, bfactors, apply_physics):
+    """
+    Generate a synthetic Cryo-EM map from an atomic model (PDB, mmCIF, or BCIF).
+    """
+    click.echo(f"Generating map for {input_path} at {resolution}A resolution...")
+    
+    grid, origin = generate_density_map(input_path, resolution, grid_spacing=spacing, use_bfactors=bfactors)
+    
+    data = np.array(grid, copy=True)
+    
+    # Voxel size is from the unit cell
+    uc = grid.unit_cell
+    vox_size = (uc.a / grid.nu, uc.b / grid.nv, uc.c / grid.nw)
+    
+    if apply_physics:
+        click.echo(f"Applying CTF (defocus={defocus}um, voltage={voltage}kV, B-factor={bfactor})...")
+        data = apply_ctf(data, vox_size, defoc=defocus, cs=cs, voltage=voltage, b_factor=bfactor)
+
+    if snr is not None:
+        click.echo(f"Adding Gaussian noise (SNR={snr})...")
+        data = add_gaussian_noise(data, snr)
+    
+    save_mrc(data, output_path, origin=origin, spacing=vox_size)
+    click.echo(f"Saved synthetic map to {output_path}")
+
+if __name__ == '__main__':
+    main()

synth_cryo_em-0.1.0/src/synth_cryo_em/core.py

@@ -0,0 +1,230 @@
+import gemmi
+import numpy as np
+import mrcfile
+from scipy.ndimage import gaussian_filter
+
+def generate_density_map(input_path, resolution, grid_spacing=None, use_bfactors=False, margin=None):
+    """
+    Generate a density map from an atomic model file (PDB, mmCIF, BCIF) using gemmi.
+    If use_bfactors is True, use atomic B-factors for local resolution.
+    """
+    st = gemmi.read_structure(input_path)
+    # If grid_spacing is not provided, use a rule of thumb (resolution / 3 or 4)
+    if grid_spacing is None:
+        grid_spacing = resolution / 3.0
+        
+    # Get all atomic positions
+    positions = []
+    for model in st:
+        for chain in model:
+            for residue in chain:
+                for atom in residue:
+                    positions.append(atom.pos.tolist())
+    
+    if not positions:
+        raise ValueError("No atoms found in structure")
+
+    positions = np.array(positions)
+    if margin is None:
+        margin = resolution * 2.0
+    
+    min_pos = positions.min(axis=0) - margin
+    max_pos = positions.max(axis=0) + margin
+    size = max_pos - min_pos
+    
+    st_shifted = st.clone()
+    cell = gemmi.UnitCell(size[0], size[1], size[2], 90, 90, 90)
+    st_shifted.cell = cell
+    
+    for model in st_shifted:
+        for chain in model:
+            for residue in chain:
+                for atom in residue:
+                    atom.pos.x -= min_pos[0]
+                    atom.pos.y -= min_pos[1]
+                    atom.pos.z -= min_pos[2]
+
+    # Map the atoms to the grid using DensityCalculatorE
+    calc = gemmi.DensityCalculatorE()
+    calc.d_min = resolution
+    
+    # Calculate sampling rate to match grid_spacing
+    # spacing = d_min / (2 * rate)  => rate = d_min / (2 * spacing)
+    calc.rate = resolution / (2.0 * grid_spacing)
+    
+    # Initialize grid
+    calc.set_grid_cell_and_spacegroup(st_shifted)
+    calc.initialize_grid()
+    
+    # If use_bfactors is True, we use the atomic B-factors.
+    # Gemmi's DensityCalculatorE uses atomic B-factors by default 
+    # when calling put_model_density_on_grid.
+    # However, we can add a constant "base" blur to represent resolution.
+    # resolution (d) relates to B-factor roughly by B = 8 * pi^2 * (d/2)^2 = 2 * pi^2 * d^2
+    # But gemmi also uses d_min as a cutoff.
+    
+    if not use_bfactors:
+        # If not using B-factors, we set them all to 0 and use a global blur
+        # equivalent to the target resolution.
+        for model in st_shifted:
+            for chain in model:
+                for residue in chain:
+                    for atom in residue:
+                        atom.b_iso = 0.0
+        # Set a global blur to match the target resolution
+        # A common heuristic is B = 8 * res^2 for synthetic maps
+        calc.blur = 8.0 * resolution**2
+    
+    calc.initialize_grid()
+    if len(st_shifted) > 0:
+        calc.put_model_density_on_grid(st_shifted[0])
+    
+    return calc.grid, min_pos
+
+def add_gaussian_noise(data, snr):
+    """
+    Add Gaussian noise to the data based on desired SNR.
+    """
+    signal_power = np.mean(data**2)
+    noise_power = signal_power / snr
+    noise = np.random.normal(0, np.sqrt(noise_power), data.shape)
+    return data + noise
+
+def apply_ctf(data, voxel_size, defoc=2.0, cs=2.7, voltage=300, amplitude_contrast=0.1, b_factor=0.0):
+    """
+    Apply a simple Contrast Transfer Function (CTF) to the 3D data.
+    defoc: defocus in micrometers
+    cs: spherical aberration in mm
+    voltage: acceleration voltage in kV
+    b_factor: envelope function B-factor
+    """
+    # Constants
+    wl = 12.26 / np.sqrt(voltage * 1000 + 0.9784 * voltage**2) # wavelength in Angstroms
+    cs_a = cs * 1e7 # cs in Angstroms
+    defoc_a = defoc * 10000 # defocus in Angstroms
+    
+    nz, ny, nx = data.shape
+    # Frequencies
+    kz = np.fft.fftfreq(nz, d=voxel_size[2])
+    ky = np.fft.fftfreq(ny, d=voxel_size[1])
+    kx = np.fft.fftfreq(nx, d=voxel_size[0])
+    
+    Kz, Ky, Kx = np.meshgrid(kz, ky, kx, indexing='ij')
+    k2 = Kz**2 + Ky**2 + Kx**2
+    
+    # Phase shift
+    chi = np.pi * wl * k2 * (defoc_a - 0.5 * wl**2 * k2 * cs_a)
+    
+    # CTF
+    ctf = - (np.sqrt(1 - amplitude_contrast**2) * np.sin(chi) + amplitude_contrast * np.cos(chi))
+    
+    # Envelope function
+    if b_factor > 0:
+        envelope = np.exp(-b_factor * k2 / 4.0)
+        ctf *= envelope
+        
+    # Apply in Fourier domain
+    data_f = np.fft.fftn(data)
+    data_f *= ctf
+    return np.real(np.fft.ifftn(data_f))
+
+def compute_fsc(data1, data2, voxel_size):
+    """
+    Compute the Fourier Shell Correlation (FSC) between two 3D maps.
+    Returns frequencies and correlation values.
+    """
+    assert data1.shape == data2.shape
+    
+    # Fourier transforms
+    f1 = np.fft.fftn(data1)
+    f2 = np.fft.fftn(data2)
+    
+    # Cross-spectral density
+    cross = f1 * np.conj(f2)
+    p1 = np.real(f1 * np.conj(f1))
+    p2 = np.real(f2 * np.conj(f2))
+    
+    # Calculate radial bins
+    nz, ny, nx = data1.shape
+    kz = np.fft.fftfreq(nz, d=voxel_size[2])
+    ky = np.fft.fftfreq(ny, d=voxel_size[1])
+    kx = np.fft.fftfreq(nx, d=voxel_size[0])
+    
+    Kz, Ky, Kx = np.meshgrid(kz, ky, kx, indexing='ij')
+    k = np.sqrt(Kz**2 + Ky**2 + Kx**2)
+    
+    # Flatten everything
+    k = k.ravel()
+    cross = cross.ravel()
+    p1 = p1.ravel()
+    p2 = p2.ravel()
+    
+    # Sort by frequency
+    idx = np.argsort(k)
+    k_sorted = k[idx]
+    cross_sorted = cross[idx]
+    p1_sorted = p1[idx]
+    p2_sorted = p2[idx]
+    
+    # Binning
+    n_bins = min(nx, ny, nz) // 2
+    bins = np.linspace(0, k_sorted.max(), n_bins + 1)
+    
+    fsc = []
+    freqs = []
+    
+    for i in range(n_bins):
+        mask = (k_sorted >= bins[i]) & (k_sorted < bins[i+1])
+        if np.any(mask):
+            c_bin = cross_sorted[mask]
+            p1_bin = p1_sorted[mask]
+            p2_bin = p2_sorted[mask]
+            
+            # Sum of cross power and individual powers
+            sum_cross = np.sum(c_bin)
+            sum_p1 = np.sum(p1_bin)
+            sum_p2 = np.sum(p2_bin)
+            
+            # FSC is real part of cross correlation / sqrt(power1 * power2)
+            # Standard definition uses the real part of the sum
+            num = np.real(sum_cross)
+            den = np.sqrt(sum_p1 * sum_p2)
+            
+            if den > 0:
+                fsc.append(num / den)
+                freqs.append((bins[i] + bins[i+1]) / 2.0)
+                
+    return np.array(freqs), np.array(fsc)
+
+def compute_ccc(data1, data2):
+    """
+    Compute the Cross-Correlation Coefficient (CCC) between two 3D maps.
+    """
+    assert data1.shape == data2.shape
+    
+    # Flatten and remove mean
+    d1 = data1.ravel()
+    d2 = data2.ravel()
+    
+    d1 = d1 - np.mean(d1)
+    d2 = d2 - np.mean(d2)
+    
+    num = np.sum(d1 * d2)
+    den = np.sqrt(np.sum(d1**2) * np.sum(d2**2))
+    
+    if den == 0:
+        return 0.0
+    return num / den
+
+def save_mrc(data, output_path, origin=(0,0,0), spacing=(1,1,1)):
+    """
+    Save numpy array to MRC file.
+    """
+    with mrcfile.new(output_path, overwrite=True) as mrc:
+        mrc.set_data(data.astype(np.float32))
+        mrc.voxel_size = spacing
+        # mrcfile uses x, y, z for origin
+        mrc.header.origin.x = origin[0]
+        mrc.header.origin.y = origin[1]
+        mrc.header.origin.z = origin[2]
+        mrc.update_header_from_data()

synth_cryo_em-0.1.0/src/synth_cryo_em/validate.py

@@ -0,0 +1,50 @@
+import click
+import mrcfile
+import numpy as np
+from .core import compute_fsc, compute_ccc
+
+@click.command()
+@click.argument('map1_path', type=click.Path(exists=True))
+@click.argument('map2_path', type=click.Path(exists=True))
+@click.option('--output', '-o', help='Path to save FSC data (CSV)')
+def main(map1_path, map2_path, output):
+    """
+    Compare two Cryo-EM maps using Fourier Shell Correlation (FSC) and CCC.
+    """
+    click.echo(f"Comparing {map1_path} and {map2_path}...")
+    
+    with mrcfile.open(map1_path) as m1, mrcfile.open(map2_path) as m2:
+        d1 = m1.data
+        d2 = m2.data
+        v1 = m1.voxel_size
+        
+        if d1.shape != d2.shape:
+            click.echo("Error: Maps have different shapes. Resampling not yet supported.", err=True)
+            return
+
+        voxel_size = (v1.x, v1.y, v1.z)
+        freqs, fsc = compute_fsc(d1, d2, voxel_size)
+        ccc = compute_ccc(d1, d2)
+        
+    click.echo(f"\nOverall Cross-Correlation Coefficient (CCC): {ccc:.4f}\n")
+
+    # Print some key values
+    click.echo(f"{'Resolution (A)':<15} | {'FSC':<10}")
+    click.echo("-" * 30)
+    for i in range(0, len(freqs), len(freqs)//10):
+        res = 1.0 / freqs[i] if freqs[i] > 0 else float('inf')
+        click.echo(f"{res:<15.2f} | {fsc[i]:<10.4f}")
+        
+    # Find 0.5 and 0.143 crossings
+    for val in [0.5, 0.143]:
+        cross_idx = np.where(fsc < val)[0]
+        if len(cross_idx) > 0:
+            res = 1.0 / freqs[cross_idx[0]]
+            click.echo(f"\nFSC={val} crossing at {res:.2f} Angstroms")
+
+    if output:
+        np.savetxt(output, np.column_stack((freqs, fsc)), delimiter=',', header='frequency,fsc')
+        click.echo(f"\nFSC data saved to {output}")
+
+if __name__ == '__main__':
+    main()

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

@@ -0,0 +1,66 @@
+Metadata-Version: 2.4
+Name: synth-cryo-em
+Version: 0.1.0
+Summary: Synthetic Cryo-EM map generator from PDB models
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: numpy
+Requires-Dist: mrcfile
+Requires-Dist: gemmi
+Requires-Dist: scipy
+Requires-Dist: click
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Provides-Extra: docs
+Requires-Dist: mkdocs; extra == "docs"
+Requires-Dist: mkdocs-material; extra == "docs"
+Requires-Dist: mkdocstrings[python]; extra == "docs"
+
+# synth-cryo-em
+
+[![Tests](https://github.com/elkins/synth-cryo-em/actions/workflows/test.yml/badge.svg)](https://github.com/elkins/synth-cryo-em/actions/workflows/test.yml)
+[![Documentation](https://img.shields.io/badge/docs-latest-blue)](https://elkins.github.io/synth-cryo-em/)
+
+A lightweight Pythonic utility to convert atomic models (PDB/CIF) into synthetic 3D Cryo-EM maps with realistic noise, CTF effects, and varying resolutions.
+
+## 🌟 Features
+- **Voxelize** atomic models with accurate resolution simulation.
+- **Simulate Physics:** Apply Contrast Transfer Functions (CTF) and envelope functions.
+- **Noise Modeling:** Add adjustable Gaussian noise to simulate low-SNR experimental data.
+- **Standard Format:** Export results to MRC files compatible with RELION, ChimeraX, and other tools.
+
+## 🚀 Quick Start
+
+### Installation
+```bash
+pip install synth-cryo-em
+```
+
+### Basic Generation
+```bash
+synth-cryo-em structure.pdb output.mrc --resolution 4.0
+```
+
+### Realistic Simulation
+```bash
+synth-cryo-em structure.pdb output.mrc --resolution 3.5 --apply-physics --snr 5
+```
+
+## 📚 Documentation
+For detailed guides and API reference, visit the [Documentation Site](https://elkins.github.io/synth-cryo-em/).
+
+## 🛠️ Development
+To install for development and documentation:
+```bash
+pip install -e ".[test,docs]"
+```
+
+Run tests:
+```bash
+pytest tests/
+```
+
+Build docs locally:
+```bash
+mkdocs serve
+```

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

@@ -0,0 +1,14 @@
+README.md
+pyproject.toml
+src/synth_cryo_em/cli.py
+src/synth_cryo_em/core.py
+src/synth_cryo_em/validate.py
+src/synth_cryo_em.egg-info/PKG-INFO
+src/synth_cryo_em.egg-info/SOURCES.txt
+src/synth_cryo_em.egg-info/dependency_links.txt
+src/synth_cryo_em.egg-info/entry_points.txt
+src/synth_cryo_em.egg-info/requires.txt
+src/synth_cryo_em.egg-info/top_level.txt
+tests/test_core.py
+tests/test_empirical.py
+tests/test_real_data.py

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

@@ -0,0 +1 @@
+

synth_cryo_em-0.1.0/src/synth_cryo_em.egg-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+synth-cryo-em = synth_cryo_em.cli:main
+synth-cryo-em-validate = synth_cryo_em.validate:main

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

@@ -0,0 +1,13 @@
+numpy
+mrcfile
+gemmi
+scipy
+click
+
+[docs]
+mkdocs
+mkdocs-material
+mkdocstrings[python]
+
+[test]
+pytest

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

@@ -0,0 +1 @@
+synth_cryo_em

synth_cryo_em-0.1.0/tests/test_core.py

@@ -0,0 +1,113 @@
+import unittest
+import os
+import numpy as np
+from synth_cryo_em.core import generate_density_map, apply_ctf, add_gaussian_noise
+
+class TestSynthCryoEM(unittest.TestCase):
+    def setUp(self):
+        self.pdb_content = """ATOM      1  N   ALA A   1      11.104   6.132  11.469  1.00 20.00           N  
+ATOM      2  CA  ALA A   1      12.000  12.000  12.000  1.00 20.00           C  
+ATOM      3  C   ALA A   1      13.104  18.132  13.469  1.00 20.00           C  
+TER
+END
+"""
+        self.test_pdb = "test_temp.pdb"
+        with open(self.test_pdb, "w") as f:
+            f.write(self.pdb_content)
+
+    def tearDown(self):
+        if os.path.exists(self.test_pdb):
+            os.remove(self.test_pdb)
+
+    def test_generate_density(self):
+        grid, origin = generate_density_map(self.test_pdb, resolution=4.0)
+        data = np.array(grid, copy=False)
+        self.assertGreater(np.sum(data), 0)
+        self.assertEqual(len(data.shape), 3)
+
+    def test_apply_ctf(self):
+        grid, origin = generate_density_map(self.test_pdb, resolution=4.0)
+        data = np.array(grid, copy=True)
+        uc = grid.unit_cell
+        vox_size = (uc.a / grid.nu, uc.b / grid.nv, uc.c / grid.nw)
+        data_ctf = apply_ctf(data, vox_size, defoc=1.0)
+        self.assertEqual(data_ctf.shape, data.shape)
+        # CTF should change the values
+        self.assertFalse(np.allclose(data, data_ctf))
+
+    def test_add_noise(self):
+        data = np.ones((10, 10, 10))
+        noisy = add_gaussian_noise(data, snr=10)
+        self.assertEqual(noisy.shape, data.shape)
+        self.assertNotEqual(np.mean(noisy), 1.0)
+
+    def test_apply_ctf_with_bfactor(self):
+        grid, origin = generate_density_map(self.test_pdb, resolution=4.0)
+        data = np.array(grid, copy=True)
+        uc = grid.unit_cell
+        vox_size = (uc.a / grid.nu, uc.b / grid.nv, uc.c / grid.nw)
+        data_ctf = apply_ctf(data, vox_size, defoc=1.0, b_factor=100.0)
+        self.assertEqual(data_ctf.shape, data.shape)
+        self.assertFalse(np.allclose(data, data_ctf))
+
+    def test_generate_density_no_atoms(self):
+        empty_pdb = "empty.pdb"
+        with open(empty_pdb, "w") as f:
+            f.write("END\n")
+        try:
+            with self.assertRaises(ValueError):
+                generate_density_map(empty_pdb, resolution=4.0)
+        finally:
+            if os.path.exists(empty_pdb):
+                os.remove(empty_pdb)
+
+    def test_generate_with_bfactors(self):
+        grid, origin = generate_density_map(self.test_pdb, resolution=4.0, use_bfactors=True)
+        data = np.array(grid, copy=False)
+        self.assertGreater(np.sum(data), 0)
+
+    def test_mmcif_support(self):
+        import gemmi
+        cif_path = "test_mmcif.cif"
+        st = gemmi.Structure()
+        model = gemmi.Model("1")
+        chain = gemmi.Chain("A")
+        res = gemmi.Residue()
+        res.name = "ALA"
+        res.seqid = gemmi.SeqId(1, ' ')
+        atom = gemmi.Atom()
+        atom.name = "CA"
+        atom.element = gemmi.Element("C")
+        atom.pos = gemmi.Position(10, 10, 10)
+        res.add_atom(atom)
+        chain.add_residue(res)
+        model.add_chain(chain)
+        st.add_model(model)
+        st.make_mmcif_document().write_file(cif_path)
+        
+        try:
+            grid, origin = generate_density_map(cif_path, resolution=4.0)
+            data = np.array(grid, copy=False)
+            self.assertGreater(np.sum(data), 0)
+        finally:
+            if os.path.exists(cif_path):
+                os.remove(cif_path)
+
+    def test_save_mrc(self):
+        from synth_cryo_em.core import save_mrc
+        import mrcfile
+        data = np.zeros((10, 10, 10), dtype=np.float32)
+        test_mrc = "test_output.mrc"
+        try:
+            save_mrc(data, test_mrc, origin=(1, 2, 3), spacing=(1.1, 1.1, 1.1))
+            self.assertTrue(os.path.exists(test_mrc))
+            with mrcfile.open(test_mrc) as mrc:
+                self.assertEqual(mrc.data.shape, (10, 10, 10))
+                self.assertAlmostEqual(mrc.voxel_size.x, 1.1, places=5)
+                self.assertAlmostEqual(mrc.header.origin.x, 1.0)
+        finally:
+            if os.path.exists(test_mrc):
+                os.remove(test_mrc)
+
+if __name__ == '__main__':
+    unittest.main()

synth_cryo_em-0.1.0/tests/test_empirical.py

@@ -0,0 +1,96 @@
+import unittest
+import os
+import numpy as np
+import mrcfile
+import gemmi
+import urllib.request
+from synth_cryo_em.core import generate_density_map, compute_ccc, compute_fsc
+
+class TestEmpiricalValidation(unittest.TestCase):
+    """
+    Functional tests comparing synthetic results with empirical expectations.
+    Uses small real-world structures to validate correlation.
+    """
+    
+    @classmethod
+    def setUpClass(cls):
+        # We use a very small, well-known protein: Crambin (PDB: 1CRN)
+        # It's small (46 residues) and stable.
+        cls.pdb_id = "1crn"
+        cls.pdb_path = f"{cls.pdb_id}.pdb"
+        
+        if not os.path.exists(cls.pdb_path):
+            url = f"https://files.rcsb.org/download/{cls.pdb_id}.pdb"
+            try:
+                urllib.request.urlretrieve(url, cls.pdb_path)
+            except Exception as e:
+                print(f"Skipping empirical test: Could not download {url}. Error: {e}")
+                cls.pdb_path = None
+
+    @classmethod
+    def tearDownClass(cls):
+        if cls.pdb_path and os.path.exists(cls.pdb_path):
+            os.remove(cls.pdb_path)
+
+    def test_crambin_reconstruction_consistency(self):
+        """
+        Validate that generating a map at a specific resolution and 
+        re-evaluating it against the same model yields high correlation.
+        This serves as a baseline 'internal' empirical check.
+        """
+        if not self.pdb_path:
+            self.skipTest("PDB file not available")
+
+        res = 3.0
+        # Use fixed parameters for consistency
+        spacing = 1.0
+        margin = 10.0
+        grid, _ = generate_density_map(self.pdb_path, resolution=res, grid_spacing=spacing, margin=margin)
+        data = np.array(grid, copy=True)
+
+        # Now generate a 'reference' map using the same parameters
+        grid_ref, _ = generate_density_map(self.pdb_path, resolution=res, grid_spacing=spacing, margin=margin)
+        data_ref = np.array(grid_ref, copy=True)
+
+        ccc = compute_ccc(data, data_ref)
+
+        # Identical parameters should yield identical results
+        self.assertAlmostEqual(ccc, 1.0, places=5)
+
+    def test_resolution_cutoffs(self):
+        """
+        Validate that the FSC correctly reflects the simulated resolution.
+        If we simulate at 6A, the FSC against a higher resolution (3A) version 
+        should show a significant drop.
+        """
+        if not self.pdb_path:
+            self.skipTest("PDB file not available")
+
+        res_low = 8.0
+        res_high = 2.0
+        # Use a fixed grid spacing and margin for both to ensure same shape
+        spacing = 1.0
+        margin = 15.0
+
+        grid_low, _ = generate_density_map(self.pdb_path, resolution=res_low, grid_spacing=spacing, margin=margin)
+        grid_high, _ = generate_density_map(self.pdb_path, resolution=res_high, grid_spacing=spacing, margin=margin)
+
+        # Ensure grids are the same size for comparison
+        data_low = np.array(grid_low, copy=True)
+        data_high = np.array(grid_high, copy=True)
+
+        uc = grid_low.unit_cell
+        voxel_size = (uc.a / grid_low.nu, uc.b / grid_low.nv, uc.c / grid_low.nw)
+
+        freqs, fsc = compute_fsc(data_low, data_high, voxel_size)
+
+        # The FSC should be lower at higher frequencies
+        # Check that FSC at high frequency (near Nyquist) is much lower than at low frequency
+        self.assertGreater(fsc[1], fsc[-1], "FSC should decrease with frequency")
+
+        # Check for a drop below 0.5 at some point
+        low_fsc_indices = np.where(fsc < 0.5)[0]
+        self.assertGreater(len(low_fsc_indices), 0, "FSC should drop below 0.5 for different resolutions")
+
+if __name__ == '__main__':
+    unittest.main()

synth_cryo_em-0.1.0/tests/test_real_data.py

@@ -0,0 +1,90 @@
+import unittest
+import os
+import numpy as np
+import mrcfile
+import gemmi
+import urllib.request
+import gzip
+import shutil
+from synth_cryo_em.core import generate_density_map, compute_ccc, compute_fsc
+
+class TestRealDataValidation(unittest.TestCase):
+    """
+    Validation against real empirical data from PDB and EMDB.
+    """
+    
+    @classmethod
+    def setUpClass(cls):
+        cls.pdb_id = "6k7v"
+        cls.emdb_id = "9943"
+        cls.pdb_path = f"{cls.pdb_id}.pdb"
+        cls.mrc_gz_path = f"emd_{cls.emdb_id}.map.gz"
+        cls.mrc_path = f"emd_{cls.emdb_id}.map"
+        
+        # Download PDB
+        if not os.path.exists(cls.pdb_path):
+            url = f"https://files.rcsb.org/download/{cls.pdb_id}.pdb"
+            try:
+                urllib.request.urlretrieve(url, cls.pdb_path)
+            except Exception as e:
+                print(f"Failed to download PDB: {e}")
+                cls.pdb_path = None
+
+        # Download EMDB map
+        if not os.path.exists(cls.mrc_path):
+            url = f"https://ftp.ebi.ac.uk/pub/databases/emdb/structures/EMD-{cls.emdb_id}/map/emd_{cls.emdb_id}.map.gz"
+            try:
+                urllib.request.urlretrieve(url, cls.mrc_gz_path)
+                with gzip.open(cls.mrc_gz_path, 'rb') as f_in:
+                    with open(cls.mrc_path, 'wb') as f_out:
+                        shutil.copyfileobj(f_in, f_out)
+            except Exception as e:
+                print(f"Failed to download/extract EMDB map: {e}")
+                cls.mrc_path = None
+
+    @classmethod
+    def tearDownClass(cls):
+        for p in [cls.pdb_path, cls.mrc_gz_path, cls.mrc_path]:
+            if p and os.path.exists(p):
+                # We might want to keep them for faster debugging, 
+                # but for CI/tests we should clean up.
+                os.remove(p)
+
+    def test_emd_9943_correlation(self):
+        """
+        Compare synthetic map from 6K7V with experimental map EMD-9943.
+        """
+        if not self.pdb_path or not self.mrc_path:
+            self.skipTest("Data not available")
+
+        # Load experimental map to get its parameters
+        with mrcfile.open(self.mrc_path) as mrc:
+            exp_data = mrc.data.copy()
+            vox_size = mrc.voxel_size
+            origin = (mrc.header.origin.x, mrc.header.origin.y, mrc.header.origin.z)
+            spacing = vox_size.x # Assuming cubic voxels
+            
+        # The experimental map has a specific resolution (3.7 A)
+        res = 3.7
+        
+        # Generate synthetic map matching experimental grid as much as possible
+        # Note: we need to handle the origin and grid size to match exactly.
+        # For now, let's just check if we can get a decent correlation.
+        
+        # We'll use our generator with the same spacing
+        grid, gen_origin = generate_density_map(self.pdb_path, resolution=res, grid_spacing=spacing)
+        gen_data = np.array(grid, copy=True)
+        
+        # Since shapes might differ (generator adds margins), we'll just check
+        # if the code runs and reports a non-zero correlation.
+        # A full structural alignment would be needed for a perfect CCC.
+        
+        self.assertGreater(np.sum(gen_data), 0)
+        self.assertEqual(len(gen_data.shape), 3)
+        
+        # In a real functional test, we would resample/align them.
+        # Here we at least validate the tool can process real PDBs.
+        print(f"Generated map shape: {gen_data.shape}, Experimental: {exp_data.shape}")
+
+if __name__ == '__main__':
+    unittest.main()