Ejemplo n.º 1
0
def beam_convolve(input_array, z, fov_mpc, beam_w = None, max_baseline = None, \
    beamshape='gaussian'):
    ''' 
	Convolve input_array with a beam of the specified form.
	The beam can be specified either by a width in arcminutes,
	or as a maximum baseline. You must specify exctly one of these
	parameters.
	
	Parameters:
		* input_array (numpy array): the array to be convolved
		* z (float): the redshift of the map
		* fov_mpc (float): the field of view in cMpc
		* beam_w (float) = None: the width of the beam in arcminutes
		* max_baseline (float): the maximum baseline in meters 
			(can be specified instead of beam_w)
		* beamshape (string): The shape of the beam 
			(only 'gaussian' supported at this time)
	
	Returns:
		The convolved array (a numpy array with the same dimensions
		as input_array).
	'''

    if (not beam_w) and (not max_baseline):
        raise Exception(
            'Please specify either a beam width or a maximum baseline')
    elif not beam_w:  #Calculate beam width from max baseline
        beam_w = get_beam_w(max_baseline, z)

    angle = angular_size(fov_mpc * 1000. / (1.0 + z), z) / 60.
    mx = input_array.shape[0]

    print_msg('Field of view is %.2f arcminutes' % (angle))
    print_msg('Convolving with %s beam of size %.2f arcminutes...' % \
       (beamshape, beam_w) )

    #Convolve with beam
    if beamshape == 'gaussian':
        sigma0 = (beam_w) / angle / (2.0 * np.sqrt(2.0 * np.log(2.))) * mx
        kernel = gauss_kernel(sigma=sigma0, size=mx)
    else:
        raise Exception('Unknown beamshape: %g' % beamshape)

    #out =  signal.fftconvolve(input_array, kernel)
    out = fftconvolve(input_array, kernel)

    #fftconvolve makes the output twice the size, so return only the central part
    ox = out.shape[0]
    return out[ox * 0.25:ox * 0.75, ox * 0.25:ox * 0.75]
Ejemplo n.º 2
0
def beam_convolve(input_array, z, fov_mpc, beam_w = None, max_baseline = None, \
				beamshape='gaussian'):
	''' 
	Convolve input_array with a beam of the specified form.
	The beam can be specified either by a width in arcminutes,
	or as a maximum baseline. You must specify exctly one of these
	parameters.
	
	Parameters:
		* input_array (numpy array): the array to be convolved
		* z (float): the redshift of the map
		* fov_mpc (float): the field of view in cMpc
		* beam_w (float) = None: the width of the beam in arcminutes
		* max_baseline (float): the maximum baseline in meters 
			(can be specified instead of beam_w)
		* beamshape (string): The shape of the beam 
			(only 'gaussian' supported at this time)
	
	Returns:
		The convolved array (a numpy array with the same dimensions
		as input_array).
	'''

	if (not beam_w) and (not max_baseline):
		raise Exception('Please specify either a beam width or a maximum baseline')
	elif not beam_w: #Calculate beam width from max baseline
		beam_w = get_beam_w(max_baseline, z)

	angle = angular_size(fov_mpc*1000./(1.0 + z), z)/60.
	mx = input_array.shape[0]

	print_msg('Field of view is %.2f arcminutes' % (angle) )
	print_msg('Convolving with %s beam of size %.2f arcminutes...' % \
				(beamshape, beam_w) )

	#Convolve with beam
	if beamshape == 'gaussian':
		sigma0 = (beam_w)/angle/(2.0 * np.sqrt(2.0*np.log(2.)))*mx
		kernel = gauss_kernel(sigma=sigma0, size=mx)
	else:
		raise Exception('Unknown beamshape: %g' % beamshape)

	#out =  signal.fftconvolve(input_array, kernel)
	out =  fftconvolve(input_array, kernel)

	#fftconvolve makes the output twice the size, so return only the central part	
	ox = out.shape[0]
	return out[ox*0.25:ox*0.75, ox*0.25:ox*0.75]
