def do_tbb(self, duration_scan, band, start_after=0, observer="", project=""): """Record duration_scan seconds of TBB data from rcumode. """ observationID = "Null" # Prepare for obs program. try: self.goto_observingstate() except RuntimeError as e: raise RuntimeError(e) # Start a beam pointing = ilisa.observations.directions.std_pointings('Z') freqband = modeparms.FrequencyBand(band) # FrequencyBand obtained from band spec sets 8 bit mode, # so create a new FrequencyBand object with only center frequency freqlo, freqhi = freqband.edgefreqs() freq0 = (freqlo + freqhi) / 2.0 actualfb = modeparms.FrequencyBand(freq0) antset = actualfb.antsets[0] self.streambeams(actualfb, pointing) print("Setting up TBBs") self._setupTBBs() print("Will start TBB recording in {}s".format(start_after)) time.sleep(start_after) print("Will freeze TBB recording in {}s".format(duration_scan)) time.sleep(duration_scan) # Arbitrary time to trigger print("Sending trigger to TBBs") self._freezeTBBdata() # Start data capture process locally dalcap = \ multiprocessing.Process(target=capture_data_DAL1, args=(self.tbbraw2h5cmd, self.tbbh5dumpdir, observer, antset, project, observationID, False)) dalcap.start() print("Streaming {}s of TBB data out of LCU".format(duration_scan)) self._startTBBdataStream(float(duration_scan)) dalcap.join()
def do_obsprog(self, scan, scanmeta=None): """At starttime execute the observation program specified by the obsfun method pointer and run with arguments specified by obsargs dict. """ scan_flat = dict(scan) del scan_flat['beam'] for k in scan['beam'].keys(): scan_flat[k] = scan['beam'][k] freqbndobj = modeparms.FrequencyBand(scan['beam']['freqspec']) scan_flat['freqbndobj'] = freqbndobj prg = programs.BasicObsPrograms(self) obsfun, obsargs_sig = prg.getprogram(scan['obsprog']) scan_flat['bfdsesdumpdir'] = scanmeta.bfdsesdumpdir # Map only args required by obsargs = {k: scan_flat[k] for k in obsargs_sig} # Setup Calibration tables on LCU: CALTABLESRC = 'default' # FIXME put this in args ## (Only BST uses calibration tables) # Choose between 'default' or 'local' self.lcu_interface.selectCalTable(CALTABLESRC) # Prepare for obs program. try: self.goto_observingstate() except RuntimeError as e: raise RuntimeError(e) # Run the observation program: obsinfolist = obsfun(**obsargs) # Stop program beam self.lcu_interface.stop_beam() if obsinfolist is not None: # Get some metadata about operational settings: # e.g. caltables used caltabinfos = [] freqbndobj = obsargs['freqbndobj'] for rcumode in freqbndobj.rcumodes: caltabinfo = self.lcu_interface.getCalTableInfo(rcumode) caltabinfos.append(caltabinfo) for i in range(len(obsinfolist)): obsinfolist[i].caltabinfos = caltabinfos obsinfo = obsinfolist[0] obsinfo.sb = freqbndobj.sb_range[0] # Move data to archive bsxSTobsEpoch, datapath = obsinfo.getobsdatapath( self.LOFARdataArchive) self.movefromlcu(self.lcu_interface.lcuDumpDir + "/*.dat", datapath) for curr_obsinfo in obsinfolist: curr_obsinfo.create_LOFARst_header(datapath) # Prepare metadata for session on this station. scanmeta.scanrecs['bsx'].set_obsfolderinfo( obsinfo.LOFARdatTYPE, bsxSTobsEpoch, freqbndobj.arg, obsinfo.integration, obsinfo.duration_scan, obsinfo.pointing) scanmeta.scanrecs['bsx'].write_scan_rec(datapath) scanmeta.scanrecs['bsx'].datapath = datapath
def get_rcumode(self,filenr=0): try: rcumode = modeparms.FrequencyBand(self.obsfolderinfo['freqband']).rcumodes[0] except: try: rcumode = self.obsinfos[filenr].beamctl_cmd['rcumode'] except: rcumode = self.obsfolderinfo['rcumode'] return str(rcumode)
def run_lcl_sched(self, stn_ses_sched_in, session_id=None): """Run a local session given a stn_ses_schedule dict. That is, dispatch to the stationdrivers to setup corresponding observations.""" stn_ses_sched = self.process_stn_ses_sched(stn_ses_sched_in, session_id) self.projectmeta, _ = projid2meta(stn_ses_sched['projectid']) self.set_stn_session_id(stn_ses_sched['session_id']) self.save_stnsessched(stn_ses_sched) sesspath = self.get_sesspath() bfdsesdumpdir = self.get_bfdsesdumpdir() # Boot Time handling nw = datetime.datetime.utcnow() starttime = stn_ses_sched['scans'][0]['starttime'] if starttime == 'NOW': starttime = nw bootupstart = starttime - datetime.timedelta(seconds=10) # Wait until it is time to bootup print("In stnsess: Wait until it is time to bootup") st = self.stndrv._waittoboot(bootupstart.strftime("%Y-%m-%dT%H:%M:%S")) for scan in stn_ses_sched['scans']: freqbndobj = modeparms.FrequencyBand(scan['beam']['freqspec']) scanrecs = {} if scan['do_acc']: scanrecs['acc'] = dataIO.ScanRecInfo(self.projectmeta) if scan['rec_bfs']: scanrecs['bfs'] = dataIO.ScanRecInfo(self.projectmeta) if scan['rec_stat_type']: scanrecs['bsx'] = dataIO.ScanRecInfo(self.projectmeta) for k in scanrecs.keys(): scanrecs[k].set_stnid(self.stndrv.get_stnid()) scanmeta = stationdriver.ScanMeta(sesspath, bfdsesdumpdir, scanrecs) if scan['obsprog'] is not None: self.stndrv.do_obsprog(scan, scanmeta=scanmeta) else: integration = scan['integration'] duration_tot = scan['duration_tot'] pointing = scan['beam']['pointing'] pointsrc = scan['beam']['pointsrc'] starttime = scan['starttime'] rec_stat_type = scan['rec_stat_type'] rec_bfs = scan['rec_bfs'] do_acc = scan['do_acc'] allsky = scan['beam']['allsky'] self.stndrv.main_scan(freqbndobj, integration, duration_tot, pointing, pointsrc, starttime, rec_stat_type, rec_bfs=rec_bfs, do_acc=do_acc, allsky=allsky, scanmeta=scanmeta)
def mockstatistics(self, statistics, integration, duration, directory=None): """Make mock statistics data file(s).""" if directory is None: directory = self.lcuDumpDir self.DryRun = False nrtimsamps = int(duration / integration) import ilisa.observations.modeparms as modeparms import datetime dd_cmdbase = 'dd if=/dev/zero' bits = self.get_bits() dtstamp = datetime.datetime.utcnow().strftime('%Y%m%d_%H%M%S') if statistics == 'bst': # Write mock bst files. (mock files contain just zeros) nrbls = modeparms.FrequencyBand().get_maxbeamletsbybits(bits) dd_bs = 8 dd_count = nrbls * nrtimsamps dd_cmdbase += ' bs={} count={}'.format(dd_bs, dd_count) for pol in ['X', 'Y']: bstfilename = "{}_bst_00{}.dat".format(dtstamp, pol) fpath = os.path.join(directory, bstfilename) dd_cmd = dd_cmdbase + ' of={}'.format(fpath) self.exec_lcu(dd_cmd) elif statistics == 'sst': # Write mock sst files nrsbs = modeparms.TotNrOfsb dd_bs = 8 dd_count = nrsbs * nrtimsamps dd_cmdbase += ' bs={} count={}'.format(dd_bs, dd_count) for rcunr in range(modeparms.nrofrcus): sstfilename = "{}_sst_rcu{:03}.dat".format(dtstamp, rcunr) fpath = os.path.join(directory, sstfilename) dd_cmd = dd_cmdbase + ' of={}'.format(fpath) self.exec_lcu(dd_cmd) elif statistics == 'xst': # Write mock sst files nrrcus = modeparms.nrofrcus dd_bs = 2 * 8 dd_count = nrrcus * nrrcus * nrtimsamps dd_cmdbase += ' bs={} count={}'.format(dd_bs, dd_count) xstfilename = "{}_xst.dat".format(dtstamp) fpath = os.path.join(directory, xstfilename) dd_cmd = dd_cmdbase + ' of={}'.format(fpath) self.exec_lcu(dd_cmd) self.DryRun = True
def goto_observingstate(self, warmup=True): """Put station into the main observing state. Parameters ---------- warmup: bool, optional Do a beam warmup after reaching swlevel 3. """ if not self.checkobservingallowed(): raise RuntimeError('Observations not allowed') swlevel_changed = self.lcu_interface.set_swlevel(3) if swlevel_changed and warmup: # Dummy or hot beam start: (takes about 10sec) # This seems necessary: first beamctl after going to swlevel 3 # seems to crash. print("Running warmup beam... @ {}".format( datetime.datetime.utcnow())) self.streambeams(modeparms.FrequencyBand('10_90'), '0.,1.5707963,AZELGEO') self.lcu_interface.stop_beam() print("Finished warmup beam... @ {}".format( datetime.datetime.utcnow()))
help="""lofar data type to record. Choose from 'acc', 'bfs', 'bst', 'sst', 'tbb', 'xst', 'nil'.""") parser.add_argument('freqspec', help='Frequency spec in Hz.') parser.add_argument('duration_tot', help='Duration in seconds. (Can be an arithmetic expression)', type=str) parser.add_argument('pointing', nargs='?', help='A direction in az,el,ref (radians) or a source name.') args = parser.parse_args() accessconf = ilisa.observations.default_access_lclstn_conf() stndrv = stationdriver.StationDriver(accessconf['LCU'], accessconf['DRU']) halt_observingstate_when_finished = True stndrv.halt_observingstate_when_finished = halt_observingstate_when_finished freqbndobj = modeparms.FrequencyBand(args.freqspec) try: pointsrc = args.pointing except AttributeError: pointsrc = None try: pointing = ilisa.observations.directions.std_pointings(pointsrc) except KeyError: try: phi, theta, ref = pointsrc.split(',', 3) pointing = pointsrc except ValueError: raise ValueError( "Error: %s invalid pointing syntax".format(args.pointing)) duration_tot = eval(str(args.duration_tot))