center-map 0.1.0__tar.gz

center_map-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Arthur Zalevsky
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

center_map-0.1.0/PKG-INFO

@@ -0,0 +1,85 @@
+Metadata-Version: 2.4
+Name: center-map
+Version: 0.1.0
+Summary: Recenter crystallographic density maps (e.g. PDBe 2fofc/fofc) on the model; a command for PyMOL
+Author-email: Arthur Zalevsky <aozalevsky@gmail.com>
+License-Expression: MIT
+Project-URL: Repository, https://github.com/aozalevsky/center-map
+Keywords: pymol,electron density,crystallography,ccp4,map
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Requires-Dist: gemmi; extra == "test"
+Dynamic: license-file
+
+# center-map
+
+`center_map` recenters crystallographic density maps on the model, the way
+the old EDS/RCSB DSN6 maps were. It is a command for PyMOL.
+
+Maps from `fetch 3tj3, type=2fofc` (PDBe) cover one unit cell starting at
+the origin, so much of the model sits outside them. `center_map` cuts a new
+box around the selection out of the periodic crystal.
+
+## Install
+
+Into the Python environment the viewer runs in:
+
+    pip install center-map
+
+then add one line to `~/.pymolrc`:
+
+    import center_map
+
+Without pip (e.g. bundled installers): *Plugin > Plugin Manager > Install
+New Plugin* and choose `center_map.py`. The only dependency is numpy,
+which is already bundled.
+
+## Use
+
+    fetch 3tj3
+    fetch 3tj3, type=2fofc
+    center_map                          # all maps, all atoms, 5 A margin
+    isomesh mesh, 3tj3_2fofc, 1.0
+
+    center_map 3tj3_2fofc, chain A      # again, on one chain of one map
+
+`center_map` replaces the map object in place; make meshes after it. A
+centered map can be centered again on atoms inside its box; for a bigger
+box, fetch the map again. `help center_map` lists the arguments.
+
+## Why the density is exact
+
+* Crystal density is periodic, so a map covering one full unit cell already
+  holds every value: grid point *i* is grid point *i* mod *N*. The box is
+  filled by copying grid values; nothing is interpolated or resampled, also
+  for non-orthogonal cells.
+* The original contour scale is kept. Maps are normally rescaled on load to
+  the sigma of the loaded grid, which for a box around the protein differs
+  from the sigma of the cell; that is switched off while the box is loaded.
+* It refuses maps it cannot handle exactly: maps that do not cover a full
+  unit cell (e.g. asymmetric-unit maps from CCP4 `fft`), and maps whose cell
+  differs from the selection's (cryo-EM maps, maps made with `map_new`,
+  other crystal forms).
+
+## Limitations
+
+One map state; object matrices (moved objects) are ignored.
+
+## Tests
+
+    pip install pytest gemmi
+    python -m pytest tests      # downloads a few PDBe maps on the first run
+
+gemmi is used only by the tests, as an independent reference: the boxes
+must match gemmi's periodic lookup bit for bit (P 21 21 21, P 1, P 21 and
+I 2 2 2 entries), land on the original map when the viewer places them,
+and cover every atom plus the margin.
+
+## License
+
+MIT. PyMOL is a trademark of Schrödinger, LLC. This project is not
+affiliated with or endorsed by Schrödinger.

center_map-0.1.0/README.md