Ejemplo n.º 3
0
def smooth_with_kernel(input_array, kernel):
    ''' 
	Smooth the input array with an arbitrary kernel.
	
	Parameters:
		* input_array (numpy array): the array to smooth
		* kernel (numpy array): the smoothing kernel. Must
			be the same size as the input array

	Returns:
		The smoothed array. A numpy array with the same
		dimensions as the input.
	'''
    assert len(input_array.shape) == len(kernel.shape)

    out = fftconvolve(input_array, kernel)

    return out
Ejemplo n.º 4
0
def smooth_with_kernel(input_array, kernel):
	''' 
	Smooth the input array with an arbitrary kernel.
	
	Parameters:
		* input_array (numpy array): the array to smooth
		* kernel (numpy array): the smoothing kernel. Must
			be the same size as the input array

	Returns:
		The smoothed array. A numpy array with the same
		dimensions as the input.
	'''
	assert len(input_array.shape) == len(kernel.shape)
	
	out = fftconvolve(input_array, kernel)
	
	return out
Ejemplo n.º 5
0
def bin_lightcone_in_frequency(lightcone, z_low, box_size_mpc, dnu):
    '''
    Bin a lightcone in frequency bins.
    
    Parameters:
        * lightcone (numpy array): the lightcone in length units
        * z_low (float): the lowest redshift of the lightcone
        * box_size_mpc (float): the side of the lightcone in Mpc
        * dnu (float): the width of the frequency bins in MHz
        
    Returns:
        The lightcone, binned in frequencies with high frequencies first
        The frequencies along the line of sight in MHz
    '''
    #Figure out dimensions and make output volume
    cell_size = box_size_mpc/lightcone.shape[0]
    distances = cm.z_to_cdist(z_low) + np.arange(lightcone.shape[2])*cell_size
    input_redshifts = cm.cdist_to_z(distances)
    input_frequencies = cm.z_to_nu(input_redshifts)
    nu1 = input_frequencies[0]
    nu2 = input_frequencies[-1]
    output_frequencies = np.arange(nu1, nu2, -dnu)
    output_lightcone = np.zeros((lightcone.shape[0], lightcone.shape[1], \
                                 len(output_frequencies)))
    
    #Bin in frequencies by smoothing and indexing
    max_cell_size = cm.nu_to_cdist(output_frequencies[-1])-cm.nu_to_cdist(output_frequencies[-2])
    smooth_scale = np.round(max_cell_size/cell_size)
    if smooth_scale < 1:
        smooth_scale = 1

    hf.print_msg('Smooth along LoS with scale %f' % smooth_scale)
    tophat3d = np.ones((1,1,smooth_scale))
    tophat3d /= np.sum(tophat3d)
    lightcone_smoothed = fftconvolve(lightcone, tophat3d)
    
    for i in range(output_lightcone.shape[2]):
        nu = output_frequencies[i]
        idx = hf.find_idx(input_frequencies, nu)
        output_lightcone[:,:,i] = lightcone_smoothed[:,:,idx]

    return output_lightcone, output_frequencies
Ejemplo n.º 6
0
def bin_lightcone_in_mpc(lightcone, frequencies, cell_size_mpc):
    '''
    Bin a lightcone in Mpc slices along the LoS
    '''
    distances = cm.nu_to_cdist(frequencies)
    n_output_cells = (distances[-1]-distances[0])/cell_size_mpc
    output_distances = np.arange(distances[0], distances[-1], cell_size_mpc)
    output_lightcone = np.zeros((lightcone.shape[0], lightcone.shape[1], n_output_cells))
    
    #Bin in Mpc by smoothing and indexing
    smooth_scale = np.round(len(frequencies)/n_output_cells)

    tophat3d = np.ones((1,1,smooth_scale))
    tophat3d /= np.sum(tophat3d)
    lightcone_smoothed = fftconvolve(lightcone, tophat3d, mode='same')
    
    for i in range(output_lightcone.shape[2]):
        idx = hf.find_idx(distances, output_distances[i])
        output_lightcone[:,:,i] = lightcone_smoothed[:,:,idx]
    
    output_redshifts = cm.cdist_to_z(output_distances)
        
    return output_lightcone, output_redshifts