dsm_cc_vis_lag = dsm_cc_vis_lag[truncated_ref_bl_ind,:,:]

delaymat = DLY.delay_envelope(ia.baselines[truncated_ref_bl_ind,:], pc, units='mks')
bw = nchan * freq_resolution
min_delay = -delaymat[0,:,1]-delaymat[0,:,0]
max_delay = delaymat[0,:,0]-delaymat[0,:,1]
clags = clean_lags.reshape(1,-1)
min_delay = min_delay.reshape(-1,1)
max_delay = max_delay.reshape(-1,1)
thermal_noise_window = NP.abs(clags) >= max_abs_delay*1e-6
thermal_noise_window = NP.repeat(thermal_noise_window, ia.baselines[truncated_ref_bl_ind,:].shape[0], axis=0)
EoR_window = NP.logical_or(clags > max_delay+3/bw, clags < min_delay-3/bw)
strict_EoR_window = NP.logical_and(EoR_window, NP.abs(clags) < 1/coarse_channel_resolution)
wedge_window = NP.logical_and(clags <= max_delay, clags >= min_delay)
non_wedge_window = NP.logical_not(wedge_window)
vis_rms_lag = OPS.rms(asm_cc_vis_lag, mask=NP.logical_not(NP.repeat(thermal_noise_window[:,:,NP.newaxis], n_snaps, axis=2)), axis=1)
vis_rms_freq = NP.abs(vis_rms_lag) / NP.sqrt(nchan) / freq_resolution
T_rms_freq = vis_rms_freq / (2.0 * FCNST.k) * NP.mean(ia.A_eff[truncated_ref_bl_ind,:]) * NP.mean(ia.eff_Q[truncated_ref_bl_ind,:]) * NP.sqrt(2.0*freq_resolution*NP.asarray(ia.t_acc).reshape(1,1,-1)) * CNST.Jy
vis_rms_lag_theory = OPS.rms(vis_noise_lag, mask=NP.logical_not(NP.repeat(EoR_window[:,:,NP.newaxis], n_snaps, axis=2)), axis=1)
vis_rms_freq_theory = NP.abs(vis_rms_lag_theory) / NP.sqrt(nchan) / freq_resolution
T_rms_freq_theory = vis_rms_freq_theory / (2.0 * FCNST.k) * NP.mean(ia.A_eff[truncated_ref_bl_ind,:]) * NP.mean(ia.eff_Q[truncated_ref_bl_ind,:]) * NP.sqrt(2.0*freq_resolution*NP.asarray(ia.t_acc).reshape(1,1,-1)) * CNST.Jy

if (dspec_min is None) or (dspec_max is None):
    dspec_max = max([NP.abs(asm_cc_skyvis_lag).max(), NP.abs(dsm_cc_skyvis_lag).max(), NP.abs(csm_cc_skyvis_lag).max()])
    dspec_min = min([NP.abs(asm_cc_skyvis_lag).min(), NP.abs(dsm_cc_skyvis_lag).min(), NP.abs(csm_cc_skyvis_lag).min()])

small_delays_EoR_window = EoR_window.T
small_delays_strict_EoR_window = strict_EoR_window.T
small_delays_wedge_window = wedge_window.T

if max_abs_delay is not None:
    fhd_obsid_pointing_radec[0,0] = fhd_lst - fhd_obsid_pointing_hadec[0,0]
    
    delay_matrix = DLY.delay_envelope(bl, fhd_obsid_pointing_dircos, units='mks')
    delaymat = DLY.delay_envelope(bl, pc, units='mks')

    min_delay = -delaymat[0,:,1]-delaymat[0,:,0]
    max_delay = delaymat[0,:,0]-delaymat[0,:,1]
    min_delay = min_delay.reshape(-1,1)
    max_delay = max_delay.reshape(-1,1)

    thermal_noise_window = NP.abs(fhd_delays) >= max_abs_delay*1e-6
    thermal_noise_window = thermal_noise_window.reshape(1,-1)
    thermal_noise_window = NP.repeat(thermal_noise_window, bl.shape[0], axis=0)
    EoR_window = NP.logical_or(fhd_delays > max_delay+1/bw, fhd_delays < min_delay-1/bw)
    wedge_window = NP.logical_and(fhd_delays <= max_delay, fhd_delays >= min_delay)
    fhd_vis_rms_lag = OPS.rms(fhd_vis_lag_noisy[:,:,0], mask=NP.logical_not(thermal_noise_window), axis=1)
    fhd_vis_rms_freq = NP.abs(fhd_vis_rms_lag) / NP.sqrt(nchan) / freq_resolution
    PDB.set_trace()
    print fhd_vis_rms_freq
    
    if max_abs_delay is not None:
        small_delays_ind = NP.abs(fhd_delays) <= max_abs_delay * 1e-6
        fhd_delays = fhd_delays[small_delays_ind]
        fhd_vis_lag_noisy = fhd_vis_lag_noisy[:,small_delays_ind,:]

    # fig = PLT.figure(figsize=(6,8))
    
    # ax = fig.add_subplot(111)
    # ax.set_xlabel('Baseline Index', fontsize=18)
    # ax.set_ylabel(r'lag [$\mu$s]', fontsize=18)
    # # dspec = ax.imshow(NP.abs(fhd_vis_lag_noisy[:,:,0].T), origin='lower', extent=(0, fhd_vis_lag_noisy.shape[0]-1, NP.amin(fhd_delays*1e6), NP.amax(fhd_delays*1e6)), interpolation=None)
    delaymat = DLY.delay_envelope(bl, pc, units='mks')

    min_delay = -delaymat[0, :, 1] - delaymat[0, :, 0]
    max_delay = delaymat[0, :, 0] - delaymat[0, :, 1]
    min_delay = min_delay.reshape(-1, 1)
    max_delay = max_delay.reshape(-1, 1)

    thermal_noise_window = NP.abs(fhd_delays) >= max_abs_delay * 1e-6
    thermal_noise_window = thermal_noise_window.reshape(1, -1)
    thermal_noise_window = NP.repeat(thermal_noise_window, bl.shape[0], axis=0)
    EoR_window = NP.logical_or(fhd_delays > max_delay + 1 / bw,
                               fhd_delays < min_delay - 1 / bw)
    wedge_window = NP.logical_and(fhd_delays <= max_delay,
                                  fhd_delays >= min_delay)
    fhd_vis_rms_lag = OPS.rms(fhd_vis_lag_noisy[:, :, 0],
                              mask=NP.logical_not(thermal_noise_window),
                              axis=1)
    fhd_vis_rms_freq = NP.abs(fhd_vis_rms_lag) / NP.sqrt(
        nchan) / freq_resolution
    PDB.set_trace()
    print fhd_vis_rms_freq

    if max_abs_delay is not None:
        small_delays_ind = NP.abs(fhd_delays) <= max_abs_delay * 1e-6
        fhd_delays = fhd_delays[small_delays_ind]
        fhd_vis_lag_noisy = fhd_vis_lag_noisy[:, small_delays_ind, :]

    # fig = PLT.figure(figsize=(6,8))

    # ax = fig.add_subplot(111)
    # ax.set_xlabel('Baseline Index', fontsize=18)