Example #1
0
def test_ghosts(lmax=700,
                mmax=5,
                fwhm=43,
                ra0=-10,
                dec0=-57.5,
                az_throw=50,
                scan_speed=2.8,
                rot_period=4.5 * 60 * 60,
                hwp_mode=None):
    '''
    Similar test to `scan_bicep`, but includes reflected ghosts

    Simulates a 24h BICEP2-like scan strategy
    using a random LCDM realisation and a 3 x 3 grid
    of Gaussian beams pairs. Bins tods into maps and
    compares to smoothed input maps (no pair-
    differencing). MPI-enabled.

    Keyword arguments
    ---------

    lmax : int,
        bandlimit (default : 700)
    mmax : int,
        assumed azimuthal bandlimit beams (symmetric in this example
        so 2 would suffice) (default : 5)
    fwhm : float,
        The beam FWHM in arcmin (default : 40)
    ra0 : float,
        Ra coord of centre region (default : -10)
    dec0 : float,  (default : -57.5)
        Ra coord of centre region
    az_throw : float,
        Scan width in azimuth (in degrees) (default : 50)
    scan_speed : float,
        Scan speed in deg/s (default : 1)
    rot_period : float,
        The instrument rotation period in sec
        (default : 600)
    hwp_mode : str, None
        HWP modulation mode, either "continuous",
        "stepped" or None. Use freq of 1 or 1/10800 Hz
        respectively (default : None)
    '''

    mlen = 24 * 60 * 60  # hardcoded mission length

    # Create LCDM realization
    ell, cls = get_cls()
    np.random.seed(25)  # make sure all MPI ranks use the same seed
    alm = hp.synalm(cls, lmax=lmax, new=True, verbose=True)  # uK

    b2 = ScanStrategy(
        mlen,  # mission duration in sec.
        sample_rate=12.01,  # sample rate in Hz
        location='spole')  # Instrument at south pole

    # Create a 3 x 3 square grid of Gaussian beams
    b2.create_focal_plane(nrow=3, ncol=3, fov=5, lmax=lmax, fwhm=fwhm)

    # Create reflected ghosts for every detector
    # We create two ghosts per detector. They overlap
    # but have different fwhm. First ghost is just a
    # scaled down version of the main beam, the second
    # has a much wider Gaussian shape.
    # After this initialization, the code takes
    # the ghosts into account without modifications
    b2.create_reflected_ghosts(b2.beams,
                               amplitude=0.01,
                               ghost_tag='ghost_1',
                               dead=False)
    b2.create_reflected_ghosts(b2.beams,
                               amplitude=0.01,
                               fwhm=100,
                               ghost_tag='ghost_2',
                               dead=False)

    # calculate tods in two chunks
    b2.partition_mission(0.5 * b2.nsamp)

    # Allocate and assign parameters for mapmaking
    b2.allocate_maps(nside=256)

    # set instrument rotation
    b2.set_instr_rot(period=rot_period, angles=[68, 113, 248, 293])

    # Set HWP rotation
    if hwp_mode == 'continuous':
        b2.set_hwp_mod(mode='continuous', freq=1.)
    elif hwp_mode == 'stepped':
        b2.set_hwp_mod(mode='stepped', freq=1 / (3 * 60 * 60.))

    # Generate timestreams, bin them and store as attributes
    b2.scan_instrument_mpi(alm,
                           verbose=1,
                           ra0=ra0,
                           dec0=dec0,
                           az_throw=az_throw,
                           nside_spin=256,
                           max_spin=mmax)

    # Solve for the maps
    maps, cond = b2.solve_for_map(fill=np.nan)

    # Plotting
    if b2.mpi_rank == 0:
        print('plotting results')

        cart_opts = dict(
            rot=[ra0, dec0, 0],
            lonra=[-min(0.5 * az_throw, 90),
                   min(0.5 * az_throw, 90)],
            latra=[-min(0.375 * az_throw, 45),
                   min(0.375 * az_throw, 45)],
            unit=r'[$\mu K_{\mathrm{CMB}}$]')

        # plot rescanned maps
        plot_iqu(maps,
                 '../scratch/img/',
                 'rescan_ghost',
                 sym_limits=[250, 5, 5],
                 plot_func=hp.cartview,
                 **cart_opts)

        # plot smoothed input maps
        nside = hp.get_nside(maps[0])
        hp.smoothalm(alm, fwhm=np.radians(fwhm / 60.), verbose=False)
        maps_raw = hp.alm2map(alm, nside, verbose=False)

        plot_iqu(maps_raw,
                 '../scratch/img/',
                 'raw_ghost',
                 sym_limits=[250, 5, 5],
                 plot_func=hp.cartview,
                 **cart_opts)

        # plot difference maps
        for arr in maps_raw:
            # replace stupid UNSEEN crap
            arr[arr == hp.UNSEEN] = np.nan

        diff = maps_raw - maps

        plot_iqu(diff,
                 '../scratch/img/',
                 'diff_ghost',
                 sym_limits=[1e+1, 1e-1, 1e-1],
                 plot_func=hp.cartview,
                 **cart_opts)

        # plot condition number map
        cart_opts.pop('unit', None)

        plot_map(cond,
                 '../scratch/img/',
                 'cond_ghost',
                 min=2,
                 max=5,
                 unit='condition number',
                 plot_func=hp.cartview,
                 **cart_opts)

        # plot input spectrum
        cls[3][cls[3] <= 0.] *= -1.
        dell = ell * (ell + 1) / 2. / np.pi
        plt.figure()
        for i, label in enumerate(['TT', 'EE', 'BB', 'TE']):
            plt.semilogy(ell, dell * cls[i], label=label)

        plt.legend()
        plt.ylabel(r'$D_{\ell}$ [$\mu K^2_{\mathrm{CMB}}$]')
        plt.xlabel(r'Multipole [$\ell$]')
        plt.savefig('../scratch/img/cls_ghost.png')
        plt.close()
