def find_best_cal(observation_number,cal_dtmax=6e5,available_cals=None,relax=False): # open up database connection try: db = schedule.getdb() except: logger.error("Unable to open connection to database") sys.exit(1) logger.debug("searching db for obsnum %d"%observation_number) try: observation=get_observation_info.MWA_Observation(observation_number,db=db) except: logger.error('Unable to retrieve observation information for observation %d' % observation_number) sys.exit(0) matches=find_matches(observation, matchdelays=True, matchfreq=True, dtmax=cal_dtmax,\ db=db,search_subset=available_cals) if (matches is None or len(matches)==0): if relax: #logger.warning("""No matches identified for observation %d, relaxing delay match #constraint."""%observation_number) #logger.warning('WARNING FLUX CAL WILL BE BOGUS') matches=find_matches(observation, matchfreq=True, matchdelays=False,dtmax=cal_dtmax,\ db=db,search_subset=available_cals) if matches is None: logger.warning('No matches identified for observation %d' % observation_number) sys.exit(1) logger.debug("sorting through %d matches for nearest calibrator"%len(matches)) for match in sorted(matches, key=lambda x: math.fabs(x-observation_number)): if match == observation_number: continue try: observation=get_observation_info.MWA_Observation(match,db=db) except: logger.error('Unable to retrieve observation information for observation %d' % match) sys.exit(0) if observation.calibration: return observation.observation_number logger.error("No cal found for observation %d "%observation_number) return None
def __setattr__(self, name, value): self.__dict__[name] = value if (name == 'filenames' and value is not None and len(value) > 0): self.ntimefiles = len(value) self.ndas = len(value[0]) for filenames in value: for filename in filenames: if not os.path.exists(filename): logger.error('File %s does not exist' % filename) self.filenames = None return None self.coarse_channels = 12 * self.ndas logger.info('Have %d x %d input files' % (self.ndas, self.ntimefiles)) elif (name == 'gpstime' and value is not None and value > 0): # if the gpstime is set, compute everything else self.observation = get_observation_info.MWA_Observation( observation_number=self.gpstime, db=self.db) if (self.observation.duration <= 0): logger.warning('Did not identify observation for gpstime %d' % self.gpstime) self.find_closest_observation() if (self.observation_number is None): self.observation = None return None self.observation = get_observation_info.MWA_Observation( observation_number=self.observation_number, db=self.db) else: self.observation_number = self.observation.observation_number self.center_channel = self.observation.center_channel self.duration = self.observation.duration elif (name == 'observation_number' and value is not None and value > 0): self.get_metadata()
def find_matches(observation, search_subset=None, matchfreq=True, matchdelays=True, dtmax=None, db=None): """ matches=find_matches(observation, matchfreq=True, matchdelays=True,dtmax=None, db=None) returns matches from the observation database that match the supplied observation observation can be specified via observation_number or get_observation_info.MWA_Observation object matches are via frequency and/or delays """ if db is None: logger.error('Must supply a database object') return None if not matchfreq and not matchdelays: logger.error('Must match frequencies and/or delays') return None if (not isinstance(observation, get_observation_info.MWA_Observation)): try: o=get_observation_info.MWA_Observation(observation,db=db) except: logger.error('Unable to retrieve observation information for observation %d' % observation) return None observation=o delays=observation.delays channels=observation.channels #receiver=observation.receivers[0] s='select observation_number from Obsc_Recv_Cmds where ' if not search_subset is None: s+=' observation_number IN ('+','.join(map(str,search_subset))+') and ' if matchfreq: s+='frequency_values = array[%s]' % ( ','.join([str(x) for x in channels])) if matchfreq and matchdelays: s+=' and ' if matchdelays: s+=' xdelaysetting[1:1]=array[array[%s]]' % ( ','.join([str(x) for x in delays])) if dtmax is not None: if matchfreq or matchdelays: s+=' and ' s+=' abs(observation_number - %d) < %d' % (observation.observation_number, dtmax) logger.debug("SQL = %s"%s) res=dbobj.execute(s,db=db) return set([xx[0] for xx in res])
from mwapy.pb import primary_beam from mwapy.obssched.base import schedule import astropy.io.fits as pyfits # open up database connection try: db = schedule.getdb() except: print "Unable to open connection to database" sys.exit(1) RA, Dec = 69.3158945833333, -47.2523944444444 gpstime = 1063400456 filename = '1063400456_corr_phased.fits' o = get_observation_info.MWA_Observation(gpstime, db=db) mwatime = ephem_utils.MWATime(gpstime=gpstime + o.duration / 2) frequency = o.center_channel * 1.28e6 delays = o.delays RAnow, Decnow = ephem_utils.precess(RA, Dec, 2000, mwatime.epoch) HA = float(mwatime.LST) - RAnow mwa = ephem_utils.Obs[ephem_utils.obscode['MWA']] Az, Alt = ephem_utils.eq2horz(HA, Decnow, mwa.lat) theta = (90 - Alt) * math.pi / 180 phi = Az * math.pi / 180 def MWA_Jones_Analytic(theta, phi,
def populate_qc(obsid, verbose=False): """ populate_qc(obsid, verbose=False) actually does the population """ try: observation_info = get_observation_info.MWA_Observation(obsid, db=db) except: logger.error('Cannot retrieve observation info for %d' % obsid) return None if verbose: print '\nFound observation:' print observation_info oi = qcdb.Observation_Info(db=qcdbcon) oi.obsid = obsid oi.lst_deg = observation_info.LST if isinstance(observation_info.HA, numpy.ndarray): oi.hourangle_deg = observation_info.HA[0] * 15 else: oi.hourangle_deg = observation_info.HA * 15 oi.obsname = observation_info.filename oi.gridname = observation_info._Schedule_Metadata.gridpoint_name oi.gridnum = observation_info._Schedule_Metadata.gridpoint_number oi.creator = observation_info._MWA_Setting.creator oi.mode = observation_info._MWA_Setting.mode oi.project = observation_info._MWA_Setting.projectid oi.calibrator = observation_info.calibration oi.center_coarse_channel = observation_info.center_channel oi.azimuth_deg = observation_info.azimuth oi.altitude_deg = observation_info.elevation oi.ra_pointing_deg = observation_info.RA oi.dec_pointing_deg = observation_info.Dec oi.coarse_channels = list(observation_info.channels) oi.beamformer_delays = list(observation_info.delays) oi.active_rx = list(observation_info.receivers) oi.exposure_time_sec = observation_info.duration oi.corr_int_time = observation_info.inttime oi.corr_int_freq = observation_info.fine_channel # DIGITAL_GAINS: are per tile corr2uvfitsheader = make_metafiles.Corr2UVFITSHeader(obsid, db=db) corr2uvfitsheader.make_header() nav_freq = int(corr2uvfitsheader.fine_channel / 10) oi.center_freq = make_metafiles.channel2frequency( corr2uvfitsheader.channel) + (nav_freq - 1) * 0.005, oi.bandwidth = corr2uvfitsheader.bandwidth oi.corr_ninputs = corr2uvfitsheader.n_inputs oi.corr_n_time_outs = corr2uvfitsheader.n_scans oi.n_fine_channels = corr2uvfitsheader.n_chans # need to calculate these oi.sun_dist, oi.sun_alt = qcdb.get_elevation_separation_azel( oi.azimuth_deg, oi.altitude_deg, obsid, 'Sun') oi.moon_dist, oi.moon_alt = qcdb.get_elevation_separation_azel( oi.azimuth_deg, oi.altitude_deg, obsid, 'Moon') oi.jupiter_dist, oi.jupiter_alt = qcdb.get_elevation_separation_azel( oi.azimuth_deg, oi.altitude_deg, obsid, 'Jupiter') # Get sky temp from Schedule_Metadata schedule_metadata = observation_info._Schedule_Metadata oi.tsys = schedule_metadata.sky_temp # Get schedule command from Mwa_Log mwa_setting = observation_info._MWA_Setting for i in xrange(len(mwa_setting.logs)): if mwa_setting.logs[i].referencetime == obsid: oi.schedule_command = mwa_setting.logs[i].comment # do some time/date conversions t = astropy.time.Time(obsid, format='gps', scale='utc') oi.mjd = t.mjd # 0 is Monday oi.day_of_week = t.datetime.weekday() oi.day_of_year = t.datetime.timetuple().tm_yday oi.date = list(t.datetime.timetuple()[:6]) if _USE_IONEX: #i=ionex.ionexmaps(t) oi.site_tec = observation_info.TEC #_ionex_files.append(i.filename) # don't know how to do: # 'site_rms_tec' # 'rx_outside_temp' # 'humidity' # 'wind_speed' # 'wind_dir' # 'solar_problem' # 'holiday' # 'FIBRFACT' return oi
def main(): observation_num=None usage="Usage: %prog [options]\n" usage+='\tMakes metadata files necessary for corr2uvfits\n' usage+='\t128T sampling windows:\n' for i in xrange(len(make_metafiles._START)): t1=ephem_utils.MWATime(gpstime=make_metafiles._START[i]) if i<len(make_metafiles._START)-1: t2=ephem_utils.MWATime(gpstime=make_metafiles._START[i+1]-1) else: t2=ephem_utils.MWATime(gpstime=9046304456) usage+='\t%s (%10d) - %s (%10d): %.1f s, %d kHz\n' % (t1.datetime.strftime('%y-%m-%dT%H:%M:%S'), t1.gpstime, t2.datetime.strftime('%y-%m-%dT%H:%M:%S'), t2.gpstime, make_metafiles._DT[i], make_metafiles._DF[i]) parser = OptionParser(usage=usage) parser.add_option('-f','--filename',dest="filename", help="Create metafiles for <FILE>",metavar="FILE") parser.add_option('-d','--datetime',dest="datetimestring", help="Create metafiles for <DATETIME> (YYYYMMDDhhmmss)", metavar="DATETIME") parser.add_option('-g','--gps',dest="gpstime", help="Create metafiles for <GPS>",type='int', metavar="GPS") parser.add_option('--contiguous',dest="contiguous", action="store_true",default=False, help="Output separate files for contiguous channels only") parser.add_option('--minbaddipoles',dest='min_bad_dipoles',default=2,type='int', help='Minimum number of bad dipoles in a single pol required to flag the entire tile [default=%default]') parser.add_option('-m','--maxdiff',dest="maxtimediff",type='int', help="Maximum time difference for search (in sec)", default=10) parser.add_option('--channels',dest="channels",default=24,type=int, help="Number of coarse channels [default=%default]") parser.add_option('--channel',dest="channel",default=None,type=int, help="Coarse channel (implies channels=1) [default=%default]") parser.add_option('--dt',dest="dt",default=0,type=float, help="[sec] Integration time [default=%default, select by gpstime]") parser.add_option('--df',dest="df",default=0,type=int, help="[kHz] Fine channel width [default=%default, select by gpstime]") parser.add_option('--timeoffset',dest="timeoffset",default=0,type=int, help="[sec] Time offset between filename and start of data [default=%default]") parser.add_option('--header',dest='header',default='header_%gpstime%_%channel%.txt', help="Name of header output file [default=%default]") parser.add_option('--antenna',dest='antenna',default='antenna_locations_%gpstime%_%channel%.txt', help="Name of antenna_locations output file [default=%default]") parser.add_option('--instr',dest='instr',default='instr_config_%gpstime%_%channel%.txt', help="Name of instr_config output file [default=%default]") parser.add_option('--rts',dest='rts',default=False,action="store_true", help="Write RTS files (array file and rts_in)?") parser.add_option('--array',dest='array',default='array_file.txt', help="Name of RTS array file output file [default=%default]") parser.add_option('-v','--verbose',action="store_true",dest="verbose",default=False, help="Increase verbosity of output") parser.add_option('--debug',action="store_true",dest="debug",default=False, help="Display all database commands") parser.add_option('-l','--lock',dest='lock',action='store_true',default=False, help='Use \"-l\" option to create header file for locked phase center (RTS input)') (options, args) = parser.parse_args() if (options.verbose): logger.setLevel(logging.INFO) logger.info('Connecting to database %s@%s' % (mwaconfig.mandc.dbuser,mwaconfig.mandc.dbhost)) if options.filename is not None: observation_num=get_observation_info.find_observation_num(options.filename, maxdiff=options.maxtimediff, db=db) if observation_num is None: logger.error('No matching observation found for filename=%s\n' % (options.filename)) sys.exit(1) elif options.datetimestring is not None: observation_num=get_observation_info.find_observation_num(options.datetimestring, maxdiff=options.maxtimediff, db=db) if observation_num is None: logger.error('No matching observation found for datetimestring=%s\n' % (options.datetimestring)) sys.exit(1) elif options.gpstime is not None: observation_num=get_observation_info.find_closest_observation((options.gpstime), maxdiff=options.maxtimediff,db=db) if observation_num is None: logger.error('No matching observation found for gpstime=%d\n' % (options.gpstime)) sys.exit(1) else: logger.error('Must specify one of filename, datetime, or gpstime') sys.exit(1) if options.channel is not None: options.channels=1 if observation_num is not None: obs=get_observation_info.MWA_Observation(observation_number=observation_num, db=db) # do this first so that the instrument_configuration can know the duration h=make_metafiles.Corr2UVFITSHeader(observation_num, coarse_channels=options.channels, coarse_channel=options.channel, timeoffset=options.timeoffset, inttime=options.dt, fine_channel=options.df, lock=options.lock, db=db) vars={'gpstime': observation_num, 'channel': make_metafiles.ternary(options.channel is None,'all',options.channel)} if '%' in options.header: options.header=make_metafiles.update_filename(options.header,vars) if '%' in options.instr: options.instr=make_metafiles.update_filename(options.instr,vars) if '%' in options.antenna: options.antenna=make_metafiles.update_filename(options.antenna,vars) T=make_metafiles.instrument_configuration(gpstime=observation_num, duration=h.obs.duration, db=db, min_bad_dipoles=options.min_bad_dipoles, debug=options.debug) result=T.make_instr_config() if result is None: logger.error('Error making instr_config file') sys.exit(1) try: f=open(options.instr,'w') except: logger.error('Could not open instr_config file %s for writing' % options.instr) sys.exit(1) f.write(str(T)) f.close() logger.info('Wrote instr_config file %s!' % (options.instr)) try: f=open(options.antenna,'w') except: logger.error('Could not open antenna_locations file %s for writing' % options.antenna) sys.exit(1) f.write(T.antenna_locations()) f.close() logger.info('Wrote antenna_locations file %s!' % (options.antenna)) if options.rts: try: f=open(options.array,'w') except: logger.error('Could not open RTS array_file file %s for writing' % options.array) sys.exit(1) f.write(T.array_file()) f.close() logger.info('Wrote array file %s!' % (options.array)) try: f=open("rts.in",'w') except: logger.error('Could not open RTS configuration file rts.in for writing' ) sys.exit(1) try: f.write(T.rts_in(rtstime=datetime.strptime(options.datetimestring,"%Y%m%d%H%M%S"))) f.close() logger.info('Wrote rts_in file !') except: logger.error('Unable to write rts_in file') if numpy.diff(obs.channels).max()>1 and options.contiguous: # the frequencies are not contiguous # determine the contiguous ranges df=numpy.diff(obs.channels) frequency_indices=numpy.where(df>1)[0] channel_selections=[] istart=0 for istop in frequency_indices: channel_selections.append(numpy.arange(istart,istop+1)) istart=istop+1 channel_selections.append(numpy.arange(istart,len(obs.channels))) else: channel_selections=[numpy.arange(len(obs.channels))] for i,channel_selection in zip(range(len(channel_selections)),channel_selections): header_name=options.header logger.info('Creating output for channels %s' % channel_selection) h.channel_selection=channel_selection h.make_header() if len(channel_selections)>1: header_name=header_name.replace('.txt','.%02d.txt' % i) try: f=open(header_name,'w') except: logger.error('Could not open header file %s for writing' % header_name) sys.exit(1) f.write(str(h)) f.close() logger.info('Wrote header file %s!' % (header_name))
coord = ICRS.from_name(options.source) except: logger.error("Unable to find coordinates for '%s'" % options.source) sys.exit(1) if coord is None: logger.error('Must supply one of (RA,Dec), (l,b), source') sys.exit(1) observation_num = get_observation_info.find_closest_observation(observationid, maxdiff=0, db=db) if observation_num is None: logger.error('Observation not found for gpstime=%d' % observationid) sys.exit(1) obs = get_observation_info.MWA_Observation(observationid, db=db) Az, El = ephem_utils.radec2azel(coord.ra.degree, coord.dec.degree, obs.observation_number) # first go from altitude to zenith angle theta = numpy.radians((90 - El)) phi = numpy.radians(Az) # this is the response for XX and YY try: respX, respY = primary_beam.MWA_Tile_analytic(theta, phi, freq=obs.center_channel * 1.28e6, delays=obs.delays) except: logger.error('Error creating primary beams\n') sys.exit(1)
def main(): usage = "Usage: %prog [options] <images>\n" usage += '\tRegrids all images onto a common coordinate frame\n' usage += '\tFrame is that of template image (if specified), otherwise first image\n' usage += '\tImage size is expanded by a given factor if desired\n' parser = OptionParser(usage=usage) parser.add_option('-i', '--image', dest='image', default=None, help='Template image base') parser.add_option('-x', '--expandx', dest='factorx', default=2, type='int', help='X Expansion factor [default=%default]') parser.add_option('-y', '--expandy', dest='factory', default=2, type='int', help='Y Expansion factor [default=%default]') parser.add_option('--projection', dest='projection', type='choice', default='ZEA', choices=['ZEA', 'SIN', 'AIT', 'HPX', 'MOL'], help='Image projection [default=%default]') parser.add_option('--deczero', dest='deczero', default=False, action='store_true', help='Set reference Dec to 0 for AIT and MOL?') parser.add_option('--nobeam', dest='beam', default=False, action='store_true', help='Do not compute primary beams') parser.add_option('-v', '--verbose', action="store_true", dest="verbose", default=False, help="Increase verbosity of output") db = None execname = inspect.stack()[0][1] imin = 1 while sys.argv[imin] != execname: imin += 1 (options, args) = parser.parse_args(args=sys.argv[imin + 1:]) images = args dobeam = not options.beam if options.image is None: image0 = images[0] else: image0 = options.image template = '_template.fits' factorx = options.factorx factory = options.factory f = pyfits.open(image0) shape0 = f[0].data.shape f[0].data = numpy.zeros( (shape0[0], shape0[1], factory * shape0[2], factorx * shape0[3])) f[0].header['CRPIX1'] = shape0[3] / 2 * factorx + 1 f[0].header['CRPIX2'] = shape0[2] / 2 * factory + 1 if os.path.exists(template): os.remove(template) f.writeto(template) print 'Created template (%dx%d pixels) from %s' % ( factorx * shape0[3], factory * shape0[2], image0) templateroot, ext = os.path.splitext(template) if os.path.exists('%s.image' % templateroot): os.system('rm -r %s.image' % templateroot) ia.fromfits(templateroot + '.image', template) csys = ia.coordsys() if not options.projection == csys.projection()['type']: csys.setprojection(options.projection) if options.projection in ['MOL', 'AIT'] and options.deczero: # set the Dec reference to 0 ddec = csys.increment()['numeric'][1] * 180 / math.pi ref = csys.referencevalue(format='n') dec0 = ref['numeric'][1] * 180 / math.pi ref['numeric'][1] = 0 csys.setreferencevalue(ref) refpix = csys.referencepixel() refpix['numeric'][1] += int(math.fabs(dec0 / ddec)) csys.setreferencepixel(value=refpix['numeric']) if os.path.exists('%s_%s.image' % (templateroot, options.projection)): os.system('rm -r %s_%s.image' % (templateroot, options.projection)) im2 = ia.regrid(templateroot + '_' + options.projection + '.image', csys=csys.torecord(), overwrite=True) ia.close() ia.open(templateroot + '_' + options.projection + '.image') if os.path.exists(templateroot + '_' + options.projection + '.fits'): os.remove(templateroot + '_' + options.projection + '.fits') print 'Created %s template %s' % (options.projection, templateroot + '_' + options.projection + '.fits') ia.tofits(templateroot + '_' + options.projection + '.fits') shape = ia.shape() ia.close() new = [] newbeam = [] for im in images: if options.verbose: print 'Working on %s...' % im fi = pyfits.open(im) try: obsid = fi[0].header['GPSTIME'] delays = fi[0].header['DELAYS'] delays = map(int, delays.split(',')) except: if db is None: from mwapy.obssched.base import schedule db = schedule.getdb() d, f = os.path.split(im) obsid = int(f.split('-')[0]) info = get_observation_info.MWA_Observation(obsid, db=db) delays = info.delays if dobeam: f, e = os.path.splitext(im) if Vstring in f and not (os.path.exists(f + '_beamXX' + e) or os.path.exists(f + '_beamI' + e)): f = f.replace(Vstring, Istring) if not os.path.exists(f + '_beamI' + e): if not os.path.exists(f + '_beamXX' + e): # need to create the beam from mwapy.pb import make_beam beamfiles = make_beam.make_beam(im, delays=delays) else: print 'XX beam %s already exists' % (f + '_beamXX' + e) beamfiles = [f + '_beamXX' + e, f + '_beamYY' + e] if not os.path.exists(f + '_beamI' + e): fx = pyfits.open(beamfiles[0]) fy = pyfits.open(beamfiles[1]) fx[0].data = 0.5 * (fx[0].data + fy[0].data) beamfileI = beamfiles[0].replace('beamXX', 'beamI') if os.path.exists(beamfileI): os.remove(beamfileI) fx.writeto(beamfileI) print 'Made beam for %s: %s' % (im, beamfileI) else: print 'I beam %s already exists' % (f + '_beamI' + e) beamfileI = f + '_beamI' + e try: outfits = regrid(im, csys, shape, options.projection) print 'Regridded %s -> %s' % (im, outfits) new.append(outfits) if dobeam: newbeam.append( regrid(beamfileI, csys, shape, options.projection)) print 'Regridded %s -> %s' % (beamfileI, newbeam[-1]) except IndexError: print 'Failed to regrid %s' % im
def main(): observation_number=None usage="Usage: %prog [options]\n" usage+='\tMatches specified observation based on frequency and/or delays; can also restrict to calibration observations\n' usage+="\tInitial observation based on a filename, a UT datetime string, or a GPS time\n" usage+="\tRequires connection to MandC database through local configuration file\n" parser = OptionParser(usage=usage) parser.add_option('-f','--filename',dest="filename", help="Search for information on <FILE>",metavar="FILE") parser.add_option('-d','--datetime',dest="datetimestring", help="Search for information on <DATETIME> (YYYYMMDDhhmmss)", metavar="DATETIME") parser.add_option('-g','--gps',dest="gpstime", help="Search for information on <GPS>",type='int', metavar="GPS") parser.add_option('-m','--maxdiff',dest="maxtimediff",type='int', help="Maximum time difference for search (in sec)", default=10) parser.add_option('-v','--verbose',action="store_true",dest="verbose",default=False, help="Increase verbosity of output") parser.add_option('--delay',action='store_true',dest='delay',default=False, help='Match delays?') parser.add_option('--freq',action='store_true',dest='freq',default=False, help='Match frequencies?') parser.add_option('--cal',action='store_true',dest='cal',default=False, help='Require calibration observations?') parser.add_option('-n','--nmax',dest='nmax',default=None,type='int', help='Maximum number of records to display [default=%default]') parser.add_option('--dtmax',dest='dtmax',default=None,type='int', help='Maximum time offset to search in seconds [default=%default]') parser.add_option('--min',action='store_true', help='Only return the obsid of the best cal match (useful for scripting).') (options, args) = parser.parse_args() if len(args)<1: search_subset = None else: search_subset = args if (options.verbose): logger.setLevel(logging.DEBUG) logger.info('Connecting to database %s@%s' % (mwaconfig.mandc.dbuser,mwaconfig.mandc.dbhost)) if not (options.delay or options.freq or options.min): logger.error('Must match either delays and/or frequencies') sys.exit(1) if options.filename is not None: observation_number=get_observation_info.find_observation_num(options.filename, maxdiff=options.maxtimediff, db=db) if observation_number is None: logger.error('No matching observation found for filename=%s\n' % (options.filename)) sys.exit(1) elif options.datetimestring is not None: observation_number=get_observation_info.find_observation_num(options.datetimestring, maxdiff=options.maxtimediff, db=db) if observation_number is None: logger.error('No matching observation found for datetimestring=%s\n' % (options.datetimestring)) sys.exit(1) elif options.gpstime is not None: observation_number=get_observation_info.find_closest_observation((options.gpstime),maxdiff=options.maxtimediff,db=db) if observation_number is None: logger.error('No matching observation found for gpstime=%d\n' % (options.gpstime)) sys.exit(1) else: logger.error('Must specify one of filename, datetime, or gpstime') sys.exit(1) if options.min: """ Only print the obsid of the _best_ calibrator. Assumes you want matching frequencies. Why would you want anything else? """ print observation_number,find_best_cal(observation_number,cal_dtmax=options.dtmax, available_cals=search_subset,relax=True) sys.exit(0) try: observation=get_observation_info.MWA_Observation(observation_number,db=db) except: logger.error('Unable to retrieve observation information for observation %d' % observation_number) sys.exit(0) matches=find_matches(observation,search_subset=search_subset, matchdelays=options.delay, matchfreq=options.freq, dtmax=options.dtmax, db=db) if (matches is None or len(matches)==0): logger.warning('No matches identified for observation %d' % observation_number) sys.exit(0) s='# Starttime Timediff Filename Cal? MJD Date Time Channels ' s+=' Delays' print s if observation.calibration: ss='T' else: ss='F' s='%10d %10d %-20s\t%s %d %04d/%02d/%02d %02d:%02d:%02d' % (observation.observation_number,0, observation.filename,ss, observation.MJD, observation.year,observation.month,observation.day, observation.hour,observation.minute,observation.second) s+=' %s' % ((','.join([str(x) for x in observation.channels]))) s+=' %s' % (','.join([str(x) for x in observation.delays])) print s nprinted=0 for match in sorted(matches, key=lambda x: math.fabs(x-observation_number)): if match == observation_number: continue try: observation=get_observation_info.MWA_Observation(match,db=db) except: logger.error('Unable to retrieve observation information for observation %d' % match) sys.exit(0) if options.cal and not observation.calibration: continue if observation.calibration: ss='T' else: ss='F' s='%10d %10d %-20s\t%s %d %04d/%02d/%02d %02d:%02d:%02d' % (observation.observation_number, (observation.observation_number-observation_number), observation.filename,ss, observation.MJD, observation.year,observation.month,observation.day, observation.hour,observation.minute,observation.second) s+=' %s' % ((','.join([str(x) for x in observation.channels]))) s+=' %s' % (','.join([str(x) for x in observation.delays])) print s nprinted+=1 if options.nmax is not None and nprinted >= options.nmax: sys.exit(0) if options.dtmax is not None and math.fabs(match-observation_number)>options.dtmax: sys.exit(0)
def main(): observation_num = None usage = "Usage: %prog [options]\n" usage += '\tMakes metadata FITS file\n' parser = OptionParser(usage=usage, version=mwapy.__version__ + ' ' + mwapy.__date__) parser.add_option('-f', '--filename', dest="filename", help="Create metafiles for <FILE>", metavar="FILE") parser.add_option('-d', '--datetime', dest="datetimestring", help="Create metafiles for <DATETIME> (YYYYMMDDhhmmss)", metavar="DATETIME") parser.add_option('-g', '--gps', dest="gpstime", help="Create metafiles for <GPS>", type='int', metavar="GPS") parser.add_option( '--contiguous', dest="contiguous", action="store_true", default=False, help="Output separate files for contiguous channels only") parser.add_option( '--quick', dest='quick', default=False, action='store_true', help='Quick output (ignores all Rx connections)? [default=%default]') parser.add_option( '--minbaddipoles', dest='min_bad_dipoles', default=2, type='int', help= 'Minimum number of bad dipoles in a single pol required to flag the entire tile [default=%default]' ) parser.add_option('-m', '--maxdiff', dest="maxtimediff", type='int', help="Maximum time difference for search (in sec)", default=10) parser.add_option( '--channels', dest="channels", default=24, type=int, help= "Number of coarse channels [default=%default, select automatically]") parser.add_option( '--dt', dest="dt", default=0, type=float, help="[sec] Integration time [default=%default, select by gpstime]") parser.add_option( '--df', dest="df", default=0, type=int, help="[kHz] Fine channel width [default=%default, select by gpstime]") parser.add_option( '--timeoffset', dest="timeoffset", default=0, type=int, help= "[sec] Time offset between filename and start of data [default=%default]" ) parser.add_option( '-o', '--output', type=str, default=None, help='Name of output FITS file [default=<gpstime>.metafits]') parser.add_option('-v', '--verbose', action="store_true", dest="verbose", default=False, help="Increase verbosity of output") #parser.add_option('-l','--lock',dest='lock',action='store_true',default=False, # help='Use \"-l\" option to create header file for locked phase center (RTS input)') (options, args) = parser.parse_args() if (options.verbose): logger.setLevel(logging.INFO) logger.info('Connecting to database %s@%s' % (mwaconfig.mandc.dbuser, mwaconfig.mandc.dbhost)) if options.filename is not None: observation_num = get_observation_info.find_observation_num( options.filename, maxdiff=options.maxtimediff, db=db) if observation_num is None: logger.error('No matching observation found for filename=%s\n' % (options.filename)) sys.exit(1) elif options.datetimestring is not None: observation_num = get_observation_info.find_observation_num( options.datetimestring, maxdiff=options.maxtimediff, db=db) if observation_num is None: logger.error( 'No matching observation found for datetimestring=%s\n' % (options.datetimestring)) sys.exit(1) elif options.gpstime is not None: observation_num = get_observation_info.find_closest_observation( (options.gpstime), maxdiff=options.maxtimediff, db=db) if observation_num is None: logger.error('No matching observation found for gpstime=%d\n' % (options.gpstime)) sys.exit(1) else: logger.error('Must specify one of filename, datetime, or gpstime') sys.exit(1) if options.output is None: options.output = '%d.metafits' % observation_num if observation_num is not None: obs = get_observation_info.MWA_Observation( observation_number=observation_num, db=db) if numpy.diff(obs.channels).max() > 1 and options.contiguous: # the frequencies are not contiguous # determine the contiguous ranges df = numpy.diff(obs.channels) frequency_indices = numpy.where(df > 1)[0] channel_selections = [] istart = 0 for istop in frequency_indices: channel_selections.append(numpy.arange(istart, istop + 1)) istart = istop + 1 channel_selections.append(numpy.arange(istart, len(obs.channels))) else: channel_selections = [numpy.arange(len(obs.channels))] # do this first so that the instrument_configuration can know the duration hh = make_metafiles.Corr2UVFITSHeader( observation_num, coarse_channels=options.channels, timeoffset=options.timeoffset, inttime=options.dt, fine_channel=options.df, #lock=options.lock, db=db) T = make_metafiles.instrument_configuration( gpstime=observation_num, duration=hh.obs.duration, min_bad_dipoles=options.min_bad_dipoles, db=db) result = T.make_instr_config(quick=options.quick) if result is None: logger.error('Error making instr_config file') sys.exit(1) for i, channel_selection in zip(range(len(channel_selections)), channel_selections): logger.info('Creating output for channels %s' % channel_selection) T.channel_selection = channel_selection hh.channel_selection = channel_selection hh.make_header() T.corr2uvfitsheader = hh h = T.make_metafits(quick=options.quick) output = options.output if len(channel_selections) > 1: output = output.replace('.metafits', '.%02d.metafits' % i) if os.path.exists(output): os.remove(output) try: h.writeto(output) logger.info('Metafits written to %s' % (output)) except Exception, e: logger.error('Unable to write metafits file %s:\n%s' % (output, e)) sys.exit(1)