nimare 0.4.2rc4__py3-none-any.whl

nimare/tests/test_meta_ibma.py

@@ -0,0 +1,240 @@
+"""Test nimare.meta.ibma (image-based meta-analytic estimators)."""
+
+import logging
+import os.path as op
+
+import numpy as np
+import pytest
+from nilearn.input_data import NiftiLabelsMasker
+
+import nimare
+from nimare.correct import FDRCorrector, FWECorrector
+from nimare.meta import ibma
+from nimare.tests.utils import get_test_data_path
+
+
+@pytest.mark.parametrize(
+    "meta,meta_kwargs,corrector,corrector_kwargs,maps",
+    [
+        pytest.param(
+            ibma.Fishers,
+            {},
+            FDRCorrector,
+            {"method": "indep", "alpha": 0.001},
+            ("z", "p", "dof"),
+            id="Fishers",
+        ),
+        pytest.param(
+            ibma.Stouffers,
+            {"use_sample_size": False, "normalize_contrast_weights": False},
+            None,
+            {},
+            ("z", "p", "dof"),
+            id="Stouffers",
+        ),
+        pytest.param(
+            ibma.Stouffers,
+            {"use_sample_size": True, "normalize_contrast_weights": False},
+            None,
+            {},
+            ("z", "p", "dof"),
+            id="Stouffers_sample_weighted",
+        ),
+        pytest.param(
+            ibma.Stouffers,
+            {"use_sample_size": False, "normalize_contrast_weights": True},
+            None,
+            {},
+            ("z", "p", "dof"),
+            id="Stouffers_contrast_weighted",
+        ),
+        pytest.param(
+            ibma.Stouffers,
+            {"use_sample_size": True, "normalize_contrast_weights": True},
+            None,
+            {},
+            ("z", "p", "dof"),
+            id="Stouffers_sample_contrast_weighted",
+        ),
+        pytest.param(
+            ibma.WeightedLeastSquares,
+            {"tau2": 0},
+            None,
+            {},
+            ("z", "p", "est", "se", "dof"),
+            id="WeightedLeastSquares",
+        ),
+        pytest.param(
+            ibma.DerSimonianLaird,
+            {},
+            None,
+            {},
+            ("z", "p", "est", "se", "tau2", "dof"),
+            id="DerSimonianLaird",
+        ),
+        pytest.param(
+            ibma.Hedges,
+            {},
+            None,
+            {},
+            ("z", "p", "est", "se", "tau2", "dof"),
+            id="Hedges",
+        ),
+        pytest.param(
+            ibma.SampleSizeBasedLikelihood,
+            {"method": "ml"},
+            None,
+            {},
+            ("z", "p", "est", "se", "tau2", "sigma2", "dof"),
+            id="SampleSizeBasedLikelihood_ml",
+        ),
+        pytest.param(
+            ibma.SampleSizeBasedLikelihood,
+            {"method": "reml"},
+            None,
+            {},
+            ("z", "p", "est", "se", "tau2", "sigma2", "dof"),
+            id="SampleSizeBasedLikelihood_reml",
+        ),
+        pytest.param(
+            ibma.VarianceBasedLikelihood,
+            {"method": "ml"},
+            None,
+            {},
+            ("z", "p", "est", "se", "tau2", "dof"),
+            id="VarianceBasedLikelihood_ml",
+        ),
+        pytest.param(
+            ibma.VarianceBasedLikelihood,
+            {"method": "reml"},
+            None,
+            {},
+            ("z", "p", "est", "se", "tau2", "dof"),
+            id="VarianceBasedLikelihood_reml",
+        ),
+        pytest.param(
+            ibma.PermutedOLS,
+            {"two_sided": True},
+            FWECorrector,
+            {"method": "montecarlo", "n_iters": 100, "n_cores": 1},
+            ("t", "z", "dof"),
+            id="PermutedOLS",
+        ),
+        pytest.param(
+            ibma.FixedEffectsHedges,
+            {"tau2": 0},
+            None,
+            {},
+            ("z", "p", "est", "se", "dof"),
+            id="FixedEffectsHedges",
+        ),
+    ],
+)
+@pytest.mark.parametrize("aggressive_mask", [True, False], ids=["aggressive", "liberal"])
+def test_ibma_smoke(
+    testdata_ibma,
+    meta,
+    aggressive_mask,
+    meta_kwargs,
+    corrector,
+    corrector_kwargs,
+    maps,
+):
+    """Smoke test for IBMA estimators."""
+    meta = meta(aggressive_mask=aggressive_mask, **meta_kwargs)
+    results = meta.fit(testdata_ibma)
+    for expected_map in maps:
+        assert expected_map in results.maps.keys()
+
+    assert isinstance(results, nimare.results.MetaResult)
+    assert isinstance(results.description_, str)
+    assert results.get_map("z", return_type="array").ndim == 1
+    z_img = results.get_map("z")
+    assert z_img.ndim == 3
+    assert z_img.shape == (10, 10, 10)
+    if corrector:
+        corr = corrector(**corrector_kwargs)
+        corr_results = corr.transform(results)
+        assert isinstance(corr_results, nimare.results.MetaResult)
+        assert isinstance(corr_results.description_, str)
+        assert corr_results.get_map("z", return_type="array").ndim == 1
+        assert corr_results.get_map("z").ndim == 3
+
+
+@pytest.mark.parametrize(
+    "estimator,expectation,masker_source",
+    [
+        (ibma.Fishers, "error", "estimator"),
+        (ibma.Stouffers, "error", "estimator"),
+        (ibma.WeightedLeastSquares, "warning", "estimator"),
+        (ibma.DerSimonianLaird, "warning", "estimator"),
+        (ibma.Hedges, "warning", "estimator"),
+        (ibma.SampleSizeBasedLikelihood, "no warning", "estimator"),
+        (ibma.VarianceBasedLikelihood, "warning", "estimator"),
+        (ibma.PermutedOLS, "no warning", "estimator"),
+    ],
+)
+def test_ibma_with_custom_masker(testdata_ibma, caplog, estimator, expectation, masker_source):
+    """Ensure voxel-to-ROI reduction works, but only for Estimators that allow it.
+
+    Notes
+    -----
+    Currently masker_source is not used, but ultimately we will want to test cases where the
+    Dataset uses a NiftiLabelsMasker.
+    """
+    atlas = op.join(get_test_data_path(), "test_pain_dataset", "atlas.nii.gz")
+    masker = NiftiLabelsMasker(atlas)
+
+    dset = testdata_ibma
+    meta = estimator(mask=masker)
+
+    if expectation == "error":
+        with pytest.raises(ValueError):
+            meta.fit(dset)
+    elif expectation == "warning":
+        with caplog.at_level(logging.WARNING, logger="nimare.meta.ibma"):
+            results = meta.fit(dset)
+            assert "will likely produce biased results" in caplog.text
+        caplog.clear()
+    else:
+        with caplog.at_level(logging.WARNING, logger="nimare.meta.ibma"):
+            results = meta.fit(dset)
+            assert "will likely produce biased results" not in caplog.text
+        caplog.clear()
+
+    # Only fit the estimator if it doesn't raise a ValueError
+    if expectation != "error":
+        assert isinstance(results, nimare.results.MetaResult)
+        # There are five "labels", but one of them has no good data,
+        # so the outputs should be 4 long.
+        assert results.maps["z"].shape == (5,)
+        assert np.isnan(results.maps["z"][0])
+        assert results.get_map("z").shape == (10, 10, 10)
+
+
+@pytest.mark.parametrize(
+    "resample_kwargs",
+    [
+        {},
+        {"resample__clip": False, "resample__interpolation": "continuous"},
+    ],
+)
+def test_ibma_resampling(testdata_ibma_resample, resample_kwargs):
+    """Test image-based resampling performance."""
+    meta = ibma.Fishers(**resample_kwargs)
+    results = meta.fit(testdata_ibma_resample)
+
+    assert isinstance(results, nimare.results.MetaResult)
+
+
+@pytest.mark.parametrize("aggressive_mask", [True, False], ids=["aggressive", "liberal"])
+def test_stouffers_multiple_contrasts(testdata_ibma_multiple_contrasts, aggressive_mask):
+    """Test Stouffer's correction with multiple contrasts."""
+    meta = ibma.Stouffers(aggressive_mask=aggressive_mask)
+    results = meta.fit(testdata_ibma_multiple_contrasts)
+
+    assert isinstance(results, nimare.results.MetaResult)
+    assert results.get_map("z", return_type="array").ndim == 1
+    z_img = results.get_map("z")
+    assert z_img.ndim == 3
+    assert z_img.shape == (10, 10, 10)