@@ -0,0 +1,68 @@
+# center-map
+
+`center_map` recenters crystallographic density maps on the model, the way
+the old EDS/RCSB DSN6 maps were. It is a command for PyMOL.
+
+Maps from `fetch 3tj3, type=2fofc` (PDBe) cover one unit cell starting at
+the origin, so much of the model sits outside them. `center_map` cuts a new
+box around the selection out of the periodic crystal.
+
+## Install
+
+Into the Python environment the viewer runs in:
+
+    pip install center-map
+
+then add one line to `~/.pymolrc`:
+
+    import center_map
+
+Without pip (e.g. bundled installers): *Plugin > Plugin Manager > Install
+New Plugin* and choose `center_map.py`. The only dependency is numpy,
+which is already bundled.
+
+## Use
+
+    fetch 3tj3
+    fetch 3tj3, type=2fofc
+    center_map                          # all maps, all atoms, 5 A margin
+    isomesh mesh, 3tj3_2fofc, 1.0
+
+    center_map 3tj3_2fofc, chain A      # again, on one chain of one map
+
+`center_map` replaces the map object in place; make meshes after it. A
+centered map can be centered again on atoms inside its box; for a bigger
+box, fetch the map again. `help center_map` lists the arguments.
+
+## Why the density is exact
+
+* Crystal density is periodic, so a map covering one full unit cell already
+  holds every value: grid point *i* is grid point *i* mod *N*. The box is
+  filled by copying grid values; nothing is interpolated or resampled, also
+  for non-orthogonal cells.
+* The original contour scale is kept. Maps are normally rescaled on load to
+  the sigma of the loaded grid, which for a box around the protein differs
+  from the sigma of the cell; that is switched off while the box is loaded.
+* It refuses maps it cannot handle exactly: maps that do not cover a full
+  unit cell (e.g. asymmetric-unit maps from CCP4 `fft`), and maps whose cell
+  differs from the selection's (cryo-EM maps, maps made with `map_new`,
+  other crystal forms).
+
+## Limitations
+
+One map state; object matrices (moved objects) are ignored.
+
+## Tests
+
+    pip install pytest gemmi
+    python -m pytest tests      # downloads a few PDBe maps on the first run
+
+gemmi is used only by the tests, as an independent reference: the boxes
+must match gemmi's periodic lookup bit for bit (P 21 21 21, P 1, P 21 and
+I 2 2 2 entries), land on the original map when the viewer places them,
+and cover every atom plus the margin.
+
+## License
+
+MIT. PyMOL is a trademark of Schrödinger, LLC. This project is not
+affiliated with or endorsed by Schrödinger.

center_map-0.1.0/center_map.egg-info/PKG-INFO

@@ -0,0 +1,85 @@
+Metadata-Version: 2.4
+Name: center-map
+Version: 0.1.0
+Summary: Recenter crystallographic density maps (e.g. PDBe 2fofc/fofc) on the model; a command for PyMOL
+Author-email: Arthur Zalevsky <aozalevsky@gmail.com>
+License-Expression: MIT
+Project-URL: Repository, https://github.com/aozalevsky/center-map
+Keywords: pymol,electron density,crystallography,ccp4,map
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Requires-Dist: gemmi; extra == "test"
+Dynamic: license-file
+
+# center-map
+
+`center_map` recenters crystallographic density maps on the model, the way
+the old EDS/RCSB DSN6 maps were. It is a command for PyMOL.
+
+Maps from `fetch 3tj3, type=2fofc` (PDBe) cover one unit cell starting at
+the origin, so much of the model sits outside them. `center_map` cuts a new
+box around the selection out of the periodic crystal.
+
+## Install
+
+Into the Python environment the viewer runs in:
+
+    pip install center-map
+
+then add one line to `~/.pymolrc`:
+
+    import center_map
+
+Without pip (e.g. bundled installers): *Plugin > Plugin Manager > Install
+New Plugin* and choose `center_map.py`. The only dependency is numpy,
+which is already bundled.
+
+## Use
+
+    fetch 3tj3
+    fetch 3tj3, type=2fofc
+    center_map                          # all maps, all atoms, 5 A margin
+    isomesh mesh, 3tj3_2fofc, 1.0
+
+    center_map 3tj3_2fofc, chain A      # again, on one chain of one map
+
+`center_map` replaces the map object in place; make meshes after it. A
+centered map can be centered again on atoms inside its box; for a bigger
+box, fetch the map again. `help center_map` lists the arguments.
+
+## Why the density is exact
+
+* Crystal density is periodic, so a map covering one full unit cell already
+  holds every value: grid point *i* is grid point *i* mod *N*. The box is
+  filled by copying grid values; nothing is interpolated or resampled, also
+  for non-orthogonal cells.
+* The original contour scale is kept. Maps are normally rescaled on load to
+  the sigma of the loaded grid, which for a box around the protein differs
+  from the sigma of the cell; that is switched off while the box is loaded.
+* It refuses maps it cannot handle exactly: maps that do not cover a full
+  unit cell (e.g. asymmetric-unit maps from CCP4 `fft`), and maps whose cell
+  differs from the selection's (cryo-EM maps, maps made with `map_new`,
+  other crystal forms).
+
+## Limitations
+
+One map state; object matrices (moved objects) are ignored.
+
+## Tests
+
+    pip install pytest gemmi
+    python -m pytest tests      # downloads a few PDBe maps on the first run
+
+gemmi is used only by the tests, as an independent reference: the boxes
+must match gemmi's periodic lookup bit for bit (P 21 21 21, P 1, P 21 and
+I 2 2 2 entries), land on the original map when the viewer places them,
+and cover every atom plus the margin.
+
+## License
+
+MIT. PyMOL is a trademark of Schrödinger, LLC. This project is not
+affiliated with or endorsed by Schrödinger.

