diff --git a/diffmaps.html b/diffmaps.html
index f469540..bedadc4 100644
--- a/diffmaps.html
+++ b/diffmaps.html
@@ -35,7 +35,7 @@ <h1 class="title">Module <code>meteor.diffmaps</code></h1>
 <h2 class="section-title" id="header-functions">Functions</h2>
 <dl>
 <dt id="meteor.diffmaps.compute_difference_map"><code class="name flex">
-<span>def <span class="ident">compute_difference_map</span></span>(<span>derivative: Map, native: Map) ‑> <a title="meteor.rsmap.Map" href="rsmap.html#meteor.rsmap.Map">Map</a></span>
+<span>def <span class="ident">compute_difference_map</span></span>(<span>derivative: Map, native: Map, *, check_isomorphous: bool = True) ‑> <a title="meteor.rsmap.Map" href="rsmap.html#meteor.rsmap.Map">Map</a></span>
 </code></dt>
 <dd>
 <div class="desc"><p>Computes amplitude and phase differences between native and derivative structure factor sets.</p>
@@ -50,6 +50,8 @@ <h2 id="parameters">Parameters</h2>
 <dd>the derivative amplitudes, phases, uncertainties</dd>
 <dt><strong><code>native</code></strong> :&ensp;<code>Map</code></dt>
 <dd>the native amplitudes, phases, uncertainties</dd>
+<dt><strong><code>check_isomorphous</code></strong> :&ensp;<code>bool</code></dt>
+<dd>perform a check to ensure the two datasets are isomorphous; recommended. Default: True.</dd>
 </dl>
 <h2 id="returns">Returns</h2>
 <dl>
@@ -58,7 +60,7 @@ <h2 id="returns">Returns</h2>
 </dl></div>
 </dd>
 <dt id="meteor.diffmaps.compute_kweighted_difference_map"><code class="name flex">
-<span>def <span class="ident">compute_kweighted_difference_map</span></span>(<span>derivative: Map, native: Map, *, k_parameter: float) ‑> <a title="meteor.rsmap.Map" href="rsmap.html#meteor.rsmap.Map">Map</a></span>
+<span>def <span class="ident">compute_kweighted_difference_map</span></span>(<span>derivative: Map, native: Map, *, k_parameter: float, check_isomorphous: bool = True) ‑> <a title="meteor.rsmap.Map" href="rsmap.html#meteor.rsmap.Map">Map</a></span>
 </code></dt>
 <dd>
 <div class="desc"><p>Compute k-weighted derivative - native structure factor map.</p>
@@ -71,6 +73,8 @@ <h2 id="parameters">Parameters</h2>
 <dd>the derivative amplitudes, phases, uncertainties</dd>
 <dt><strong><code>native</code></strong> :&ensp;<code>Map</code></dt>
 <dd>the native amplitudes, phases, uncertainties</dd>
+<dt><strong><code>check_isomorphous</code></strong> :&ensp;<code>bool</code></dt>
+<dd>perform a check to ensure the two datasets are isomorphous; recommended. Default: True.</dd>
 </dl>
 <h2 id="returns">Returns</h2>
 <dl>
@@ -109,7 +113,7 @@ <h2 id="returns">Returns</h2>
 0.77, 0.78, 0.79, 0.8 , 0.81, 0.82, 0.83, 0.84, 0.85, 0.86, 0.87,
 0.88, 0.89, 0.9 , 0.91, 0.92, 0.93, 0.94, 0.95, 0.96, 0.97, 0.98,
 0.99, 1.
-])) ‑> reciprocalspaceship.dataset.DataSet</span>
+]), check_isomorphous: bool = True) ‑> reciprocalspaceship.dataset.DataSet</span>
 </code></dt>
 <dd>
 <div class="desc"><p>Compute k-weighted differences between native and derivative amplitudes and phases.</p>
@@ -124,6 +128,8 @@ <h2 id="parameters">Parameters</h2>
 <dd>the native amplitudes, phases, uncertainties</dd>
 <dt><strong><code>k_parameter_values_to_scan</code></strong> :&ensp;<code>np.ndarray | Sequence[float]</code></dt>
 <dd>The values to scan to optimize the k-weighting parameter, by default is 0.00, 0.01 &hellip; 1.00</dd>
+<dt><strong><code>check_isomorphous</code></strong> :&ensp;<code>bool</code></dt>
+<dd>perform a check to ensure the two datasets are isomorphous; recommended. Default: True.</dd>
 </dl>
 <h2 id="returns">Returns</h2>
 <dl>
@@ -133,12 +139,6 @@ <h2 id="returns">Returns</h2>
 <dd>optimized k-weighting parameter</dd>
 </dl></div>
 </dd>
-<dt id="meteor.diffmaps.set_common_crystallographic_metadata"><code class="name flex">
-<span>def <span class="ident">set_common_crystallographic_metadata</span></span>(<span>map1: Map, map2: Map, *, output: Map) ‑> None</span>
-</code></dt>
-<dd>
-<div class="desc"></div>
-</dd>
 </dl>
 </section>
 <section>
@@ -160,7 +160,6 @@ <h2 id="returns">Returns</h2>
 <li><code><a title="meteor.diffmaps.compute_kweighted_difference_map" href="#meteor.diffmaps.compute_kweighted_difference_map">compute_kweighted_difference_map</a></code></li>
 <li><code><a title="meteor.diffmaps.compute_kweights" href="#meteor.diffmaps.compute_kweights">compute_kweights</a></code></li>
 <li><code><a title="meteor.diffmaps.max_negentropy_kweighted_difference_map" href="#meteor.diffmaps.max_negentropy_kweighted_difference_map">max_negentropy_kweighted_difference_map</a></code></li>
-<li><code><a title="meteor.diffmaps.set_common_crystallographic_metadata" href="#meteor.diffmaps.set_common_crystallographic_metadata">set_common_crystallographic_metadata</a></code></li>
 </ul>
 </li>
 </ul>
diff --git a/index.html b/index.html
index 2a3ad55..989a61b 100644
--- a/index.html
+++ b/index.html
@@ -5,8 +5,7 @@
 <meta name="viewport" content="width=device-width, initial-scale=1, minimum-scale=1">
 <meta name="generator" content="pdoc3 0.11.1">
 <title>meteor API documentation</title>
-<meta name="description" content="METEOR
-…">
+<meta name="description" content="☄️ METEOR …">
 <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/10up-sanitize.css/13.0.0/sanitize.min.css" integrity="sha512-y1dtMcuvtTMJc1yPgEqF0ZjQbhnc/bFhyvIyVNb9Zk5mIGtqVaAB1Ttl28su8AvFMOY0EwRbAe+HCLqj6W7/KA==" crossorigin>
 <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/10up-sanitize.css/13.0.0/typography.min.css" integrity="sha512-Y1DYSb995BAfxobCkKepB1BqJJTPrOp3zPL74AWFugHHmmdcvO+C48WLrUOlhGMc0QG7AE3f7gmvvcrmX2fDoA==" crossorigin>
 <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/11.9.0/styles/default.min.css" crossorigin>
