def main():
logger = logger_defaults.getProgramLogger("observe", loglevel=logging.INFO)
# Define antennas
ant_list = [
"1c", "1g", "1h", "1k", "1e", "2a", "2b", "2c", "2e", "2h", "2j", "2k",
"2l", "2m", "3c", "3d", "3l", "4j", "5b", "4g"
]
ata_control.reserve_antennas(ant_list)
atexit.register(ata_control.release_antennas, ant_list, False)
obs_time = 300
antlo_list = [ant + lo.upper() for ant in ant_list for lo in ['b', 'c']]
freqs = [2200] * len(ant_list)
freqs_c = [3000] * len(ant_list)
ata_control.set_freq(freqs, ant_list, lo='b', nofocus=True)
ata_control.set_freq(freqs_c, ant_list, lo='c')
time.sleep(30)
source = "3c295"
ata_control.make_and_track_ephems(source, ant_list)
ata_control.autotune(ant_list)
snap_if.tune_if_antslo(antlo_list)
obs_time = 650
print("=" * 79)
print("start_record_in_x.py -H 1 2 3 4 5 6 7 8 -i 15 -n %i" % obs_time)
os.system("start_record_in_x.py -H 1 2 3 4 5 6 7 8 -i 15 -n %i" % obs_time)
print("Recording for %i seconds..." % obs_time)
time.sleep(obs_time + 20)
for i in range(10):
source = "3c345"
ata_control.make_and_track_ephems(source, ant_list)
time.sleep(20) #make sure delay engine is updated
print("=" * 79)
print("start_record_in_x.py -H 1 2 3 4 5 6 7 8 -i 15 -n %i" % obs_time)
os.system("start_record_in_x.py -H 1 2 3 4 5 6 7 8 -i 15 -n %i" %
obs_time)
print("Recording for %i seconds..." % obs_time)
time.sleep(obs_time + 20)
source = "3c295"
ata_control.make_and_track_ephems(source, ant_list)
time.sleep(20) #make sure delay engine is updated
print("=" * 79)
print("start_record_in_x.py -H 1 2 3 4 5 6 7 8 -i 15 -n %i" % obs_time)
os.system("start_record_in_x.py -H 1 2 3 4 5 6 7 8 -i 15 -n %i" %
obs_time)
print("Recording for %i seconds..." % obs_time)
time.sleep(obs_time + 20)
def main():
logger = logger_defaults.getProgramLogger("observe", loglevel=logging.INFO)
antlo_list = [
"1cB", "1eB", "1gB", "1hB", "1kB", "2aB", "2bB", "2cB", "2eB", "2hB",
"2jB", "2lB", "2mB", "3cB", "3dB", "3lB", "4jB", "5bB", "4gB"
]
ant_list = list(set([antlo[:-1] for antlo in antlo_list]))
los = list(set([antlo[-1] for antlo in antlo_list]))
#freqs = [950]*3 + [1600]*3 + [2250]*3
#ant_list = ["1f"]
freqs = [3000] * len(ant_list)
freqs = [6000] * len(ant_list)
#freqs = [8450]*len(ant_list)
ata_control.reserve_antennas(ant_list)
atexit.register(ata_control.release_antennas, ant_list, False)
#ata_control.set_freq(freqs, ant_list, lo='a')
ata_control.set_freq(freqs, ant_list, lo='b')
time.sleep(30)
source = "3c286"
ata_control.make_and_track_ephems(source, ant_list)
ata_control.autotune(ant_list)
snap_if.tune_if_antslo(antlo_list)
def main():
logger = logger_defaults.getProgramLogger("observe",
loglevel=logging.INFO)
# pulsar observation
ant_list = ["1c", "1e", "1g", "1h", "1k", "2a", "2b", "2c",
"2e", "2h", "2j", "2k", "2l", "2m", "3c", "3d",
"3l", "4j", "5b", "4g"] #2a? 1k?
ant_list = ["1c", "1h", "1k", "2a", "2b",
"2e", "2h", "2j", "2k", "2l", "3c", "3d",
"3l", "4j", "5b", "4g"] #2a? 1k?
ant_list = ["1c", "2a", "4j", "2h", "3d", "4g", "1k", "1h", "2b"]
lo = "a"
antlo_list = [ant+lo.upper() for ant in ant_list]
freqs = [2200]*len(ant_list)
ata_control.reserve_antennas(ant_list)
atexit.register(ata_control.release_antennas, ant_list, False)
ata_control.set_freq(freqs, ant_list, lo='a')
time.sleep(20)
#ata_control.set_freq(freqs_c, ant_list, lo='c')
#time.sleep(30)
#source = "3c84"
#ata_control.make_and_track_ephems(source, ant_list)
#ata_control.autotune(ant_list)
snap_if.tune_if_antslo(antlo_list)
def main():
logger = logger_defaults.getProgramLogger("observe", loglevel=logging.INFO)
ant_list = [
"1c", "1g", "1h", "1k", "1e", "2a", "2b", "2c", "2e", "2h", "2j", "2k",
"2l", "2m", "3c", "3d", "3l", "4j", "5b", "4g"
] #2a? 1k?
lo = "b"
antlo_list = [ant + lo.upper() for ant in ant_list]
#antlo_list += [ant+"C" for ant in ant_list]
#los = list(set([antlo[-1] for antlo in antlo_list]))
freqs = [3000] * len(ant_list)
#freqs_c = [3000]*len(ant_list)
ata_control.reserve_antennas(ant_list)
atexit.register(ata_control.release_antennas, ant_list, False)
ata_control.set_freq(freqs, ant_list, lo='b')
#time.sleep(30)
#ata_control.set_freq(freqs_c, ant_list, lo='c', nofocus=True)
#time.sleep(30)
source = "3c295"
ata_control.make_and_track_ephems(source, ant_list)
ata_control.autotune(ant_list)
snap_if.tune_if_antslo(antlo_list)
def main():
logger = logger_defaults.getProgramLogger("observe", loglevel=logging.INFO)
# pulsar observation
ant_list = [
"1c", "1g", "1h", "1k", "1e", "2a", "2b", "2c", "2e", "2h", "2j", "2k",
"2l", "2m", "3c", "3d", "3l", "4j", "5b", "4g"
]
lo = "c"
antlo_list = [ant + lo.upper() for ant in ant_list]
#antlo_list += [ant+"C" for ant in ant_list]
#los = list(set([antlo[-1] for antlo in antlo_list]))
freqs = [3000] * len(ant_list)
freqs_c = [1400 + 800] * len(ant_list)
ata_control.reserve_antennas(ant_list)
atexit.register(ata_control.release_antennas, ant_list, False)
ata_control.set_freq(freqs, ant_list, lo='b')
time.sleep(20)
ata_control.set_freq(freqs_c, ant_list, lo='c', nofocus=True)
time.sleep(30)
source = "3c454.3"
ata_control.make_and_track_ephems(source, ant_list)
def main():
logger = logger_defaults.getProgramLogger("observe",
loglevel=logging.INFO)
# pulsar observation
antlo_list = ["1aA", "1fA", "1cA", "2aA", "4jA", "2hA", "3dA", "4gA", "1kA", "5cA", "1hA", "2bA",
"1cB", "1eB", "1gB", "1hB",
"1kB", "2aB", "2bB", #"2cB",
"2eB", "2hB", "2jB"]
ant_list = [antlo[:-1] for antlo in antlo_list]
los = list(set([antlo[-1] for antlo in antlo_list]))
#freqs = [950]*3 + [1600]*3 + [2250]*3
#ant_list = ["1f"]
freqs = [1500]*len(ant_list)
ata_control.reserve_antennas(list(set(ant_list)))
atexit.register(ata_control.release_antennas, list(set(ant_list)), True)
ata_control.set_freq(freqs, ant_list, lo='a')
ata_control.set_freq(freqs, ant_list, lo='b')
time.sleep(30)
source = "J0332+5434"
ata_control.make_and_track_ephems(source, list(set(ant_list)))
ata_control.autotune(ant_list, power_level=-15)
snap_if.tune_if_antslo(antlo_list)
obs_time = 600
utc = snap_dada.start_recording(antlo_list, obs_time,
disable_rfi=True, npolout=1, acclen=120)
def main():
logger = logger_defaults.getProgramLogger("observe", loglevel=logging.INFO)
# pulsar observation
ant_list = [
"1c", "1e", "1g", "1h", "1k", "2a", "2b", "2c", "2e", "2h", "2j", "2l",
"2m", "3c", "3d", "3l", "4j", "5b", "4g", "2k"
]
antlo_list = [ant + "B" for ant in ant_list]
#antlo_list += [ant+"C" for ant in ant_list]
#los = list(set([antlo[-1] for antlo in antlo_list]))
#freqs = [1800]*len(ant_list)
freqs = [3000] * len(ant_list)
ata_control.reserve_antennas(ant_list)
atexit.register(ata_control.release_antennas, ant_list, False)
ata_control.set_freq(freqs, ant_list, lo='b')
time.sleep(30)
source = "m31"
ata_control.make_and_track_ephems(source, ant_list)
ata_control.autotune(ant_list)
snap_if.tune_if_antslo(antlo_list)
def main():
logger = logger_defaults.getProgramLogger("observe", loglevel=logging.INFO)
# pulsar observation
ant_list = [
"1c", "1e", "1g", "1h", "2a", "2b", "2c", "2e", "2h", "2j", "2k", "2l",
"2m", "3c", "3d", "3l", "4j", "5b", "4g"
] #1k left out cuz of weird movement
antlo_list = [ant + "B" for ant in ant_list]
#antlo_list += [ant+"C" for ant in ant_list]
#los = list(set([antlo[-1] for antlo in antlo_list]))
freqs = [3500] * len(ant_list)
ata_control.reserve_antennas(ant_list)
atexit.register(ata_control.release_antennas, ant_list, False)
ata_control.set_freq(freqs, ant_list, lo='b')
time.sleep(30)
#source = "3c345"
#ata_control.make_and_track_ephems(source, ant_list)
#goes_az = 203.323 #121.96 (goes 16)
#goes_el = 40.119 #23.63
az = 223.323
el = 40.119
ata_control.set_az_el(ant_list, az, el)
ata_control.autotune(ant_list)
snap_if.tune_if_antslo(antlo_list)
def main():
logger = logger_defaults.getProgramLogger("observe", loglevel=logging.INFO)
# pulsar observation
ant_list = [
"1c", "1e", "1g", "1h", "1k", "2a", "2b", "2c", "2e", "2h", "2j", "2l",
"2m", "3c", "3d", "3l", "4j", "5b", "4g", "2k"
]
antlo_list = [ant + "B" for ant in ant_list]
#antlo_list += [ant+"C" for ant in ant_list]
#los = list(set([antlo[-1] for antlo in antlo_list]))
#freqs = [1800]*len(ant_list)
freqs = [3000] * len(ant_list)
ata_control.reserve_antennas(ant_list)
atexit.register(ata_control.release_antennas, ant_list, False)
ata_control.set_freq(freqs, ant_list, lo='b')
time.sleep(30)
#source = "casa"
offset = 12 / 60. #degrees
ra = 23.391 + (offset / 360 * 24) #hours
dec = 58.808 + offset
ata_control.make_and_track_ra_dec(ra, dec, ant_list)
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 main():
logger = logger_defaults.getProgramLogger("observe", loglevel=logging.INFO)
# multiple source observation
ant_list = [
"1c", "1e", "1g", "1h", "1k", "2a", "2b", "2c", "2e", "2h", "2j", "2l",
"2k", "2m", "3c", "3d", "3l", "4j", "5b", "4g"
]
antlo_list = [ant + "B" for ant in ant_list]
freqs = [3000] * len(ant_list)
ata_control.reserve_antennas(ant_list)
atexit.register(ata_control.release_antennas, ant_list, False)
ata_control.set_freq(freqs, ant_list, lo='b')
#time.sleep(30)
source_name = ['3c273', '3c286', '3c295']
do_autotune = True
while True:
for i, source in enumerate(source_name):
print(i, source)
if 85 > ata_sources.check_source(source)['el'] > 21:
ata_control.make_and_track_ephems(source, ant_list)
if do_autotune:
ata_control.autotune(ant_list)
snap_if.tune_if_antslo(antlo_list)
do_autotune = False
print("Tuning complete")
#time.sleep(20)
obs_time = 610 #925 #seconds
print("=" * 79)
print("Starting new obs")
print("start_record_in_x.py -H 1 2 3 4 -i 10 -n %i" % obs_time)
os.system("start_record_in_x.py -H 1 2 3 4 -i 10 -n %i" %
obs_time)
print("Recording on sky source %s..." % source)
time.sleep(obs_time + 20)
print("=" * 79)
print("Obs completed")
else:
print(
str(source) +
" is not high (or low) enough to observe, trying again once all others are targeted"
)
def main():
logger = logger_defaults.getProgramLogger("observe", loglevel=logging.INFO)
# multiple source observation
ant_list = [
"1c", "1e", "1g", "1h", "1k", "2a", "2b", "2c", "2e", "2h", "2j", "2l",
"2m", "3c", "3d", "3l", "4j", "5b", "4g"
] #2k left out
antlo_list = [ant + "B" for ant in ant_list]
freqs = [1500] * len(ant_list)
ata_control.reserve_antennas(ant_list)
atexit.register(ata_control.release_antennas, ant_list, False)
ata_control.set_freq(freqs, ant_list, lo='b')
#time.sleep(30)
print("Aquiring source list")
lista = []
with open("source_radec.txt") as f:
source_list = f.readlines()[1:]
for x in source_list:
lista.append(x.split(' ')[0])
source_name = lista
print(source_name)
#source_name = source_name[1] #if you want to just observe one of the sources
print("source list aquired")
for i, source in enumerate(source_name):
print(i, source)
if ata_sources.check_source(source)['el'] > 17:
ata_control.make_and_track_ephems(source, ant_list)
ata_control.autotune(ant_list)
snap_if.tune_if_antslo(antlo_list)
obs_time = 30
#_ = input("press enter to continue")
utc = snap_dada.start_recording(antlo_list,
obs_time,
disable_rfi=True,
npolout=1,
acclen=120)
else:
continue
def main():
logger = logger_defaults.getProgramLogger("observe", loglevel=logging.INFO)
# Define antennas
ant_list = [
"1c", "1g", "1h", "1k", "1e", "2a", "2b", "2c", "2e", "2h", "2j", "2k",
"2l", "2m", "3c", "3d", "3l", "4j", "5b", "4g"
]
ata_control.reserve_antennas(ant_list)
atexit.register(ata_control.release_antennas, ant_list, False)
obs_time = 300
antlo_list = [ant + lo.upper() for ant in ant_list for lo in ['b', 'c']]
source = "3c48"
freqs = [1400] * len(ant_list)
ata_control.set_freq(freqs, ant_list, lo='b') #, nofocus=True)
#ata_control.set_freq(freqs_c, ant_list, lo='c')
ata_control.make_and_track_ephems(source, ant_list)
ata_control.autotune(ant_list)
snap_if.tune_if_antslo(antlo_list)
print("Tuning complete")
print("=" * 79)
print("Starting new obs")
print("start_record_in_x.py -H 1 2 3 4 5 6 7 8 -i 15 -n %i" % obs_time)
os.system("start_record_in_x.py -H 1 2 3 4 5 6 7 8 -i 15 -n %i" % obs_time)
print("Recording...")
time.sleep(obs_time + 20)
print("=" * 79)
print("Source 1 Obs completed")
#SOURCE 2
source = "3c84"
freqs = [1400 + 800] * len(ant_list)
ata_control.set_freq(freqs, ant_list, lo='b') #, nofocus=True)
ata_control.make_and_track_ephems(source, ant_list)
snap_if.tune_if_antslo(antlo_list)
print("Tuning complete")
print("=" * 79)
print("Starting new obs")
print("start_record_in_x.py -H 1 2 3 4 5 6 7 8 -i 15 -n %i" % obs_time)
os.system("start_record_in_x.py -H 1 2 3 4 5 6 7 8 -i 15 -n %i" % obs_time)
print("Recording...")
time.sleep(obs_time + 20)
print("=" * 79)
print("Obs completed")
def main():
logger = logger_defaults.getProgramLogger("observe", loglevel=logging.INFO)
# Define antennas
ant_list = [
"1c", "1g", "1h", "1k", "1e", "2a", "2b", "2c", "2e", "2h", "2j", "2k",
"2l", "2m", "3c", "3d", "3l", "4j", "5b", "4g"
]
ata_control.reserve_antennas(ant_list)
atexit.register(ata_control.release_antennas, ant_list, False)
antlo_list = [ant + lo.upper() for ant in ant_list for lo in ['b', 'c']]
freqs = [3000] * len(ant_list)
freqs_c = [3000] * len(ant_list)
# set LO + focus frequencies
ata_control.set_freq(freqs, ant_list, lo='b', nofocus=True)
ata_control.set_freq(freqs_c, ant_list, lo='c')
time.sleep(30)
# Track source
source = "3c84"
ata_control.make_and_track_ephems(source, ant_list)
# autotune + IF tuning
ata_control.autotune(ant_list)
snap_if.tune_if_antslo(antlo_list)
print("Tuning complete")
#time.sleep(20)
xgpu_int_time = 6.5536 #seconds
obs_time = 600 #seconds
print("=" * 79)
print("Setting correlator integration time")
print("set_postproc_keys.py -s --prefix XTIMEINT=%f" % xgpu_int_time)
os.system("set_postproc_keys.py -s --prefix XTIMEINT=%f" % xgpu_int_time)
print("=" * 79)
print("Starting new obs")
print("start_record_in_x.py -H 1 2 3 4 5 6 7 8 -i 10 -n %i" % obs_time)
os.system("start_record_in_x.py -H 1 2 3 4 5 6 7 8 -i 10 -n %i" % obs_time)
print("Recording...")
time.sleep(obs_time + 20)
print("=" * 79)
print("Obs completed")
def main():
logger = logger_defaults.getProgramLogger("observe", loglevel=logging.INFO)
# pulsar observation
ant_list = ["1c", "2a", "2b", "2h"]
ata_control.reserve_antennas(ant_list)
freq = 1500
ata_control.set_freq(freq, ant_list)
source = "J0534+2200"
ata_control.make_and_track_ephems(source, ant_list)
obs_time = 3600
os.system(ATTEMP_SCRIPT)
ata_control.release_antennas(ant_list, True)
def main():
logger = logger_defaults.getProgramLogger("observe", loglevel=logging.INFO)
ant_list = [
"1c", "1e", "1g", "1h", "1k", "2a", "2b", "2c", "2e", "2h", "2j", "2k",
"2l", "2m", "3c", "3d", "3l", "4j", "5b", "4g"
] #2a? 1k?
lo = "b"
antlo_list = [ant + lo.upper() for ant in ant_list]
#antlo_list += [ant+"C" for ant in ant_list]
#los = list(set([antlo[-1] for antlo in antlo_list]))
freqs = [4000] * len(ant_list)
ata_control.reserve_antennas(ant_list)
atexit.register(ata_control.release_antennas, ant_list, False)
ata_control.set_freq(freqs, ant_list, lo='b')
#time.sleep(20)
#ata_control.set_freq(freqs_c, ant_list, lo='c')
#time.sleep(30)
cal_source = '3c273'
source = "virgo"
ata_control.make_and_track_ephems(source, ant_list)
ata_control.autotune(ant_list)
snap_if.tune_if_antslo(antlo_list)
os.system("start_record_in_x.py -H 1 2 3 4 -i 5 -n 3600")
time.sleep(3600)
ata_control.make_and_track_ephems(cal_source, ant_list)
os.system("start_record_in_x.py -H 1 2 3 4 -i 5 -n 180")
time.sleep(180)
for i in range(10):
ata_control.make_and_track_ephems(source, ant_list)
os.system("start_record_in_x.py -H 1 2 3 4 -i 5 -n 1800")
time.sleep(1800)
ata_control.make_and_track_ephems(cal_source, ant_list)
os.system("start_record_in_x.py -H 1 2 3 4 -i 5 -n 180")
time.sleep(180)
def main():
logger = logger_defaults.getProgramLogger("observe",
loglevel=logging.INFO)
ant_list = ["1c", "1e", "1g", "1h", "1k", "2a", "2b", "2c",
"2e", "2h", "2j", "2l", "2m", "3c", "3d",
"3l", "4j", "5b", "4g", "2k"]
antlo_list = [ant+"B" for ant in ant_list]
#antlo_list += [ant+"C" for ant in ant_list]
ata_control.reserve_antennas(ant_list)
atexit.register(ata_control.release_antennas, ant_list, False)
time.sleep(30)
freqs = np.arange(2250, 11200, 550)
obs_time = 20
start_az = 20
start_el = 0
end_az = 360
end_el = 90
step = 10
az_list = np.arange(start_az, end_az, step)
el_list = np.arange(start_el, end_el, step)
for freq in freqs:
ata_control.set_freq(freq, ant_list, lo='b')
ata_control.autotune(ant_list)
snap_if.tune_if_antslo(antlo_list)
for az in az_list:
for el in el_list:
print("az: %.2f, el: %.2f" %(az, el))
os.system("killall ata_udpdb")
ata_control.set_az_el(ant_list, az, el)
utc = snap_dada.start_recording(antlo_list, obs_time, acclen=120*16,
disable_rfi=True)
time.sleep(10)
def main():
logger = logger_defaults.getProgramLogger("observe",
loglevel=logging.INFO)
# pulsar observation
#ant_list = ["1f", "1h"]#, "1k", "5c"]
#freqs = [950, 1600]#, 1600, 950]
#ant_list = ["1a", "4j", "1k"]
#freqs = [950] + [1600] + [2250]
ant_list = ["1f", "5c", "1a", "1c", "2a", "4j", "2h", "1k", "1h"]
antlo_list = ["1aA", "1fA", "2aA", "2hA", "3dA", "4gA", "1kA", "5cA", "1hA", "2bA",
"1cB", "1eB", "1gB", #rfsoc1
# "2cB", #rfsoc2
"2eB", "2jB", #"2kB", #rfsoc3
"2mB", "3cB", #rfsoc4
"3lB", "5bB", "4jB" #rfsoc5
]
freq = 1500
ant_list = [antlo[:-1] for antlo in antlo_list]
#ant_list = ["1f", "1k"]
#freqs = [950, 1600]
ata_control.reserve_antennas(ant_list)
atexit.register(ata_control.release_antennas, ant_list, False)
source = "j0534+2200"
ata_control.make_and_track_ephems(source, ant_list)
ata_control.autotune(ant_list)
#snap_dada.set_freq_auto(freqs, ant_list)
ata_control.set_freq([freq]*len(ant_list), ant_list, lo='a')
time.sleep(20)
ata_control.set_freq([freq]*len(ant_list), ant_list, lo='b')
#snap_if.tune_if_ants(ant_list)
snap_if.tune_if_antslo(antlo_list)
obs_time = 1200
#for i in range(3):
utc = snap_dada.start_recording(antlo_list, obs_time,
npolout=1, acclen=120, disable_rfi=True)
mv_utc_antlo_to_ant(utc)
def main():
logger = logger_defaults.getProgramLogger("observe", loglevel=logging.INFO)
# FRB observation
ant_list = [
"1c", "1e", "1g", "1h", "1k", "2a", "2b", "2c", "2e", "2h", "2j", "2l",
"2m", "3c", "3d", "3l", "4j", "5b", "4g"
] #no 2k yet
lo = "B"
antlo_list = [ant + lo for ant in ant_list]
freqs = [1500] * len(ant_list)
ata_control.reserve_antennas(list(set(ant_list)))
atexit.register(ata_control.release_antennas, list(set(ant_list)), True)
ata_control.set_freq(freqs, ant_list, lo='b')
time.sleep(30)
source = "J1934+2153"
ata_control.make_and_track_ephems(source, list(set(ant_list)))
ata_control.autotune(ant_list, power_level=-15)
obs_time = 1200
#Note - ncycles should not be less than nhours, to ensure that the backend
#can catch up and process the files before filling up disk space
nhours = 1
ncycles = 3
for icycle in range(ncycles):
for i in range(nhours * 3):
snap_if.tune_if_antslo(antlo_list)
utc = snap_dada.start_recording(antlo_list,
obs_time,
npolout=1,
acclen=120,
disable_rfi=True)
mv_utc_antlo_to_ant(utc)
Path('/mnt/buf0/obs/%s/obs.sumall' % utc).touch()
snap_dada.mark_obs_for_heimdall(utc)
time.sleep(300)
def main():
logger = logger_defaults.getProgramLogger("observe", loglevel=logging.INFO)
ant_list = [
"1c", "1e", "1g", "1h", "2a", "2b", "2c", "2e", "2h", "2j", "2k", "2l",
"2m", "3c", "3d", "3l", "4j", "5b", "4g"
] # whats going on with 1k? 2k points somewhere else
ant_2k = ['2k']
lo = 'B'
antlo_list = [ant + lo for ant in ant_list]
pams = {ant + pol: 27 for ant in ant_list for pol in ["x", "y"]}
ifs = {antlo + pol: 20 for antlo in antlo_list for pol in ["x", "y"]}
ata_control.set_pams(pams)
snap_if.setatten(ifs)
freq = 1600
#snap_dada.set_freq_auto([freq]*len(ant_list), ant_list)
ata_control.set_freq([freq] * len(ant_list), ant_list, lo='b')
obs_time = 60
az = 203.323 #121.96
el = 40.119 #23.63
#step = 2
#az_list = np.arange(goes_az - 10, goes_az + 10, step)
#el_list = np.arange(goes_el - 10, goes_el + 10, step)
#for az in az_list:
# for el in el_list
print("az: %.2f, el: %.2f" % (az, el))
os.system("killall ata_udpdb")
ata_control.set_az_el(ant_2k, az, el)
utc = snap_dada.start_recording(antlo_list,
obs_time,
acclen=120 * 16,
disable_rfi=True)
time.sleep(10)
def main():
logger = logger_defaults.getProgramLogger("observe",
loglevel=logging.INFO)
ant_list = ["1c", "1g", "1h", "1k", "1e", "2a", "2b", "2c",
"2e", "2h", "2j", "2k", "2l", "2m", "3c", "3d",
"3l", "4j", "5b", "4g"] #2a? 1k?
ata_control.reserve_antennas(ant_list)
atexit.register(ata_control.release_antennas, ant_list, False)
antlo_list = [ant+lo.upper() for ant in ant_list for lo in ['b','c']]
#freqs_list = np.arange(1500,10000,500)[11:]
freqs_list = [3000,6000,9000]
source = "3c84"
ata_control.make_and_track_ephems(source, ant_list)
ata_control.autotune(ant_list)
obs_time = 3760
for freq in freqs_list:
freqs = [freq]*len(ant_list)
freqs_c = [freq]*len(ant_list)
ata_control.set_freq(freqs, ant_list, lo='b', nofocus=True)
ata_control.set_freq(freqs_c, ant_list, lo='c')
time.sleep(30)
#snap_if.tune_if_antslo(antlo_list)
print("="*79)
print("Starting new obs at obsfreq: %f" %freq)
print("start_record_in_x.py -H 1 2 3 4 5 6 7 8 -i 15 -n %i" %obs_time)
os.system("start_record_in_x.py -H 1 2 3 4 5 6 7 8 -i 15 -n %i" %obs_time)
print("Recording for %i seconds..." %obs_time)
time.sleep(obs_time+20)
print("="*79)
print("Obs completed")
def main():
alist = ['1a', '1c', '2h'] #define antennas list (alist)
src = 'moon' #define target source
#az_off = 5 #define azimuth offset for on-off scan
#el_off = 5 #define elevation offset for on-off scan
freq = 1400 #set center frequency in MHz
duration = 30 #duration of tracking
#lock out the antennas you will be using
ac.reserve_antennas(alist)
#turn on the LNAs if they're not already on
ac.try_on_lnas(alist)
#set up with Autotune
ac.autotune(alist)
#display starting coordinates so
#you can verify antennas have moved
start_radec = ac.getRaDec(alist)
print("The current coordinates are: ", start_radec)
#create ephemeris file that tells the antenna
#where it should be pointing at each timestamp
ac.make_and_track_ephems(src, alist)
#set the center frequency
ac.set_freq(freq, alist)
#print the coordinates after the antennas have
#been given the point and track command to ensure
#that they moved.
src_radec = ac.getRaDec(alist)
print("The source coordinates are: ", src_radec)
#stay on source for the given duration
time.sleep(duration)
#unlock the antennas once you're done
ac.release_antennas(alist, True)
def main():
parser = ArgumentParser(description='ATA Antenna Controller')
parser.add_argument(
'--frequency',
'-f',
type=int,
default=3000,
help=
"Frequency in MHz to tune the LOs to default is 3000 (e.g. 3000 for 3 GHz)",
required=False)
args = parser.parse_args()
ants_lo_a = ["1c", "2a", "4j"] # Lo a
ants_lo_b = ["1a", "1f", "4g", "5c"] # LO b
ants_lo_c = ["2h", "1k", "1h"]
ants_lo_d = ["2b", "3c"]
ant_list = ants_lo_a + ants_lo_b + ants_lo_c + ants_lo_d
# Reserve antennas, and make sure to unreserve when code exists
print("Reserving antennas " + str(ant_list))
ata_control.reserve_antennas(ant_list)
# Tune the RF over fiber power
freq = args.frequency
print("Autotuning to " + str(freq) + "...")
ata_control.autotune(ant_list)
ata_control.set_freq(freq, ants_lo_a, lo='a')
ata_control.set_freq(freq, ants_lo_b, lo='b')
ata_control.set_freq(freq, ants_lo_c, lo='c')
ata_control.set_freq(freq, ants_lo_d, lo='d')
# pick source and point dishes
while True:
cmd = input("'park' to exit or target name (e.g. casa or 3c84) ")
if cmd == 'park':
break
source = cmd
print("[" + str(datetime.now().strftime("%Y-%m-%d %H:%M:%S")) +
"] Tracking to " + source)
ata_control.make_and_track_source(source, ant_list)
print("[" + str(datetime.now().strftime("%Y-%m-%d %H:%M:%S")) +
"] Running.")
_ = input("Press ENTER to change state")
print("Releasing antennas...")
ata_control.release_antennas(ant_list, True)
print("Done.")
def main():
logger = logger_defaults.getProgramLogger("observe",
loglevel=logging.INFO)
#parser = argparse.ArgumentParser(description="Observing script")
#parser.add_argument("ants", nargs="+", help="ant names")
#args = parser.parse_args()
#ants = args.ants
nbatches = 15
ant_list = ["1a","1c","1f","2a","2b","2h","4g","5c"]
az_offset = 0
el_offset = 10
obs_time = 30
source = "casa"
#source = "moon"
ata_control.try_on_lnas(ant_list)
#ata_control.make_and_track_ephems(source, ant_list)
ata_control.create_ephems2(source, az_offset, el_offset)
#freqs = np.arange(1200, 8000, 400)
freqs = np.arange(1000, 11000, 500)
for freq in freqs:
print (freq)
ata_control.set_freq(freq, ant_list)
# record on
ata_control.point_ants2(source, "on", ant_list)
ant_list.append('rfi')
utc = snap_dada.start_recording(ant_list, obs_time)
ant_list.remove('rfi')
# record off
ata_control.point_ants2(source, "off", ant_list)
ant_list.append('rfi')
utc = snap_dada.start_recording(ant_list, obs_time)
ant_list.remove('rfi')
ata_control.release_antennas(ant_list, True)
def main():
logger = logger_defaults.getProgramLogger("observe", loglevel=logging.INFO)
ant_list = ['2k', '2e', '2m', '2j', '3d', '1k']
lo = 'B'
antlo_list = [ant + lo for ant in ant_list]
pams = {ant + pol: 27 for ant in ant_list for pol in ["x", "y"]}
ifs = {antlo + pol: 20 for antlo in antlo_list for pol in ["x", "y"]}
ata_control.set_pams(pams)
snap_if.setatten(ifs)
freq = 1600
#snap_dada.set_freq_auto([freq]*len(ant_list), ant_list)
ata_control.set_freq([freq] * len(ant_list), ant_list, lo='b')
obs_time = 20
#goes 17
goes_az = 203.323 #121.96 (goes 16)
goes_el = 40.119 #23.63
step = 0.5
az_list = np.arange(goes_az - 3, goes_az + 3, step)[6:]
el_list = np.arange(goes_el - 3, goes_el + 3, step)
for az in az_list:
for el in el_list:
print("az: %.2f, el: %.2f" % (az, el))
os.system("killall ata_udpdb")
ata_control.set_az_el(ant_list, az, el)
utc = snap_dada.start_recording(antlo_list,
obs_time,
acclen=120 * 16,
disable_rfi=True)
time.sleep(10)
def main():
logger = logger_defaults.getProgramLogger("observe", loglevel=logging.INFO)
ant_list = ['1k', '2k', '2e', '2j', '2m']
lo = 'B'
antlo_list = [ant + lo for ant in ant_list]
ata_control.reserve_antennas(ant_list)
atexit.register(ata_control.release_antennas, ant_list, False)
pams = {ant + pol: 27 for ant in ant_list for pol in ["x", "y"]}
ifs = {antlo + pol: 20 for antlo in antlo_list for pol in ["x", "y"]}
ata_control.set_pams(pams)
snap_if.setatten(ifs)
freq = 1600
#obs_time = 70
###snap_dada.set_freq_auto([freq]*len(ant_list), ant_list)
ata_control.set_freq([freq] * len(ant_list), ant_list, lo='b')
goes_az = 203.323 #121.96 (goes 16)
goes_el = 40.119 #23.63
#el swivel
#az_list = np.linspace(goes_az - 10, goes_az + 10, 60 // 5)
spac = 0.05
az_list = np.arange(goes_az - 3, goes_az + 3 + spac, spac)
el_start = goes_el + 3
el_end = goes_el - 3
#az swivel
#el_start = goes_el # - 10
#az_start = goes_az - 10
#az_end = goes_az + 10
for az_start in az_list:
os.system("killall ata_udpdb")
invr = 2.55e-5
print("az: %.2f, el: %.2f" % (az_start, el_start))
ata_control.set_az_el(ant_list, az_start, el_start)
#_ = input("enter to continue")
grace_time = 15 # time between now and antenna actually moving
t_start = time.time()
t_start += 37 #leap seconds
t_start += grace_time #let's start this in X seconds into the future
t_span = 30 #seconds
obs_time = int(t_span + 1 * grace_time)
steps = t_span // 5 #5 seconds per step
ephem = generate_ephem_el_swivel(az_start, el_start, el_end, t_start,
t_span, steps, invr)
#ephem = generate_ephem_az_swivel(az_start, az_end, el_start, t_start, t_span, steps, invr)
print(ephem)
ephem_name = "/tmp/ephem_goes17_az_%.3f.txt" % az_start
ephem_to_txt(ephem_name, ephem)
print("ephem file saved to disk")
id = upload_ephemeris(ephem_name)
ata_control.track_ephemeris(id, ant_list)
#_ = input("tracking..., hit enter to continue")
utc = snap_dada.start_recording(antlo_list,
obs_time,
acclen=120 * 4,
disable_rfi=True)
this_utc_basedir = os.path.join(snap_config.ATA_CFG['OBSDIR'], utc)
dst_ephem_file = os.path.join(this_utc_basedir,
os.path.basename(ephem_name))
copyfile(ephem_name, dst_ephem_file)
time.sleep(10)
def main():
logger = logger_defaults.getProgramLogger("observe", loglevel=logging.INFO)
# moon observation
az_offset = 20.
el_offset = 0.
#ant_list = ["1a", "1f", "1c", "2a", "2b", "3d",
# "4g", "1k", "5c", "1h", "4j", "2h"]
ant_list = [
"1c", "1e", "1g", "1h", "1k", "2a", "2b", "2c", "2e", "2h", "2j", "2k",
"2l", "2m", "3c", "3d", "3l", "4j", "5b", "4g"
]
antlo_list = [ant + "B" for ant in ant_list]
#ant_list = [antlo[:-1] for antlo in antlo_list]
ata_control.reserve_antennas(ant_list)
atexit.register(ata_control.release_antennas, ant_list, False)
obs_time = 30
n_on_off = 1
source = "moon"
ata_control.create_ephems2(source, az_offset, el_offset)
ata_control.point_ants2(source, "off", ant_list)
ata_control.autotune(ant_list)
#freqs = np.arange(1200, 9500, 350)
#freqs = np.arange(1200, 11200, 350)
#freqs = np.arange(1200, 1900, 350)
freqs = np.arange(2250, 11200, 550)
#snap_dada.set_freq_auto([freqs[0]]*len(ant_list), ant_list)
#ata_control.set_freq([freqs[0]]*len(ant_list), ant_list, lo='a')
ata_control.set_freq([freqs[0]] * len(ant_list), ant_list, lo='b')
snap_if.tune_if_antslo(antlo_list)
time.sleep(30)
utcs_all = []
for ifreq, freq in enumerate(freqs):
utcs_this_freq = []
if ifreq != 0:
#ata_control.set_freq([freq]*len(ant_list), ant_list, lo='a')
time.sleep(20)
ata_control.set_freq([freq] * len(ant_list), ant_list, lo='b')
snap_if.tune_if_antslo(antlo_list)
for i in range(n_on_off):
# record on
ata_control.point_ants2(source, "on", ant_list)
ntries = 0
while True:
try:
utc = snap_dada.start_recording(antlo_list,
obs_time,
npolout=2,
acclen=120 * 16,
disable_rfi=True)
break
except Exception as e:
print("Got exception")
print(e)
ntries += 1
if ntries > 3:
raise e
time.sleep(0.5)
utcs_this_freq.append(utc)
mv_utc_antlo_to_ant(utc)
os.system("killall ata_udpdb")
#record off
ata_control.point_ants2(source, "off", ant_list)
ntries = 0
while True:
try:
utc = snap_dada.start_recording(antlo_list,
obs_time,
npolout=2,
acclen=120 * 16,
disable_rfi=True)
break
except Exception as e:
print("Got Exception")
print(e)
ntries += 1
if ntries > 3:
raise e
time.sleep(0.5)
utcs_this_freq.append(utc)
mv_utc_antlo_to_ant(utc)
os.system("killall ata_udpdb")
utcs_all.append(utcs_this_freq)
initial_utc = utcs_all[0][0]
os.system("mkdir /mnt/datax-netStorage-40G/calibration/" + initial_utc)
for freq, utcs in zip(freqs, utcs_all):
os.system("mkdir /mnt/datax-netStorage-40G/calibration/%s/freq_%i" %
(initial_utc, freq))
for utc in utcs:
os.system(
"mv /mnt/buf0/obs/%s /mnt/datax-netStorage-40G/calibration/%s/freq_%i"
% (utc, initial_utc, freq))
os.system(
"/home/obsuser/scripts/fil2csv.py /mnt/datax-netStorage-40G/calibration/%s/*/*/*/*.fil"
% (initial_utc))
"""
os.system("mkdir /mnt/datax-netStorage-40G/calibration/"+initial_utc)
for freq, utcs in zip(freqs, utcs_all):
for utc in utcs:
os.system("mv /mnt/buf0/obs/%s /mnt/datax-netStorage-40G/calibration/%s"
%(utc, initial_utc))
"""
o = open("/mnt/datax-netStorage-40G/calibration/obs.dat", "a")
o.write("%s %s %i\n" % (initial_utc, source, n_on_off))
o.close()
def do_snap_waterfall(ant_str,freq, source, fpga_file, waterfalllen, do_park = False):
logger = logger_defaults.getModuleLogger(__name__)
ant_list = snap_array_helpers.string_to_array(ant_str);
full_ant_str = snap_array_helpers.array_to_string(ant_list)
if waterfalllen < 2:
logger.error('waterfall len too short')
raise RuntimeError('waterfall len too short')
try:
ant_groups = ata_control.get_snap_dictionary(ant_list)
except:
logstr = "unable to match antennas with snaps"
logger.exception(logstr)
raise
if len(ant_list) != 1:
logger.error('only 1 antenna allowed')
raise RuntimeError('only 1 antenna allowed')
if len(ant_groups) != 1:
logger.error('only 1 antenna allowed')
raise RuntimeError('only 1 antenna allowed')
ant_dict = {}
for csnap in ant_groups:
if len(ant_groups[csnap]) != 1:
logger.error('only one antenna per snap allowed, got {}: {}'.format(csnap,",".join(ant_groups[csnap])))
raise RuntimeError("only 1 antenna per snap allowed")
snaphost = csnap
currAnt = ant_groups[csnap][0]
logger.info("Reserving antennas %s in bfa antgroup" % full_ant_str)
try:
ata_control.reserve_antennas(ant_list)
except:
logstr = "unable to reserve the antennas"
logger.exception(logstr)
raise
logger.info("starting plotting")
try:
ata_control.try_on_lna(currAnt)
source_status = ata_positions.ATAPositions.getFirstInListThatIsUp([source])
if not source_status:
errormsg = 'source {} is not up (or too close to sun/moon)... terminating observation set {}'.format(source,obs_set_id)
logger.error(errormsg)
raise RuntimeError(errormsg)
if source_status['status'] != 'up':
if source_status['status'] == 'next_up':
errormsg = 'source {} is not up (or too close to sun/moon). Will be up in {} minutes. Terminating observation set {}'.format(source,source_status['minutes'],obs_set_id)
else:
errormsg = 'source {} is not up (or too close to sun/moon)... terminating observation set {}'.format(source,obs_set_id)
logger.error(errormsg)
raise RuntimeError(errormsg)
logger.info("pointing the antennas")
ata_control.make_and_track_ephems(source, currAnt );
logger.info("autotuning")
ata_control.autotune(currAnt)
ata_control.rf_switch_thread([currAnt])
logger.info("changing to frequency {}".format(freq))
ata_control.set_freq(freq, currAnt)
snap_recorder.setSnapRMS(snaphost,currAnt,fpga_file,default_rms)
snap_plot.plotWaterfall(snaphost, waterfalllen, freq,fpga_file)
except KeyboardInterrupt:
logger.info("Keyboard interuption")
except Exception as e:
logger.exception("something went wrong")
errmsg = "Finishing recording - failed: {}".format(e)
raise
finally:
logger.info("shutting down")
ata_control.release_antennas(ant_list, do_park)
def main():
logger = logger_defaults.getProgramLogger("observe",
loglevel=logging.INFO)
# multiple source observation
ant_list = ["1c", "1e", "1g", "1h", "1k", "2a", "2b", "2c",
"2e", "2h", "2j", "2l", "2k", "2m", "3c", "3d",
"3l", "4j", "5b", "4g"]
antlo_list = [ant+lo for ant in ant_list for lo in ['B', 'C']]
freqs = [6000]*len(ant_list)
freqs_c = [3000]*len(ant_list)
ata_control.reserve_antennas(ant_list)
atexit.register(ata_control.release_antennas, ant_list, False)
ata_control.set_freq(freqs, ant_list, lo='b')
ata_control.set_freq(freqs_c, ant_list, lo='c', nofocus=True)
#time.sleep(30)
print("Aquiring source list")
lista = []
with open("source_radec_ant_cal.txt") as f:
source_list = f.readlines()[1:]
for x in source_list:
lista.append(x.split(' ')[0])
source_name = lista
print(source_name)
do_autotune = True
while True:
for i, source in enumerate(source_name):
print(i, source)
if 85 > ata_sources.check_source(source)['el'] > 21:
ata_control.make_and_track_ephems(source, ant_list)
if do_autotune:
ata_control.autotune(ant_list)
snap_if.tune_if_antslo(antlo_list)
do_autotune = False
print("Tuning complete")
#time.sleep(20)
obs_time = 930 #610 #925 #seconds
print("="*79)
print("Starting new obs")
print("start_record_in_x.py -H 1 2 3 4 5 6 7 8 -i 15 -n %i" %obs_time)
os.system("start_record_in_x.py -H 1 2 3 4 5 6 7 8 -i 15 -n %i" %obs_time)
print("Recording on sky source %s..." %source)
time.sleep(obs_time+15+20)
print("="*79)
print("Obs completed")
else:
print(str(source) + " is not high (or low) enough to observe, trying again once all others are targeted")
def main():
logger = logger_defaults.getProgramLogger("observe", loglevel=logging.INFO)
ant_list = ['1h', '2h']
#ant_list = ["1a", "1f", "1c", "2a", "2b", "2h",
# "3c", "4g", "1k", "5c", "1h", "4j"]
#ant_list = ["1a", "1f", "1c", "2a", "2b", "3d",
# "3c", "4g", "1k", "5c", "1h", "4j"]
#ant_list = ["1c", "1e", "1g", "1h", "1k", "2a", "2b", "2c",
# "2e", "2h", "2j", "2k", "2l", "2m", "3c", "3d",
# "3l", "4j", "5b", "4g"]
lo = "B"
antlo_list = [ant + lo for ant in ant_list]
#ant_list = ["2a", "2b", "5c"]
pms = {ant: ata_pointing.PointingModel(ant) for ant in ant_list}
#pm = ata_pointing.PointingModel('3c')
ata_control.reserve_antennas(ant_list)
atexit.register(ata_control.release_antennas, ant_list, False)
#pams = {ant+pol:27 for ant in ant_list for pol in ["x","y"]}
#ifs = {antlo+pol:20 for antlo in antlo_list for pol in ["x","y"]}
#ata_control.set_pams(pams)
#snap_if.setatten(ifs)
freq = 1575
#snap_dada.set_freq_auto([freq]*len(ant_list), ant_list)
ata_control.set_freq([freq] * len(ant_list), ant_list, lo='b')
# define how to grid the sky
pbfwhm = (3.5 / freq * 1000.0)
delta = pbfwhm / 2.0
obs_time = 30
# elevation then azimuth
offsets = [[0., 4 * delta], [0., delta], [0., 0.], [0., -delta],
[0., -4 * delta], [-4 * delta, 0.], [-delta, 0.], [0., 0.],
[delta, 0.], [4 * delta, 0.]]
obs_time = 20
utcs = []
sats_observed = []
time_obs = []
t = time.time()
basedir = "/home/obsuser/pointing_2pol"
# create directory for the pointing
os.mkdir("%s/%i" % (basedir, t))
ofile = open("%s/%i/%i_atapointer.txt" % (basedir, t, t), "w")
#tpoints = {ant:open("/home/obsuser/pointing/%i/%i_%s_%p.tpoint" %(t,t,ant,polr), "w")
# for ant in ant_list}
tpoints_x = {
ant: open("%s/%i/%i_%s_x.tpoint" % (basedir, t, t, ant), "w")
for ant in ant_list
}
tpoints_y = {
ant: open("%s/%i/%i_%s_y.tpoint" % (basedir, t, t, ant), "w")
for ant in ant_list
}
atexit.register(ofile.close)
for tpointx in tpoints_x.values():
atexit.register(tpointx.close)
for tpointy in tpoints_y.values():
atexit.register(tpointy.close)
for ant in ant_list:
tpoint_file = tpoints_x[ant]
pm = pms[ant]
write_header(tpoint_file, pm, freq, "x")
for ant in ant_list:
tpoint_file = tpoints_y[ant]
pm = pms[ant]
write_header(tpoint_file, pm, freq, "y")
while True:
sats = ata_sources.get_sats()['GPS']
setting_sats, rising_sats = select_group_sats(sats)
to_observe = None
# select a rising satellite from rising group first
# then check if there's any setting satellite, and observe
# that instead. The rising satellite will be selected in the
# following iteration
for sat_group in [rising_sats, setting_sats]:
for sat in sat_group:
name, az, el = sat['name'], float(sat['az']), float(sat['el'])
# skip if satellite has been observed in the last 5 times
if name in sats_observed[-5:]:
continue
to_observe = sat
ofile.write("will observe: %s, state: %s\n" %
(name, sat['state']))
break
# if all the satellites have been observed
if not to_observe:
# chose a random satellite that is setting, in case there's one
if len(setting_sats) != 0:
to_observe = random.choice(setting_sats)
# else chose one that is rising, if there's one
if len(rising_sats) != 0:
to_observe = random.choice(rising_sats)
if to_observe:
az, el = float(sat['az']), float(sat['el'])
name = sat['name']
ofile.write("%s: Observing: %s\n" %
(datetime.datetime.now(), to_observe['name']))
ofile.write("%s: Az, el, state: %.2f, %.2f, %s\n" %
(datetime.datetime.now(), az, el, sat['state']))
ephem = ata_control.create_ephem(name, **{
'duration': 2,
'interval': 1
})
ephem = np.array(ephem)
# offsets = az/el
for i in range(nRepeats):
got_nan = False
azs = {ant: [] for ant in ant_list}
els = {ant: [] for ant in ant_list}
az_offs = {ant: [] for ant in ant_list}
el_offs = {ant: [] for ant in ant_list}
meas_x = {ant: [] for ant in ant_list}
meas_y = {ant: [] for ant in ant_list}
igrid = 0
t1 = time.time() * 1e9 #nanoseconds
# now do the cross pattern
for offset in offsets:
ofile.write("%s: %s" % (datetime.datetime.now(), offset))
ofile.write("\n")
ata_control.make_and_track_source(name,
ant_list) #track source
ata_control.autotune(ant_list)
snap_if.tune_if_antslo(antlo_list)
ata_control.track_and_offset(name,
ant_list,
xoffset=offset)
for ant in ant_list:
# XXX: what az/el are these? Encoder or astronomical?
az_el = ata_control.get_az_el(ant_list)[ant]
# Determine the true position of satellite
x_el_off = offset[0]
el_off = offset[1]
az_off = x_el_off / np.cos(np.deg2rad(az_el[1]))
azs[ant].append(az_el[0] - az_off)
els[ant].append(az_el[1] - el_off)
az_offs[ant].append(az_off)
el_offs[ant].append(el_off)
# record data
utc = snap_dada.start_recording(antlo_list,
obs_time,
acclen=120 * 16,
disable_rfi=True)
os.system("killall ata_udpdb")
# move data from antlo to ant format in /mnt/buf0/obs/utc
mv_utc_antlo_to_ant(utc)
# get the measurement data
for ant in ant_list:
try:
meas_x[ant].append(get_power(utc, ant, 'x'))
except:
got_nan = True
meas_x[ant].append(np.nan)
for ant in ant_list:
try:
meas_y[ant].append(get_power(utc, ant, 'y'))
except:
got_nan = True
meas_y[ant].append(np.nan)
t2 = time.time() * 1e9 #nanoseconds
az_avg_src, el_avg_src = get_ephem_az_el(ephem, t1, t2)
for ant in ant_list:
ofile.write(ant + "\n")
az_avg = np.array(azs[ant]).mean()
el_avg = np.array(els[ant]).mean()
ofile.write("%s: azimuths: " % (datetime.datetime.now()) +
float_arr_to_str(azs[ant]) + "\n")
ofile.write("%s: elevations: " %
(datetime.datetime.now()) +
float_arr_to_str(els[ant]) + "\n")
ofile.write("%s: az_offsets: " %
(datetime.datetime.now()) +
float_arr_to_str(az_offs[ant]) + "\n")
ofile.write("%s: el_offsets: " %
(datetime.datetime.now()) +
float_arr_to_str(el_offs[ant]) + "\n")
ofile.write("%s: meas: " % (datetime.datetime.now()) +
float_arr_to_str(meas_x[ant]) + "\n")
ofile.write("%s: meas: " % (datetime.datetime.now()) +
float_arr_to_str(meas_y[ant]) + "\n")
ofile.write("%s: source az_avg: " %
(datetime.datetime.now()) + str(az_avg) + "\n")
ofile.write("%s: source el_avg: " %
(datetime.datetime.now()) + str(el_avg) + "\n")
ofile.write("%s: source ephem az_avg: " %
(datetime.datetime.now()) + str(az_avg_src) +
"\n")
ofile.write("%s: source ephem el_avg: " %
(datetime.datetime.now()) + str(el_avg_src) +
"\n")
#xpol
try:
peak_el_x = analyzeFivePoints(el_offs[ant][:5],
meas_x[ant][:5])
peak_pos_el_x, peak_val_el_x, peak_width_el_x = peak_el_x
peak_az_x = analyzeFivePoints(az_offs[ant][5:],
meas_x[ant][5:])
peak_pos_az_x, peak_val_az_x, peak_width_az_x = peak_az_x
peak_sbr_x = np.sqrt(peak_val_az_x**2 +
peak_val_el_x**2)
except:
ofile.write(
"%s: Something went wrong with measuring power with ant: %s, pol x\n"
% (datetime.datetime.now(), ant))
continue
ofile.write(
"El: %f %f %f\n" %
(peak_pos_el_x, peak_val_el_x, peak_width_el_x))
ofile.write(
"Az: %f %f %f\n" %
(peak_pos_az_x, peak_val_az_x, peak_width_az_x))
meas_az_x = (az_avg + peak_pos_az_x)
meas_el_x = (el_avg + peak_pos_el_x)
meas_az_x, meas_el_x, ir = pms[ant].applyTPOINTCorrections(
meas_az_x, meas_el_x, 0)
dt = datetime.datetime.now()
hour = dt.hour + dt.minute / 60.
tpoints_x[ant].write(
"%.3f, %.3f, %.3f, %.3f, %.3f, %.3f ! %.3f, %.3f\n" %
(az_avg, el_avg, meas_az_x, meas_el_x, peak_sbr_x,
hour, peak_pos_az_x, peak_pos_el_x))
tpoints_x[ant].flush()
#ypol
try:
peak_el_y = analyzeFivePoints(el_offs[ant][:5],
meas_y[ant][:5])
peak_pos_el_y, peak_val_el_y, peak_width_el_y = peak_el_y
peak_az_y = analyzeFivePoints(az_offs[ant][5:],
meas_y[ant][5:])
peak_pos_az_y, peak_val_az_y, peak_width_az_y = peak_az_y
peak_sbr_y = np.sqrt(peak_val_az_y**2 +
peak_val_el_y**2)
except:
ofile.write(
"%s: Something went wrong with measuring power with ant: %s pol y\n"
% (datetime.datetime.now(), ant))
continue
#ofile.write("El: %f %f %f\n" %(peak_pos_el, peak_val_el, peak_width_el))
#ofile.write("Az: %f %f %f\n" %(peak_pos_az, peak_val_az, peak_width_az))
meas_az_y = (az_avg + peak_pos_az_y)
meas_el_y = (el_avg + peak_pos_el_y)
meas_az_y, meas_el_y, ir = pms[ant].applyTPOINTCorrections(
meas_az_y, meas_el_y, 0)
dt = datetime.datetime.now()
hour = dt.hour + dt.minute / 60.
tpoints_y[ant].write(
"%.3f, %.3f, %.3f, %.3f, %.3f, %.3f ! %.3f, %.3f\n" %
(az_avg, el_avg, meas_az_y, meas_el_y, peak_sbr_y,
hour, peak_pos_az_y, peak_pos_el_y))
tpoints_y[ant].flush()
if got_nan:
#os.system("bash ~/backends/frb_backend/snap_init_spec_skipprog.bash")
os.system(
"bash /home/obsuser/src/ata_snap_rfsoc/program_rfsoc_spec.sh"
)
sats_observed.append(to_observe['name'])
else:
# wait for 20 minutes and see what other satellite pops up
print(rising_sats)
print(setting_sats)
ofile.write("%s: nothing to observe, waiting\n" %
(datetime.datetime.now()))
#sats_observed = []
time.sleep(20 * 60)
ofile.flush()