center_map-0.1.0/center_map.egg-info/SOURCES.txt

@@ -0,0 +1,10 @@
+LICENSE
+README.md
+center_map.py
+pyproject.toml
+center_map.egg-info/PKG-INFO
+center_map.egg-info/SOURCES.txt
+center_map.egg-info/dependency_links.txt
+center_map.egg-info/requires.txt
+center_map.egg-info/top_level.txt
+tests/test_center_map.py

center_map-0.1.0/center_map.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

center_map-0.1.0/center_map.egg-info/requires.txt

@@ -0,0 +1,5 @@
+numpy
+
+[test]
+pytest
+gemmi

center_map-0.1.0/center_map.egg-info/top_level.txt

@@ -0,0 +1 @@
+center_map

center_map-0.1.0/center_map.py

@@ -0,0 +1,106 @@
+"""center_map: recenter crystallographic maps on a selection.
+
+    pip install center-map
+    echo "import center_map" >> ~/.pymolrc
+"""
+import os
+import tempfile
+
+import numpy as np
+from pymol import cmd, CmdException
+
+
+def center_map(map='', selection='all', margin=5.0, quiet=1, _self=cmd):
+    '''
+DESCRIPTION
+
+    Recenter crystallographic map(s) on a selection, like the old EDS/RCSB
+    DSN6 maps did. Maps from "fetch code, type=2fofc" cover one unit cell
+    starting at the origin, so the model often sits partly outside them.
+
+    The map must cover a full unit cell of the selection's crystal, or
+    already contain the new box (e.g. centering again on fewer atoms).
+    Values are copied from the periodic lattice, not interpolated, and keep
+    the contour scale of the original map.
+
+USAGE
+
+    center_map [ map [, selection [, margin ]]]
+
+ARGUMENTS
+
+    map = str: map object {default: all maps}
+
+    selection = str: atoms the map should cover {default: all}
+
+    margin = float: padding around the atoms, in Angstrom {default: 5}
+
+EXAMPLE
+
+    fetch 3tj3
+    fetch 3tj3, type=2fofc
+    center_map
+    isomesh mesh, 3tj3_2fofc, 1.0
+    '''
+    margin, quiet = float(margin), int(quiet)
+    xyz = _self.get_coords(selection)
+    sym = _self.get_symmetry(selection)
+    if xyz is None or not sym:
+        raise CmdException('"%s" has no atoms or no unit cell' % selection)
+    for name in [map] if map else _self.get_names_of_type('object:map'):
+        with tempfile.TemporaryDirectory() as tmp:
+            path = os.path.join(tmp, 'map.ccp4')
+            _self.save(path, name)
+            with open(path, 'rb') as f:
+                raw = f.read()
+        h = np.frombuffer(raw, np.int32, 256).copy()  # CCP4 header words
+        cell = h[10:16].view(np.float32)
+        if not np.allclose(cell, sym[:6], rtol=1e-3):
+            raise CmdException('%s: unit cell differs from "%s"' % (name, selection))
+        n, start, axes = h[0:3], h[4:7], h[16:19] - 1  # column, row, section
+        N = h[7:10][axes]  # cell sampling along the file axes
+        data = np.frombuffer(raw, np.float32, int(n.prod()), 1024 + h[23]).reshape(n[::-1])
+
+        # box in grid units around the atoms; margin along each axis is
+        # margin * |reciprocal axis|, i.e. measured perpendicular to the cell faces
+        a, b, c = cell[:3]
+        ca, cb, cg = np.cos(np.radians(cell[3:]))
+        sg = np.sqrt(1 - cg * cg)
+        v = np.sqrt(1 - ca * ca - cb * cb - cg * cg + 2 * ca * cb * cg)
+        frac = np.linalg.inv([[a, b * cg, c * cb],
+                              [0, b * sg, c * (ca - cb * cg) / sg],
+                              [0, 0, c * v / sg]])[axes]
+        f = xyz @ frac.T
+        pad = margin * np.linalg.norm(frac, axis=1)
+        lo = np.floor((f.min(0) - pad) * N).astype(np.int32)
+        hi = np.ceil((f.max(0) + pad) * N).astype(np.int32) + 1
+
+        # crystal density is periodic: grid point i is grid point i mod N; that
+        # needs a full cell along an axis, unless the box lies inside the map
+        if h[3] != 2 or not ((n >= N) | ((lo >= start) & (hi <= start + n))).all():
+            raise CmdException('%s does not cover a full unit cell, nor the box '
+                               'around "%s"' % (name, selection))
+        idx = [(np.arange(l, u) - s) % m for l, u, s, m in zip(lo, hi, start, N)]
+        box = data[np.ix_(*idx[::-1])]
+
+        h[0:3], h[4:7], h[23] = hi - lo, lo, 0
+        tmpname = _self.get_unused_name('_center_map')
+        normalize = _self.get('normalize_ccp4_maps')
+        _self.set('normalize_ccp4_maps', 0)  # sigma of the box != sigma of the cell
+        try:
+            _self.load_raw(h.tobytes() + box.tobytes(), 'ccp4', tmpname, quiet=1)
+        finally:
+            _self.set('normalize_ccp4_maps', normalize)
+        _self.delete(name)
+        _self.set_name(tmpname, name)
+        if not quiet:
+            print(' center_map: %s covers "%s" + %g A' % (name, selection, margin))
+
+
+def __init_plugin__(app=None):
+    pass  # lets the Plugin Manager install this file; the command is registered on import
+
+
+cmd.extend('center_map', center_map)
+cmd.auto_arg[0]['center_map'] = cmd.auto_arg[0]['map_double']
+cmd.auto_arg[1]['center_map'] = cmd.auto_arg[1]['map_trim']

