def arm_snaps(snaps):
logger = logger_defaults.getModuleLogger(__name__)
logger.info("Arming snaps...")
disable_ethernet_output(snaps)
current_sync = snaps[0].sync_get_ext_count()
time.sleep(0.05)
while (snaps[0].sync_get_ext_count() == current_sync):
time.sleep(0.05)
sync_time_arr = []
for snap in snaps:
sync_time = snap.sync_arm()
sync_time_arr.append(sync_time)
if len(set(sync_time_arr)) != 1:
for i, snap in enumerate(snaps):
print(snap.host, sync_time_arr[i])
raise RuntimeError("Sync times is different across all FPGAs!")
enable_ethernet_output(snaps)
logger = logger_defaults.getModuleLogger(__name__)
logger.info("Snaps armed successfully, synctime: %i" % sync_time)
return sync_time
def saveFile(filepart, snapdict, azoffset, eloffset, recid, setid):
logger_defaults.getModuleLogger(__name__)
uvdat = create_snap_uvdata(snapdict, azoffset, eloffset, recid, setid=None)
filename = os.path.join(
snap_dirs.get_output_dir(),
'snap_' + str(recid) + '_' + filepart + '_' + snapdict['ant'] + '.h5')
uvdat.write_uvh5(filename)
def plotAuto(host,
rfc=None,
fpga_file=snap_defaults.plot_snap_file,
srate=snap_defaults.srate,
ifc=snap_defaults.ifc):
snap = getSelectSnap(host, fpga_file, srate, sel='auto')
if not rfc or rfc == 0.0:
rfc = ata_control.get_sky_freq()
logger = logger_defaults.getModuleLogger(__name__)
logger.info(
"no rfc provided. rfc readed from the ata sky frequency: {}".
format(rfc))
plt.ion()
fig, ax = plt.subplots(2, 1)
fig.was_closed = False
fig.canvas.mpl_connect('close_event', handle_close)
while (not fig.was_closed):
frange, d0, d1 = snap_recorder.get_log_data(snap, 'auto', rfc, srate,
ifc)
ax[0].clear()
ax[1].clear()
ax[0].plot(frange, d0)
ax[1].plot(frange, d1)
ax[0].set_ylabel("Power [dB arb. ref.]")
ax[1].set_ylabel("Power [dB arb. ref.]")
ax[1].set_xlabel("Frequency [MHz]")
plt.show()
plt.pause(0.001)
def updateRMSVals(cobsid, attendict):
"""
update the antennas information with a given dictionary
dictionary example:
{ '1a': {'rmsy': 0.3544, 'rmsx': 12.2489},
'2a': {'rmsy': 0.3846, 'rmsx': 26.9986} }
"""
logger = logger_defaults.getModuleLogger(__name__)
mydb = ATAdb.connect_to_db('obs')
mycursor = mydb.cursor()
insertcmd = (
"update rec_ants set dsp_rms_x=%(rmsx)s, dsp_rms_y=%(rmsy)s where ant=%(ant)s and id=%(id)s"
)
for ant in attendict.keys():
cdict = {
'ant': ant,
'id': cobsid,
'rmsx': attendict[ant]['rmsx'],
'rmsy': attendict[ant]['rmsy']
}
logger.info("updating rms row for ant {} and recording id {}".format(
ant, cobsid))
mycursor.execute(insertcmd, cdict)
mydb.commit()
mycursor.close()
mydb.close()
def updateAttenVals(cobsid, attendict):
"""
update the antennas information with a given dictionary
dictionary example:
{ '1a': {'attenx': 17, 'atteny': 0},
'2a': {'attenx': 30, 'atteny': 0} }
"""
logger = logger_defaults.getModuleLogger(__name__)
mydb = ATAdb.connect_to_db('obs')
mycursor = mydb.cursor()
insertcmd = (
"update rec_ants set dsp_atten_x=%(attenx)s, dsp_atten_y=%(atteny)s where ant=%(ant)s and id=%(id)s"
)
for ant in attendict.keys():
cdict = {
'ant': ant,
'id': cobsid,
'attenx': attendict[ant]['attenx'],
'atteny': attendict[ant]['atteny']
}
logger.info(
"updating attenuators row for ant {} and recording id {}".format(
ant, cobsid))
mycursor.execute(insertcmd, cdict)
mydb.commit()
mycursor.close()
mydb.close()
def updateAttenRMSVals(cobsid, attendict):
"""
update the antennas information with a given dictionary
dictionary example:
{ '1a': {'attenx': 17, 'rmsy': 0.3544, 'rmsx': 12.2489, 'atteny': 0},
'2a': {'attenx': 30, 'rmsy': 0.3846, 'rmsx': 26.9986, 'atteny': 0} }
"""
logger = logger_defaults.getModuleLogger(__name__)
mydb = ATAdb.connect_to_db('obs')
mycursor = mydb.cursor()
insertcmd = (
"update rec_ants set dsp_atten_x=%(attenx)s, dsp_atten_y=%(atteny)s, "
"dsp_rms_x=%(rmsx)s, dsp_rms_y=%(rmsy)s where ant=%(ant)s and id=%(id)s"
)
for ant in attendict.keys():
cdict = attendict[ant].copy()
logger.info(
"updating attenuators/rms row for ant {} and recording id {}".
format(ant, cobsid))
cdict['ant'] = ant
cdict['id'] = cobsid
mycursor.execute(insertcmd, cdict)
mydb.commit()
mycursor.close()
mydb.close()
def markRecordingsOK(obsid_list):
"""
mark recordings as ok.
"""
logger = logger_defaults.getModuleLogger(__name__)
if not obsid_list:
logger.warning('List is empty!')
return
if not isinstance(obsid_list, list) and len(obsid_list) == 1:
obsid_list = [obsid_list]
mydb = ATAdb.connect_to_db('obs')
mycursor = mydb.cursor()
insertcmd_part = ("update recordings set status='OK' where id in (%s)")
#in_p=', '.join(map(lambda x: '%s', obsid_list))
in_p = ', '.join(['%s'] * len(obsid_list))
insertcmd = insertcmd_part % in_p
logger.info("changing status of recordings {} to OK".format(', '.join(
map(str, obsid_list))))
mycursor.execute(insertcmd, obsid_list)
mydb.commit()
mycursor.close()
mydb.close()
def startRecording(obsid, mydate=None):
"""
Parameters:
obsid: (int)
mydate: (datetime.datetime)
updates recording start time of obsid recording to now() or mydate
"""
logger = logger_defaults.getModuleLogger(__name__)
mydb = ATAdb.connect_to_db('obs')
mycursor = mydb.cursor()
if mydate:
insertcmd = (
"update recordings set tstart=%(strttime)s, status='STARTED' where id=%(id)s"
)
dict1 = {'id': obsid, 'strttime': mydate.strftime('%Y-%m-%d %H:%M:%S')}
else:
insertcmd = (
"update recordings set tstart=now(), status='STARTED' where id=%(id)s"
)
dict1 = {'id': obsid}
logger.info("updating start time of the recording")
mycursor.execute(insertcmd, dict1)
mydb.commit()
mycursor.close()
mydb.close()
def set_freq_auto(freqs, ant_list):
"""
Automatically sets sky/focus frequencies
according to the ant-LO mapping in the config files
"""
logger = logger_defaults.getModuleLogger(__name__)
if type(freqs) in [float, int]:
freqs = [freqs] * len(ant_list)
assert len(freqs) == len(ant_list),\
"Number of requested frequencies should match number of antennas"
obs_ant_tab = ATA_SNAP_TAB[ATA_SNAP_TAB.ANT_name.isin(ant_list)]
los = pd.unique(obs_ant_tab.LO)
lo_freq_mapping = {}
for ant, freq in zip(ant_list, freqs):
obs_ant = obs_ant_tab[obs_ant_tab.ANT_name == ant]
obs_ant_lo = str(obs_ant.LO.values.squeeze())
if obs_ant_lo in lo_freq_mapping:
assert freq == lo_freq_mapping[obs_ant_lo],\
"A wrong LO-ant mapping for ant: %s" %(obs_ant.ANT_name)
else:
lo_freq_mapping[obs_ant_lo] = freq
for lo, freq in lo_freq_mapping.items():
ants_sub = list(obs_ant_tab[obs_ant_tab.LO == lo].ANT_name)
logger.info("Setting {freq:.2f} (LO: {lo:s}) sky freq for"\
"ants: ({ants:s})".format(freq=float(freq), lo=lo,
ants=",".join(ants_sub)))
ata_control.set_freq(freq, ants_sub, lo)
def setatten(antpol_dict):
"""
antpol_dict: dict with example values
{'1ax': 12.0, '1ay': 13.5}
"""
logger = logger_defaults.getModuleLogger(__name__)
if_channels = []
atten_values = []
for antpol, attenval in antpol_dict.items():
if not (antpol.endswith("x") or antpol.endswith("y")):
raise RuntimeError("Antpol (%s) doesn't end with 'x' or 'y'" %
(antpol))
ant = antpol[:-1]
pol = antpol[-1]
if ant not in list(ATA_SNAP_TAB.ANT_name):
raise RuntimeError("Antenna (%s) not in antenna list: %s" %
(ant, list(ATA_SNAP_TAB.ANT_name)))
snap_hostname = ATA_SNAP_TAB[ATA_SNAP_TAB.ANT_name ==
ant].snap_hostname.values[0]
snap_if_entry = ATA_SNAP_IF[ATA_SNAP_IF.snap_hostname == snap_hostname]
if_ch = snap_if_entry['ch' + pol].values[0]
if_channels.append(if_ch)
atten_values.append(attenval)
_setatten(if_channels, atten_values)
def setRMS(ant_dict,fpga_file=snap_defaults.spectra_snap_file,rms=snap_defaults.rms,srate=snap_defaults.srate):
"""
set attenuators values for SNAP observation
"""
logger = logger_defaults.getModuleLogger(__name__)
ant_list = snap_array_helpers.dict_to_list(ant_dict)
snaps = ant_dict.keys()
nsnaps = len(snaps)
rdict = {}
with concurrent.futures.ProcessPoolExecutor(max_workers=nsnaps) as executor:
threads = []
for snap in snaps:
t = executor.submit(snap_recorder.setSnapRMS,snap,ant_dict[snap],fpga_file,rms)
threads.append(t)
for t in threads:
retval = t.result()
rdict[retval['ant']] = retval
retval.pop('ant')
return rdict
def set_acc_len(snaps, acclen):
logger = logger_defaults.getModuleLogger(__name__)
hosts = [snap.host for snap in snaps]
logger.info("Setting accumulation of snaps: %s to "\
"a length of: %i" %(",".join(hosts), acclen))
for snap in snaps:
snap.set_accumulation_length(acclen)
def do_snap_plot_simple(snaphost, freq, fpga_file):
logger = logger_defaults.getModuleLogger(__name__)
logger.info("starting plotting")
snap_plot.plotAuto(snaphost, freq, fpga_file)
def dbsumdb(inkeys, outkey, loggerfile):
logger = logger_defaults.getModuleLogger(__name__)
script = os.path.join(MYCWD, snap_dada_defaults.dbsumdb_script)
cmd = script + " " + " ".join(inkeys) + "-o "+ outkey +\
">> " + logfile + " 2>&1"
logger.info("Executing: %s" %cmd)
os.system(cmd)
def destroy_buffers(keylist, logfile):
logger = logger_defaults.getModuleLogger(__name__)
logger.info("Destroying dada buffers")
script = os.path.join(MYCWD, snap_dada_defaults.destroy_buf_script)
cmd = script + " " + " ".join(keylist) + ">> " + logfile + " 2>&1"
logger.info("Executing: %s" %cmd)
os.system(cmd)
def disconnect_snaps(snaps):
logger = logger_defaults.getModuleLogger(__name__)
logger.info("disconnecting snaps")
for snap in snaps:
try:
snap.fpga.disconnect()
except Exception as e:
warnings.warn(str(e))
def filter_ant_recording_list(rec_list,
r_type,
freq_filter=None,
ant_filter=None):
"""
Filters rec_list and creates a new list with copied entities. Only copies the
rows that matches r_type.
optionally, filters by antennas and frequencies
"""
logger = logger_defaults.getModuleLogger(__name__)
prop_r_type = obs_common.getRecType(r_type)
retList = []
if not freq_filter and not ant_filter:
#filtering just types
logger.info('filtering for {}'.format(prop_r_type))
for row in rec_list:
if row['type'] == prop_r_type:
retList.append(row)
return retList
elif not freq_filter:
#filtering types and antennas
logger.info('filtering for {}, antennas {}'.format(
prop_r_type, ','.join(ant_filter)))
for row in rec_list:
if row['type'] == prop_r_type and row['ant'] in ant_filter:
retList.append(row)
return retList
elif not ant_filter:
#filtering types and frequencies
logger.info('filtering for {}, freqs {}'.format(
prop_r_type, ','.join(map(str, freq_filter))))
for row in rec_list:
if row['type'] == prop_r_type and row['freq'] in freq_filter:
retList.append(row)
return retList
else:
logger.info('filtering for {}, antennas {}, freqs {}'.format(
prop_r_type, ','.join(ant_filter), ','.join(map(str,
freq_filter))))
for row in rec_list:
if row['type'] == prop_r_type and row[
'freq'] in freq_filter and row['ant'] in ant_filter:
retList.append(row)
return retList
logger.error("something went wrong?")
raise RuntimeError('this part shouldn\'t be reachable')
def getAntRecordings(obs_set_id):
"""
Returns a list of recordings/antenna information for given observation setid
"""
logger = logger_defaults.getModuleLogger(__name__)
if not obs_set_id:
logger.error("no obsid provided")
raise RuntimeError("no obsid provided")
mydb = ATAdb.connect_to_db('obs')
mycursor = mydb.cursor()
insertcmd = (
"select recordings.id, recordings.setid, recordings.tstart, recordings.tstop, "
"recordings.freq, recordings.type, recordings.description, rec_ants.ant, "
"rec_ants.az, rec_ants.el, rec_ants.source "
"from rec_ants inner join recordings on recordings.id = rec_ants.id "
"where recordings.status='OK' and recordings.setid=%(id)s "
"order by rec_ants.ant, recordings.freq, recordings.description")
dict1 = {'id': obs_set_id}
logger.info("fetching ant/recordings from set {}".format(obs_set_id))
mycursor.execute(insertcmd, dict1)
rows = mycursor.fetchall()
retList = []
if not rows:
logger.warning("no recordings found")
mycursor.close()
mydb.close()
return retList
logger.info("found {} recordings".format(len(rows)))
for row in rows:
cdict = {
'setid': row[1],
'recid': row[0],
'ant': row[7],
'freq': row[4],
'desc': row[6],
'tstart': row[2],
'tstop': row[3],
'type': row[5],
'source': row[10],
'az': row[8],
'el': row[9]
}
retList.append(cdict)
mycursor.close()
mydb.close()
return retList
def getatten(antlo_list):
"""
antlo_list: list if ant_los similar to:
"1aA", "1kA", "1kB", "1hB", "2aA", "2aB", "3dc"
where the last letter in the name is the LO letter
returns:
dict with keys same as antlo_list, but appended with
"x" and "y" for each polarisation, and the attenuation value
as dictionary values
"""
logger = logger_defaults.getModuleLogger(__name__)
assert type(antlo_list) == list
obs_ant_tab = ATA_SNAP_TAB[ATA_SNAP_TAB.antlo.isin(antlo_list)]
assert len(obs_ant_tab) == len(antlo_list)
ata_snap_if = ATA_SNAP_IF[ATA_SNAP_IF.snap_hostname.isin(
obs_ant_tab.snap_hostname)]
att_modules = ata_snap_if.module.unique()
retdict = {}
for att_mod in att_modules:
this_snap_if = ata_snap_if[ata_snap_if.module == att_mod]
antchnumber = []
for _, row in this_snap_if.iterrows():
antchnumber.append(row.chx)
antchnumber.append(row.chy)
command = "ssh sonata@gain-module%i " % (int(att_mod))
command += "'python attenuatorMain.py"
command += " -n "
command += " ".join(antchnumber)
command += " -g "
command += "'"
logger.info(command)
process = subprocess.Popen(command,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
shell=True)
stdout, stderr = process.communicate()
ch_if_attn = _translate_if_output(stdout)
for _, row in this_snap_if.iterrows():
antlo = obs_ant_tab[obs_ant_tab.snap_hostname ==
row.snap_hostname].antlo.values[0]
retdict[antlo + "x"] = float(ch_if_attn[row['chx']])
retdict[antlo + "y"] = float(ch_if_attn[row['chy']])
return retdict
def record_same(ant_dict,freq,source,ncaptures,obstype,obsuser,desc,filefragment,backend="SNAP",
az_offset=0,el_offset=0,fpga_file=snap_defaults.spectra_snap_file,obs_set_id=None):
"""
basic recording scripts, where all antennas are pointed on in the same position
NOTE:
the frequency, antenna pointing and source has to be set up earlier. This function only
records data and populates the database with given information.
Parameters
-------------
ant_dict : dict
the snap to antenna mapping for the recording. e.g. {'snap2': '2a','snap1': '2j'}
freq : float
the frequency
Returns
-------------
long
observation (recording) id
Raises
-------------
"""
logger = logger_defaults.getModuleLogger(__name__)
#setting up the observation and starting it
recid = obs_db.initRecording(freq,obstype,backend,desc,obsuser,obs_set_id)
logger.info("got recording id {}".format(recid))
snap_dirs.set_output_dir_obsid(obs_set_id)
ant_list = snap_array_helpers.dict_to_list(ant_dict)
logger.info("updating database with antennas {}".format(", ".join(ant_list)))
obs_db.initAntennasTable(recid,ant_list,source,az_offset,el_offset,True)
logger.info("starting recording {}".format(recid))
obs_db.startRecording(recid)
snaps = ant_dict.keys()
nsnaps = len(snaps)
with concurrent.futures.ProcessPoolExecutor(max_workers=nsnaps) as executor:
threads = []
for snap in snaps:
t = executor.submit(single_snap_recording,snap,ant_dict[snap],ncaptures,fpga_file,freq,filefragment,source,az_offset,el_offset,recid,obs_set_id)
threads.append(t)
for t in threads:
retval = t.result()
obs_db.stopRecording(recid)
return recid
def create_dir(dirname):
logger = logger_defaults.getModuleLogger(__name__)
output_dir = os.path.expanduser(dirname)
try:
if not os.path.exists(output_dir):
os.makedirs(output_dir)
logger.info('directory {} created'.format(output_dir))
except OSError:
logger.error("Error: Creating directory %s" % output_dir)
raise
def processSEFDfiles(datadir,
rec_list,
method=OnOffCalc.defaultFilterType,
compareflag=False,
uploadflag=False,
dbflag=True):
import concurrent.futures
logger = logger_defaults.getModuleLogger(__name__)
if not len(rec_list):
logger.error('Rec list is empty')
raise RuntimeError('List is empty')
retlist = {}
with concurrent.futures.ProcessPoolExecutor(max_workers=8) as executor:
threads = []
while (rec_list):
cant = rec_list[0]['ant']
cfreq = rec_list[0]['freq']
cList, rec_list = obs_list.split_ant_recording_list(
rec_list, [cfreq], [cant])
#this part can be executed by calling in separate threads/processes
t = executor.submit(processSignleAntFreqSEFDfiles, datadir, cList,
method, compareflag, uploadflag, dbflag)
threads.append(t)
for t in concurrent.futures.as_completed(threads):
try:
rval = t.result()
#preparation for multicore
cant = rval['ant']
cfreq = rval['freq']
#if this is the first freq for that antenna
if cant not in retlist:
retlist[cant] = {}
if cfreq in retlist[cant]:
logger.warning(
"for some reason, we already have a data in {}:{}".
format(cant, cfreq))
retlist[cant][cfreq] = rval
except Exception as e:
logger.error(
"error while processing antena {} freq {} : {}".format(
cant, cfreq, e))
raise
#pass
if uploadflag:
sefd_graphs.makeHtml(retlist)
sefd_graphs.makeJson(retlist)
return retlist
def create_buffers(keylist, bufsze_list, logfile):
logger = logger_defaults.getModuleLogger(__name__)
pairs = ""
for key, bufsze in zip(keylist, bufsze_list):
pairs += key
pairs += " "
pairs += str(bufsze)
pairs += " "
script = os.path.join(MYCWD, snap_dada_defaults.create_buf_script)
cmd = script + " " + pairs + ">> " + logfile + " 2>&1"
logger.info("Executing: %s" %cmd)
os.system(cmd)
def get_obs_params(setid, sources, ant_snap_dictionary, freq_list):
all_antennas_list = snap_array_helpers.dict_list_to_list(
ant_snap_dictionary)
logger = logger_defaults.getModuleLogger(__name__)
meas_dictionary = get_all_meas_dict(setid, all_antennas_list)
snapKeys = ant_snap_dictionary.keys()
outputDict = {}
if meas_dictionary:
#using sets because it automatically removes duplicates
#we are allowing to re-measure some frequencies on some
#of the antennas. e.g. ant1a was measured on 1,2,3 GHz
#and ant1c on 1,2 GHz and they belong to different snaps,
#while order was 1,2,3,4 GHzwe would order to measure
#1a and 2c on 3 and 4 GHz, duplicating 3GHz for 1a
freq_set = set(freq_list)
todo_freq_set = set()
antennas_got = meas_dictionary.keys()
for sk in snapKeys:
clist = ant_snap_dictionary[sk]
#for each host, we are searching for first antenna that
#was not measured, or was measured but has still some
#not measured frequencies
for cant in clist:
if cant in antennas_got:
#antenna was measured, testing freq list
flist = meas_dictionary[cant]['freq']
diffset = freq_set - set(flist)
#we have some unmeasured freqencies for that antenna
if diffset:
outputDict[sk] = cant
todo_freq_set.update(diffset)
break
else:
outputDict[sk] = cant
todo_freq_set.update(freq_list)
break
outputFreqList = list(todo_freq_set)
else:
#there were no measurements for those antennas
#taking first antenna from each list and copying
#the frequency list
outputFreqList = freq_list
for sk in snapKeys:
clist = ant_snap_dictionary[sk]
outputDict[sk] = clist[0]
return outputDict, outputFreqList
def tune_if(snap_hosts, fpgfile=None, target_rms=TARGET_RMS):
"""
Function to tune the IF
"""
logger = logger_defaults.getModuleLogger(__name__)
logger.info("IF tuner entered")
assert type(snap_hosts) == list
if type(snap_hosts[0]) == str:
snaps_dict = {
snap: ata_snap_fengine.AtaSnapFengine(
snap, transport=casperfpga.KatcpTransport)
for snap in snap_hosts
}
elif type(snap_hosts[0]) == ata_snap_fenging.AtaSnapFengine:
snaps_dict = {snap.hostname: snap for snap in snap_hosts}
if not fpgfile:
fpgfile = FPGFILE
for feng in snaps_dict.values():
feng.fpga.get_system_information(fpgfile)
snap_names = list(snaps_dict.keys())
if_tab = ATA_SNAP_IF[ATA_SNAP_IF.snap_hostname.isin(snap_names)]
ant_ch = if_tab.values[:, 1:].flatten()
logger.info("Tuning: %s" % if_tab.snap_hostname)
logger.info("Attemp chans: %s" % ant_ch)
prev_attn = np.array([START_ATTN] * len(ant_ch))
for i in range(3):
prev_attn[prev_attn > MAX_ATT] = MAX_ATT
prev_attn[prev_attn < MIN_ATT] = MIN_ATT
_setatten(ant_ch, prev_attn)
rms = []
for snap_name in list(if_tab.snap_hostname.values):
snap = snaps_dict[snap_name]
set_device_lock(snap_name)
x, y = snap.adc_get_samples()
release_device_lock(snap_name)
rms.append(x.std())
rms.append(y.std())
rms = np.array(rms)
d_attn = 20 * np.log10(rms / target_rms)
prev_attn = round50th(prev_attn + d_attn)
logger.info("IF tuner ended")
def plotWaterfall(host,
wlen,
rfc=None,
fpga_file=snap_defaults.plot_snap_file,
srate=snap_defaults.srate,
ifc=snap_defaults.ifc):
snap = getSelectSnap(host, fpga_file, srate, sel='auto')
if not rfc or rfc == 0.0:
rfc = ata_control.get_sky_freq()
logger = logger_defaults.getModuleLogger(__name__)
logger.info(
"no rfc provided. rfc readed from the ata sky frequency: {}".
format(rfc))
plt.ion()
fig, ax = plt.subplots(1, 2)
fig.was_closed = False
fig.canvas.mpl_connect('close_event', handle_close)
frange, d0, d1 = snap_recorder.get_log_data(snap, 'auto', rfc, srate, ifc)
dataX = np.zeros((wlen, len(d0)))
dataY = np.zeros((wlen, len(d1)))
dataExtent = [frange[0], frange[-1], wlen - 1, 0]
dataX[0, :] = d0
dataY[0, :] = d1
while (not fig.was_closed):
ax[0].clear()
ax[1].clear()
mp1 = ax[0].imshow(dataX,
aspect='auto',
interpolation='none',
extent=dataExtent)
mp2 = ax[1].imshow(dataY,
aspect='auto',
interpolation='none',
extent=dataExtent)
ax[0].set_ylabel("snap no")
ax[0].set_xlabel("Frequency [MHz]")
ax[1].set_xlabel("Frequency [MHz]")
ax[0].set_title('X pol')
ax[0].set_title('Y pol')
plt.show()
plt.pause(0.001)
frange, d0, d1 = snap_recorder.get_log_data(snap, 'auto', rfc, srate,
ifc)
dataX[1:, :] = dataX[0:-1, :]
dataY[1:, :] = dataY[0:-1, :]
dataX[0, :] = d0
dataY[0, :] = d1
def get_all_meas_dict(setid, antenna_list):
logger = logger_defaults.getModuleLogger(__name__)
mydb = ATASQL.connectObsDb()
mycursor = mydb.cursor()
if not antenna_list:
logger.warning('antenna list empty for id {}'.format(setid))
return None
insertcmd_part = (
"select recordings.freq,recordings.description,recordings.id, "
"rec_ants.ant,rec_ants.az,rec_ants.el "
"from (recordings inner join rec_ants on recordings.id = rec_ants.id ) "
"where recordings.status = 'OK' and recordings.setid = %s ")
cpart2 = (" and rec_ants.ant in (%s)")
in_p = ', '.join(map(lambda x: '%s', antenna_list))
insertcmd_part2 = cpart2 % in_p
insertcmd = insertcmd_part + insertcmd_part2
exec_list = [setid] + antenna_list
logger.info("getting previous measurements for id {} antennas {}".format(
setid, ",".join(antenna_list)))
mycursor.execute(insertcmd, exec_list)
myiterator = mycursor.fetchall()
if not myiterator:
mycursor.close()
mydb.close()
return None
returndict = {}
for (freq, desc, obsid, ant, az, el) in myiterator:
if ant not in returndict:
cdict = {'freq': [], 'desc': [], 'obsid': [], 'az': [], 'el': []}
returndict[ant] = cdict
returndict[ant]['freq'].append(freq)
returndict[ant]['desc'].append(desc)
returndict[ant]['obsid'].append(obsid)
returndict[ant]['az'].append(az)
returndict[ant]['el'].append(el)
mycursor.close()
mydb.close()
return returndict
def get_next(source_list, ant_groups, freq_list, d=None):
logger = logger_defaults.getModuleLogger(__name__)
if (d == None):
d = dt.datetime.now()
# First, determine if there is a source up. Go through the source_list
# in prder and get the first one that is up
best_source_up = ata_positions.ATAPositions.getFirstInListThatIsUp(
source_list, d)
logger.debug(best_source_up)
if (best_source_up == None):
logger.warning("No source is up")
return None
if (best_source_up['status'] == 'next_up'):
logger.info("no source is up, next up in {0:f} minutes".format(
best_source_up['minutes']))
return { "status" : "none_up", "next_up" : best_source_up['source'], \
"minutes" : best_source_up['minutes'] }
source = best_source_up['source']
logger.info("Best source = %s" % source)
result = {}
selected_source = source
selected_freq = 0.0
selected_ants = []
for snap_index, snap in enumerate(
snap_list): # enumerate() gives us the index
next_info = pick_next_freq_ant_for_snap(snap, ant_list[snap_index],
freq_list, source)
# If this is the first snap, this determines the frequency to use
if (snap_index == (len(snap_list) - 1)):
selected_freq = next_info['freq']
selected_ants.append(next_info['ant'])
return {
"status": "OK",
"source": source,
"ants": selected_ants,
"freq": selected_freq
}
def print_ant_recording_list(rec_list, headers=None, printHeaderNames=True):
"""
Print the content of recordingAntennaList(rec_list)
if headers=None, prints all fields
if printHeaderNames is true, prints the first line with header description
"""
logger = logger_defaults.getModuleLogger(__name__)
avalHeaders = 'setid,recid,ant,freq,description,tstart,tstop,type,source,az,el'
if not headers:
htoprint = avalHeaders.split(',')
else:
htoprint = headers.split(',')
if printHeaderNames:
print('\t'.join(htoprint))
for crow in rec_list:
slist = []
for cheader in htoprint:
if cheader == 'setid':
slist.append('{0:d}'.format(crow['setid']))
elif cheader == 'recid':
slist.append('{0:d}'.format(crow['recid']))
elif cheader == 'ant':
slist.append('{0:s}'.format(crow['ant']))
elif cheader == 'freq':
slist.append('{0:.2f}'.format(crow['freq']))
elif cheader == 'description':
slist.append('{0:s}'.format(crow['desc']))
elif cheader == 'tstart':
slist.append('{}'.format(crow['tstart']))
elif cheader == 'tstop':
slist.append('{}'.format(crow['tstop']))
elif cheader == 'type':
slist.append('{0:s}'.format(crow['type']))
elif cheader == 'source':
slist.append('{0:s}'.format(crow['source']))
elif cheader == 'az':
slist.append('{0:.2f}'.format(crow['az']))
elif cheader == 'el':
slist.append('{0:.2f}'.format(crow['el']))
else:
logger.error('unknown header')
raise KeyError('unknown header')
print('\t'.join(slist))
def setatten(antpol_dict):
"""
antpol_dict: dict with example values
{'1ax': 12.0, '1ay': 13.5}
"""
logger = logger_defaults.getModuleLogger(__name__)
antlo_list = []
for antpol, attenval in antpol_dict.items():
if not (antpol.endswith("x") or antpol.endswith("y")):
raise RuntimeError("Antpol (%s) doesn't end with 'x' or 'y'" %
(antpol))
ant = antpol[:-1]
antlo_list.append(ant)
antlo_list = list(set(antlo_list))
obs_ant_tab = ATA_SNAP_TAB[ATA_SNAP_TAB.antlo.isin(antlo_list)]
attemp_modules = set(ATA_SNAP_IF.module.tolist())
for att_mod in attemp_modules:
ata_snap_if_this_attmod = ATA_SNAP_IF[ATA_SNAP_IF.module == att_mod]
if_channels = []
atten_values = []
for antpol, attenval in antpol_dict.items():
antlo = antpol[:-1]
pol = antpol[-1]
if antlo not in list(ATA_SNAP_TAB.antlo):
raise RuntimeError("Antenna (%s) not in antenna list: %s" %
(ant, list(ATA_SNAP_TAB.antlo)))
snap_hostname = ATA_SNAP_TAB[ATA_SNAP_TAB.antlo ==
antlo].snap_hostname.values[0]
if not snap_hostname in list(
ata_snap_if_this_attmod.snap_hostname):
continue
snap_if_entry = ATA_SNAP_IF[ATA_SNAP_IF.snap_hostname ==
snap_hostname]
if_ch = snap_if_entry['ch' + pol].values[0]
if_channels.append(if_ch)
atten_values.append(attenval)
if not if_channels:
continue
_setatten(if_channels, atten_values, att_mod)
