def find_t_sys_gain(pulsar, obsid, beg=None, t_int=None, p_ra=None, p_dec=None,\ obs_metadata=None, query=None, trcvr="/group/mwaops/PULSAR/MWA_Trcvr_tile_56.csv"): """ Finds the system temperature and gain for an observation. A function snippet originally written by Nick Swainston - adapted for general VCS use. Parameters: ----------- pulsar: str the J name of the pulsar. e.g. J2241-5236 obsid: int The observation ID. e.g. 1226406800 beg: int The beginning of the observing time t_int: float The total time that the target is in the beam p_ra: str OPTIONAL - the target's right ascension p_dec: str OPTIONAL - the target's declination obs_metadata: list OPTIONAL - the array generated from mwa_metadb_utils.get_common_obs_metadata(obsid) query: object OPTIONAL - The return of the psrqpy function for this pulsar trcvr: str The location of the MWA receiver temp csv file. Default = '/group/mwaops/PULSAR/MWA_Trcvr_tile_56.csv' Returns: -------- t_sys: float The system temperature t_sys_err: float The system temperature's uncertainty gain: float The system gain gain_err: float The gain's uncertainty """ #get ra and dec if not supplied if p_ra is None or p_dec is None and query is None: logger.debug("Obtaining pulsar RA and Dec from ATNF") query = psrqpy.QueryATNF(psrs=[pulsar], loadfromdb=ATNF_LOC).pandas p_ra = query["RAJ"][0] p_dec = query["DECJ"][0] elif query is not None: query = psrqpy.QueryATNF(psrs=[pulsar], loadfromdb=ATNF_LOC).pandas p_ra = query["RAJ"][0] p_dec = query["DECJ"][0] #get metadata if not supplied if obs_metadata is None: logger.debug("Obtaining obs metadata") obs_metadata = mwa_metadb_utils.get_common_obs_metadata(obsid) obsid, obs_ra, obs_dec, _, delays, centrefreq, channels = obs_metadata #get beg if not supplied if beg is None or t_int is None: logger.debug("Calculating beginning time for pulsar coverage") beg, _, t_int = find_times(obsid, pulsar, beg=beg) #Find 'start_time' for fpio - it's usually about 7 seconds #obs_start, _ = mwa_metadb_utils.obs_max_min(obsid) start_time = beg - int(obsid) #Get important info trec_table = Table.read(trcvr, format="csv") ntiles = 128 #TODO actually we excluded some tiles during beamforming, so we'll need to account for that here beam_power = fpio.get_beam_power_over_time([obsid, obs_ra, obs_dec, t_int, delays,\ centrefreq, channels],\ np.array([[pulsar, p_ra, p_dec]]),\ dt=100, start_time=start_time) beam_power = np.mean(beam_power) # Usa a primary beam function to convolve the sky temperature with the primary beam # (prints suppressed) sys.stdout = open(os.devnull, 'w') _, _, Tsky_XX, _, _, _, Tsky_YY, _ = pbtant.make_primarybeammap( int(obsid), delays, centrefreq * 1e6, 'analytic', plottype='None') sys.stdout = sys.__stdout__ #TODO can be inaccurate for coherent but is too difficult to simulate t_sky = (Tsky_XX + Tsky_YY) / 2. # Get T_sys by adding Trec and Tsky (other temperatures are assumed to be negligible t_sys_table = t_sky + submit_to_database.get_Trec(trec_table, centrefreq) t_sys = np.mean(t_sys_table) t_sys_err = t_sys * 0.02 #TODO: figure out what t_sys error is logger.debug("pul_ra: {} pul_dec: {}".format(p_ra, p_dec)) _, _, zas = mwa_metadb_utils.mwa_alt_az_za(obsid, ra=p_ra, dec=p_dec) theta = np.radians(zas) gain = submit_to_database.from_power_to_gain(beam_power, centrefreq * 1e6, ntiles, coh=True) logger.debug("beam_power: {} theta: {} pi: {}".format( beam_power, theta, np.pi)) gain_err = gain * ((1. - beam_power) * 0.12 + 2. * (theta / (0.5 * np.pi))**2. + 0.1) # Removed the below error catch because couldn't find an obs that breaks it #sometimes gain_err is a numpy array and sometimes it isnt so i have to to this... #try: # gain_err.shape # gain_err = gain_err[0] #except: # pass return t_sys, t_sys_err, gain, gain_err
def main(): usage = "Usage: %prog [options]\n" usage += "\tCreates an image of the 408 MHz sky (annoted with sources) that includes contours for the MWA primary beam\n" usage += "\tThe beam is monochromatic, and is the sum of the XX and YY beams\n" usage += "\tThe date/time (UT) and beamformer delays must be specified\n" usage += "\tBeamformer delays should be separated by commas\n" usage += "\tFrequency is in MHz, or a coarse channel number (can also be comma-separated list)\n" usage += "\tDefault is to plot centered on RA=0, but if -r/--racenter, will center on LST\n" usage += "\tContours will be plotted at %s of the peak\n" % contourlevels usage += "\tExample:\tpython primarybeammap.py -c 98 --beamformer=1,0,0,0,3,3,3,3,6,6,6,6,9,9,9,8 \n\n" parser = OptionParser(usage=usage) parser.add_option('-c', '--channel', dest='channel', default=None, help='Center channel(s) of observation') parser.add_option('-f', '--frequency', dest='frequency', default=None, help='Center frequency(s) of observation [MHz]') parser.add_option('-b', '--beamformer', dest='delays', default="0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0", help='16 beamformer delays separated by commas') parser.add_option('-D', '--date', dest='date', default=None, help='UT Date') parser.add_option('-t', '--time', dest='time', default=None, help='UT Time') parser.add_option('-g', '--gps', dest='gps', default=None, help='GPS time') parser.add_option( '-m', '--model', dest='model', default='analytic', help='beam model: analytic, advanced, full_EE, full_EE_AAVS05') parser.add_option( '-p', '--plottype', dest='plottype', default='beamsky', help='Type of plot: all, beam, sky, beamsky, beamsky_scaled') parser.add_option('--title', dest='title', default=None, help='Plot title') parser.add_option('-e', '--ext', dest='extension', default='png', help='Plot extension [default=%default]') parser.add_option('-r', '--racenter', action="store_true", dest="center", default=False, help="Center on LST?") parser.add_option('-s', '--sunline', dest="sunline", default="1", choices=['0', '1'], help="Plot sun [default=%default]") parser.add_option('--tle', dest='tle', default=None, help='Satellite TLE file') parser.add_option('--duration', dest='duration', default=300, type=int, help='Duration for plotting satellite track') parser.add_option('--size', dest='size', default=1000, type=int, help='Resolution of created beam file') parser.add_option('--dir', dest='dir', default=None, help='output directory') parser.add_option('-v', '--verbose', action="store_true", dest="verbose", default=False, help="Increase verbosity of output") (options, args) = parser.parse_args() if options.dir is not None: mkdir_p(options.dir) if options.frequency is not None: if (',' in options.frequency): try: frequency = list(map(float, options.frequency.split(','))) except ValueError: logger.error("Could not parse frequency %s\n" % options.frequency) sys.exit(1) else: try: frequency = float(options.frequency) except ValueError: logger.error("Could not parse frequency %s\n" % options.frequency) sys.exit(1) else: frequency = options.frequency if options.channel is not None: if (',' in options.channel): try: channel = list(map(float, options.channel.split(','))) except ValueError: logger.error("Could not parse channel %s\n" % options.channel) sys.exit(1) else: try: channel = float(options.channel) except ValueError: logger.error("Could not parse channel %s\n" % options.channel) sys.exit(1) else: channel = options.channel if options.delays is not None: try: if (',' in options.delays): delays = list(map(int, options.delays.split(','))) else: delays = 16 * [int(options.delays)] except ValueError: logger.error("Could not parse beamformer delays %s\n" % options.delays) sys.exit(1) else: delays = options.delays extension = options.extension plottype = options.plottype model = options.model if model not in [ 'analytic', 'advanced', 'full_EE', 'full_EE_AAVS05', '2016', '2015', '2014' ]: logger.error("Model %s not found\n" % model) sys.exit(1) if plottype not in ['all', 'beam', 'sky', 'beamsky', 'beamsky_scaled']: logger.error("Plot type %s not found\n" % plottype) sys.exit(1) gpsstring = options.gps gps = int(gpsstring) if (len(delays) < 16): logger.error("Must supply 1 or 16 delays\n") sys.exit(1) if (frequency is None): if (channel is not None): if (isinstance(channel, list)): frequency = list( 1.28 * numpy.array(channel) ) # multiplication by 1e6 is done later at line Convert to Hz else: frequency = 1.28 * channel # multiplication by 1e6 is done later at line Convert to Hz if frequency is None: logger.error("Must supply frequency or channel\n") sys.exit(1) if (isinstance(frequency, int) or isinstance(frequency, float)): frequency = [frequency] frequency = numpy.array(frequency) * 1e6 # Convert to Hz for freq in frequency: print('frequency', freq) result = make_primarybeammap(gps, delays, freq, model=model, plottype=plottype, extension=extension, resolution=options.size, directory=options.dir) if (result is not None): print("Wrote %s" % result)
#!/usr/bin/env python """ Script for calculating A/T for MWA Script calling function primarybeammap_tant.py to calculate antenna temperature according to MWA beam model (analytic, AEE or FEE) and scaled Haslam map Example usage: python ./mwa_sensitivity.py -b 18,13,8,3,17,12,7,2,16,11,6,1,15,10,5,0 -c 169 -p all -g 0 -m full_EE python ./mwa_sensitivity.py -c 169 -p all -g 0 -m full_EE Starting version by Marcin Sokolowski main task is: make_primarybeammap() This is the script interface to the functions and modules defined in MWA_Tools/src/primarybeamap.py """ import errno import math from optparse import OptionParser import os import sys from astropy.io import fits as pyfits import numpy as np from mwa_pb.primarybeammap_tant import contourlevels, get_beam_power, logger, make_primarybeammap from mwa_pb import mwa_sweet_spots from mwa_pb import metadata
def calculate_sensitivity(freq, delays, gps, trcv_type, T_rcv, size, dirname, model, plottype, extension, pointing_az_deg=0, pointing_za_deg=0, add_sources=False, zenithnorm=True, antnum=128, inttime=120, bandwidth=1280000): freq_mhz = freq / 1e6 print 'frequency=%.2f -> delays=%s' % (freq, delays) # if trcv_type',default='trcv_from_skymodel_with_err if trcv_type != "value": if trcv_type == "trcv_from_skymodel_with_err": T_rcv = trcv_from_skymodel_with_err(freq_mhz) print "T_rcv calculated from trcv_from_skymodel_with_err = %.2f K" % ( T_rcv) result = make_primarybeammap(gps, delays, freq, model=model, plottype=plottype, extension=extension, resolution=size, directory=dirname, zenithnorm=zenithnorm, b_add_sources=add_sources) (beamsky_sum_XX, beam_sum_XX, Tant_XX, beam_dOMEGA_sum_XX, beamsky_sum_YY, beam_sum_YY, Tant_YY, beam_dOMEGA_sum_YY) = result beams = get_beam_power(delays, freq, model=model, pointing_az_deg=pointing_az_deg, pointing_za_deg=pointing_za_deg, zenithnorm=zenithnorm) gain_XX = beams['XX'] / (beam_dOMEGA_sum_XX / (4.00 * math.pi)) gain_YY = beams['YY'] / (beam_dOMEGA_sum_YY / (4.00 * math.pi)) ant_efficiency = 1.00 aeff_XX = (7161.97 / (freq_mhz * freq_mhz)) * (gain_XX * ant_efficiency) aeff_YY = (7161.97 / (freq_mhz * freq_mhz)) * (gain_YY * ant_efficiency) T_sys_XX = (Tant_XX + T_rcv) T_sys_YY = (Tant_YY + T_rcv) sens_XX = aeff_XX / T_sys_XX sens_YY = aeff_YY / T_sys_YY sefd_XX = (2760.00 / sens_XX) # 2k/(A/T) sefd_YY = (2760.00 / sens_YY) # 2k/(A/T) noise_XX = sefd_XX / math.sqrt(bandwidth * inttime * antnum * (antnum - 1)) noise_YY = sefd_YY / math.sqrt(bandwidth * inttime * antnum * (antnum - 1)) print "%.2f Hz :" % (freq) lstring = "\t\tXX (%.2f MHz) : T_ant_XX = %.2f = (%.8f / %.8f) , beam(%.4f,%.4f)=%.8f , gain=%.8f , aeff=%.8f, " lstring += "sensitivity (A/T) = %.20f -> SEFD_XX = %.2f Jy -> noise_XX = %.4f Jy" params = (freq_mhz, Tant_XX, beamsky_sum_XX, beam_sum_XX, pointing_az_deg, pointing_za_deg, beams['XX'], gain_XX, aeff_XX, sens_XX, sefd_XX, noise_XX) print lstring % params lstring = "\t\tYY (%.2f MHz) : T_ant_YY = %.2f = (%.8f / %.8f) , beam(%.4f,%.4f)=%.8f , gain=%.8f , aeff=%.8f, " lstring += "sensitivity (A/T) = %.20f -> SEFD_YY = %.2f Jy -> noise_YY = %.4f Jy" params = (freq_mhz, Tant_YY, beamsky_sum_YY, beam_sum_YY, pointing_az_deg, pointing_za_deg, beams['YY'], gain_YY, aeff_YY, sens_YY, sefd_YY, noise_YY) print lstring % params print "Noise expected on XX images = %.4f Jy" % noise_XX print "Noise expected on YY images = %.4f Jy" % noise_YY return (aeff_XX, T_sys_XX, sens_XX, sefd_XX, noise_XX, aeff_YY, T_sys_YY, sens_YY, sefd_YY, noise_YY)
def find_t_sys_gain(pulsar, obsid, p_ra=None, p_dec=None, dect_beg=None, dect_end=None, obs_beg=None, obs_end=None, common_metadata=None, full_metadata=None, query=None, min_z_power=0.3, trcvr=data_load.TRCVR_FILE): """Finds the system temperature and gain for an observation. Parameters ---------- pulsar : `str` The Jname of the pulsar. obsid : `int` The MWA Observation ID. p_ra, p_dec : `str`, optional The target's right ascension and declination in sexidecimals. If not supplied will use the values from the ANTF. dect_beg, dect_end : `int`, optional The beg and end GPS time of the detection to calculate over. If not supplied will estimate beam enter and exit. obs_beg, obs_end : `int`, optional Beginning and end GPS time of the observation. If not supplied will use :py:meth:`vcstools.metadb_utils.obs_max_min` to find it. common_metadata : `list`, optional The list of common metadata generated from :py:meth:`vcstools.metadb_utils.get_common_obs_metadata`. full_metadata : `dict`, optional The dictionary of metadata generated from :py:meth:`vcstools.metadb_utils.getmeta`. query : psrqpy object, optional A previous psrqpy.QueryATNF query. Can be supplied to prevent performing a new query. min_z_power : `float`, optional Zenith normalised power cut off. |br| Default: 0.3. trcvr : `str` The location of the MWA receiver temp csv file. |br| Default: <vcstools_data_dir>MWA_Trcvr_tile_56.csv Returns ------- t_sys : `float` The system temperature in K. t_sys_err : `float` The system temperature's uncertainty. gain : `float` The system gain in K/Jy. gain_err : `float` The gain's uncertainty. """ # get ra and dec if not supplied if query is None: logger.debug("Obtaining pulsar RA and Dec from ATNF") query = psrqpy.QueryATNF(psrs=[pulsar], loadfromdb=data_load.ATNF_LOC).pandas query_id = list(query['PSRJ']).index(pulsar) if not p_ra or not p_dec: p_ra = query["RAJ"][query_id] p_dec= query["DECJ"][query_id] # get metadata if not supplied if not common_metadata: logger.debug("Obtaining obs metadata") common_metadata = get_common_obs_metadata(obsid) obsid, obs_ra, obs_dec, _, delays, centrefreq, channels = common_metadata if not dect_beg or not dect_end: # Estimate integration time from when the source enters and exits the beam dect_beg, dect_end = source_beam_coverage_and_times(obsid, pulsar, p_ra=p_ra, p_dec=p_dec, obs_beg=obs_beg, obs_end=obs_end, min_z_power=min_z_power, common_metadata=common_metadata, query=query)[:2] start_time = dect_end - int(obsid) t_int = dect_end - dect_beg + 1 #Get important info ntiles = 128 #TODO actually we excluded some tiles during beamforming, so we'll need to account for that here beam_power = get_beam_power_over_time(np.array([[pulsar, p_ra, p_dec]]), common_metadata=[obsid, obs_ra, obs_dec, t_int, delays, centrefreq, channels], dt=100, start_time=start_time) mean_beam_power = np.mean(beam_power) # Usa a primary beam function to convolve the sky temperature with the primary beam # prints suppressed sys.stdout = open(os.devnull, 'w') _, _, Tsky_XX, _, _, _, Tsky_YY, _ = pbtant.make_primarybeammap(int(obsid), delays, centrefreq*1e6, 'analytic', plottype='None') sys.stdout = sys.__stdout__ #TODO can be inaccurate for coherent but is too difficult to simulate t_sky = (Tsky_XX + Tsky_YY) / 2. # Get T_sys by adding Trec and Tsky (other temperatures are assumed to be negligible t_sys_table = t_sky + get_Trec(centrefreq, trcvr_file=trcvr) t_sys = np.mean(t_sys_table) t_sys_err = t_sys*0.02 #TODO: figure out what t_sys error is logger.debug("pul_ra: {} pul_dec: {}".format(p_ra, p_dec)) _, _, zas = mwa_alt_az_za(obsid, ra=p_ra, dec=p_dec) theta = np.radians(zas) gain = from_power_to_gain(mean_beam_power, centrefreq*1e6, ntiles, coh=True) logger.debug("mean_beam_power: {} theta: {} pi: {}".format(mean_beam_power, theta, np.pi)) gain_err = gain * ((1. - mean_beam_power)*0.12 + 2.*(theta/(0.5*np.pi))**2. + 0.1) return t_sys, t_sys_err, gain, gain_err