@@ -26,13 +25,12 @@
 <h1 class="title">Package <code>meteor</code></h1>
 </header>
 <section id="section-intro">
-<h1 id="meteor">METEOR</h1>
-<hr>
+<h1 id="meteor">☄️ METEOR</h1>
 <p><strong>Map Enhancement Tools for Ephemeral Occupancy Refinement</strong></p>
-<p><a href="https://github.com/your_username/your_repo/actions/workflows/tests.yml"><img alt="Pytest" src="https://github.com/alisiafadini/meteor/actions/workflows/tests.yml/badge.svg"></a>
-<a href="https://github.com/your_username/your_repo/actions/workflows/mypy.yml"><img alt="Mypy" src="https://github.com/alisiafadini/meteor/actions/workflows/mypy.yml/badge.svg"></a>
-<a href="https://github.com/your_username/your_repo/actions/workflows/lint.yml"><img alt="Ruff" src="https://github.com/alisiafadini/meteor/actions/workflows/lint.yml/badge.svg"></a>
-<a href="https://codecov.io/gh/alisiafadini/meteor"><img alt="codecov" src="https://codecov.io/gh/alisiafadini/meteor/graph/badge.svg?token=NCYMP06MNS"></a>
+<p><a href="https://github.com/rs-station/meteor/actions/workflows/tests.yml"><img alt="Pytest" src="https://github.com/rs-station/meteor/actions/workflows/tests.yml/badge.svg"></a>
+<a href="https://github.com/rs-station/meteor/actions/workflows/mypy.yml"><img alt="Mypy" src="https://github.com/rs-station/meteor/actions/workflows/mypy.yml/badge.svg"></a>
+<a href="https://github.com/rs-station/meteor/actions/workflows/lint.yml"><img alt="Ruff" src="https://github.com/rs-station/meteor/actions/workflows/lint.yml/badge.svg"></a>
+<a href="https://codecov.io/github/rs-station/meteor"><img alt="codecov" src="https://codecov.io/github/rs-station/meteor/graph/badge.svg?token=pn9lOy3fMp"></a>
 <img alt="GitHub Tag" src="https://img.shields.io/github/v/tag/rs-station/meteor"></p>
 <p><code><a title="meteor" href="#meteor">meteor</a></code> is a tool for computing crystallographic difference maps. </p>
 <p><code><a title="meteor" href="#meteor">meteor</a></code> specializes the robust identification of weak signals arising from minor but scientifically interesting populations, such as bound ligands or changes that occur in time-resolved experiments. That said, if you need an difference map, <code><a title="meteor" href="#meteor">meteor</a></code> can do it!</p>
@@ -163,7 +161,7 @@ <h2 class="section-title" id="header-submodules">Sub-modules</h2>
 <nav id="sidebar">
 <div class="toc">
 <ul>
-<li><a href="#meteor">METEOR</a><ul>
+<li><a href="#meteor">☄️ METEOR</a><ul>
 <li><a href="#quickstart">quickstart</a></li>
 <li><a href="#the-science-behind-meteor">the science behind meteor</a><ul>
 <li><a href="#philosophy-better-science-through-automation">philosophy: better science through automation</a></li>
diff --git a/iterative.html b/iterative.html
index 6781911..bb8255f 100644
--- a/iterative.html
+++ b/iterative.html
@@ -32,39 +32,46 @@ <h1 class="title">Module <code>meteor.iterative</code></h1>
 <section>
 </section>
 <section>
-<h2 class="section-title" id="header-functions">Functions</h2>
+</section>
+<section>
+<h2 class="section-title" id="header-classes">Classes</h2>
 <dl>
-<dt id="meteor.iterative.iterative_tv_phase_retrieval"><code class="name flex">
-<span>def <span class="ident">iterative_tv_phase_retrieval</span></span>(<span>initial_derivative: Map, native: Map, *, convergence_tolerance: float = 0.001, max_iterations: int = 100, tv_weights_to_scan: list[float] = [0.001, 0.01, 0.1], verbose: bool = False) ‑> tuple[<a title="meteor.rsmap.Map" href="rsmap.html#meteor.rsmap.Map">Map</a>, pandas.core.frame.DataFrame]</span>
+<dt id="meteor.iterative.IterativeTvDenoiser"><code class="flex name class">
+<span>class <span class="ident">IterativeTvDenoiser</span></span>
+<span>(</span><span>*, convergence_tolerance: float = 0.001, max_iterations: int = 100, tv_weights_to_scan: list[float] = [0.001, 0.01, 0.1], verbose: bool = False)</span>
 </code></dt>
 <dd>
-<div class="desc"><p>Here is a brief pseudocode sketch of the alogrithm. Structure factors F below are complex unless
-explicitly annotated |*|.</p>
+<div class="desc"><p>An implementation of <code><a title="meteor" href="index.html">meteor</a></code>'s iterative TV phase update algorithm.</p>
+<p>The big idea is to iteratively TV denoise a map, then project it back onto the set of:
+- experimentally determined structure factor amplitudes
+- fixed (likely computed) phases for the <code>native</code> dataset</p>
+<p>The only thing left to change are the <code>derivative</code> phases, which are latent.</p>
+<p>Here is a brief pseudocode sketch of the alogrithm. Structure factors F below are complex
+unless explicitly annotated |*|.</p>
 <pre><code>Input: |F|, |Fh|, phi_c
 Note: F = |F| * exp{ phi_c } is the native/dark data,
-     |Fh| represents the derivative/triggered/light data
+    |Fh| represents the derivative/triggered/light data
 
 Initialize:
- - D_F = ( |Fh| - |F| ) * exp{ phi_c }
+- D_F = ( |Fh| - |F| ) * exp{ phi_c }
 
 while not converged:
     D_rho = FT{ D_F }                       Fourier transform
     D_rho' = TV{ D_rho }                    TV denoise: apply real space prior
     D_F' = FT-1{ D_rho' }                   back Fourier transform
