Afterglow Exposure Model

How does the Campaign Manager determine exposure lengths?

Skynet employs a credit-based currency system that observers use to schedule their observations. However, since Skynet is a heterogenous network, one credit cannot be easily mapped to a fixed unit of observing time. For example, to achieve a signal-to-noise ratio (SNR) for a given target, a 1.0-m telescope in the remote Chilean Andes would need to expose for a much shorter duration than the 40 year old, 24-inch Morehead telescope located in downtown Chapel Hill. For this reason, mapping one credit to one observing second, or any other fixed unit of time, does not make sense.

Instead, Skynet charges one credit for a one-second exposure on Skynet’s PROMPT-5 telescope and scales based on the observer’s selected telescope’s efficiency relative to PROMPT5. To achieve this, Skynet uses a cron job to calculate the efficiencies of each telescope once per week using the most recent, open filtered exposures.

These efficiencies, $\epsilon_{t}$, are defined as the inverse of the exposure time, $t_{exp}$ needed to achieve a limiting magnitude, $m$, of 20 at a SNR of 5:

$$\epsilon_{t} = \frac{(SNR/5)^{2} · 10^{(m − 20)/2.5}}{t_{exp}}$$

Here, the assumption is made that the source of interest is sufficiently bright enough that the noise is purely Poisson. Thus, the SNR factor in the above equation is squared. Outlier rejection is performed using Robust Chauvenet Rejection (Maples et al. 2018) to eliminate anomalous data points due to weather, hardware issues, or any other source of contamination.

This equation is used as the starting point for scaling exposure lengths in the Campaign Manager. A number of factors must be added to account for the variability of the observed target and for the different hardware used when observing.

Since the CM is interested in calculating exposure lengths, not efficiencies, we start by taking the inverse of the telescope efficiency equation such that:

$$t_{exp} = \frac{(SNR/5)^{2} · 10^{(m − 20)/2.5}}{\epsilon_{t}}$$

The SNR variable is fixed by the observer and the telescope efficiency is automatically calculated and stored in the Skynet database, so the Campaign Manager's job is to model the magnitude of the object at some time since the event trigger.

Accounting for Hardware

Since telescope efficiencies are calculated using open filters only, I multiply by the ratio of the selected filter efficiency to the open filter efficiency. Filter efficiencies are stored in the Skynet database along with the telescope efficiencies. The equation becomes:

$$t_{exp} = \frac{(SNR/5)^{2} · 10^{(m − 20)/2.5}}{\epsilon_{t}} \times \frac{\epsilon_{f}}{\epsilon_{f,open}}$$

In addition to the filter's efficiency, another factor is added to account for the filter's flux zero point. While this factor can be added here without consequence, I account for the zero point in the following section for modeling the magnitude.

Accounting for Target Variability

The magnitude of an astronomical target can be written as:

$$m = m_{ref} - 2.5 \cdot log_{10}(F / F_{ref})$$

Where $m$ is the measured magnitude, $F$ is the measured flux, and the $ref$ terms are the equivalent for a reference measurement. The reference values are provided by the observer, so to model the magnitude, we actually only need to model the flux. For those not familiar with astronomy, a larger magnitude corresponds to a fainter object. For example, an 15th magnitude star is 100 times brighter than a 20th magnitude star.

The flux can be written as a function of the target's temporal and spectral indices as well as the filter's flux zero point:

$$F \propto f(\alpha)\cdot g(\beta) \cdot h(F_{zp}) \cdot j(ebv)$$

Where $\alpha$ is the temporal index, $\beta$ is the spectral index, $F_{zp}$ is the filter's flux zero point, and $ebv$ is the measure of interstellar reddening due to dust extinction.

Flux Zero Points

The zero points are empirically calculated and well known. A useful summary of zero point values has been tabulated by Dr. Martini at Ohio State University and is available at Useful Astronomical Data.

Flux Zero Point Python Code

def get_zero_point_dependence(self) -> float:
    """ Returns the zero point contribution

    :return: contribution of the filter zero point dependencies
    """
    return self.hardware.filter.zero_point / self.reference_parameters.filter.zero_point

Temporal Evolution

The Campaign Manager employs both a power law temporal function as well as an exponential temporal function. The temporal power law model including the reference value:

$$(\frac{t - t_{t}}{t_{ref}})^{\alpha}$$

Where $t$ is the time of the exposure, $t_{t}$ is the time of the trigger (e.g., for gamma-ray bursts, this is the time of the stellar collapse or binary merger), and $t_{ref}$ is the reference time. I use the convention that a negative temporal index corresponds to a fading object.

Temporal Python Code