center_map-0.1.0/pyproject.toml

@@ -0,0 +1,23 @@
+[build-system]
+requires = ["setuptools>=77"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "center-map"
+version = "0.1.0"
+description = "Recenter crystallographic density maps (e.g. PDBe 2fofc/fofc) on the model; a command for PyMOL"
+readme = "README.md"
+license = "MIT"
+authors = [{name = "Arthur Zalevsky", email = "aozalevsky@gmail.com"}]
+requires-python = ">=3.6"
+dependencies = ["numpy"]  # the viewer itself is not installed from PyPI
+keywords = ["pymol", "electron density", "crystallography", "ccp4", "map"]
+
+[project.urls]
+Repository = "https://github.com/aozalevsky/center-map"
+
+[project.optional-dependencies]
+test = ["pytest", "gemmi"]
+
+[tool.setuptools]
+py-modules = ["center_map"]

center_map-0.1.0/setup.cfg

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

center_map-0.1.0/tests/test_center_map.py

@@ -0,0 +1,174 @@
+"""Tests for center_map. Need network on first run (maps are cached in .pytest_cache).
+
+gemmi is used only here, as an independent reference implementation.
+"""
+import numpy as np
+import pytest
+from pymol import cmd, CmdException
+
+from center_map import center_map  # importing registers the PyMOL command
+
+gemmi = pytest.importorskip('gemmi')
+
+SITE = '3tj3 and chain A and resi 100-110'
+
+ENTRIES = {
+    '3tj3': 'P 21 21 21, model sticks out of the cell',
+    '2vb1': 'P 1, triclinic',
+    '1ejg': 'P 21, monoclinic',
+    '1tqn': 'I 2 2 2, centred',
+}
+
+
+@pytest.fixture(scope='session')
+def fetch_dir(pytestconfig):
+    return str(pytestconfig.cache.mkdir('pdbe'))
+
+
+def fetch(fetch_dir, code, *types):
+    cmd.reinitialize()
+    cmd.set('fetch_path', fetch_dir)
+    for t in ('cif',) + types:
+        if cmd.fetch(code, type=t, async_=0) == -1:
+            pytest.skip('cannot fetch %s %s' % (code, t))
+
+
+def as_gemmi(name, tmp_path):
+    path = str(tmp_path / (name + '.ccp4'))
+    cmd.save(path, name)
+    return gemmi.read_ccp4_map(path)
+
+
+def box_xyz(m):
+    """Cell sampling, box start and box data of an exported map, in x,y,z order."""
+    N = np.array([m.header_i32(8 + i) for i in range(3)])
+    start = np.rint(np.array(m.get_extent().minimum.tolist()) * N).astype(int)
+    m.setup(float('nan'), gemmi.MapSetup.ReorderOnly)
+    return N, start, np.array(m.grid, copy=True)
+
+
+def far_corner(ref, code):
+    """Pseudoatom at lattice point (2, -3, 1): a box around it wraps on every axis."""
+    corner = ref.grid.unit_cell.orthogonalize(gemmi.Fractional(2, -3, 1))
+    cmd.pseudoatom('spot', pos=corner.tolist())
+    cmd.set_symmetry('spot', *cmd.get_symmetry(code))
+    return 'spot'
+
+
+@pytest.mark.parametrize('code', ENTRIES)
+@pytest.mark.parametrize('where', ['model', 'far_corner'])
+def test_values_identical_to_gemmi_periodic_lookup(code, where, fetch_dir, tmp_path):
+    fetch(fetch_dir, code, '2fofc')
+    ref = as_gemmi(code + '_2fofc', tmp_path)
+    ref.setup(float('nan'))
+    assert not np.isnan(np.array(ref.grid)).any()
+    selection = far_corner(ref, code) if where == 'far_corner' else code
+
+    center_map(code + '_2fofc', selection)
+
+    N, start, ours = box_xyz(as_gemmi(code + '_2fofc', tmp_path))
+    assert ours.shape != tuple(N) or start.any(), 'map was not moved'
+    expected = ref.grid.get_subarray(start.tolist(), list(ours.shape))
+    assert np.array_equal(ours, expected)  # bit-identical, so no renormalization either
+    assert cmd.get_setting_boolean('normalize_ccp4_maps')
+
+
+@pytest.mark.parametrize('code', ENTRIES)
+def test_recentering_an_already_centered_map(code, fetch_dir, tmp_path):
+    fetch(fetch_dir, code, '2fofc')
+    ref = as_gemmi(code + '_2fofc', tmp_path)
+    ref.setup(float('nan'))
+    # a box wider than the cell on every axis, no longer starting at the origin
+    center_map(code + '_2fofc', 'first (%s and q > 0)' % code, 0.55 * max(cmd.get_symmetry(code)[:3]))
+    N, start, data = box_xyz(as_gemmi(code + '_2fofc', tmp_path))
+    assert start.any() and (np.array(data.shape) >= N).all()
+
+    center_map(code + '_2fofc', far_corner(ref, code))
+
+    _, start, ours = box_xyz(as_gemmi(code + '_2fofc', tmp_path))
+    assert np.array_equal(ours, ref.grid.get_subarray(start.tolist(), list(ours.shape)))
+
+
+def test_centering_again_inside_a_centered_map(fetch_dir, tmp_path):
+    fetch(fetch_dir, '3tj3', '2fofc')
+    ref = as_gemmi('3tj3_2fofc', tmp_path)
+    ref.setup(float('nan'))
+    center_map('3tj3_2fofc', '3tj3', 5)  # box narrower than the cell along x and z
+
+    center_map('3tj3_2fofc', SITE, 3)
+
+    _, start, ours = box_xyz(as_gemmi('3tj3_2fofc', tmp_path))
+    assert np.array_equal(ours, ref.grid.get_subarray(start.tolist(), list(ours.shape)))
+
+
+@pytest.mark.parametrize('code', ENTRIES)
+def test_box_covers_every_atom_plus_margin(code, fetch_dir, tmp_path):
+    fetch(fetch_dir, code, '2fofc')
+    margin = 3.0
+    center_map(code + '_2fofc', code, margin)
+
+    m = as_gemmi(code + '_2fofc', tmp_path)
+    cell = m.grid.unit_cell
+    N, start, data = box_xyz(m)
+    frac = np.array([cell.fractionalize(gemmi.Position(*p)).tolist()
+                     for p in cmd.get_coords(code)])
+    rec = cell.reciprocal()
+    pad = margin * np.array([rec.a, rec.b, rec.c])
+    assert ((frac - pad) * N >= start).all()
+    assert ((frac + pad) * N <= start + np.array(data.shape) - 1).all()
+
+
+@pytest.mark.parametrize('code', ENTRIES)
+def test_pymol_places_centered_map_on_original(code, fetch_dir, tmp_path):
+    fetch(fetch_dir, code, '2fofc')
+    cmd.copy('orig', code + '_2fofc')
+    before = cmd.get_volume_field('orig')
+
+    center_map(code + '_2fofc', code)
+    _, start, data = box_xyz(as_gemmi(code + '_2fofc', tmp_path))
+    assert data.shape != before.shape or start.any(), 'map was not moved'
+
+    # PyMOL interpolates the centered map at the original (in-cell) grid nodes;
+    # exact up to float32 rounding, while a 1-voxel shift would differ by ~1 sigma
+    cmd.map_set('orig', 'copy', code + '_2fofc')
+    after = cmd.get_volume_field('orig')
+    inner = [(np.arange(n) > s) & (np.arange(n) < s + d - 1)
+             for n, s, d in zip(before.shape, start, data.shape)]
+    mask = np.ix_(*inner)
+    assert before[mask].size > 1000
+    np.testing.assert_allclose(after[mask], before[mask], rtol=0, atol=2e-3)
+
+
+def test_default_centers_all_maps_on_all_atoms(fetch_dir):
+    fetch(fetch_dir, '3tj3', '2fofc', 'fofc')
+    cmd.do('center_map')
+    lo, hi = np.array(cmd.get_extent('3tj3'))
+    for name in ('3tj3_2fofc', '3tj3_fofc'):
+        mlo, mhi = np.array(cmd.get_extent(name))
+        assert (mlo <= lo - 5).all() and (mhi >= hi + 5).all(), name
+
+
+def test_refuses_map_not_covering_full_cell(fetch_dir):
+    fetch(fetch_dir, '3tj3', '2fofc')
+    inside = '3tj3 and x > 20 and y > 10 and z > 10'  # map_trim ignores atoms off the map
+    assert cmd.count_atoms(inside)
+    cmd.map_trim('3tj3_2fofc', inside, 2.0)
+    assert cmd.get_volume_field('3tj3_2fofc').size < 64 * 80 * 108
+    with pytest.raises(CmdException, match='unit cell'):
+        center_map('3tj3_2fofc', '3tj3')
+
+
+def test_refuses_map_from_another_cell(fetch_dir):
+    fetch(fetch_dir, '3tj3')
+    if cmd.fetch('2vb1', type='2fofc', async_=0) == -1:
+        pytest.skip('cannot fetch 2vb1 2fofc')
+    with pytest.raises(CmdException, match='cell'):
+        center_map('2vb1_2fofc', '3tj3')
+
+
+def test_refuses_map_computed_in_pymol(fetch_dir):
+    fetch(fetch_dir, '3tj3')
+    cmd.map_new('gmap', 'gaussian', 1.0, SITE, 2)
+    assert 'gmap' in cmd.get_names()
+    with pytest.raises(CmdException, match='cell'):
+        center_map('gmap', '3tj3')