-    Fh' = (D_F' + F) * [|Fh| / |D_F' + F|]  Fourier space projection onto experimental set
+    Fh' = (D_F' + F) * [|Fh| / |D_F' + F|]  Fourier space projection to experimental set
     D_F = Fh' - F
 </code></pre>
-<p>Where the TV weight parameter is determined using golden section optimization. The algorithm
+<p>Where the TV weight parameter is determined at each step by optimizing over a fixed range of
+values. Golden-section search could also be used, but tests have revealed a limited set of about
+three order-of-magnitude values to scan leads to faster convergence in most cases. The algorithm
 iterates until the changes in the derivative phase drop below a specified threshold.</p>
+<p>Initialize an iterative TV denoiser.</p>
 <h2 id="parameters">Parameters</h2>
 <dl>
-<dt><strong><code>initial_derivative</code></strong> :&ensp;<code>Map</code></dt>
-<dd>the derivative amplitudes, and initial guess for the phases</dd>
-<dt><strong><code>native</code></strong> :&ensp;<code>Map</code></dt>
-<dd>the native amplitudes, phases</dd>
 <dt><strong><code>convergance_tolerance</code></strong> :&ensp;<code>float</code></dt>
-<dd>If the change in the estimated derivative SFs drops below this value (phase, per-component)
-then return. Default 1e-4.</dd>
+<dd>If the change in the estimated derivative SFs drops below this value (phase,
+per-component) then return. Default 1e-4.</dd>
 <dt><strong><code>max_iterations</code></strong> :&ensp;<code>int</code></dt>
 <dd>If this number of iterations is reached, stop early. Default 1000.</dd>
 <dt><strong><code>tv_weights_to_scan</code></strong> :&ensp;<code>list[float]</code>, optional</dt>
@@ -72,21 +79,252 @@ <h2 id="parameters">Parameters</h2>
 by default [0.001, 0.01, 0.1, 1.0].</dd>
 <dt><strong><code>verbose</code></strong> :&ensp;<code>bool</code></dt>
 <dd>Log or not.</dd>
-</dl>
-<h2 id="returns">Returns</h2>
-<dl>
-<dt><strong><code>output_map</code></strong> :&ensp;<code>Map</code></dt>
-<dd>The estimated derivative phases, along with the input amplitudes and input computed phases.</dd>
-<dt><strong><code>metadata</code></strong> :&ensp;<code>pd.DataFrame</code></dt>
-<dd>Information about the algorithm run as a function of iteration. For each step, includes:
-the tv_weight used, the negentropy (after the TV step), and the average phase change in
-degrees.</dd>
 </dl></div>
+<details class="source">
+<summary>
+<span>Expand source code</span>
+</summary>
+<pre><code class="python">class IterativeTvDenoiser:
+    &#34;&#34;&#34;
+    An implementation of `meteor`&#39;s iterative TV phase update algorithm.
+
+    The big idea is to iteratively TV denoise a map, then project it back onto the set of:
+     - experimentally determined structure factor amplitudes
+     - fixed (likely computed) phases for the `native` dataset
+
+    The only thing left to change are the `derivative` phases, which are latent.
+
+    Here is a brief pseudocode sketch of the alogrithm. Structure factors F below are complex
+    unless explicitly annotated |*|.
+
+        Input: |F|, |Fh|, phi_c
+        Note: F = |F| * exp{ phi_c } is the native/dark data,
+            |Fh| represents the derivative/triggered/light data
+
+        Initialize:
+        - D_F = ( |Fh| - |F| ) * exp{ phi_c }
+
+        while not converged:
+            D_rho = FT{ D_F }                       Fourier transform
+            D_rho&#39; = TV{ D_rho }                    TV denoise: apply real space prior
+            D_F&#39; = FT-1{ D_rho&#39; }                   back Fourier transform
+            Fh&#39; = (D_F&#39; + F) * [|Fh| / |D_F&#39; + F|]  Fourier space projection to experimental set
+            D_F = Fh&#39; - F
+
+    Where the TV weight parameter is determined at each step by optimizing over a fixed range of
+    values. Golden-section search could also be used, but tests have revealed a limited set of about
+    three order-of-magnitude values to scan leads to faster convergence in most cases. The algorithm
+    iterates until the changes in the derivative phase drop below a specified threshold.
+    &#34;&#34;&#34;
+
+    def __init__(
+        self,
+        *,
+        convergence_tolerance: float = ITERATIVE_TV_CONVERGENCE_TOLERANCE,
+        max_iterations: int = ITERATIVE_TV_MAX_ITERATIONS,
+        tv_weights_to_scan: list[float] = DEFAULT_TV_WEIGHTS_TO_SCAN_AT_EACH_ITERATION,
+        verbose: bool = False,
+    ) -&gt; None:
+        &#34;&#34;&#34;
+        Initialize an iterative TV denoiser.
+
+        Parameters
+        ----------
+        convergance_tolerance: float
+            If the change in the estimated derivative SFs drops below this value (phase,
+            per-component) then return. Default 1e-4.
+
+        max_iterations: int
+            If this number of iterations is reached, stop early. Default 1000.
+
+        tv_weights_to_scan : list[float], optional
+            A list of TV regularization weights (λ values) to be scanned for optimal results,
+            by default [0.001, 0.01, 0.1, 1.0].
+
+        verbose: bool
+            Log or not.
+        &#34;&#34;&#34;
+        self.tv_weights_to_scan = tv_weights_to_scan
+        self.convergence_tolerance = convergence_tolerance
+        self.max_iterations = max_iterations
+        self.verbose = verbose
+
+        if verbose:
+            log.info(
+                &#34;convergence criteria:&#34;,
+                phase_tolerance=convergence_tolerance,
+                max_iterations=max_iterations,
+            )
+
+    def _tv_denoise_complex_difference_sf(
+        self,
+        complex_difference_sf: rs.DataSeries,
+        *,
+        cell: CellType,
+        spacegroup: SpacegroupType,
+    ) -&gt; tuple[rs.DataSeries, TvDenoiseResult]:
+        &#34;&#34;&#34;Apply a single iteration of TV denoising to set of complex SFs, return complex SFs&#34;&#34;&#34;
+        diffmap = Map.from_structurefactor(
+            complex_difference_sf,
+            index=complex_difference_sf.index,
+            cell=cell,
+            spacegroup=spacegroup,
+        )
+
+        denoised_map, tv_metadata = tv_denoise_difference_map(
+            diffmap,
+            weights_to_scan=self.tv_weights_to_scan,
+            full_output=True,
+        )
+
+        return denoised_map.to_structurefactor(), tv_metadata
+
+    def _iteratively_denoise_sf_amplitudes(
+        self,
+        *,
+        initial_derivative: rs.DataSeries,
+        native: rs.DataSeries,
+        cell: CellType,
+        spacegroup: SpacegroupType,
+    ) -&gt; tuple[rs.DataSeries, pd.DataFrame]:
+        &#34;&#34;&#34;
+        Estimate the derivative phases using the iterative TV algorithm.
+
+        This function contains the algorithm logic.
+
+        Parameters
+        ----------
+        native: rs.DataSeries
+            The complex native structure factors, usually experimental amplitudes and calculated phases
+
+        initial_complex_derivative : rs.DataSeries
+            The complex derivative structure factors, usually with experimental amplitudes and esimated
+            phases (often calculated from the native structure)
+
+        cell: gemmi.Cell | Sequence[float] | np.ndarray
+            Unit cell, should match both the `native` and `derivative` datasets (usual: use native)
+
+        spacegroup: gemmi.SpaceGroup | str | int
+            The spacegroup; both the `native` and `derivative` datasets
+
+        Returns
+        -------
+        estimated_complex_derivative: rs.DataSeries
+            The derivative SFs, with the same amplitudes but phases altered to minimize the TV.
+
+        metadata: pd.DataFrame
+            Information about the algorithm run as a function of iteration. For each step, includes:
+            the tv_weight used, the negentropy (after the TV step), and the average phase change in
+            degrees.
+        &#34;&#34;&#34;
+        derivative = initial_derivative.copy()
+        _assert_are_dataseries(native, derivative)
+
+        converged: bool = False
+        num_iterations: int = 0
+        metadata: list[dict[str, float]] = []
+
+        # do differences with rs.DataSeries, handles missing indices
+        difference: rs.DataSeries = initial_derivative - native
+
+        while not converged:
+            denoised_difference_sfs, tv_metadata = self._tv_denoise_complex_difference_sf(
+                difference, cell=cell, spacegroup=spacegroup
+            )
+
+            # project onto the native amplitudes to obtain an &#34;updated_derivative&#34;
+            #   Fh&#39; = (D_F&#39; + F) * [|Fh| / |D_F&#39; + F|]
+            updated_derivative: rs.DataSeries = denoised_difference_sfs + native
+            updated_derivative *= np.abs(derivative) / np.abs(updated_derivative)
+
+            # compute phase change, THEN set: derivative &lt;- updated_derivative
+            phase_change = average_phase_diff_in_degrees(derivative, updated_derivative)
+            derivative = updated_derivative
+
+            difference = derivative - native
+
+            converged = phase_change &lt; self.convergence_tolerance
+            num_iterations += 1
+
+            metadata.append(
+                {
+                    &#34;iteration&#34;: num_iterations,
+                    &#34;tv_weight&#34;: tv_metadata.optimal_tv_weight,
+                    &#34;negentropy_after_tv&#34;: tv_metadata.optimal_negentropy,
+                    &#34;average_phase_change&#34;: phase_change,
+                },
+            )
+            if self.verbose:
+                log.info(
+                    f&#34;  iteration {num_iterations:04d}&#34;,  # noqa: G004
+                    phase_change=round(phase_change, 4),
+                    negentropy=round(tv_metadata.optimal_negentropy, 4),
+                    tv_weight=tv_metadata.optimal_tv_weight,
+                )
+
+            if num_iterations &gt; self.max_iterations:
+                break
+
+        return derivative, pd.DataFrame(metadata)
+
+    def __call__(
+        self,
+        *,
+        derivative: Map,
+        native: Map,
+        check_isomorphous: bool = True,
+    ) -&gt; tuple[Map, pd.DataFrame]:
+        &#34;&#34;&#34;
+        Denoise by estimating new, low-TV phases for the `derivative` dataset.
+
+        Parameters
+        ----------
+        derivative: Map
+            the derivative amplitudes, and initial guess for the phases
+
+        native: Map
+            the native amplitudes, phases
+
+        check_isomorphous: bool
+            perform a check to ensure the two datasets are isomorphous; recommended. Default: True.
+
+        Returns
+        -------
+        updated_derivative: Map
+            The estimated derivative phases, along with the input amplitudes and input phases.
+
+        metadata: pd.DataFrame
+            Information about the algorithm run as a function of iteration. For each step, includes:
+            the tv_weight used, the negentropy (after the TV step), and the average phase change in
+            degrees.
+        &#34;&#34;&#34;
+        if check_isomorphous:
+            assert_isomorphous(derivative=derivative, native=native)
+
+        it_tv_complex_derivative, metadata = self._iteratively_denoise_sf_amplitudes(
+            native=native.to_structurefactor(),
+            initial_derivative=derivative.to_structurefactor(),
+            cell=native.cell,
+            spacegroup=native.spacegroup,
+        )
+
+        updated_derivative_map = Map.from_structurefactor(
+            it_tv_complex_derivative,
+            cell=derivative.cell,
+            spacegroup=derivative.spacegroup,
+        )
+
+        if derivative.has_uncertainties:
+            updated_derivative_map.set_uncertainties(
+                derivative.uncertainties,
+                column_name=derivative.uncertainties_column_name,
+            )
+
+        return updated_derivative_map, metadata</code></pre>
+</details>
 </dd>
 </dl>
 </section>
-<section>
-</section>
 </article>
 <nav id="sidebar">
 <div class="toc">
@@ -98,9 +336,11 @@ <h2 id="returns">Returns</h2>
 <li><code><a title="meteor" href="index.html">meteor</a></code></li>
 </ul>
 </li>
-<li><h3><a href="#header-functions">Functions</a></h3>
-<ul class="">
-<li><code><a title="meteor.iterative.iterative_tv_phase_retrieval" href="#meteor.iterative.iterative_tv_phase_retrieval">iterative_tv_phase_retrieval</a></code></li>
+<li><h3><a href="#header-classes">Classes</a></h3>
+<ul>
+<li>
+<h4><code><a title="meteor.iterative.IterativeTvDenoiser" href="#meteor.iterative.IterativeTvDenoiser">IterativeTvDenoiser</a></code></h4>
+</li>
 </ul>
 </li>
 </ul>
diff --git a/rsmap.html b/rsmap.html
index a8c012d..b9f2a68 100644
--- a/rsmap.html
+++ b/rsmap.html
@@ -32,6 +32,15 @@ <h1 class="title">Module <code>meteor.rsmap</code></h1>
 <section>
 </section>
 <section>
+<h2 class="section-title" id="header-functions">Functions</h2>
+<dl>
+<dt id="meteor.rsmap.assert_is_map"><code class="name flex">
+<span>def <span class="ident">assert_is_map</span></span>(<span>obj: Any, *, require_uncertainties: bool) ‑> None</span>
+</code></dt>
+<dd>
+<div class="desc"></div>
+</dd>
+</dl>
 </section>
 <section>
 <h2 class="section-title" id="header-classes">Classes</h2>
@@ -260,6 +269,10 @@ <h2 class="section-title" id="header-classes">Classes</h2>
         values = self._verify_amplitude_type(values)
         self[self._amplitude_column] = values
 
+    @property
+    def amplitude_column_name(self) -&gt; str:
+        return self._amplitude_column
+
     @property
     def phases(self) -&gt; rs.DataSeries:
         return self[self._phase_column]
@@ -269,6 +282,10 @@ <h2 class="section-title" id="header-classes">Classes</h2>
         values = self._verify_phase_type(values)
         self[self._phase_column] = values
 
+    @property
+    def phase_column_name(self) -&gt; str:
+        return self._phase_column
+
     @property
     def has_uncertainties(self) -&gt; bool:
         return self._uncertainty_column in self.columns
@@ -308,8 +325,14 @@ <h2 class="section-title" id="header-classes">Classes</h2>
             )
 
     @property
