default=2, help="number of offset sources to scan (default=%default)") # Set default value for any option (both standard and experiment-specific options) parser.set_defaults(description='Radial holography scan', nd_params='off') # Parse the command line opts, args = parser.parse_args() if len(args) == 0: raise ValueError( "Please specify at least one target argument via name ('Cygnus A'), " "description ('azel, 20, 30') or catalogue file name ('sources.csv')") # Check basic command-line options and obtain a kat object connected to the appropriate system with verify_and_connect(opts) as kat: targets = collect_targets(kat, args) # Initialise a capturing session (which typically opens an HDF5 file) with start_session(kat, **vars(opts)) as session: # Use the command-line options to set up the system session.standard_setup(**vars(opts)) if not opts.no_delays and not kat.dry_run: if session.dbe.req.auto_delay('on'): user_logger.info("Turning on delay tracking.") else: user_logger.error('Unable to turn on delay tracking.') elif opts.no_delays and not kat.dry_run: if session.dbe.req.auto_delay('off'): user_logger.info("Turning off delay tracking.") else: user_logger.error('Unable to turn off delay tracking.')
help= 'Do a fine grained pointscan with an extent of 1 degree and a duration of 60 seconds.' 'The intention of this is for use in Ku-band obsevations where the beam is 8 arc-min .' ) parser.set_defaults(description='Point source scan') # Parse the command line opts, args = parser.parse_args() if opts.quick: opts.dump_rate = 2.0 uniquename = 0 with verify_and_connect(opts) as kat: if len(args) > 0: # Load pointing calibrator catalogues and command line targets pointing_sources = collect_targets(kat, args) else: # Default catalogue contains the radec sources in the standard kat database pointing_sources = kat.sources.filter(tags='radec') user_logger.info( "No valid targets specified, loaded default catalogue with %d targets" % (len(pointing_sources), )) # Remove sources in skip catalogue file, if provided if opts.skip_catalogue is not None and os.path.exists(opts.skip_catalogue): skip_sources = katpoint.Catalogue(file(opts.skip_catalogue)) for target in skip_sources: pointing_sources.remove(target.name) user_logger.info("After skipping, %d targets are left" % (len(pointing_sources), ))
parser.set_defaults(description='Beamformer calibration', nd_params='off', dump_rate=1.0, mode='bc16n400M1k') # Parse the command line opts, args = parser.parse_args() # Check options and arguments and connect to KAT proxies and devices if len(args) == 0: raise ValueError("Please specify the target (and optionally calibrator) " "to observe as arguments") with verify_and_connect(opts) as kat: cbf = kat.dbe7 # Antennas and polarisations forming beamformer ants = ant_array(kat, opts.ants) pol = 'h' if opts.beamformer == 'bf0' else 'v' # Pick first target as main beamformer target target = collect_targets(kat, args[:1]).targets[0] # Determine beamformer weights if calibrator is provided if len(args) > 1: cal_target = collect_targets(kat, args[1:]).targets[0] cal_target = cal_target.add_tags('gaincal') user_logger.info('Obtaining beamformer weights on calibrator source %r' % (cal_target.name)) if not cal_target.flux_model: raise ValueError("Calibrator '%s' has no flux density model" % (cal_target.description,)) with start_session(kat, **vars(opts)) as session: session.standard_setup(**vars(opts)) session.capture_start() session.label('track') session.track(cal_target, duration=opts.cal_duration)
type='float', default=2.0, help='Length of each scan, in degrees (default=%default)') # Set default value for any option (both standard and experiment-specific options) parser.set_defaults(description='Radial raster scan') # Parse the command line opts, args = parser.parse_args() if len(args) == 0: raise ValueError( "Please specify at least one target argument via name ('Cygnus A'), " "description ('azel, 20, 30') or catalogue file name ('sources.csv')") # Check options and build KAT configuration, connecting to proxies and devices with verify_and_connect(opts) as kat: observation_sources = collect_targets(kat, args) # Start capture session, which creates HDF5 file with start_session(kat, **vars(opts)) as session: session.standard_setup(**vars(opts)) session.capture_start() for target in observation_sources: session.label('raster') user_logger.info( "Initiating radial scan (%d %g-second scans extending %g degrees) on target '%s'" % (opts.num_scans, opts.scan_duration, opts.scan_extent, target.name)) # Calculate average time that noise diode is operated per scan, to add to scan duration in check below nd_time = session.nd_params['on'] + session.nd_params['off'] nd_time *= opts.scan_duration / max(session.nd_params['period'],
) # Set default value for any option (both standard and experiment-specific options) parser.set_defaults(description='Imaging run', nd_params='coupler,0,0,-1', dump_rate=0.1) # Parse the command line opts, args = parser.parse_args() # Check options and arguments, and build KAT configuration, connecting to proxies and devices if len(args) == 0: raise ValueError( "Please specify the target(s) and calibrator(s) to observe as arguments, either as " "description strings or catalogue filenames") with verify_and_connect(opts) as kat: sources = collect_targets(kat, args) user_logger.info( "Imaging targets are [%s]" % (', '.join([("'%s'" % (target.name, )) for target in sources.filter(['~bpcal', '~gaincal'])]), )) user_logger.info("Bandpass calibrators are [%s]" % (', '.join([("'%s'" % (bpcal.name, )) for bpcal in sources.filter('bpcal')]), )) user_logger.info("Gain calibrators are [%s]" % (', '.join([("'%s'" % (gaincal.name, )) for gaincal in sources.filter('gaincal')]), )) duration = { 'target': opts.target_duration, 'bpcal': opts.bpcal_duration, 'gaincal': opts.gaincal_duration
def run_observation(opts, kat): """Extract control and observation information provided in observation file.""" obs_plan_params = opts.obs_plan_params # remove observation specific instructions housed in YAML file del opts.obs_plan_params # set up duration periods for observation control obs_duration = -1 if "durations" in obs_plan_params: if "obs_duration" in obs_plan_params["durations"]: obs_duration = obs_plan_params["durations"]["obs_duration"] # check for nonsensical observation duration setting if abs(obs_duration) < 1e-5: user_logger.error( "Unexpected value: obs_duration: {}".format(obs_duration)) return # TODO: the description requirement in sessions should be re-evaluated # since the schedule block has the description # Description argument in instruction_set should be retired, but is # needed by sessions # Assign proposal_description if available, else create a dummy if "description" not in vars(opts): session_opts = vars(opts) description = "Observation run" if "proposal_description" in vars(opts): description = opts.proposal_description session_opts["description"] = description nr_obs_loops = len(obs_plan_params["observation_loop"]) with start_session(kat.array, **vars(opts)) as session: session.standard_setup(**vars(opts)) # Each observation loop contains a number of observation cycles over LST ranges # For a single observation loop, only a start LST and duration is required # Target observation loop observation_timer = time.time() for obs_cntr, observation_cycle in enumerate( obs_plan_params["observation_loop"]): if nr_obs_loops > 1: user_logger.info("Observation loop {} of {}.".format( obs_cntr + 1, nr_obs_loops)) user_logger.info("Loop LST range {}.".format( observation_cycle["LST"])) # Unpack all target information if not ("target_list" in observation_cycle.keys()): user_logger.error( "No targets provided - stopping script instead of hanging around" ) continue obs_targets = observation_cycle["target_list"] target_list = obs_targets["target"].tolist() # build katpoint catalogues for tidy handling of targets catalogue = collect_targets(kat.array, target_list) obs_tags = [] for tgt in obs_targets: # catalogue names are no longer unique name = tgt["name"] # add tag evaluation to identify catalogue targets tags = tgt["target"].split(",")[1].strip() for cat_tgt in catalogue: if name == cat_tgt.name: if ("special" in cat_tgt.tags or "xephem" in cat_tgt.tags or tags == " ".join(cat_tgt.tags)): tgt["target"] = cat_tgt obs_tags.extend(cat_tgt.tags) break obs_tags = list(set(obs_tags)) cal_tags = [tag for tag in obs_tags if tag[-3:] == "cal"] # observer object handle to track the observation timing in a more user # friendly way # observer = catalogue._antenna.observer ref_antenna = catalogue.antenna observer = ref_antenna.observer start_datetime = timestamp2datetime(time.time()) observer.date = ephem.Date(start_datetime) user_logger.trace("TRACE: requested start time " "({}) {}".format( datetime2timestamp(start_datetime), start_datetime)) user_logger.trace("TRACE: observer at start\n {}".format(observer)) # Only observe targets in valid LST range if nr_obs_loops > 1 and obs_cntr < nr_obs_loops - 1: [start_lst, end_lst] = get_lst(observation_cycle["LST"], multi_loop=True) if end_lst is None: # for multi loop the end lst is required raise RuntimeError( 'Multi-loop observations require end LST times') next_obs_plan = obs_plan_params["observation_loop"][obs_cntr + 1] [next_start_lst, next_end_lst] = get_lst(next_obs_plan["LST"]) user_logger.trace("TRACE: current LST range {}-{}".format( ephem.hours(str(start_lst)), ephem.hours(str(end_lst)))) user_logger.trace("TRACE: next LST range {}-{}".format( ephem.hours(str(next_start_lst)), ephem.hours(str(next_end_lst)))) else: next_start_lst = None next_end_lst = None [start_lst, end_lst] = get_lst(observation_cycle["LST"]) # Verify the observation is in a valid LST range # and that it is worth while continuing with the observation # Do not use float() values, ephem.hours does not convert as # expected local_lst = observer.sidereal_time() user_logger.trace("TRACE: Local LST {}".format( ephem.hours(local_lst))) # Only observe targets in current LST range log_msg = "Local LST outside LST range {}-{}".format( ephem.hours(str(start_lst)), ephem.hours(str(end_lst))) if float(start_lst) < end_lst: # lst ends before midnight if not _same_day(start_lst, end_lst, local_lst): if obs_cntr < nr_obs_loops - 1: user_logger.info(log_msg) else: user_logger.error(log_msg) continue else: # lst ends after midnight if _next_day(start_lst, end_lst, local_lst): if obs_cntr < nr_obs_loops - 1: user_logger.info(log_msg) else: user_logger.error(log_msg) continue # Verify that it is worth while continuing with the observation # The filter functions uses the current time as timestamps # and thus incorrectly set the simulation timestamp if not kat.array.dry_run: # Quit early if there are no sources to observe if len(catalogue.filter(el_limit_deg=opts.horizon)) == 0: raise NoTargetsUpError( "No targets are currently visible - " "please re-run the script later") # Quit early if the observation requires all targets to be visible if opts.all_up and (len( catalogue.filter(el_limit_deg=opts.horizon)) != len(catalogue)): raise NotAllTargetsUpError( "Not all targets are currently visible - please re-run the script" "with --visibility for information") # List sources and their associated functions from observation tags not_cals_filter_list = [] for cal_type in cal_tags: not_cals_filter_list.append("~{}".format(cal_type)) cal_array = [cal.name for cal in catalogue.filter(cal_type)] if len(cal_array) < 1: continue # do not display empty tags user_logger.info("{} calibrators are {}".format( str.upper(cal_type[:-3]), cal_array)) user_logger.info("Observation targets are [{}]".format(", ".join([ repr(target.name) for target in catalogue.filter(not_cals_filter_list) ]))) # TODO: setup of noise diode pattern should be moved to sessions # so it happens in the line above if "noise_diode" in obs_plan_params: nd_setup = obs_plan_params["noise_diode"] nd_lead = nd_setup.get('lead_time') # Set noise diode period to multiple of correlator integration time. if not kat.array.dry_run: cbf_corr = session.cbf.correlator dump_period = cbf_corr.sensor.int_time.get_value() else: dump_period = 0.5 # sec user_logger.debug( 'DEBUG: Correlator integration time {} [sec]'.format( dump_period)) if "cycle_len" in nd_setup: if (nd_setup['cycle_len'] >= dump_period): cycle_len_frac = nd_setup['cycle_len'] // dump_period nd_setup['cycle_len'] = cycle_len_frac * dump_period msg = ('Set noise diode period ' 'to multiple of correlator dump period: ' 'cycle length = {} [sec]'.format( nd_setup['cycle_len'])) else: msg = ('Requested cycle length {}s ' '< correlator dump period {}s, ' 'ND not synchronised with dump edge'.format( nd_setup['cycle_len'], dump_period)) user_logger.warning(msg) noisediode.pattern( kat.array, nd_setup, lead_time=nd_lead, ) # Adding explicit init after "Capture-init failed" exception was # encountered session.capture_init() user_logger.debug("DEBUG: Initialise capture start with timestamp " "{} ({})".format(int(time.time()), timestamp2datetime( time.time()))) # Go to first target before starting capture user_logger.info("Slewing to first target") observe(session, ref_antenna, obs_targets[0], slewonly=True) # Only start capturing once we are on target session.capture_start() user_logger.trace("TRACE: capture start time after slew " "({}) {}".format(time.time(), timestamp2datetime( time.time()))) user_logger.trace( "TRACE: observer after slew\n {}".format(observer)) done = False sanity_cntr = 0 while not done: # small errors can cause an infinite loop here # preventing infinite loops sanity_cntr += 1 if sanity_cntr > 100000: user_logger.error("While limit counter has reached {}, " "exiting".format(sanity_cntr)) break # Cycle through target list in order listed targets_visible = False time_remaining = obs_duration observation_timer = time.time() for tgt_cntr, target in enumerate(obs_targets): katpt_target = target["target"] user_logger.debug("DEBUG: {} {}".format(tgt_cntr, target)) user_logger.trace( "TRACE: initial observer for target\n {}".format( observer)) # check target visible before doing anything # make sure the target would be visible for the entire duration target_duration = target['duration'] visible = True if type(katpt_target.body) is ephem.FixedBody: visible = above_horizon( target=katpt_target.body.copy(), observer=observer.copy(), horizon=opts.horizon, duration=target_duration) if not visible: show_horizon_status = True # warning for cadence targets only when they are due if (target["cadence"] > 0 and target["last_observed"] is not None): delta_time = time.time() - target["last_observed"] show_horizon_status = delta_time >= target[ "cadence"] if show_horizon_status: user_logger.warn("Target {} below {} deg horizon, " "continuing".format( target["name"], opts.horizon)) continue user_logger.trace( "TRACE: observer after horizon check\n {}".format( observer)) # check and observe all targets with cadences while_cntr = 0 cadence_targets = list(obs_targets) while True: tgt = cadence_target(cadence_targets) if not tgt: break # check enough time remaining to continue if obs_duration > 0 and time_remaining < tgt[ "duration"]: done = True break # check target visible before doing anything user_logger.trace("TRACE: cadence" "target\n{}\n {}".format( tgt, catalogue[tgt["name"]])) user_logger.trace("TRACE: initial observer for cadence" "target\n {}".format(observer)) user_logger.trace( "TRACE: observer before track\n {}".format( observer)) user_logger.trace( "TRACE: target observation # {} last observed " "{}".format(tgt["obs_cntr"], tgt["last_observed"])) cat_target = catalogue[tgt["name"]] if above_horizon( target=cat_target.body, observer=cat_target.antenna.observer.copy(), horizon=opts.horizon, duration=tgt["duration"]): if observe(session, ref_antenna, tgt, **obs_plan_params): targets_visible += True tgt["obs_cntr"] += 1 tgt["last_observed"] = time.time() else: # target not visibile to sessions anymore cadence_targets.remove(tgt) user_logger.trace( "TRACE: observer after track\n {}".format( observer)) user_logger.trace( "TRACE: target observation # {} last observed " "{}".format(tgt["obs_cntr"], tgt["last_observed"])) else: cadence_targets.remove(tgt) while_cntr += 1 if while_cntr > len(obs_targets): break if done: break user_logger.trace( "TRACE: observer after cadence\n {}".format(observer)) # observe non cadence target if target["cadence"] < 0: user_logger.trace( "TRACE: normal target\n {}".format(target)) user_logger.trace( "TRACE: observer before track\n {}".format( observer)) user_logger.trace("TRACE: ts before observe {}".format( time.time())) user_logger.trace("TRACE: target last " "observed {}".format( target["last_observed"])) targets_visible += observe(session, ref_antenna, target, **obs_plan_params) user_logger.trace( "TRACE: observer after track\n {}".format( observer)) user_logger.trace("TRACE: ts after observe {}".format( time.time())) if targets_visible: target["obs_cntr"] += 1 target["last_observed"] = time.time() user_logger.trace( "TRACE: target observation # {} last observed " "{}".format(target["obs_cntr"], target["last_observed"])) user_logger.trace( "TRACE: observer after track\n {}".format( observer)) # loop continuation checks delta_time = time.time() - session.start_time user_logger.trace( "TRACE: time elapsed {} sec".format(delta_time)) user_logger.trace( "TRACE: total obs duration {} sec".format( obs_duration)) if obs_duration > 0: time_remaining = obs_duration - delta_time user_logger.trace( "TRACE: time remaining {} sec".format( time_remaining)) next_target = obs_targets[(tgt_cntr + 1) % len(obs_targets)] user_logger.trace("TRACE: next target before cadence " "check:\n{}".format(next_target)) # check if there is a cadence target that must be run # instead of next target for next_cadence_tgt_idx in range( tgt_cntr + 1, len(obs_targets)): next_cadence_target = obs_targets[ next_cadence_tgt_idx % len(obs_targets)] if next_cadence_target["cadence"] > 0: user_logger.trace( "TRACE: time needed for next obs " "{} sec".format( next_cadence_target["cadence"])) next_target = obs_targets[next_cadence_tgt_idx % len(obs_targets)] continue user_logger.trace("TRACE: next target after cadence " "check:\n{}".format(next_target)) user_logger.trace("TRACE: time needed for next obs " "{} sec".format( next_target["duration"])) if (time_remaining < 1.0 or time_remaining < next_target["duration"]): user_logger.info( "Scheduled observation time lapsed - ending observation" ) done = True break # during dry-run when sessions exit time is reset so will be incorrect # outside the loop observation_timer = time.time() if obs_duration < 0: user_logger.info( "Observation list completed - ending observation") done = True # for multiple loop, check start lst of next loop if next_start_lst is not None: check_local_lst = observer.sidereal_time() if (check_local_lst > next_start_lst) or (not _next_day( next_start_lst, next_end_lst, check_local_lst)): user_logger.info("Moving to next LST loop") done = True # End if there is nothing to do if not targets_visible: user_logger.warning( "No more targets to observe - stopping script " "instead of hanging around") done = True user_logger.trace("TRACE: observer at end\n {}".format(observer)) # display observation cycle statistics # currently only available for single LST range observations if nr_obs_loops < 2: print user_logger.info("Observation loop statistics") total_obs_time = observation_timer - session.start_time if obs_duration < 0: user_logger.info("Single run through observation target list") else: user_logger.info("Desired observation time {:.2f} sec " "({:.2f} min)".format(obs_duration, obs_duration / 60.0)) user_logger.info("Total observation time {:.2f} sec " "({:.2f} min)".format(total_obs_time, total_obs_time / 60.0)) if len(obs_targets) > 0: user_logger.info("Targets observed :") for unique_target in np.unique(obs_targets["name"]): cntrs = obs_targets[obs_targets["name"] == unique_target]["obs_cntr"] durations = obs_targets[obs_targets["name"] == unique_target]["duration"] if np.isnan(durations).any(): user_logger.info("{} observed {} times".format( unique_target, np.sum(cntrs))) else: user_logger.info("{} observed for {} sec".format( unique_target, np.sum(cntrs * durations))) print
type='float', default=-1.0, help="Minimum duration to run experiment, in seconds " "(default=one loop through sources)") # Set default value for any option (both standard and experiment-specific options) parser.set_defaults(description='Baseline calibration', nd_params='off', no_delays=True) # Parse the command line opts, args = parser.parse_args() with verify_and_connect(opts) as kat: # Create baseline calibrator catalogue if len(args) > 0: # Load catalogue files or targets if given baseline_sources = collect_targets(kat, args) else: # Prune the standard catalogue to only contain sources that # are good for baseline calibration great_sources = [ '3C123', 'Taurus A', 'Orion A', 'Hydra A', '3C273', 'Virgo A', 'Centaurus A', 'Pictor A' ] good_sources = [ '3C48', '3C84', 'J0408-6545', 'J0522-3627', '3C161', 'J1819-6345', 'J1939-6342', '3C433', 'J2253+1608' ] baseline_sources = katpoint.Catalogue( [kat.sources[src] for src in great_sources + good_sources], antenna=kat.sources.antenna) user_logger.info(
mirrorx=opts.mirrorx) timeperstep = opts.sampletime if len(args) == 0: raise ValueError( "Please specify a target argument via name ('Ori A'), " "description ('azel, 20, 30') or catalogue file name ('sources.csv')") # Check basic command-line options and obtain a kat object connected to the appropriate system with verify_and_connect(opts) as kat: if not kat.dry_run and kat.ants.req.mode('STOP'): user_logger.info( "Setting Antenna Mode to 'STOP', Powering on Antenna Drives.") else: user_logger.error("Unable to set Antenna mode to 'STOP'.") catalogue = collect_targets(kat, args) targets = catalogue.targets if len(targets) == 0: raise ValueError( "Please specify a target argument via name ('Ori A'), " "description ('azel, 20, 30') or catalogue file name ('sources.csv')" ) target = targets[0] #only use first target lasttargetel = target.azel()[1] * 180.0 / np.pi # Initialise a capturing session (which typically opens an HDF5 file) with start_session(kat, **vars(opts)) as session: # Use the command-line options to set up the system session.standard_setup(**vars(opts)) if not opts.no_delays and not kat.dry_run: if session.dbe.req.auto_delay('on'):
# Check options and build KAT configuration, connecting to proxies and devices with verify_and_connect(opts) as kat: args_target_list =[] if not kat.dry_run and kat.ants.req.mode('STOP') : user_logger.info("Setting Antenna Mode to 'STOP', Powering on Antenna Drives.") else: user_logger.error("Unable to set Antenna mode to 'STOP'.") observation_sources = katpoint.Catalogue(antenna=kat.sources.antenna) for catfile in args: try: observation_sources.add_tle(file(catfile)) except IOError: # If the file failed to load assume it is a target string args_target_list.append(catfile) if len(args_target_list) > 0 : args_target_obj = collect_targets(kat,args_target_list) observation_sources.add(args_target_obj) #user_logger.info("Found %d targets from Command line and %d targets from %d Catalogue(s) " % # (len(args_target_obj),num_catalogue_targets,len(args)-len(args_target_list),)) # Quit early if there are no sources to observe if len(observation_sources.filter(el_limit_deg=opts.horizon)) == 0: user_logger.warning("No targets are currently visible - please re-run the script later") else: # Start capture session, which creates HDF5 file with start_session(kat, **vars(opts)) as session: if not opts.no_delays and not kat.dry_run : if session.dbe.req.auto_delay('on'): user_logger.info("Turning on delay tracking.") else: user_logger.error('Unable to turn on delay tracking.') elif opts.no_delays and not kat.dry_run:
# Parse the command line opts, args = parser.parse_args() # Frequency channels to keep start_freq_channel = int(opts.channels.split(',')[0]) end_freq_channel = int(opts.channels.split(',')[1]) if opts.no_plots: plt = None with verify_and_connect(opts) as kat: with start_session(kat, **vars(opts)) as session: session.standard_setup(**vars(opts)) session.capture_start() # Pick a target, either explicitly or the closest strong one if len(args) > 0: target = collect_targets(kat, [args[0]]).targets[0] else: # Get current position of first antenna in the list (assume the rest are the same or close) if kat.dry_run: current_az, current_el = session._fake_ants[0][2:] else: current_az = session.ants[0].sensor.pos_actual_scan_azim.get_value() current_el = session.ants[0].sensor.pos_actual_scan_elev.get_value() if current_az is None: user_logger.warning("Sensor kat.%s.sensor.pos_actual_scan_azim failed - using default azimuth" % (session.ants[0].name)) current_az = 0. if current_el is None: user_logger.warning("Sensor kat.%s.sensor.pos_actual_scan_elev failed - using default elevation" % (session.ants[0].name)) current_el = 30.
if len(args) == 0: raise ValueError("Please specify the target") with verify_and_connect(opts) as kat: cbf = kat.dbe7 ants = kat.ants if opts.buffercap: # set passband w.r.t. SPEAD rx bw, cfreq = [200000000, 100000000] else: bw, cfreq = [400000000, 200000000] for beam in ['bf0', 'bf1']: cbf.req.dbe_k7_beam_passband(beam, bw, cfreq) # We are only interested in the first target user_logger.info('Looking up main beamformer target...') target = collect_targets(kat, args[:1]).targets[0] # Ensure that the target is up target_elevation = np.degrees(target.azel()[1]) if target_elevation < opts.horizon: raise ValueError( "The desired target to be observed is below the horizon") # Start correlator capture session with start_session(kat, **vars(opts)) as corr_session: # Force delay tracking to be on opts.no_delays = False corr_session.standard_setup(**vars(opts)) corr_session.capture_start() # Dictionary to hold observation metadata to send over to beamformer receiver for beam in beams:
dump_rate=0.1, nd_params='coupler,20,0,20') # Parse the command line opts, args = parser.parse_args() if len(args) == 0: raise ValueError( "Please specify at target argument via name ('Cygnus A'), " "description ('azel, 20, 30') or catalogue file name ('sources.csv')") sensorlist = opts.sensor_watch.split(',') endobs = False # Check options and build KAT configuration, connecting to proxies and devices with verify_and_connect(opts) as kat: strong_sources = collect_targets(kat, args) cold_sources = collect_targets(kat, [opts.cold_target]) sensors = read_sensors(kat.ants, sensorlist) # Get band info from subarray controller band = kat.sub.sensor.band.get_value() if not band: raise ValueError( "Please ensure that the subarray has a well-defined band, not %r" % (band, )) # Get existing attenuation settings attenuation_old = {} atten_sensor = {} for ant in kat.ants: for pol in 'hv': input_name = ant.name + pol