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