nimare/tests/test_meta_kernel.py

@@ -0,0 +1,209 @@
+"""Test nimare.meta.kernel (CBMA kernel estimators)."""
+
+import nibabel as nib
+import numpy as np
+import pytest
+from scipy.ndimage import center_of_mass
+
+from nimare.meta import kernel
+from nimare.utils import get_masker, get_template, mm2vox
+
+
+@pytest.mark.parametrize(
+    "kern, res, param, return_type, kwargs",
+    [
+        (kernel.ALEKernel, 1, "dataset", "image", {"sample_size": 20}),
+        (kernel.ALEKernel, 2, "dataset", "image", {"sample_size": 20}),
+        (kernel.ALEKernel, 1, "dataframe", "image", {"sample_size": 20}),
+        (kernel.ALEKernel, 2, "dataframe", "image", {"sample_size": 20}),
+        (kernel.ALEKernel, 1, "dataset", "array", {"sample_size": 20}),
+        (kernel.ALEKernel, 2, "dataset", "array", {"sample_size": 20}),
+        (kernel.ALEKernel, 1, "dataframe", "array", {"sample_size": 20}),
+        (kernel.ALEKernel, 2, "dataframe", "array", {"sample_size": 20}),
+        (kernel.MKDAKernel, 1, "dataset", "image", {"r": 4, "value": 1}),
+        (kernel.MKDAKernel, 2, "dataset", "image", {"r": 4, "value": 1}),
+        (kernel.MKDAKernel, 1, "dataframe", "image", {"r": 4, "value": 1}),
+        (kernel.MKDAKernel, 2, "dataframe", "image", {"r": 4, "value": 1}),
+        (kernel.KDAKernel, 1, "dataset", "image", {"r": 4, "value": 1}),
+        (kernel.KDAKernel, 2, "dataset", "image", {"r": 4, "value": 1}),
+        (kernel.KDAKernel, 1, "dataframe", "image", {"r": 4, "value": 1}),
+        (kernel.KDAKernel, 2, "dataframe", "image", {"r": 4, "value": 1}),
+    ],
+)
+def test_kernel_peaks(testdata_cbma, tmp_path_factory, kern, res, param, return_type, kwargs):
+    """Peak/COMs of kernel maps should match the foci fed in (assuming focus isn't masked out).
+
+    Notes
+    -----
+    Remember that dataframe --> dataset won't work.
+    Test on multiple template resolutions.
+    """
+    tmpdir = tmp_path_factory.mktemp("test_kernel_peaks")
+    testdata_cbma.update_path(tmpdir)
+
+    id_ = "pain_03.nidm-1"
+
+    template = get_template(space=f"mni152_{res}mm", mask="brain")
+    masker = get_masker(template)
+
+    xyz = testdata_cbma.coordinates.loc[testdata_cbma.coordinates["id"] == id_, ["x", "y", "z"]]
+    ijk = mm2vox(xyz, masker.mask_img.affine)
+    ijk = np.squeeze(ijk.astype(int))
+
+    if param == "dataframe":
+        input_ = testdata_cbma.coordinates.copy()
+    elif param == "dataset":
+        input_ = testdata_cbma.copy()
+
+    kern_instance = kern(**kwargs)
+    output = kern_instance.transform(input_, masker, return_type=return_type)
+
+    if return_type == "image":
+        kern_data = output[0].get_fdata()
+    elif return_type == "array":
+        kern_data = np.squeeze(masker.inverse_transform(output[:1, :]).get_fdata())
+    else:
+        f = output.images.loc[output.images["id"] == id_, kern_instance.image_type].values[0]
+        kern_data = nib.load(f).get_fdata()
+
+    if isinstance(kern_instance, kernel.ALEKernel):
+        loc_idx = np.array(np.where(kern_data == np.max(kern_data))).T
+    elif isinstance(kern_instance, (kernel.MKDAKernel, kernel.KDAKernel)):
+        loc_idx = np.array(center_of_mass(kern_data)).astype(int).T
+    else:
+        raise Exception(f"A {type(kern_instance)}? Why?")
+
+    loc_ijk = np.squeeze(loc_idx)
+
+    assert np.array_equal(ijk, loc_ijk)
+
+
+@pytest.mark.parametrize(
+    "kern, kwargs",
+    [
+        (kernel.ALEKernel, {"sample_size": 20}),
+        (kernel.MKDAKernel, {"r": 4, "value": 1}),
+        (kernel.KDAKernel, {"r": 4, "value": 1}),
+    ],
+)
+def test_kernel_transform_attributes(kern, kwargs):
+    """Check that attributes are added at transform."""
+    kern_instance = kern(**kwargs)
+    assert not hasattr(kern_instance, "filename_pattern")
+    assert not hasattr(kern_instance, "image_type")
+    kern_instance._infer_names()
+    assert hasattr(kern_instance, "filename_pattern")
+    assert hasattr(kern_instance, "image_type")
+
+
+@pytest.mark.parametrize(
+    "kern, kwargs, set_kwargs",
+    [
+        (kernel.ALEKernel, {"sample_size": 20}, {"sample_size": None, "fwhm": 10}),
+        (kernel.MKDAKernel, {"r": 4, "value": 1}, {"r": 10, "value": 3}),
+        (kernel.KDAKernel, {"r": 4, "value": 1}, {"r": 10, "value": 3}),
+    ],
+)
+def test_kernel_smoke(testdata_cbma, kern, kwargs, set_kwargs):
+    """Smoke test for different kernel transformers and check that you can reset params."""
+    coordinates = testdata_cbma.coordinates.copy()
+
+    kern_instance = kern(**kwargs)
+    ma_maps = kern_instance.transform(coordinates, testdata_cbma.masker, return_type="image")
+    assert len(ma_maps) == len(testdata_cbma.ids) - 2
+    ma_maps = kern_instance.transform(coordinates, testdata_cbma.masker, return_type="array")
+    assert ma_maps.shape[0] == len(testdata_cbma.ids) - 2
+
+    # Test set_params
+    kern_instance.set_params(**set_kwargs)
+    kern_instance2 = kern(**set_kwargs)
+    ma_maps1 = kern_instance.transform(coordinates, testdata_cbma.masker, return_type="array")
+    ma_maps2 = kern_instance2.transform(coordinates, testdata_cbma.masker, return_type="array")
+    assert ma_maps1.shape[0] == ma_maps2.shape[0] == len(testdata_cbma.ids) - 2
+    assert np.array_equal(ma_maps1, ma_maps2)
+
+
+def test_ALEKernel_fwhm(testdata_cbma):
+    """Peaks of ALE kernel maps should match the foci fed in (assuming focus isn't masked out).
+
+    Test with explicit FWHM.
+    """
+    coordinates = testdata_cbma.coordinates.copy()
+
+    id_ = "pain_03.nidm-1"
+    kern = kernel.ALEKernel(fwhm=10)
+    ma_maps = kern.transform(coordinates, masker=testdata_cbma.masker, return_type="image")
+
+    xyz = coordinates.loc[coordinates["id"] == id_, ["x", "y", "z"]]
+    ijk = mm2vox(xyz, testdata_cbma.masker.mask_img.affine)
+    ijk = np.squeeze(ijk.astype(int))
+
+    kern_data = ma_maps[0].get_fdata()
+    max_idx = np.array(np.where(kern_data == np.max(kern_data))).T
+    max_ijk = np.squeeze(max_idx)
+    assert np.array_equal(ijk, max_ijk)
+
+
+def test_ALEKernel_sample_size(testdata_cbma):
+    """Peaks of ALE kernel maps should match the foci fed in (assuming focus isn't masked out).
+
+    Test with explicit sample size.
+    """
+    coordinates = testdata_cbma.coordinates.copy()
+
+    id_ = "pain_03.nidm-1"
+    kern = kernel.ALEKernel(sample_size=20)
+    ma_maps = kern.transform(coordinates, masker=testdata_cbma.masker, return_type="image")
+
+    xyz = coordinates.loc[coordinates["id"] == id_, ["x", "y", "z"]]
+    ijk = mm2vox(xyz, testdata_cbma.masker.mask_img.affine)
+    ijk = np.squeeze(ijk.astype(int))
+
+    kern_data = ma_maps[0].get_fdata()
+    max_idx = np.array(np.where(kern_data == np.max(kern_data))).T
+    max_ijk = np.squeeze(max_idx)
+    assert np.array_equal(ijk, max_ijk)
+
+
+def test_ALEKernel_memory(testdata_cbma, tmp_path_factory):
+    """Test ALEKernel with memory caching enable."""
+    cachedir = tmp_path_factory.mktemp("test_ALE_memory")
+
+    coord = testdata_cbma.coordinates.copy()
+
+    kern_cached = kernel.ALEKernel(sample_size=20, memory=str(cachedir), memory_level=2)
+    ma_maps_cached = kern_cached.transform(coord, masker=testdata_cbma.masker, return_type="array")
+
+    kern = kernel.ALEKernel(sample_size=20, memory=None)
+    ma_maps = kern.transform(coord, masker=testdata_cbma.masker, return_type="array")
+
+    assert np.array_equal(ma_maps_cached, ma_maps)
+
+    # Test that memory is actually used
+    kern_cached_fast = kernel.ALEKernel(sample_size=20, memory=str(cachedir), memory_level=2)
+    ma_maps_cached_fast = kern_cached_fast.transform(
+        coord, masker=testdata_cbma.masker, return_type="array"
+    )
+
+    assert np.array_equal(ma_maps_cached_fast, ma_maps)
+
+
+def test_MKDA_kernel_sum_across(testdata_cbma):
+    """Test if creating a summary array is equivalent to summing across the sparse array."""
+    kern = kernel.MKDAKernel(r=10, value=1)
+    coordinates = testdata_cbma.coordinates.copy()
+    sparse_ma_maps = kern.transform(coordinates, masker=testdata_cbma.masker, return_type="sparse")
+    summary_map = kern.transform(
+        coordinates, masker=testdata_cbma.masker, return_type="summary_array"
+    )
+
+    summary_sparse_ma_map = sparse_ma_maps.sum(axis=0)
+    mask_data = testdata_cbma.masker.mask_img.get_fdata().astype(bool)
+
+    # Indexing the sparse array is slow, perform masking in the dense array
+    summary_sparse_ma_map = summary_sparse_ma_map.todense().reshape(-1)
+    summary_sparse_ma_map = summary_sparse_ma_map[mask_data.reshape(-1)]
+
+    assert (
+        np.testing.assert_array_equal(summary_map, summary_sparse_ma_map.astype(np.int32)) is None
+    )

