Observation Planning

night_observability(facility, ra, dec, obsdate; alt_limit=30.0, alt_max=90.0,
                    moon_min_sep=30.0, dark_offset=0.0, step_minutes=1)

Compute the observability grid for a target on a given night. Internally uses Float32 for LST, HA, alt, az arrays.

Returns a NamedTuple with fields:

• utc: UTC hours vector (Float64)
• lst: local sidereal time, hours (Float32)
• ha: hour angle, hours (Float32)
• alt: altitude, degrees (Float32)
• az: azimuth, degrees (Float32)
• lst_midnight: LST at local midnight (Float64)
• good_alt: indices where alt_limit < alt < alt_max
• moon_sep: Moon–target separation, degrees (Float32)
• moon_fli: fractional lunar illumination (Float64, single value for the night)
• good_moon: indices where moon_sep > moon_min_sep

Arguments:

• facility: FacilityConfig (provides lat, lon)
• ra: right ascension in degrees
• dec: declination in degrees
• obsdate: DateTime of the observing evening
• alt_limit: minimum elevation in degrees (default 30)
• alt_max: maximum safe elevation in degrees (default 90, e.g. 80 for CHARA)
• moon_min_sep: minimum Moon separation in degrees (default 30)
• dark_offset: hours after sunset / before sunrise for deeper twilight (default 0)
• step_minutes: time resolution in minutes (default 1)

best_pop(facility, dec, ha, config; n_best=5, min_minutes=10, delay_length=nothing)

Brute-force search over all POP combinations.

Returns a vector of NamedTuples (pop, score) sorted by score (minutes observable), keeping up to n_best results with score ≥ min_minutes.

Arguments:

• config: telescope configuration (0/1/2); only telescopes with config>0 are used
• n_best: number of top solutions to return
• min_minutes: discard solutions below this threshold
• delay_length: override per-telescope delay limits with a uniform value (m)

print_pop_results(facility, config, results)

Pretty-print the output of best_pop.

obs_plan(targetname, facility, ra, dec, obsdate, pop, config;
         alt_limit=30.0, alt_max=90.0, delay_length=nothing,
         dark_offset=0.0, step_minutes=1, figsize=(10,5), savefile="")

Produce a Gantt-style observability plot for one target on one night, showing dark time, altitude window, and delay feasibility.

Pass delay_length=43.0 for a conservative delay estimate. Pass savefile="path.png" to save to file and close the figure.

chara_plan(targetname, facility, ra, dec, obsdate, pop, config;
           alt_limit=30.0, alt_max=90.0, delay_length=nothing,
           dark_offset=0.0, step_minutes=1)

Produce a delay-vs-LST plot with altitude overlay, similar to the classic chara_plan software from GSU.

Each baseline's delay cart position is plotted vs LST, with the altitude curve and elevation limit overlaid.

Pass delay_length=43.0 for a conservative delay estimate.

compute_delays(facility, dec, ha, config, pop; pop_array=CHARA_POP_ARRAY, airpath=CHARA_AIRPATH)

Compute delay cart positions for all baselines over a time grid.

Returns (delay_carts, nbaselines, baseline_names, baseline_stations) where delay_carts is nbaselines × length(ha).

Arguments:

• facility: FacilityConfig
• dec: declination in degrees
• ha: hour angle vector (hours)
• config: telescope configuration vector (0=unused, 1=use, 2=reference)
• pop: POP assignment vector (one per telescope)

in_delay(facility, dec, ha, config, pop; delay_length=nothing, kwargs...)

Determine when the target is within delay-line limits for all baselines.

Returns a NamedTuple with:

• delay_carts: delay cart positions (nbaselines × ntimes)
• has_delay: BitVector, true where all baselines are within limits
• good_delay: indices into the time grid where observing is feasible
• nbaselines, baseline_names, baseline_stations

The per-telescope delay limits come from facility.delay_lengths. Pass delay_length=43.0 to override with a uniform (conservative) value.

moon_illumination(jd)

Fractional lunar illumination (0–1) for a given Julian Date.

moon_radec(jd)

Low-precision Moon RA/Dec (degrees) for a given Julian Date. Accuracy ~1° in position — sufficient for separation checks.

angular_separation(ra1, dec1, ra2, dec2)

Angular separation in degrees between two positions (all in degrees).