Example #2
0
def test_satellite_scan(lmax=700,
                        mmax=2,
                        fwhm=43,
                        ra0=-10,
                        dec0=-57.5,
                        az_throw=50,
                        scan_speed=2.8,
                        hwp_mode=None,
                        alpha=45.,
                        beta=45.,
                        alpha_period=5400.,
                        beta_period=600.,
                        delta_az=0.,
                        delta_el=0.,
                        delta_psi=0.,
                        jitter_amp=1.0):
    '''
    Simulates a satellite scan strategy 
    using a random LCDM realisation and a 3 x 3 grid
    of Gaussian beams pairs. Bins tods into maps and
    compares to smoothed input maps (no pair-
    differencing). MPI-enabled.

    Keyword arguments
    ---------

    lmax : int,
        bandlimit (default : 700)
    mmax : int, 
        assumed azimuthal bandlimit beams (symmetric in this example
        so 2 would suffice) (default : 2)
    fwhm : float,
        The beam FWHM in arcmin (default : 40)
    ra0 : float,
        Ra coord of centre region (default : -10)
    dec0 : float,  (default : -57.5)
        Ra coord of centre region
    az_throw : float,
        Scan width in azimuth (in degrees) (default : 50)
    scan_speed : float,
        Scan speed in deg/s (default : 1)
    hwp_mode : str, None
        HWP modulation mode, either "continuous",
        "stepped" or None. Use freq of 1 or 1/10800 Hz
        respectively (default : None)
    '''

    print('Simulating a satellite...')
    mlen = 3 * 24 * 60 * 60  # hardcoded mission length

    # Create LCDM realization
    ell, cls = get_cls()
    np.random.seed(25)  # make sure all MPI ranks use the same seed
    alm = hp.synalm(cls, lmax=lmax, new=True, verbose=True)  # uK

    sat = ScanStrategy(
        mlen,  # mission duration in sec.
        external_pointing=True,  # Telling code to use non-standard scanning
        sample_rate=12.01,  # sample rate in Hz
        location='space')  # Instrument at south pole

    # Create a 3 x 3 square grid of Gaussian beams
    sat.create_focal_plane(nrow=7, ncol=7, fov=15, lmax=lmax, fwhm=fwhm)

    # calculate tods in two chunks
    sat.partition_mission(0.5 * sat.nsamp)

    # Allocate and assign parameters for mapmaking
    sat.allocate_maps(nside=256)

    scan_opts = dict(q_bore_func=sat.satellite_scan,
                     ctime_func=sat.satellite_ctime,
                     q_bore_kwargs=dict(),
                     ctime_kwargs=dict())

    # Generate timestreams, bin them and store as attributes
    sat.scan_instrument_mpi(alm,
                            verbose=1,
                            ra0=ra0,
                            dec0=dec0,
                            az_throw=az_throw,
                            nside_spin=256,
                            max_spin=mmax,
                            **scan_opts)

    # Solve for the maps
    maps, cond, proj = sat.solve_for_map(fill=np.nan, return_proj=True)

    # Plotting
    if sat.mpi_rank == 0:
        print('plotting results')

        cart_opts = dict(unit=r'[$\mu K_{\mathrm{CMB}}$]')

        # plot rescanned maps

        plot_iqu(maps,
                 '../scratch/img/',
                 'rescan_satellite',
                 sym_limits=[250, 5, 5],
                 plot_func=hp.mollview,
                 **cart_opts)

        # plot smoothed input maps
        nside = hp.get_nside(maps[0])
        hp.smoothalm(alm, fwhm=np.radians(fwhm / 60.), verbose=False)
        maps_raw = hp.alm2map(alm, nside, verbose=False)

        plot_iqu(maps_raw,
                 '../scratch/img/',
                 'raw_satellite',
                 sym_limits=[250, 5, 5],
                 plot_func=hp.mollview,
                 **cart_opts)

        # plot difference maps
        for arr in maps_raw:
            # replace stupid UNSEEN crap
            arr[arr == hp.UNSEEN] = np.nan

        diff = maps_raw - maps

        plot_iqu(diff,
                 '../scratch/img/',
                 'diff_satellite',
                 sym_limits=[1e-6, 1e-6, 1e-6],
                 plot_func=hp.mollview,
                 **cart_opts)

        # plot condition number map
        cart_opts.pop('unit', None)

        plot_map(cond,
                 '../scratch/img/',
                 'cond_satellite',
                 min=2,
                 max=5,
                 unit='condition number',
                 plot_func=hp.mollview,
                 **cart_opts)

        plot_map(proj[0],
                 '../scratch/img/',
                 'hits_satellite',
                 unit='Hits',
                 plot_func=hp.mollview,
                 **cart_opts)
