def METHOD_NAME(self):
    rank = 0
    if self.comm is not None:
        rank = self.comm.rank
    # make a simple pointing matrix
    pointing = OpPointingHpix(nside=self.nside, nest=False, mode="I")
    pointing.exec(self.data)
    # generate timestreams
    op = OpSimDipole(mode="solar", coord="G")
    op.exec(self.data)
    # make a binned map
    # construct distributed maps to store the covariance,
    # noise weighted map, and hits
    invnpp = DistPixels(
        self.data,
        nnz=1,
        dtype=np.float64,
        nest=False,
    )
    invnpp.data.fill(0.0)
    zmap = DistPixels(
        self.data,
        nnz=1,
        dtype=np.float64,
        nest=False,
    )
    zmap.data.fill(0.0)
    hits = DistPixels(
        self.data,
        nnz=1,
        dtype=np.int64,
        nest=False,
    )
    hits.data.fill(0)
    # accumulate the inverse covariance and noise weighted map.
    # Use detector weights based on the analytic NET.
    tod = self.data.obs[0]["tod"]
    detweights = {}
    for d in tod.local_dets:
        detweights[d] = 1.0
    build_invnpp = OpAccumDiag(
        detweights=detweights, invnpp=invnpp, hits=hits, zmap=zmap, name="dipole"
    )
    build_invnpp.exec(self.data)
    invnpp.allreduce()
    hits.allreduce()
    zmap.allreduce()
    hits.write_healpix_fits(os.path.join(self.outdir, "hits.fits"))
    invnpp.write_healpix_fits(os.path.join(self.outdir, "invnpp.fits"))
    zmap.write_healpix_fits(os.path.join(self.outdir, "zmap.fits"))
    # invert it
    covariance_invert(invnpp, 1.0e-3)
    invnpp.write_healpix_fits(os.path.join(self.outdir, "npp.fits"))
    # compute the binned map, N_pp x Z
    covariance_apply(invnpp, zmap)
    zmap.write_healpix_fits(os.path.join(self.outdir, "binned.fits"))
    if rank == 0:
        import matplotlib.pyplot as plt
        mapfile = os.path.join(self.outdir, "hits.fits")
        data = hp.read_map(mapfile, nest=False)
        nt.assert_almost_equal(
            data, self.data.comm.ngroups * self.ndet * np.ones_like(data)
        )
        outfile = "{}.png".format(mapfile)
        hp.mollview(data, xsize=1600, nest=False)
        plt.savefig(outfile)
        plt.close()
        mapfile = os.path.join(self.outdir, "binned.fits")
        data = hp.read_map(mapfile, nest=False)
        # verify that the extrema are in the correct location
        # and have the correct value.
        minmap = np.min(data)
        maxmap = np.max(data)
        nt.assert_almost_equal(maxmap, self.dip_check, decimal=5)
        nt.assert_almost_equal(minmap, -self.dip_check, decimal=5)
        minloc = np.argmin(data)
        maxloc = np.argmax(data)
        nt.assert_equal(minloc, self.dip_min_pix)
        nt.assert_equal(maxloc, self.dip_max_pix)
        outfile = "{}.png".format(mapfile)
        hp.mollview(data, xsize=1600, nest=False)
        plt.savefig(outfile)
        plt.close()
    return