def get_temporal_dependence(self, time: float) -> float:
    """ Calculates the temporal contribution

    :param time: number of seconds since the transient trigger time
    :return: contribution of the temporal dependence
    """
    return (((time - self.transient.trigger_time) / self.reference_parameters.time)
            ** self.transient.temporal_index)

Spectral Evolution

The spectral power law function is written as:

$$(\frac{\nu}{\nu_{ref}})^{\beta}$$

Where $\nu$ is the frequency of the selected filter, $\nu_{ref}$ is the frequency of the reference filter, and $\beta$ is the spectral index. I use the convention that a negative spectral index corresponds to a redder object.

Spectral Python Code

def get_spectral_dependence(self) -> float:
    """ Calculates the spectral contribution

    :return: contribution of the spectral dependence
    """
    return ((self.hardware.filter.frequency / self.reference_parameters.filter.frequency)
            ** self.transient.spectral_index)

Dust Extinction

The extinguished flux is related to the unextinguished flux by a multiplying factor of $10^{-\frac{A_{\lambda}}{2.5}}$. Since the magnitude and flux are related through $-2.5 \cdot log_{10}$, this results in an additive factor of $A_{\lambda}$ to the modeled magnitude. For the calculation of $A_{\lambda}$, I refer the reader to a paper, Cardelli (1989), which describes the analytic extinction function that I implement exactly.

Dust Extinction Python Code

def get_extinction_dependence(self, r_v: float = 3.1) -> float:
    """ Calculates the dust extinction contribution for the extinguished
    power law model. Implementation of Cardelli et al. (1989).

    :param r_v: extinction coefficient in V band
    :return: contribution of the dust extinction dependence
    """
    x = 1.0 / self.hardware.filter.wavelength(um=True)
    y = x - 1.82
    a, b = 0.0, 0.0

    # Infrared
    if 0.3 <= x <= 1.1:
        a = 0.574 * x ** 1.61
        b = -0.527 * x ** 1.61

    # Optical/NIR
    elif 1.1 < x <= 3.3:
        a = (1 + 0.17699 * y - 0.50447 * y ** 2 - 0.02427 * y ** 3 +
             0.72085 * y ** 4 + 0.01979 * y ** 5 - 0.7753 * y ** 6 + 0.32999 * y ** 7)
        b = (1.41338 * y + 2.28305 * y ** 2 + 1.07233 * y ** 3 -
             5.38434 * y ** 4 - 0.62251 * y ** 5 + 5.3026 * y ** 6 - 2.09002 * y ** 7)

    return r_v * self.transient.ebv * (a + b / r_v)

Modeled Magnitude

With all of the above considerations, the model for the magnitude of a target at some time for some frequency is:

$$m = m_{ref} - 2.5 \cdot [\alpha log_{10}(\frac{t - t_{t}}{t_{ref}}) + \beta log_{10}(\frac{\nu}{\nu_{ref}}) - log_{10}(F_{zp} / F_{zp, ref})] + A_{\lambda}$$

Magnitude Python Code

def magnitude(self, time: float) -> float:
    """ Models the magnitude at the provided time given the reference
    parameters.

    :param time: number of seconds since the transient trigger time
    :return: modeled magnitude at the provided time
    """
    return (self.reference_parameters.magnitude -
            (2.5 * (math.log10(self.get_temporal_dependence(time))
                    + math.log10(self.get_spectral_dependence())
                    - math.log10(self.get_zero_point_dependence())))
            + self.get_extinction_dependence())

The Full Exposure Model

The Campaign Manager calculates the magnitude at a given time for a given filter and evaluates the equation derived in the Accounting for Hardware section above. The equation is retyped below for convenience.

$$t_{exp} = \frac{(SNR/5)^{2} · 10^{(m − 20)/2.5}}{\epsilon_{t}} \times \frac{\epsilon_{f}}{\epsilon_{f,open}}$$

Typing out the magnitude equation in the above equation would be an ugly mess, so I'm not going to do that here.

Exposure Length Python Code

def exposure_length(self, magnitude: float) -> float:
    """ Calculates the exposure length for a desired SNR using
    the defined model parameters.

    :param magnitude: modeled magnitude
    :return: exposure length in seconds
    """
    return (self.get_snr_dependence() * self.get_hardware_dependence()
            * (10.0 ** ((magnitude - 20.0) / 2.5))

There we have it! An exposure length model that accounts for both the hardware used to take the image and for the target's brightness variability.

Additional Information

This model is also implemented in an open-source education web tool that I developed (see the Transient Plotter page). In this tool, I implement the algorithm in TypeScript rather than Python.

I also built a pretty neat debugging tool to visualize the modeled magnitudes and exposure lengths. It's open-source, but I don't think anyone other than myself would ever have a purpose to use it. Continue to the next section for a detailed description of the tool.