Example #3
0
def scan_atacama(lmax=700,
                 mmax=5,
                 fwhm=40,
                 mlen=48 * 60 * 60,
                 nrow=3,
                 ncol=3,
                 fov=5.0,
                 ra0=[-10, 170],
                 dec0=[-57.5, 0],
                 el_min=45.,
                 cut_el_min=False,
                 az_throw=50,
                 scan_speed=1,
                 rot_period=0,
                 hwp_mode='continuous'):
    '''
    Simulates 48h of an atacama-based telescope with a 3 x 3 grid
    of Gaussian beams pairs. Prefers to scan the bicep patch but
    will try to scan the ABS_B patch if the first is not visible.

    Keyword arguments
    ---------

    lmax : int
        bandlimit (default : 700)
    mmax : int
        assumed azimuthal bandlimit beams (symmetric in this example
        so 2 would suffice) (default : 5)
    fwhm : float
        The beam FWHM in arcmin (default : 40)
    mlen : int
        The mission length [seconds] (default : 48 * 60 * 60)
    nrow : int
        Number of detectors along row direction (default : 3)
    ncol : int
        Number of detectors along column direction (default : 3)
    fov : float
        The field of view in degrees (default : 5.0)
    ra0 : float, array-like
        Ra coord of centre region (default : [-10., 85.])
    dec0 : float, array-like
        Ra coord of centre region (default : [-57.5, 0.])
    el_min : float
        Minimum elevation range [deg] (default : 45)
    cut_el_min: bool
            If True, excludes timelines where el would be less than el_min
    az_throw : float
        Scan width in azimuth (in degrees) (default : 10)
    scan_speed : float
        Scan speed in deg/s (default : 1)
    rot_period : float
        The instrument rotation period in sec
        (default : 600)
    hwp_mode : str, None
        HWP modulation mode, either "continuous",
        "stepped" or None. Use freq of 1 or 1/10800 Hz
        respectively (default : continuous)
    '''

    # hardcoded mission length

    # Create LCDM realization
    ell, cls = get_cls()
    np.random.seed(25)  # make sure all MPI ranks use the same seed
    alm = hp.synalm(cls, lmax=lmax, new=True, verbose=True)  # uK

    ac = ScanStrategy(
        mlen,  # mission duration in sec.
        sample_rate=12.01,  # sample rate in Hz
        location='atacama')  # Instrument at south pole

    # Create a 3 x 3 square grid of Gaussian beams
    ac.create_focal_plane(nrow=nrow, ncol=ncol, fov=fov, lmax=lmax, fwhm=fwhm)

    # calculate tods in two chunks
    ac.partition_mission(0.5 * ac.mlen * ac.fsamp)

    # Allocate and assign parameters for mapmaking
    ac.allocate_maps(nside=256)

    # set instrument rotation
    ac.set_instr_rot(period=rot_period)

    # Set HWP rotation
    if hwp_mode == 'continuous':
        ac.set_hwp_mod(mode='continuous', freq=1.)
    elif hwp_mode == 'stepped':
        ac.set_hwp_mod(mode='stepped', freq=1 / (3 * 60 * 60.))

    # Generate timestreams, bin them and store as attributes
    ac.scan_instrument_mpi(alm,
                           verbose=2,
                           ra0=ra0,
                           dec0=dec0,
                           az_throw=az_throw,
                           nside_spin=256,
                           el_min=el_min,
                           cut_el_min=cut_el_min,
                           create_memmap=True)

    # Solve for the maps
    maps, cond = ac.solve_for_map(fill=np.nan)

    # Plotting
    if ac.mpi_rank == 0:
        print('plotting results')
        img_out_path = '../scratch/img/'

        moll_opts = dict(unit=r'[$\mu K_{\mathrm{CMB}}$]')

        # plot rescanned maps
        plot_iqu(maps,
                 img_out_path,
                 'rescan_atacama',
                 sym_limits=[250, 5, 5],
                 plot_func=hp.mollview,
                 **moll_opts)

        # plot smoothed input maps
        nside = hp.get_nside(maps[0])
        hp.smoothalm(alm, fwhm=np.radians(fwhm / 60.), verbose=False)
        maps_raw = hp.alm2map(alm, nside, verbose=False)

        plot_iqu(maps_raw,
                 img_out_path,
                 'raw_atacama',
                 sym_limits=[250, 5, 5],
                 plot_func=hp.mollview,
                 **moll_opts)

        # plot difference maps
        for arr in maps_raw:
            # replace stupid UNSEEN crap
            arr[arr == hp.UNSEEN] = np.nan

        diff = maps_raw - maps

        plot_iqu(diff,
                 img_out_path,
                 'diff_atacama',
                 sym_limits=[1e-6, 1e-6, 1e-6],
                 plot_func=hp.mollview,
                 **moll_opts)

        # plot condition number map
        moll_opts.pop('unit', None)

        plot_map(cond,
                 img_out_path,
                 'cond_atacama',
                 min=2,
                 max=5,
                 unit='condition number',
                 plot_func=hp.mollview,
                 **moll_opts)

        # plot input spectrum
        cls[3][cls[3] <= 0.] *= -1.
        dell = ell * (ell + 1) / 2. / np.pi
        plt.figure()
        for i, label in enumerate(['TT', 'EE', 'BB', 'TE']):
            plt.semilogy(ell, dell * cls[i], label=label)

        plt.legend()
        plt.ylabel(r'$D_{\ell}$ [$\mu K^2_{\mathrm{CMB}}$]')
        plt.xlabel(r'Multipole [$\ell$]')
        plt.savefig('../scratch/img/cls_atacama.png')
        plt.close()

        print("Results written to {}".format(os.path.abspath(img_out_path)))