nimare/tests/test_meta_mkda.py

@@ -0,0 +1,234 @@
+"""Test nimare.meta.mkda (KDA-based meta-analytic algorithms)."""
+
+import logging
+
+import numpy as np
+
+import nimare
+from nimare.correct import FDRCorrector, FWECorrector
+from nimare.meta import KDA, MKDAChi2, MKDADensity, MKDAKernel
+
+
+def test_MKDADensity_kernel_instance_with_kwargs(testdata_cbma):
+    """Smoke test for MKDADensity with a kernel transformer object.
+
+    With kernel arguments provided, which should result in a warning, but the original
+    object's parameters should remain untouched.
+    """
+    kern = MKDAKernel(r=2)
+    meta = MKDADensity(kern, kernel__r=6, null_method="montecarlo", n_iters=10)
+
+    assert meta.kernel_transformer.get_params().get("r") == 2
+
+
+def test_MKDADensity_kernel_class(testdata_cbma):
+    """Smoke test for MKDADensity with a kernel transformer class."""
+    meta = MKDADensity(MKDAKernel, kernel__r=5, null_method="montecarlo", n_iters=10)
+    results = meta.fit(testdata_cbma)
+    assert isinstance(results, nimare.results.MetaResult)
+
+
+def test_MKDADensity_kernel_instance(testdata_cbma):
+    """Smoke test for MKDADensity with a kernel transformer object."""
+    kern = MKDAKernel(r=5)
+    meta = MKDADensity(kern, null_method="montecarlo", n_iters=10)
+    results = meta.fit(testdata_cbma)
+    assert isinstance(results, nimare.results.MetaResult)
+
+
+def test_MKDADensity_approximate_null(testdata_cbma_full, caplog):
+    """Smoke test for MKDADensity with the "approximate" null_method."""
+    meta = MKDADensity(null="approximate")
+    results = meta.fit(testdata_cbma_full)
+    corr = FWECorrector(method="montecarlo", voxel_thresh=0.001, n_iters=5, n_cores=1)
+    corr_results = corr.transform(results)
+    assert isinstance(results, nimare.results.MetaResult)
+    assert isinstance(results.description_, str)
+    assert isinstance(corr_results, nimare.results.MetaResult)
+    assert isinstance(corr_results.description_, str)
+
+    # Check that the vfwe_only option does not work
+    corr2 = FWECorrector(
+        method="montecarlo",
+        voxel_thresh=0.001,
+        n_iters=5,
+        n_cores=1,
+        vfwe_only=True,
+    )
+    with caplog.at_level(logging.WARNING):
+        corr_results2 = corr2.transform(results)
+
+    assert "Running permutations from scratch." in caplog.text
+
+    assert isinstance(corr_results2, nimare.results.MetaResult)
+    assert "logp_level-voxel_corr-FWE_method-montecarlo" in corr_results2.maps
+    assert "logp_desc-size_level-cluster_corr-FWE_method-montecarlo" not in corr_results2.maps
+
+
+def test_MKDADensity_montecarlo_null(testdata_cbma):
+    """Smoke test for MKDADensity with the "montecarlo" null_method."""
+    meta = MKDADensity(null_method="montecarlo", n_iters=10)
+    results = meta.fit(testdata_cbma)
+    corr = FWECorrector(method="montecarlo", voxel_thresh=0.001, n_iters=5, n_cores=1)
+    corr_results = corr.transform(results)
+    assert isinstance(results, nimare.results.MetaResult)
+    assert isinstance(results.description_, str)
+    assert isinstance(corr_results, nimare.results.MetaResult)
+    assert isinstance(corr_results.description_, str)
+
+    # Check that the vfwe_only option works
+    corr2 = FWECorrector(
+        method="montecarlo",
+        voxel_thresh=0.001,
+        n_iters=5,
+        n_cores=1,
+        vfwe_only=True,
+    )
+    corr_results2 = corr2.transform(results)
+    assert isinstance(corr_results2, nimare.results.MetaResult)
+    assert "logp_level-voxel_corr-FWE_method-montecarlo" in corr_results2.maps
+    assert "logp_desc-size_level-cluster_corr-FWE_method-montecarlo" not in corr_results2.maps
+
+
+def test_MKDAChi2_fdr(testdata_cbma):
+    """Smoke test for MKDAChi2."""
+    meta = MKDAChi2()
+    results = meta.fit(testdata_cbma, testdata_cbma)
+    corr = FDRCorrector(method="indep", alpha=0.001)
+    corr_results = corr.transform(results)
+    assert isinstance(results, nimare.results.MetaResult)
+    assert isinstance(results.description_, str)
+    assert isinstance(corr_results, nimare.results.MetaResult)
+    assert isinstance(corr_results.description_, str)
+
+    methods = FDRCorrector.inspect(results)
+    assert methods == ["indep", "negcorr"]
+
+
+def test_MKDAChi2_fwe_1core(testdata_cbma):
+    """Smoke test for MKDAChi2."""
+    meta = MKDAChi2()
+    results = meta.fit(testdata_cbma, testdata_cbma)
+    valid_methods = FWECorrector.inspect(results)
+    assert "montecarlo" in valid_methods
+
+    corr = FWECorrector(method="montecarlo", n_iters=5, n_cores=1)
+    corr_results = corr.transform(results)
+    assert isinstance(results, nimare.results.MetaResult)
+    assert isinstance(results.description_, str)
+    assert isinstance(corr_results, nimare.results.MetaResult)
+    assert isinstance(corr_results.description_, str)
+    assert (
+        "values_desc-pFgA_level-voxel_corr-fwe_method-montecarlo"
+        in corr_results.estimator.null_distributions_.keys()
+    )
+    assert (
+        "values_desc-pAgF_level-voxel_corr-fwe_method-montecarlo"
+        in corr_results.estimator.null_distributions_.keys()
+    )
+
+
+def test_MKDAChi2_fwe_2core(testdata_cbma):
+    """Smoke test for MKDAChi2."""
+    meta = MKDAChi2()
+    results = meta.fit(testdata_cbma, testdata_cbma)
+    assert isinstance(results, nimare.results.MetaResult)
+    corr_2core = FWECorrector(method="montecarlo", n_iters=5, n_cores=2)
+    cres_2core = corr_2core.transform(results)
+    assert isinstance(cres_2core, nimare.results.MetaResult)
+
+
+def test_KDA_approximate_null(testdata_cbma):
+    """Smoke test for KDA with approximate null and FWE correction."""
+    meta = KDA(null_method="approximate")
+    results = meta.fit(testdata_cbma)
+    corr = FWECorrector(method="montecarlo", n_iters=5, n_cores=1)
+    corr_results = corr.transform(results)
+    assert isinstance(results, nimare.results.MetaResult)
+    assert isinstance(results.description_, str)
+    assert results.get_map("p", return_type="array").dtype == np.float64
+    assert isinstance(corr_results, nimare.results.MetaResult)
+    assert isinstance(corr_results.description_, str)
+    assert (
+        corr_results.get_map(
+            "logp_level-voxel_corr-FWE_method-montecarlo", return_type="array"
+        ).dtype
+        == np.float64
+    )
+    assert (
+        corr_results.get_map(
+            "logp_desc-size_level-cluster_corr-FWE_method-montecarlo", return_type="array"
+        ).dtype
+        == np.float64
+    )
+    assert (
+        corr_results.get_map(
+            "logp_desc-mass_level-cluster_corr-FWE_method-montecarlo", return_type="array"
+        ).dtype
+        == np.float64
+    )
+
+
+def test_KDA_fwe_1core(testdata_cbma):
+    """Smoke test for KDA with montecarlo null and FWE correction."""
+    meta = KDA(null_method="montecarlo", n_iters=10)
+    results = meta.fit(testdata_cbma)
+    corr = FWECorrector(method="montecarlo", n_iters=5, n_cores=1)
+    corr_results = corr.transform(results)
+    assert isinstance(results, nimare.results.MetaResult)
+    assert results.get_map("p", return_type="array").dtype == np.float64
+    assert isinstance(corr_results, nimare.results.MetaResult)
+    assert (
+        corr_results.get_map(
+            "logp_level-voxel_corr-FWE_method-montecarlo", return_type="array"
+        ).dtype
+        == np.float64
+    )
+    assert (
+        corr_results.get_map(
+            "logp_desc-mass_level-cluster_corr-FWE_method-montecarlo", return_type="array"
+        ).dtype
+        == np.float64
+    )
+    assert (
+        corr_results.get_map(
+            "logp_desc-size_level-cluster_corr-FWE_method-montecarlo", return_type="array"
+        ).dtype
+        == np.float64
+    )
+
+
+def test_MKDADensity_approximate_montecarlo_convergence(testdata_cbma_full):
+    """Evaluate convergence between approximate and montecarlo null methods in MKDA."""
+    est_a = MKDADensity(null_method="approximate")
+    n_iters = 10
+    est_e = MKDADensity(null_method="montecarlo", n_iters=n_iters)
+    res_a = est_a.fit(testdata_cbma_full)
+    res_e = est_e.fit(testdata_cbma_full)
+    # Get smallest p-value above 0 from the montecarlo estimator; above this,
+    # the two should converge reasonably closely.
+    min_p = 1 / n_iters
+    p_idx = res_e.maps["p"] > min_p
+    p_approximate = res_a.maps["p"][p_idx]
+    p_montecarlo = res_e.maps["p"][p_idx]
+    # Correlation must be near unity and mean difference should be tiny
+    assert np.corrcoef(p_approximate, p_montecarlo)[0, 1] > 0.98
+    assert (p_approximate - p_montecarlo).mean() < 1e-3
+
+
+def test_KDA_approximate_montecarlo_convergence(testdata_cbma_full):
+    """Evaluate convergence between approximate and montecarlo null methods in KDA."""
+    est_a = KDA(null_method="approximate")
+    n_iters = 10
+    est_e = KDA(null_method="montecarlo", n_iters=n_iters)
+    res_a = est_a.fit(testdata_cbma_full)
+    res_e = est_e.fit(testdata_cbma_full)
+    # Get smallest p-value above 0 from the montecarlo estimator; above this,
+    # the two should converge reasonably closely.
+    min_p = 1 / n_iters
+    p_idx = res_e.maps["p"] > min_p
+    p_approximate = res_a.maps["p"][p_idx]
+    p_montecarlo = res_e.maps["p"][p_idx]
+    # Correlation must be near unity and mean difference should be tiny
+    assert np.corrcoef(p_approximate, p_montecarlo)[0, 1] > 0.98
+    assert (p_approximate - p_montecarlo).mean() < 1e-3