-    def complex_amplitudes(self) -&gt; np.ndarray:
-        return self.amplitudes.to_numpy() * np.exp(1j * np.deg2rad(self.phases.to_numpy()))
+    def uncertainties_column_name(self) -&gt; str:
+        if self.has_uncertainties:
+            if not isinstance(self._uncertainty_column, str):
+                msg = &#34;misconfigured uncertainty column&#34;
+                raise RuntimeError(msg)
+            return self._uncertainty_column
+        msg = &#34;uncertainties not set for Map object&#34;
+        raise AttributeError(msg)
 
     def canonicalize_amplitudes(self) -&gt; None:
         canonicalize_amplitudes(
@@ -320,8 +343,31 @@ <h2 class="section-title" id="header-classes">Classes</h2>
         )
 
     def to_structurefactor(self) -&gt; rs.DataSeries:
+        &#34;&#34;&#34;Return a DataSeries of complex structure factor amplitudes&#34;&#34;&#34;
         return super().to_structurefactor(self._amplitude_column, self._phase_column)
 
+    @overload
+    @classmethod
+    def from_structurefactor(
+        cls,
+        complex_structurefactor: rs.DataSeries,
+        *,
+        index: None = None,
+        cell: CellType | None = None,
+        spacegroup: SpacegroupType | None = None,
+    ) -&gt; Map: ...
+
+    @overload
+    @classmethod
+    def from_structurefactor(
+        cls,
+        complex_structurefactor: np.ndarray,
+        *,
+        index: pd.Index,
+        cell: CellType | None = None,
+        spacegroup: SpacegroupType | None = None,
+    ) -&gt; Map: ...
+
     @classmethod
     @cellify(&#34;cell&#34;)
     @spacegroupify(&#34;spacegroup&#34;)
@@ -329,21 +375,54 @@ <h2 class="section-title" id="header-classes">Classes</h2>
         cls,
         complex_structurefactor: np.ndarray | rs.DataSeries,
         *,
-        index: pd.Index,
+        index: pd.Index | None = None,
         cell: CellType | None = None,
         spacegroup: SpacegroupType | None = None,
     ) -&gt; Map:
         # 1. `rs.DataSet.from_structurefactor` exists, but it operates on a column that&#39;s already
         #    part of the dataset; having such a (redundant) column is forbidden by `Map`
         # 2. recprocalspaceship has a `from_structurefactor` method, but it is occasionally
-        #    mangling indices for me when the input is a numpy array, as of 16 OCT 24 - @tjlane
-        amplitudes, phases = complex_array_to_rs_dataseries(complex_structurefactor, index=index)
+        #    mangling indices for me when the input is a numpy array, as of 16 OCT 24
+        #
+        # hopefully we can resolve these and reuse code! - @tjlane
+
+        if index is None:
+            if isinstance(complex_structurefactor, rs.DataSeries) and hasattr(
+                complex_structurefactor, &#34;index&#34;
+            ):
+                index = complex_structurefactor.index
+
+            else:
+                msg = &#34;if `complex_structurefactor` is not a `DataSeries` with an `index` attribute&#34;
+                msg += &#34;, and index must be provided&#34;
+                raise ValueError(msg)
+
+        elif index.shape != complex_structurefactor.shape:
+            msg = f&#34;`complex_structurefactor` {complex_structurefactor.shape} does not have same &#34;
+            msg += f&#34;shape as `index` {index.shape}&#34;
+            raise ShapeMismatchError(msg)
+
+        amplitudes = rs.DataSeries(
+            np.abs(complex_structurefactor),
+            index=index,
+            dtype=rs.StructureFactorAmplitudeDtype(),
+            name=&#34;F&#34;,
+        )
+
+        phases = rs.DataSeries(
+            np.angle(complex_structurefactor, deg=True),
+            index=index,
+            dtype=rs.PhaseDtype(),
+            name=&#34;PHI&#34;,
+        )
+
         dataset = rs.DataSet(
-            rs.concat([amplitudes.rename(&#34;F&#34;), phases.rename(&#34;PHI&#34;)], axis=1),
+            rs.concat([amplitudes, phases], axis=1),
             index=index,
             cell=cell,
             spacegroup=spacegroup,
         )
+
         return cls(dataset)
 
     @classmethod
@@ -535,7 +614,7 @@ <h2 id="returns">Returns</h2>
 </dl></div>
 </dd>
 <dt id="meteor.rsmap.Map.from_structurefactor"><code class="name flex">
-<span>def <span class="ident">from_structurefactor</span></span>(<span>cls, complex_structurefactor: np.ndarray | rs.DataSeries, *, index: pd.Index, cell: CellType | None = None, spacegroup: SpacegroupType | None = None) ‑> <a title="meteor.rsmap.Map" href="#meteor.rsmap.Map">Map</a></span>
+<span>def <span class="ident">from_structurefactor</span></span>(<span>cls, complex_structurefactor: np.ndarray | rs.DataSeries, *, index: pd.Index | None = None, cell: CellType | None = None, spacegroup: SpacegroupType | None = None) ‑> <a title="meteor.rsmap.Map" href="#meteor.rsmap.Map">Map</a></span>
 </code></dt>
 <dd>
 <div class="desc"></div>
@@ -549,7 +628,7 @@ <h2 id="returns">Returns</h2>
 </dl>
 <h3>Instance variables</h3>
 <dl>
-<dt id="meteor.rsmap.Map.amplitudes"><code class="name">prop <span class="ident">amplitudes</span> : rs.DataSeries</code></dt>
+<dt id="meteor.rsmap.Map.amplitude_column_name"><code class="name">prop <span class="ident">amplitude_column_name</span> : str</code></dt>
 <dd>
 <div class="desc"></div>
 <details class="source">
@@ -557,11 +636,11 @@ <h3>Instance variables</h3>
 <span>Expand source code</span>
 </summary>
 <pre><code class="python">@property
-def amplitudes(self) -&gt; rs.DataSeries:
-    return self[self._amplitude_column]</code></pre>
+def amplitude_column_name(self) -&gt; str:
+    return self._amplitude_column</code></pre>
 </details>
 </dd>
-<dt id="meteor.rsmap.Map.complex_amplitudes"><code class="name">prop <span class="ident">complex_amplitudes</span> : np.ndarray</code></dt>
+<dt id="meteor.rsmap.Map.amplitudes"><code class="name">prop <span class="ident">amplitudes</span> : rs.DataSeries</code></dt>
 <dd>
 <div class="desc"></div>
 <details class="source">
@@ -569,8 +648,8 @@ <h3>Instance variables</h3>
 <span>Expand source code</span>
 </summary>
 <pre><code class="python">@property
-def complex_amplitudes(self) -&gt; np.ndarray:
-    return self.amplitudes.to_numpy() * np.exp(1j * np.deg2rad(self.phases.to_numpy()))</code></pre>
+def amplitudes(self) -&gt; rs.DataSeries:
+    return self[self._amplitude_column]</code></pre>
 </details>
 </dd>
 <dt id="meteor.rsmap.Map.has_uncertainties"><code class="name">prop <span class="ident">has_uncertainties</span> : bool</code></dt>
@@ -585,6 +664,18 @@ <h3>Instance variables</h3>
     return self._uncertainty_column in self.columns</code></pre>
 </details>
 </dd>
+<dt id="meteor.rsmap.Map.phase_column_name"><code class="name">prop <span class="ident">phase_column_name</span> : str</code></dt>
+<dd>
+<div class="desc"></div>
+<details class="source">
+<summary>
+<span>Expand source code</span>
+</summary>
+<pre><code class="python">@property
+def phase_column_name(self) -&gt; str:
+    return self._phase_column</code></pre>
+</details>
+</dd>
 <dt id="meteor.rsmap.Map.phases"><code class="name">prop <span class="ident">phases</span> : rs.DataSeries</code></dt>
 <dd>
 <div class="desc"></div>
@@ -625,6 +716,24 @@ <h3>Instance variables</h3>
     raise AttributeError(msg)</code></pre>
 </details>
 </dd>
+<dt id="meteor.rsmap.Map.uncertainties_column_name"><code class="name">prop <span class="ident">uncertainties_column_name</span> : str</code></dt>
+<dd>
+<div class="desc"></div>
+<details class="source">
+<summary>
+<span>Expand source code</span>
+</summary>
+<pre><code class="python">@property
+def uncertainties_column_name(self) -&gt; str:
+    if self.has_uncertainties:
+        if not isinstance(self._uncertainty_column, str):
+            msg = &#34;misconfigured uncertainty column&#34;
+            raise RuntimeError(msg)
+        return self._uncertainty_column
+    msg = &#34;uncertainties not set for Map object&#34;
+    raise AttributeError(msg)</code></pre>
+</details>
+</dd>
 </dl>
 <h3>Methods</h3>
 <dl>
@@ -857,25 +966,7 @@ <h2 id="examples">Examples</h2>
 <span>def <span class="ident">to_structurefactor</span></span>(<span>self) ‑> reciprocalspaceship.dataseries.DataSeries</span>
 </code></dt>
 <dd>
-<div class="desc"><p>Convert structure factor amplitudes and phases to complex structure
-factors</p>
-<h2 id="parameters">Parameters</h2>
-<dl>
-<dt><strong><code>sf_key</code></strong> :&ensp;<code>str</code></dt>
-<dd>Column label for structure factor amplitudes</dd>
-<dt><strong><code>phase_key</code></strong> :&ensp;<code>str</code></dt>
-<dd>Column label for phases</dd>
-</dl>
-<h2 id="returns">Returns</h2>
-<dl>
-<dt><code>rs.DataSeries</code></dt>
-<dd>Complex structure factors</dd>
-</dl>
-<h2 id="see-also">See Also</h2>
-<dl>
-<dt><code>DataSet.from_structurefactor</code></dt>
-<dd>Convert complex structure factor to amplitude and phase</dd>
-</dl></div>
+<div class="desc"><p>Return a DataSeries of complex structure factor amplitudes</p></div>
 </dd>
 <dt id="meteor.rsmap.Map.write_mtz"><code class="name flex">
 <span>def <span class="ident">write_mtz</span></span>(<span>self, file_path: str | Path) ‑> None</span>
@@ -955,14 +1046,19 @@ <h3>Ancestors</h3>
 <li><code><a title="meteor" href="index.html">meteor</a></code></li>
 </ul>
 </li>
+<li><h3><a href="#header-functions">Functions</a></h3>
+<ul class="">
+<li><code><a title="meteor.rsmap.assert_is_map" href="#meteor.rsmap.assert_is_map">assert_is_map</a></code></li>
+</ul>
+</li>
 <li><h3><a href="#header-classes">Classes</a></h3>
 <ul>
 <li>
 <h4><code><a title="meteor.rsmap.Map" href="#meteor.rsmap.Map">Map</a></code></h4>
 <ul class="">
+<li><code><a title="meteor.rsmap.Map.amplitude_column_name" href="#meteor.rsmap.Map.amplitude_column_name">amplitude_column_name</a></code></li>
 <li><code><a title="meteor.rsmap.Map.amplitudes" href="#meteor.rsmap.Map.amplitudes">amplitudes</a></code></li>
 <li><code><a title="meteor.rsmap.Map.canonicalize_amplitudes" href="#meteor.rsmap.Map.canonicalize_amplitudes">canonicalize_amplitudes</a></code></li>
-<li><code><a title="meteor.rsmap.Map.complex_amplitudes" href="#meteor.rsmap.Map.complex_amplitudes">complex_amplitudes</a></code></li>
 <li><code><a title="meteor.rsmap.Map.compute_dHKL" href="#meteor.rsmap.Map.compute_dHKL">compute_dHKL</a></code></li>
 <li><code><a title="meteor.rsmap.Map.drop" href="#meteor.rsmap.Map.drop">drop</a></code></li>
 <li><code><a title="meteor.rsmap.Map.from_3d_numpy_map" href="#meteor.rsmap.Map.from_3d_numpy_map">from_3d_numpy_map</a></code></li>
@@ -972,6 +1068,7 @@ <h4><code><a title="meteor.rsmap.Map" href="#meteor.rsmap.Map">Map</a></code></h
 <li><code><a title="meteor.rsmap.Map.get_hkls" href="#meteor.rsmap.Map.get_hkls">get_hkls</a></code></li>
 <li><code><a title="meteor.rsmap.Map.has_uncertainties" href="#meteor.rsmap.Map.has_uncertainties">has_uncertainties</a></code></li>
 <li><code><a title="meteor.rsmap.Map.insert" href="#meteor.rsmap.Map.insert">insert</a></code></li>
+<li><code><a title="meteor.rsmap.Map.phase_column_name" href="#meteor.rsmap.Map.phase_column_name">phase_column_name</a></code></li>
 <li><code><a title="meteor.rsmap.Map.phases" href="#meteor.rsmap.Map.phases">phases</a></code></li>
 <li><code><a title="meteor.rsmap.Map.read_mtz_file" href="#meteor.rsmap.Map.read_mtz_file">read_mtz_file</a></code></li>
 <li><code><a title="meteor.rsmap.Map.resolution_limits" href="#meteor.rsmap.Map.resolution_limits">resolution_limits</a></code></li>
@@ -979,6 +1076,7 @@ <h4><code><a title="meteor.rsmap.Map" href="#meteor.rsmap.Map">Map</a></code></h
 <li><code><a title="meteor.rsmap.Map.to_ccp4_map" href="#meteor.rsmap.Map.to_ccp4_map">to_ccp4_map</a></code></li>
 <li><code><a title="meteor.rsmap.Map.to_structurefactor" href="#meteor.rsmap.Map.to_structurefactor">to_structurefactor</a></code></li>
 <li><code><a title="meteor.rsmap.Map.uncertainties" href="#meteor.rsmap.Map.uncertainties">uncertainties</a></code></li>
+<li><code><a title="meteor.rsmap.Map.uncertainties_column_name" href="#meteor.rsmap.Map.uncertainties_column_name">uncertainties_column_name</a></code></li>
 <li><code><a title="meteor.rsmap.Map.write_mtz" href="#meteor.rsmap.Map.write_mtz">write_mtz</a></code></li>
 </ul>
 </li>
diff --git a/testing.html b/testing.html
index 8a3ace3..72451a7 100644
--- a/testing.html
+++ b/testing.html
@@ -46,6 +46,12 @@ <h2 class="section-title" id="header-functions">Functions</h2>
 <dd>
 <div class="desc"></div>
 </dd>
+<dt id="meteor.testing.diffmap_realspace_rms"><code class="name flex">
+<span>def <span class="ident">diffmap_realspace_rms</span></span>(<span>map1: Map, map2: Map) ‑> float</span>
+</code></dt>
+<dd>
+<div class="desc"></div>
+</dd>
 <dt id="meteor.testing.single_carbon_density"><code class="name flex">
 <span>def <span class="ident">single_carbon_density</span></span>(<span>carbon_position: tuple[float, float, float], space_group: gemmi.SpaceGroup, unit_cell: gemmi.UnitCell, high_resolution_limit: float) ‑> gemmi.Ccp4Map</span>
 </code></dt>
@@ -112,6 +118,7 @@ <h3>Class variables</h3>
 <ul class="">
 <li><code><a title="meteor.testing.assert_phases_allclose" href="#meteor.testing.assert_phases_allclose">assert_phases_allclose</a></code></li>
 <li><code><a title="meteor.testing.check_test_file_exists" href="#meteor.testing.check_test_file_exists">check_test_file_exists</a></code></li>
+<li><code><a title="meteor.testing.diffmap_realspace_rms" href="#meteor.testing.diffmap_realspace_rms">diffmap_realspace_rms</a></code></li>
 <li><code><a title="meteor.testing.single_carbon_density" href="#meteor.testing.single_carbon_density">single_carbon_density</a></code></li>
 <li><code><a title="meteor.testing.single_carbon_structure" href="#meteor.testing.single_carbon_structure">single_carbon_structure</a></code></li>
 </ul>
diff --git a/utils.html b/utils.html
index e175393..f786a53 100644
--- a/utils.html
+++ b/utils.html
@@ -34,45 +34,23 @@ <h1 class="title">Module <code>meteor.utils</code></h1>
 <section>
 <h2 class="section-title" id="header-functions">Functions</h2>
 <dl>
-<dt id="meteor.utils.average_phase_diff_in_degrees"><code class="name flex">
-<span>def <span class="ident">average_phase_diff_in_degrees</span></span>(<span>array1: np.ndarray, array2: np.ndarray) ‑> float</span>
+<dt id="meteor.utils.assert_isomorphous"><code class="name flex">
+<span>def <span class="ident">assert_isomorphous</span></span>(<span>*, derivative: rs.DataSet, native: rs.DataSet) ‑> None</span>
 </code></dt>
 <dd>
 <div class="desc"></div>
 </dd>
-<dt id="meteor.utils.canonicalize_amplitudes"><code class="name flex">
-<span>def <span class="ident">canonicalize_amplitudes</span></span>(<span>dataset: rs.DataSet, *, amplitude_column: str, phase_column: str, inplace: bool = False) ‑> reciprocalspaceship.dataset.DataSet | None</span>
+<dt id="meteor.utils.average_phase_diff_in_degrees"><code class="name flex">
+<span>def <span class="ident">average_phase_diff_in_degrees</span></span>(<span>array1: np.ndarray | rs.DataSeries, array2: np.ndarray | rs.DataSeries) ‑> float</span>
 </code></dt>
 <dd>
 <div class="desc"></div>
 </dd>
-<dt id="meteor.utils.complex_array_to_rs_dataseries"><code class="name flex">
-<span>def <span class="ident">complex_array_to_rs_dataseries</span></span>(<span>complex_structure_factors: np.ndarray, *, index: Index) ‑> tuple[reciprocalspaceship.dataseries.DataSeries, reciprocalspaceship.dataseries.DataSeries]</span>
+<dt id="meteor.utils.canonicalize_amplitudes"><code class="name flex">
+<span>def <span class="ident">canonicalize_amplitudes</span></span>(<span>dataset: rs.DataSet, *, amplitude_column: str, phase_column: str, inplace: bool = False) ‑> reciprocalspaceship.dataset.DataSet | None</span>
 </code></dt>
 <dd>
-<div class="desc"><p>Convert an array of complex structure factors into two reciprocalspaceship DataSeries, one
-representing the structure factor amplitudes and one for the phases.</p>
-<h2 id="parameters">Parameters</h2>
-<dl>
-<dt><strong><code>complex_structure_factors</code></strong> :&ensp;<code>np.ndarray</code></dt>
-<dd>the complex-valued structure factors, as a numpy array</dd>
-<dt><strong><code>index</code></strong> :&ensp;<code>pandas.Index</code></dt>
-<dd>the indices (HKL) for each structure factor in <code>complex_structure_factors</code></dd>
-</dl>
-<h2 id="returns">Returns</h2>
-<dl>
-<dt><strong><code>amplitudes</code></strong> :&ensp;<code>DataSeries</code></dt>
-<dd>with StructureFactorAmplitudeDtype</dd>
-<dt><strong><code>phases</code></strong> :&ensp;<code>DataSeries</code></dt>
-<dd>with PhaseDtype</dd>
-</dl>
-<h2 id="raises">Raises</h2>
-<dl>
-<dt><code>ValueError</code></dt>
-<dd>if <code>complex_structure_factors and </code>index` do not have the same shape</dd>
-</dl>
-<h2 id="see-also">See Also</h2>
-<p><code>`reciprocalspaceship/utils/structurefactors.from_structurefactor(...)</code> An equivalent function<code>, </code>that does not require the index and does less index/data checking.`</p></div>
+<div class="desc"></div>
 </dd>
 <dt id="meteor.utils.cut_resolution"><code class="name flex">
 <span>def <span class="ident">cut_resolution</span></span>(<span>dataset: rs.DataSet, *, dmax_limit: float | None = None, dmin_limit: float | None = None) ‑> reciprocalspaceship.dataset.DataSet</span>
@@ -97,6 +75,25 @@ <h2 id="see-also">See Also</h2>
 <section>
 <h2 class="section-title" id="header-classes">Classes</h2>
 <dl>
+<dt id="meteor.utils.NotIsomorphousError"><code class="flex name class">
+<span>class <span class="ident">NotIsomorphousError</span></span>
+<span>(</span><span>*args, **kwargs)</span>
+</code></dt>
+<dd>
+<div class="desc"><p>Unspecified run-time error.</p></div>
+<details class="source">
+<summary>
+<span>Expand source code</span>
+</summary>
+<pre><code class="python">class NotIsomorphousError(RuntimeError): ...</code></pre>
+</details>
+<h3>Ancestors</h3>
+<ul class="hlist">
+<li>builtins.RuntimeError</li>
+<li>builtins.Exception</li>
+<li>builtins.BaseException</li>
+</ul>
+</dd>
 <dt id="meteor.utils.ShapeMismatchError"><code class="flex name class">
 <span>class <span class="ident">ShapeMismatchError</span></span>
 <span>(</span><span>*args, **kwargs)</span>
@@ -130,9 +127,9 @@ <h3>Ancestors</h3>
 </li>
 <li><h3><a href="#header-functions">Functions</a></h3>
 <ul class="">
+<li><code><a title="meteor.utils.assert_isomorphous" href="#meteor.utils.assert_isomorphous">assert_isomorphous</a></code></li>
 <li><code><a title="meteor.utils.average_phase_diff_in_degrees" href="#meteor.utils.average_phase_diff_in_degrees">average_phase_diff_in_degrees</a></code></li>
 <li><code><a title="meteor.utils.canonicalize_amplitudes" href="#meteor.utils.canonicalize_amplitudes">canonicalize_amplitudes</a></code></li>
-<li><code><a title="meteor.utils.complex_array_to_rs_dataseries" href="#meteor.utils.complex_array_to_rs_dataseries">complex_array_to_rs_dataseries</a></code></li>
 <li><code><a title="meteor.utils.cut_resolution" href="#meteor.utils.cut_resolution">cut_resolution</a></code></li>
 <li><code><a title="meteor.utils.filter_common_indices" href="#meteor.utils.filter_common_indices">filter_common_indices</a></code></li>
 <li><code><a title="meteor.utils.numpy_array_to_map" href="#meteor.utils.numpy_array_to_map">numpy_array_to_map</a></code></li>
@@ -141,6 +138,9 @@ <h3>Ancestors</h3>
 <li><h3><a href="#header-classes">Classes</a></h3>
 <ul>
 <li>
+<h4><code><a title="meteor.utils.NotIsomorphousError" href="#meteor.utils.NotIsomorphousError">NotIsomorphousError</a></code></h4>
+</li>
+<li>
 <h4><code><a title="meteor.utils.ShapeMismatchError" href="#meteor.utils.ShapeMismatchError">ShapeMismatchError</a></code></h4>
 </li>
 </ul>
diff --git a/validate.html b/validate.html
index dbf23ac..8307bfc 100644
--- a/validate.html
+++ b/validate.html
@@ -34,8 +34,35 @@ <h1 class="title">Module <code>meteor.validate</code></h1>
 <section>
 <h2 class="section-title" id="header-functions">Functions</h2>
 <dl>
+<dt id="meteor.validate.map_negentropy"><code class="name flex">
+<span>def <span class="ident">map_negentropy</span></span>(<span>map_to_assess: Map, *, tolerance: float = 0.1) ‑> float</span>
+</code></dt>
+<dd>
+<div class="desc"><p>Computes the negentropy of a crystallographic map.</p>
+<p>Negentropy is defined as the difference between the entropy of a given
+distribution and the entropy of a Gaussian distribution with the same variance.
+It is a measure of non-Gaussianity, with higher values indicating greater deviation
+from Gaussianity.</p>
+<h2 id="parameters">Parameters</h2>
+<dl>
+<dt><strong><code>map_to_assess</code></strong> :&ensp;<code>Map</code></dt>
+<dd>The map (coefficients) we will compute the negentropy for.</dd>
+<dt><strong><code>tolerance</code></strong> :&ensp;<code>float</code></dt>
+<dd>Tolerance level determining if the negentropy is suspiciously negative. Defaults to 0.1.</dd>
+</dl>
+<h2 id="returns">Returns</h2>
+<dl>
+<dt><strong><code>negentropy</code></strong> :&ensp;<code>float</code></dt>
+<dd>The negentropy of the distribution of the (implicitly computed) map voxels.</dd>
+</dl>
+<h2 id="raises">Raises</h2>
+<dl>
+<dt><strong><code>ValueError</code></strong> :&ensp;<code>If the computed <a title="meteor.validate.negentropy" href="#meteor.validate.negentropy">negentropy()</a> is less than the negative tolerance,</code></dt>
+<dd>indicating potential issues with the computation.</dd>
+</dl></div>
+</dd>
 <dt id="meteor.validate.negentropy"><code class="name flex">
-<span>def <span class="ident">negentropy</span></span>(<span>samples: np.ndarray, tolerance: float = 0.1) ‑> float</span>
+<span>def <span class="ident">negentropy</span></span>(<span>samples: np.ndarray, *, tolerance: float = 0.1) ‑> float</span>
 </code></dt>
 <dd>
 <div class="desc"><p>Computes the negentropy of a given sample array.</p>
@@ -257,6 +284,7 @@ <h2 id="raises">Raises</h2>
 </li>
 <li><h3><a href="#header-functions">Functions</a></h3>
 <ul class="">
+<li><code><a title="meteor.validate.map_negentropy" href="#meteor.validate.map_negentropy">map_negentropy</a></code></li>
 <li><code><a title="meteor.validate.negentropy" href="#meteor.validate.negentropy">negentropy</a></code></li>
 </ul>
 </li>