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))