Pointing generation

One of the most basic facilities provided by CMBMissionSim is the generation of pointing timelines. CMBMissionSim assumes that the spacecraft orbits around the L2 Lagrangean point of the Sun-Earth system, and that it performs a monotonous spin around some axis, optionally with some precession period. This is a quite rigid scheme, but it is the one followed by Planck, CORE, and LiteBIRD.

The basic object used to create pointings is the ScanningStrategy structure. You can build a ScanningStrategy object using one of its constructors. The most basic one takes the following syntax:

ScanningStrategy(;
    spin_rpm = 0,
    prec_rpm = 0,
    yearly_rpm = 1  / (MINUTES_PER_DAY * DAYS_PER_YEAR),
    hwp_rpm = 0,
    spinsunang_rad = deg2rad(45.0),
    borespinang_rad = deg2rad(50.0),
)

Note that this constructor only takes keywords, and that the measurement units used for them are different from the ones used in the fields in ScanningStrategy. Units in the constructors have been chosen in order to be easy to use, while units in ScanningStrategy allow to make computations more efficient.

Another kind of constructor allows to load the scanning strategy definition from a JSON file. It comes in two flavours:

# First version: pass a file object to `ScanningStrategy`
open("my_scanning_strategy.json", "r") do inpf
    sstr = ScanningStrategy(inpf)
end

# Second version (easier): pass the name of the file
sstr = ScanningStrategy("my_scanning_strategy.json")

These JSON files can be created using the function save:

sstr = ScanningStrategy(spinsunang_rad = deg2rad(35.0))
save("my_scanning_strategy.json", sstr)

If you have loaded the Plots.jl package, you can produce a rough diagram of the scanning strategy using the plot function on a ScanningStrategy object:

using Plots
sstr = ScanningStrategy(
    spinsunang_rad = deg2rad(35.0),
    borespinang_rad = deg2rad(40.0),
)
plot(sstr)

/home/travis/.julia/packages/GR/ZI5OE/src/../deps/gr/bin/gksqt: error while loading shared libraries: libQt5Widgets.so.5: cannot open shared object file: No such file or directory
connect: Connection refused
GKS: can't connect to GKS socket application
Did you start 'gksqt'?

GKS: Open failed in routine OPEN_WS
GKS: GKS not in proper state. GKS must be either in the state WSOP or WSAC in routine ACTIVATE_WS

(Conventionally, the angle between the spin axis and the Sun-Spacecraft direction is indicated with the symbol α, and the angle between the boresight direction and the spin axis with β.)

Once you have a ScanningStrategy object, you generate the sequence of pointing directions through one of the following functions:

genpointings and genpointings! generate a set of pointing directions that encompass a range of time; most of the time you will use this.
time2pointing and time2pointing! generate one pointing direction at a time; they are useful if you are working on a system with limited memory resources.

The version with the ! and the end save their result in a preallocated block, while the other ones use the return value of the function. The former is useful if you are using some strategy to pre-allocate memory in order to optimize running times. For instance, the following code is not optimal, as genpointings is re-creating the same result matrix over and over again:

const SECONDS_IN_A_HOUR = 3600.
sstr = ScanningStrategy()
start_time = 0.0
# Simulate an observation lasting 1000 hours
for hour_num in 1:1000
    # Each call to "genpointings" allocates a new "pnt" matrix:
    # doing it multiple times like in this "for" loop takes time and
    # slows down the execution!
    pnt = genpointings(sstr, start_time:(start_time + SECONDS_IN_A_HOUR),
        Float64[0, 0, 1], 0.0)
    # Use "pnt" here
    # ...
end

The code below is more efficient, as the allocation is done only once:

const SECONDS_IN_A_HOUR = 3600.
sstr = ScanningStrategy()
start_time = 0.0

# Allocate this variable once and for all
pnt = Array{Float64}(undef, SECONDS_IN_A_HOUR, 6)

# Simulate an observation lasting 1000 hours
for hour_num in 1:1000
    # Use "pnt" again and again, overwriting it each time: this is
    # much faster!
    genpointings!(sstr, start_time:(start_time + SECONDS_IN_A_HOUR),
        Float64[0, 0, 1], 0.0, pnt)
    # Use "pnt" here
    # ...
end

`ScanningStrategy`

Harlequin.ScanningStrategy — Type.

The structure ScanningStrategy encodes the information needed to build a set of pointing directions. It contains the following fields:

omega_spin_hz: angular speed of the rotation around the spin axis (equal to 2πν)
omega_prec_hz: angular speed of the rotation around the precession axis (equal to 2πν)
omega_year_hz: angular speed of the rotation around the Elliptic axis (equal to 2πν)
omega_hwp_hz: angular speed of the rotation of the half-wave plate (equal to 2πν)
spinsunang_rad: angle between the spin axis and the Sun-Earth direction
borespinang_rad: angle between the boresight direction and the spin axis
q1, q3: quaternions used to generate the pointings

Each field has its measure unit appended to the name. For instance, field spinsunang_rad must be expressed in radians.

Pointing generation

ScanningStrategy

Pre-defined scanning strategies

Generating pointings over long periods of time

Loading and saving scanning strategies

Pointing generation

Utility functions

`ScanningStrategy`