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