Example #4
0
def idea_jon():

    nside_spin = 512
    ra0 = 0
    dec0 = -90
    az_throw = 10
    max_spin = 5
    fwhm = 32.2
    scan_opts = dict(verbose=1,
                     ra0=ra0,
                     dec0=dec0,
                     az_throw=az_throw,
                     nside_spin=nside_spin,
                     max_spin=max_spin,
                     binning=True)

    lmax = 800

    alm = tools.gauss_blm(1e-5, lmax, pol=False)
    ell = np.arange(lmax + 1)
    fl = np.sqrt((2 * ell + 1) / 4. / np.pi)
    hp.almxfl(alm, fl, mmax=None, inplace=True)
    fm = (-1)**(hp.Alm.getlm(lmax)[1])
    alm *= fm
    alm = tools.get_copol_blm(alm)

    # create Beam properties and pickle (this is just to test load_focal_plane)
    import tempfile
    import shutil
    import pickle
    opj = os.path.join

    blm_dir = os.path.abspath(
        opj(os.path.dirname(__file__), '../tests/test_data/example_blms'))
    po_file = opj(blm_dir, 'blm_hp_X1T1R1C8A_800_800.npy')
    eg_file = opj(blm_dir, 'blm_hp_eg_X1T1R1C8A_800_800.npy')

    tmp_dir = tempfile.mkdtemp()

    beam_file = opj(tmp_dir, 'beam_opts.pkl')
    beam_opts = dict(az=0,
                     el=0,
                     polang=0.,
                     btype='Gaussian',
                     name='X1T1R1C8',
                     fwhm=fwhm,
                     lmax=800,
                     mmax=800,
                     amplitude=1.,
                     po_file=po_file,
                     eg_file=eg_file)

    with open(beam_file, 'wb') as handle:
        pickle.dump(beam_opts, handle, protocol=pickle.HIGHEST_PROTOCOL)

    # init scan strategy and instrument
    ss = ScanStrategy(
        1.,  # mission duration in sec.
        sample_rate=10000,
        location='spole')

    ss.allocate_maps(nside=1024)
    ss.load_focal_plane(tmp_dir, no_pairs=True)

    # remove tmp dir and contents
    shutil.rmtree(tmp_dir)

    ss.set_el_steps(0.01, steps=np.linspace(-10, 10, 100))

    # Generate maps with Gaussian beams
    ss.scan_instrument_mpi(alm, **scan_opts)
    ss.reset_el_steps()

    # Solve for the maps
    maps_g, cond_g = ss.solve_for_map(fill=np.nan)

    # Generate maps with elliptical Gaussian beams
    ss.allocate_maps(nside=1024)
    ss.beams[0][0].btype = 'EG'
    ss.scan_instrument_mpi(alm, **scan_opts)
    ss.reset_el_steps()

    # Solve for the maps
    maps_eg, cond_eg = ss.solve_for_map(fill=np.nan)

    # Generate map with Physical Optics beams and plot them
    ss.allocate_maps(nside=1024)
    ss.beams[0][0].btype = 'PO'
    ss.scan_instrument_mpi(alm, **scan_opts)
    ss.reset_el_steps()

    # Solve for the maps
    maps_po, cond_po = ss.solve_for_map(fill=np.nan)

    # Plotting
    print('plotting results')

    cart_opts = dict(  #rot=[ra0, dec0, 0],
        lonra=[-min(0.5 * az_throw, 10),
               min(0.5 * az_throw, 10)],
        latra=[-min(0.375 * az_throw, 10),
               min(0.375 * az_throw, 10)],
        unit=r'[$\mu K_{\mathrm{CMB}}$]')

    # plot smoothed input maps
    nside = hp.get_nside(maps_g[0])
    hp.smoothalm(alm, fwhm=np.radians(fwhm / 60.), verbose=False)
    maps_raw = hp.alm2map(alm, nside, verbose=False)

    plot_iqu(maps_raw,
             '../scratch/img/',
             'raw_delta',
             sym_limits=[1, 1, 1],
             plot_func=hp.cartview,
             **cart_opts)