def get_beam_power_over_time(beam_meta_data, names_ra_dec, dt=296, centeronly=True, verbose=False, option='analytic', degrees=False, start_time=0): """ Calulates the power (gain at coordinate/gain at zenith) for each source over time. get_beam_power_over_time(beam_meta_data, names_ra_dec, dt=296, centeronly=True, verbose=False, option = 'analytic') Args: beam_meta_data: [obsid,ra, dec, time, delays,centrefreq, channels] obsid metadata obtained from meta.get_common_obs_metadata names_ra_dec: and array in the format [[source_name, RAJ, DecJ]] dt: time step in seconds for power calculations (default 296) centeronly: only calculates for the centre frequency (default True) verbose: prints extra data to (default False) option: primary beam model [analytic, advanced, full_EE] start_time: the time in seconds from the begining of the observation to start calculating at """ obsid, _, _, time, delays, centrefreq, channels = beam_meta_data names_ra_dec = np.array(names_ra_dec) logger.info("Calculating beam power for OBS ID: {0}".format(obsid)) starttimes = np.arange(start_time, time + start_time, dt) stoptimes = starttimes + dt stoptimes[stoptimes > time] = time Ntimes = len(starttimes) midtimes = float(obsid) + 0.5 * (starttimes + stoptimes) if not centeronly: PowersX = np.zeros((len(names_ra_dec), Ntimes, len(channels))) PowersY = np.zeros((len(names_ra_dec), Ntimes, len(channels))) # in Hz frequencies = np.array(channels) * 1.28e6 else: PowersX = np.zeros((len(names_ra_dec), Ntimes, 1)) PowersY = np.zeros((len(names_ra_dec), Ntimes, 1)) if centrefreq > 1e6: logger.warning( "centrefreq is greater than 1e6, assuming input with units of Hz." ) frequencies = np.array([centrefreq]) else: frequencies = np.array([centrefreq]) * 1e6 if degrees: RAs = np.array(names_ra_dec[:, 1], dtype=float) Decs = np.array(names_ra_dec[:, 2], dtype=float) else: RAs, Decs = sex2deg(names_ra_dec[:, 1], names_ra_dec[:, 2]) if len(RAs) == 0: sys.stderr.write('Must supply >=1 source positions\n') return None if not len(RAs) == len(Decs): sys.stderr.write('Must supply equal numbers of RAs and Decs\n') return None if verbose is False: #Supress print statements of the primary beam model functions sys.stdout = open(os.devnull, 'w') for itime in range(Ntimes): # this differ's from the previous ephem_utils method by 0.1 degrees _, Azs, Zas = mwa_alt_az_za(midtimes[itime], ra=RAs, dec=Decs, degrees=True) # go from altitude to zenith angle theta = np.radians(Zas) phi = np.radians(Azs) for ifreq in range(len(frequencies)): #Decide on beam model if option == 'analytic': rX, rY = primary_beam.MWA_Tile_analytic( theta, phi, freq=frequencies[ifreq], delays=delays, zenithnorm=True, power=True) elif option == 'advanced': rX, rY = primary_beam.MWA_Tile_advanced( theta, phi, freq=frequencies[ifreq], delays=delays, zenithnorm=True, power=True) elif option == 'full_EE': rX, rY = primary_beam.MWA_Tile_full_EE(theta, phi, freq=frequencies[ifreq], delays=delays, zenithnorm=True, power=True) PowersX[:, itime, ifreq] = rX PowersY[:, itime, ifreq] = rY if verbose is False: sys.stdout = sys.__stdout__ Powers = 0.5 * (PowersX + PowersY) return Powers
def calc_jones(az, za, target_freq_Hz=205e6): za_rad = za * math.pi / 180.0 az_rad = az * math.pi / 180.0 za_rad = np.array([[za_rad]]) az_rad = np.array([[az_rad]]) gridpoint = mwa_sweet_spots.find_closest_gridpoint(az, za) print("Az = %.2f [deg], za = %.2f [deg], gridpoint = %d" % (az, za, gridpoint[0])) delays = gridpoint[4] delays = np.vstack((delays, delays)) print(delays) print("-----------") Jones_FullEE = primary_beam.MWA_Tile_full_EE(za_rad, az_rad, target_freq_Hz, delays=delays, zenithnorm=True, jones=True, interp=True) # swap axis to have Jones martix in the 1st Jones_FullEE_swap = np.swapaxes(np.swapaxes(Jones_FullEE, 0, 2), 1, 3) # TEST if equivalent to : Jones_FullEE_2D = Jones_FullEE_swap[:, :, 0, 0] # Jones_FullEE_2D = np.array([ [Jones_FullEE_swap[0, 0][0][0], Jones_FullEE_swap[0, 1][0][0]] , [Jones_FullEE_swap[1, 0][0][0], Jones_FullEE_swap[1, 1][0][0]] ]) print("Jones FullEE:") print("----------------------") print(Jones_FullEE) print("----------------------") print(Jones_FullEE_2D) print("----------------------") beams = {} beams['XX'], beams['YY'] = primary_beam.MWA_Tile_full_EE(za_rad, az_rad, target_freq_Hz, delays=delays, zenithnorm=True, power=True) print("Beams power = %.4f / %.4f" % (beams['XX'], beams['YY'])) # Average Embeded Element model: print("size(delays) = %d" % np.size(delays)) Jones_AEE = primary_beam.MWA_Tile_advanced(za_rad, az_rad, target_freq_Hz, delays=delays, jones=True) # Jones_AEE = primary_beam.MWA_Tile_advanced(np.array([[0]]), np.array([[0]]), target_freq_Hz,delays=delays, zenithnorm=True, jones=True) Jones_AEE_swap = np.swapaxes(np.swapaxes(Jones_AEE, 0, 2), 1, 3) Jones_AEE_2D = Jones_AEE_swap[:, :, 0, 0] # Jones_AEE_2D = np.array([ [Jones_AEE_swap[0, 0][0][0], Jones_AEE_swap[0, 1][0][0]], [Jones_AEE_swap[1, 0][0][0], Jones_AEE_swap[1, 1][0][0]] ]) print("----------------------") print("Jones AEE:") print("----------------------") print(Jones_AEE) print("----------------------") print(Jones_AEE_2D) print("----------------------") Jones_Anal = primary_beam.MWA_Tile_analytic(za_rad, az_rad, target_freq_Hz, delays=delays, zenithnorm=True, jones=True) Jones_Anal_swap = np.swapaxes(np.swapaxes(Jones_Anal, 0, 2), 1, 3) Jones_Anal_2D = Jones_Anal_swap[:, :, 0, 0] print("---------------------- COMPARISON OF JONES MATRICES FEE vs. AEE ----------------------") print("Jones FullEE:") print("----------------------") print(Jones_FullEE_2D) print("----------------------") print() print("Jones AEE:") print("----------------------") print(Jones_AEE_2D) print("----------------------") print() print("----------------------") print("Jones Analytic:") print("----------------------") print(Jones_Anal_2D) print("----------------------") return (Jones_FullEE_2D, Jones_AEE_2D, Jones_Anal_2D)
def calc_ratio(dec, target_freq_Hz, gridpoint): za = dec + 26.7 az = 0 print("\n\n\n\n") print("################################# DEC = %.2f #################################" % dec) za_rad = za * math.pi / 180.0 az_rad = az * math.pi / 180.0 za_rad = np.array([[za_rad]]) az_rad = np.array([[az_rad]]) # non-realistic scenario - I am ~tracking the source with the closest sweetspot - whereas I should be staying at the same sweetspot # gridpoint=find_closest_gridpoint(za) # print("dec=%.4f [deg] -> za=%.4f [deg] - %s" % (dec, za, gridpoint)) delays = gridpoint[4] delays = np.vstack((delays, delays)) print(delays) print("-----------") Jones_FullEE = primary_beam.MWA_Tile_full_EE(za_rad, az_rad, target_freq_Hz, delays=delays, zenithnorm=True, jones=True, interp=True) # swap axis to have Jones martix in the 1st Jones_FullEE_swap = np.swapaxes(np.swapaxes(Jones_FullEE, 0, 2), 1, 3) # TEST if equivalent to : Jones_FullEE_2D = Jones_FullEE_swap[:, :, 0, 0] # Jones_FullEE_2D = np.array([ [Jones_FullEE_swap[0, 0][0][0], Jones_FullEE_swap[0, 1][0][0]], [Jones_FullEE_swap[1, 0][0][0], Jones_FullEE_swap[1, 1][0][0]] ]) print("Jones FullEE:") print("----------------------") print(Jones_FullEE) print("----------------------") print(Jones_FullEE_2D) print("----------------------") # Average Embeded Element model: print("size(delays) = %d" % np.size(delays)) Jones_AEE = primary_beam.MWA_Tile_advanced(za_rad, az_rad, target_freq_Hz, delays=delays, jones=True) # Jones_AEE = primary_beam.MWA_Tile_advanced(np.array([[0]]), np.array([[0]]), target_freq_Hz, delays=delays, zenithnorm=True, jones=True) Jones_AEE_swap = np.swapaxes(np.swapaxes(Jones_AEE, 0, 2), 1, 3) Jones_AEE_2D = Jones_AEE_swap[:, :, 0, 0] # Jones_AEE_2D = np.array([ [Jones_AEE_swap[0, 0][0][0], Jones_AEE_swap[0, 1][0][0]], [Jones_AEE_swap[1, 0][0][0], Jones_AEE_swap[1, 1][0][0]] ]) print("----------------------") print("Jones AEE:") print("----------------------") print(Jones_AEE) print("----------------------") print(Jones_AEE_2D) print("----------------------") # Analytical Model: # beams = {} # beams['XX'], beams['YY'] = primary_beam.MWA_Tile_analytic(za_rad, az_rad, target_freq_Hz, delays=delays, zenithnorm=True, jones=True) Jones_Anal = primary_beam.MWA_Tile_analytic(za_rad, az_rad, target_freq_Hz, delays=delays, zenithnorm=True, jones=True) Jones_Anal_swap = np.swapaxes(np.swapaxes(Jones_Anal, 0, 2), 1, 3) Jones_Anal_2D = Jones_Anal_swap[:, :, 0, 0] # Jones_Anal_2D = np.array([ [Jones_Anal_swap[0, 0][0][0], Jones_Anal_swap[0, 1][0][0]] , [Jones_Anal_swap[1, 0][0][0],Jones_Anal_swap[1, 1][0][0]] ]) print("----------------------") print("Jones Analytic:") print("----------------------") print(Jones_Anal) print("----------------------") print(Jones_Anal_2D) print("----------------------") print("TEST:") print("----------------------") print("%.8f %.8f" % (Jones_Anal_2D[0, 0], Jones_Anal_2D[0, 1])) print("%.8f %.8f" % (Jones_Anal_2D[1, 0], Jones_Anal_2D[1, 1])) print("----------------------") # Use Jones_FullEE_2D as REAL sky and then ... B_sky = np.array([[1, 0], [0, 1]]) Jones_FullEE_2D_H = np.transpose(Jones_FullEE_2D.conj()) B_app = np.dot(Jones_FullEE_2D, np.dot(B_sky, Jones_FullEE_2D_H)) # E x B x E^H # test the procedure itself: Jones_FullEE_2D_H_Inv = inv2x2(Jones_FullEE_2D_H) Jones_FullEE_2D_Inv = inv2x2(Jones_FullEE_2D) B_sky_cal = np.dot(Jones_FullEE_2D_Inv, np.dot(B_app, Jones_FullEE_2D_H_Inv)) print(B_sky) print("Recovered using FullEE model:") print(B_sky_cal) # calibrate back using AEE model : # Jones_AEE_2D=Jones_Anal_2D # overwrite Jones_AEE_2D with Analytic to use it for calibration Jones_AEE_2D_H = np.transpose(Jones_AEE_2D.conj()) Jones_AEE_2D_H_Inv = inv2x2(Jones_AEE_2D_H) Jones_AEE_2D_Inv = inv2x2(Jones_AEE_2D) B_sky_cal = np.dot(Jones_AEE_2D_Inv, np.dot(B_app, Jones_AEE_2D_H_Inv)) print("Recovered using AEE model:") print(B_sky_cal) # I_cal = B_sky_cal[0, 0] + B_sky_cal[1, 1] # print "FINAL : %.8f ratio = %.8f / 2 = %.8f" % (dec,abs(I_cal),(abs(I_cal)/2.00)) # ratio = abs(B_sky_cal[0][0] / B_sky_cal[1][1]) # FINAL VALUES for the paper to compare with Figure 4 in GLEAM paper : ratio_ms = B_sky_cal[0][0] / B_sky_cal[1][1] gleam_ratio = ratio_ms gleam_XX = B_sky_cal[0][0] gleam_YY = B_sky_cal[1][1] # gleam_q_leakage = (B_sky_cal[0][0] - B_sky_cal[1][1]) / (B_sky_cal[0][0] + B_sky_cal[1][1]) print("DEBUG (DEC = %.2f deg) : GLEAM-ratio = %.4f = (%s / %s)" % (dec, gleam_ratio, gleam_XX, gleam_YY)) return (gleam_ratio.real, gleam_XX, gleam_YY)
az, target_freq_Hz, delays=delays, zenithnorm=options.zenithnorm, jones=True, interp=True) if options.wsclean_image: sign_uv = -1 elif model == 'avg_EE' or model == 'advanced' or model == '2015' or model == 'AEE': logger.info("Correcting with AEE(%s) model at frequency %.2f Hz" % (model, target_freq_Hz)) # logging.getLogger("mwa_tile").setLevel(logging.DEBUG) Jones = primary_beam.MWA_Tile_advanced(za, az, target_freq_Hz, delays=delays, zenithnorm=options.zenithnorm, jones=True) if options.wsclean_image: sign_uv = -1 elif model == 'analytic' or model == '2014': logger.info("Correcting with analytic model") Jones = primary_beam.MWA_Tile_analytic(za, az, target_freq_Hz, delays=delays, zenithnorm=options.zenithnorm, jones=True) if options.wsclean_image: sign_q = -1 else:
def createArrayFactor(za, az, pixel_area, data): """ Primary function to calculate the array factor with the given information. Input: delays - the beamformer delays required for point tile beam (should be a set of 16 numbers) time - the time at which to evaluate the target position (as we need Azimuth and Zenith angle, which are time dependent) obsfreq - the centre observing frequency for the observation eff - the array efficiency (frequency and pointing dependent, currently require engineers to calculate for us...) flagged_tiles - the flagged tiles from the calibration solution (in the RTS format) xpos - x position of the tiles ypos - y position of the tiles zpos - z position of the tiles theta_res - the zenith angle resolution in degrees phi_res - the azimuth resolution in degrees za_chunk - list of ZA to compute array factor for write - whether to actually write a file to disk rank - mpi rank (thread index) Return: results - a list of lists cotaining [ZA, Az, beam power], for all ZA and Az in the given band """ obsid = data['obsid'] ra = data['ra'] dec = data['dec'] times = data['time'] delays = data['delays'] xpos = data['x'] ypos = data['y'] zpos = data['z'] cable_delays = data['cd'] theta_res = data['tres'] phi_res = data['pres'] beam_model = data['beam'] coplanar = data['coplanar'] ord_version = data['ord_version'] no_delays = data['no_delays'] plot_jobid = data['plot_jobid'] # work out core depent part of data to process nfreq = len(data['freqs']) ifreq = rank % nfreq ichunk = rank // nfreq obsfreq = data['freqs'][ifreq] logger.info( "rank {:3d} Calculating phase of each sky position for each tile".format(rank)) # calculate the relevent wavenumber for (theta,phi) #logger.info( "rank {:3d} Calculating wavenumbers".format(rank)) if ord_version: #gx, gy, gz = calc_geometric_delay_distance((np.pi / 2) - az, za) gx, gy, gz = calc_geometric_delay_distance(az, za) logger.debug("rank {:3d} Wavenumbers shapes: {} {} {}".format(rank, gx.shape, gy.shape, gz.shape)) # phase of each sky position for each tile ph_tile = cal_phase_ord(xpos, ypos, zpos, cable_delays, gx, gy, gz, obsfreq, coplanar=coplanar, no_delays=no_delays) gx = gy = gz = None # Dereference for garbage collection else: kx, ky, kz = calcWaveNumbers(obsfreq, (np.pi / 2) - az, za) #logger.debug("kx[0] {} ky[0] {} kz[0] {}".format(kx[0], ky[0], kz[0])) logger.debug("rank {:3d} Wavenumbers shapes: {} {} {}".format(rank, kx.shape, ky.shape, kz.shape)) # phase of each sky position for each tile ph_tile = calcSkyPhase(xpos, ypos, zpos, kx, ky, kz, coplanar=coplanar) kx = ky = kz = None # Dereference for garbage collection requests.get('https://ws.mwatelescope.org/progress/update', params={'jobid':plot_jobid, 'workid':rank, 'current':2, 'total':5, 'desc':'Tile beam'}) # calculate the tile beam at the given Az,ZA pixel logger.info( "rank {:3d} Calculating tile beam".format(rank)) if beam_model == 'hyperbeam': # This method is no longer needed as mwa_pb uses hyperbeam jones = beam.calc_jones_array(az, za, obsfreq, delays, [1.0] * 16, True) jones = jones.reshape(za.shape[0], 1, 2, 2) vis = pb.mwa_tile.makeUnpolInstrumentalResponse(jones, jones) jones = None # Dereference for garbage collection tile_xpol, tile_ypol = (vis[:, :, 0, 0].real, vis[:, :, 1, 1].real) vis = None # Dereference for garbage collection elif beam_model == 'analytic': tile_xpol, tile_ypol = pb.MWA_Tile_analytic(za, az, freq=obsfreq, delays=[delays, delays], zenithnorm=True, power=True) elif beam_model == 'advanced': tile_xpol, tile_ypol = pb.MWA_Tile_advanced(za, az, freq=obsfreq, delays=[delays, delays], zenithnorm=True, power=True) elif beam_model == 'full_EE': tile_xpol, tile_ypol = pb.MWA_Tile_full_EE(za, az, freq=obsfreq, delays=np.array([delays, delays]), zenithnorm=True, power=True, interp=False) #logger.info("rank {:3d} Combining tile pattern".format(rank)) tile_pattern = np.divide(np.add(tile_xpol, tile_ypol), 2.0) tile_pattern = tile_pattern.flatten() logger.debug("max(tile_pattern) {}".format(max(tile_pattern))) omega_A_times = [] sum_B_T_times = [] sum_B_times = [] phased_array_pattern_times = [] for ti, time in enumerate(times): requests.get('https://ws.mwatelescope.org/progress/update', params={'jobid':plot_jobid, 'workid':rank, 'current':3+ti, 'total' :3+len(times), 'desc':'{}/{} array factor'.format(1+ti, len(times))}) # get the target azimuth and zenith angle in radians and degrees # these are defined in the normal sense: za = 90 - elevation, az = angle east of North (i.e. E=90) logger.info( "rank {:3d} Calculating phase of each sky position for the target at time {}".format(rank, time)) srcAz, srcZA, _, _ = getTargetAZZA(ra, dec, time)# calculate the target (kx,ky,kz) if ord_version: #t_gx, t_gy, t_gz = calc_geometric_delay_distance((np.pi / 2) - srcAz, srcZA) t_gx, t_gy, t_gz = calc_geometric_delay_distance(srcAz, srcZA) # phase of each sky position for each tile ph_target = cal_phase_ord(xpos, ypos, zpos, cable_delays, t_gx, t_gy, t_gz, obsfreq, coplanar=coplanar, no_delays=no_delays) else: target_kx, target_ky, target_kz = calcWaveNumbers(obsfreq, (np.pi / 2) - srcAz, srcZA) # Get phase of target for each tile phase of each sky position for each tile ph_target = calcSkyPhase(xpos, ypos, zpos, target_kx, target_ky, target_kz) # determine the interference pattern seen for each tile logger.info( "rank {:3d} Calculating array_factor".format(rank)) #logger.debug("rank {:3d} ti: {} ph_tile {}".format(rank, ti, ph_tile)) #logger.debug("rank {:3d} ti: {} ph_target {}".format(rank, ti, ph_target)) array_factor, array_factor_power = calcArrayFactor(ph_tile, ph_target) ph_target = None # Dereference for garbage collection #logger.debug("array_factor_power[0] {}".format(array_factor_power[0])) logger.debug("rank {:3d} array_factor[0] {}".format(rank, array_factor[0])) logger.debug("rank {:3d} array_factor shapes: {}".format(rank, array_factor.shape)) logger.debug("rank {:3d} array factor maximum = {}".format(rank, np.amax(array_factor_power))) # calculate the phased array power pattern logger.info( "rank {:3d} Calculating phased array pattern".format(rank)) logger.debug("rank {:3d} tile_pattern.shape {} array_factor_power.shape {}".format(rank, tile_pattern.shape, array_factor_power.shape)) phased_array_pattern = np.multiply(tile_pattern, array_factor_power) #phased_array_pattern = tile_pattern[0][0] * np.abs(array_factor)**2 # indexing due to tile_pattern now being a 2-D array phased_array_pattern_times.append(phased_array_pattern) # add this contribution to the beam solid angle logger.info( "rank {:3d} Calculating omega_A".format(rank)) #omega_A_array = np.sin(za) * array_factor_power * np.radians(theta_res) * np.radians(phi_res) #omega_A_array = np.multiply(np.multiply(np.multiply(np.sin(za), array_factor_power), np.radians(theta_res)), np.radians(phi_res)) omega_A_array = np.multiply(array_factor_power, pixel_area) logger.debug("rank {:3d} omega_A_array shapes: {}".format(rank, omega_A_array.shape)) omega_A = np.sum(omega_A_array) logger.debug("rank {:3d} freq {:.2f}MHz beam_area: {}".format(rank, obsfreq/1e6, omega_A)) omega_A_times.append(omega_A) #logger.debug("omega_A[1] vals: za[1] {}, array_factor_power[1] {}, theta_res {}, phi_res {}".format(za[1], array_factor_power[1], theta_res, phi_res)) #logger.debug("omega_A[1] {}".format(omega_A_array[1])) # Do a partial sum over the sky and frequency to be finished outside of the function sum_B_T, sum_B = partial_convolve_sky_map(az, za, pixel_area, phased_array_pattern, obsfreq, time) sum_B_T_times.append(sum_B_T) sum_B_times.append(sum_B) ph_tile = None # Dereference for garbage collection # Average over time #omega_A = np.average(omega_A_times) #sum_B_T = np.average(sum_B_T_times) #sum_B = np.average(sum_B_times) #phased_array_pattern = np.average(phased_array_pattern_times, axis=0) logger.debug("rank {:3d} phased_array_pattern: {}".format(rank, phased_array_pattern)) logger.debug("rank {:3d} omega_A_times: {}".format(rank, omega_A_times)) logger.info("rank {:3d} done".format(rank)) # return lists of results for each time step return np.array(omega_A_times), np.array(sum_B_T_times), np.array(sum_B_times), np.array(phased_array_pattern_times)
def get_beam_power_over_time(names_ra_dec, common_metadata=None, dt=296, centeronly=True, verbose=False, option='analytic', degrees=False, start_time=0): """Calculates the zenith normalised power for each source over time. Parameters ---------- names_ra_dec : `list` An array in the format [[source_name, RAJ, DecJ]] common_metadata : `list`, optional The list of common metadata generated from :py:meth:`vcstools.metadb_utils.get_common_obs_metadata` dt : `int`, optional The time interval of how often powers are calculated. |br| Default: 296. centeronly : `boolean`, optional Only calculates for the centre frequency. |br| Default: `True`. verbose : `boolean`, optional If `True` will not supress the output from mwa_pb. |br| Default: `False`. option : `str`, optional The primary beam model to use out of [analytic, advanced, full_EE, hyperbeam]. |br| Default: analytic. degrees : `boolean`, optional If true assumes RAJ and DecJ are in degrees. |br| Default: `False`. start_time : `int`, optional The time in seconds from the begining of the observation to start calculating at. |br| Default: 0. Returns ------- Powers : `numpy.array`, (len(names_ra_dec), ntimes, nfreqs) The zenith normalised power for each source over time. """ if common_metadata is None: common_metadata = get_common_obs_metadata(obsid) obsid, _, _, time, delays, centrefreq, channels = common_metadata names_ra_dec = np.array(names_ra_dec) amps = [1.0] * 16 logger.debug("Calculating beam power for OBS ID: {0}".format(obsid)) if option == 'hyperbeam': if "mwa_hyperbeam" not in sys.modules: logger.error( "mwa_hyperbeam not installed so can not use hyperbeam to create a beam model. Exiting" ) sys.exit(1) beam = mwa_hyperbeam.FEEBeam(config.h5file) # Work out time steps to calculate over starttimes = np.arange(start_time, time + start_time, dt) stoptimes = starttimes + dt stoptimes[stoptimes > time] = time ntimes = len(starttimes) midtimes = float(obsid) + 0.5 * (starttimes + stoptimes) # Work out frequency steps if centeronly: if centrefreq > 1e6: logger.warning( "centrefreq is greater than 1e6, assuming input with units of Hz." ) frequencies = np.array([centrefreq]) else: frequencies = np.array([centrefreq]) * 1e6 nfreqs = 1 else: # in Hz frequencies = np.array(channels) * 1.28e6 nfreqs = len(channels) # Set up np power array PowersX = np.zeros((len(names_ra_dec), ntimes, nfreqs)) PowersY = np.zeros((len(names_ra_dec), ntimes, nfreqs)) # Convert RA and Dec to desired units if degrees: RAs = np.array(names_ra_dec[:, 1], dtype=float) Decs = np.array(names_ra_dec[:, 2], dtype=float) else: RAs, Decs = sex2deg(names_ra_dec[:, 1], names_ra_dec[:, 2]) # Then check if they're valid if len(RAs) == 0: sys.stderr.write('Must supply >=1 source positions\n') return None if not len(RAs) == len(Decs): sys.stderr.write('Must supply equal numbers of RAs and Decs\n') return None if verbose is False: #Supress print statements of the primary beam model functions sys.stdout = open(os.devnull, 'w') for itime in range(ntimes): # this differ's from the previous ephem_utils method by 0.1 degrees _, Azs, Zas = mwa_alt_az_za(midtimes[itime], ra=RAs, dec=Decs, degrees=True) # go from altitude to zenith angle theta = np.radians(Zas) phi = np.radians(Azs) for ifreq in range(nfreqs): #Decide on beam model if option == 'analytic': rX, rY = primary_beam.MWA_Tile_analytic( theta, phi, freq=frequencies[ifreq], delays=delays, zenithnorm=True, power=True) elif option == 'advanced': rX, rY = primary_beam.MWA_Tile_advanced( theta, phi, freq=frequencies[ifreq], delays=delays, zenithnorm=True, power=True) elif option == 'full_EE': rX, rY = primary_beam.MWA_Tile_full_EE(theta, phi, freq=frequencies[ifreq], delays=delays, zenithnorm=True, power=True) elif option == 'hyperbeam': jones = beam.calc_jones_array(phi, theta, int(frequencies[ifreq]), delays[0], amps, True) jones = jones.reshape(1, len(phi), 2, 2) vis = primary_beam.mwa_tile.makeUnpolInstrumentalResponse( jones, jones) rX, rY = (vis[:, :, 0, 0].real, vis[:, :, 1, 1].real) PowersX[:, itime, ifreq] = rX PowersY[:, itime, ifreq] = rY if verbose is False: sys.stdout = sys.__stdout__ Powers = 0.5 * (PowersX + PowersY) return Powers