ACIS Users Guide, Rev. A

4.2 Performing a Bias-Only Science Run

This section describes the activities used to perform a bias-only science run. Some of the information presented in this section also applies to the optional bias computation stage of a science run (see Section 4.1).

The overall process of performing a bias-only science run within ACIS is similar to that for a normal science run, except that the run automatically terminates once the bias maps have been calculated and, if configured to do so, telemetered.

4.2.1 Estimating Bias Computation Time

4.2.1.1 Continuous Clocking Mode

Description

In Continuous Clocking Mode, the bias values for the columns is computed using 1024 samples, from two consecutive data sets of 512 rows each. The computation time is almost always less than the frame time.

Frame Time

The frame time in Continuous Clocking Mode is given by:

frame_time := 512 * second/row
where the second/row is a function of the summing parameters.
Refer to Section 4.1.1.1 for the formula.

Bias Time

Rounding up to the nearest frame time for time to calculate the actual bias values, the total bias computation time for Continuous Clocking mode is:

bias_time (seconds) := (frame_time * (2 + 1))

4.2.1.2 Timed Exposure Mode

Description

In Timed Exposure Mode, the time taken to compute the bias maps depends heavily on the number of exposures needed to compute the bias, which, in turn, depends on the clocking parameters and bias parameters used, and the number of exposures discarded because the algorithm did not keep up with the incoming exposures.

Whether or not the algorithm keeps up is a function of speed of the algorithm running in the FEPs, and the number of events and background events in the CCD images.

Ignoring the problem of discarded exposures for the moment (which may multiply the time by factors of 2 or more), the following describes the amount of time required to compute a bias for Timed Exposure Mode, in terms of the of the parameters in the Timed Exposure Parameter Block (see Section 4.1.4.1).

Frame Time

First, compute the frame time for the primaryExposure, and if dutyCycle is not zero, the secondaryExposure times. If the desired exposure time is not a "short- exposure" (see Section 4.1.1.2), the frame time for the primaryExposure is:

(primaryExposure / 10) + 0.04104 seconds
(i.e. the static integration time plus the "smear" time)

If the exposure time is a "short-exposure", then the frame time is:

(staggered_smear_time + transfer_time) +
(primaryExposure / 10) + 0.04104 seconds

Where (staggered_smear_time + transfer_time) is the minimum
non-short integration time described in Section 4.1.1.2 

For the frame time of the secondaryExposure field, replace "primaryExposure" with "secondaryExposure" in the above expressions.

Whole-Frame Mode - Number of Frames

The number of frames used to compute a bias level in Whole-Frame mode is specified by either the biasArg0 or biasArg1, which ever is greater.

number_of_frames := max(biasArg0, biasArg1)

Strip-Mode - Number of Frames

In "Strip" mode, the image buffer is divided into "strips" of rows, where each strip contains 1 sample for each pixel in the collection of rows. The bias algorithm collects these strips for a set of rows, and then computes the bias level for those rows. There is always at least 1 exposure dropped during the computation phase. The following estimate assumes that only 1 exposure is dropped. However, in practice, the number of exposures dropped will vary.

If the number of exposures per pixel, biasArg0, divides evenly into the image buffer size of 1024 rows, then the number of frames is:

number_of_frames := (biasArg0 + 1) * biasArg0

If biasArg0 does not divide evenly, the expression is:

number_of_frames := ((biasArg0 + 1) * biasArg0) + biasArg0

(this assumes the computation of the last set of strips is
small compared to the frame time)

Bias Time - Single Integration Time

If using a single integration time (i.e. dutyCycle == 0), then the time taken to compute the bias is:

bias_time (seconds) := primary_frame_time *
                       (ignoreInitialFrames + number_of_frames)

Bias Time - Multiple Integration Times

If using multiple integration times (dutyCycle != 0), and using an initial discard count that divides evenly by the number of exposures in a cycle ((ignoreInitialFrames MOD (dutyCycle + 1)) == 0), then the time to compute the bias is:

number_of_primaries := [ignoreInitialFrames DIV (dutyCycle + 1)] +
                       (number_of_frames DIV dutyCycle) +
                       (1 if number_of_frames MOD dutyCycle != 0)

number_of_secondaries := number_of_frames +
              [(ignoreInitialFrames * dutyCycle) DIV (dutyCycle + 1)]

bias_time (seconds) :=   (primary_frame_time * number_of_primaries) +
              (secondary_frame_time * number_of_secondaries)

If the initial discard count does not divide evenly, the time to compute the bias is:

number_of_primaries := [ignoreInitialFrames DIV (dutyCycle + 1)] +
                       (number_of_frames DIV dutyCycle) +
                       (1 if number_of_frames MOD dutyCycle != 0)

number_of_secondaries := number_of_frames +
              [(ignoreInitialFrames * dutyCycle) DIV (dutyCycle + 1)] +
              ([ignoreInitialFrames MOD (dutyCycle + 1)] - 1)

bias_time (seconds) :=   (primary_frame_time * number_of_primaries) +
              (secondary_frame_time * number_of_secondaries)

TBD -complete this section to deal with a method of determining when exposures will be dropped and how many.

4.2.2 Estimating Bias Transmission Time

Description

Continuous Clocking Mode uses less than 1 telemetry packet for each bias map, and takes less than 1 second to form and post the maps for each FEP.

Timed Exposure Mode, on the other hand, takes many packets to send the FEP bias maps. The time taken depends on the number of maps being sent, the number of rows in the bias maps, and whether or not the maps are compressed, and if so, how well they compressed.

Total Number of Pixels

The total number of rows being telemetered is:

number_of_rows      := number_of_FEPs * (subArrayRowCount+1)
pixels_per_row      := 1024 if onChip2x2Summing == 0 or
                    := 512 if onChip2x2Summing == 1
number_of_pixels    := number_of_rows * pixels_per_row

Time if Un-compressed, 24Kbps

If the bias maps are not compressed, each pixel is packed into 12-bits in the bias data telemetry packets. Ignoring the overhead, the time to send the maps, assuming 24K bits per second of telemetry, is:

bias_telemetry_time (seconds) := number_of_rows * 12 bits / 24Kbps

For example, it takes about 53 minutes to send 6 un-compressed FEP bias maps, given a standard 1024 row image, without on-chip summing.

Time if Compressed, 24Kbps

The time taken to send compressed bias maps depends on how well the maps compress. At XRCF, the compression factor was about 4 to 1 (this is about as good as it gets), and took about 13 minutes to send all 6 bias maps. As the CCDs erode over the life of the mission, the compression will become less effective, and take longer to send the maps.

4.2.3 Loading a Parameter Block

The commands needed to load the parameter blocks for a bias-only run are identical to those for a normal science run, except that the state of the recomputeBias flag is ignored. A bias is always re-computed for a bias-only run, and the system behaves as if the recomputeBias flag is asserted. For a description of loading parameter blocks, see Section 4.1.4.1 and Section 4.1.4.3 (NOTE: Although windows are not used during a bias- only run, if a parameter block references a window parameter block, the window parameter block must not be corrupt).

4.2.4 Starting the Bias-Only Run

Description

Prior to starting a bias-only science run, the user should have powered on the FEPs and Video boards needed for the run (see Section 3.3.2 and Section 3.3.3) and planned and loaded the parameter blocks needed for the run (see Section 4.1.1, Section 4.1.2, Section 4.1.3, Section 4.1.4). The user initiates a science run using the "Start Science" command packet, where the opcode of the command selects the type of bias-only science run to perform, and the blockSlotIndex parameter selects which parameter block to use to configure the run. If the opcode is CMDOP_BIAS_TE, then a Timed Exposure bias-only run is performed, and the parameter block is read from the slots reserved for Timed Exposure runs. If the opcode is CMDOP_BIAS_CC, the a Continuous Clocking bias-only run is performed, and the parameter block is read from the Continuous Clocking slot array.

Just as for a normal science run, once started, the Science Manager will configure the processing parameters, load the CCD settings into the DEA video boards, load the sequencer memory of the video boards, configure the Front End Processor parameters. It will then "jitter" the video board DACs to clear charge out of the CCDs. The task will command the FEPs to compute a bias, and then start the video board sequencers. Once the bias is complete, the task will stop the sequencers, and will send the bias maps to telemetry, if requested by the "trickleBias" flag. Once the bias maps have been sent, the task will automatically terminate the run.

Commands

Command to start a Timed Exposure Bias-Only Science Run:

startScience: CMDOP_BIAS_TE
{
  blockSlotIndex  = 0..4  - Index Timed Exposure Parameter Block Slot
}

Command to start a Continuous Clocking Bias-Only Science Run:

startScience: CMDOP_BIAS_CC
{
  blockSlotIndex  = 0..4  - Index Continuous Clocking Parameter Slot
}

Engineering Telemetry

When performing the bias run, the Software Housekeeping task blinks the LED values between two values, about once a minute (see Section 3.4.3.1).

If system had not watchdog-reset since the last commanded reset:

LED_RUN_SCIENCE_A
LED_RUN_SCIENCE_B

If the system had watchdog-reset:

LED_WD_SCIENCE_A
LED_WD_SCIENCE_B

Science Telemetry

Command Echo on a successful receipt of Timed Exposure start request:

commandEcho: TTAG_CMD_ECHO
{
  arrival          = time command arrived (BEP Ticks)
  result           = CMDRESULT_OK (other values indicate an error)

  echoed command   =
  startScience: CMDOP_BIAS_TE
  {
    blockSlotIndex = 0..4
  }
}

Command Echo on a successful receipt of Continuous Clocking start request:

commandEcho: TTAG_CMD_ECHO
{
  arrival          = time command arrived (BEP Ticks)
  result           = CMDRESULT_OK (other values indicate an error)

  echoed command   =
  startScience: CMDOP_BIAS_CC
  {
    blockSlotIndex = 0..4
  }
}

If a science run had been started, and not yet stopped, when the command is received, the "result" field of the echo will contain CMDRESULT_CLOBBERED. In this case, the earlier run will be aborted (NOTE: The FEPs will be reset), and the new run will be configured and started.

If the radiation monitor had been activated, then the start of the run will be deferred until the monitor is de-activated. In this case the "result" field will contain CMDRESULT_INHIBITED.

If the selected parameter block checksum does not match its contents (i.e. has been corrupted), the system will attempt to determine if the run was configured to use the Imaging CCDs or the Spectroscopy CCDs. If any of the CCDs in the fepSelect field of the parameter block choose an Imaging CCD (I0..I3), the system will attempt to use the parameter block contained in slot 0. If not, it will try to default to the parameter block in slot 1. If the default is not corrupt, the intent was for the system to use the default parameter block, and the "result" field will be set to CMDRESULT_CORRUPT_DEFAULT. Due to a "bug" in the software, however, the system will use the most recently configured parameter block for the type of run that was chosen, either Timed Exposure or Continuous Clocking (NOTE: Some might consider this a feature).

If the original parameter block is corrupt, and the selected default parameter block is also corrupt (or they're one and the same), the run will not be started, and the "result" field will contain CMDRESULT_CORRUPT_IDLE.

Since the field ranges within the parameter block are only checked during the set-up stage of the run, after the receipt of the command has been acknowledged via the command echo, if a parameter contained in the block is invalid or unsupported, the Command Echo will not indicate the problem, and supply a CMDRESULT_OK. Instead, the run will not be started, and a "Science Report" packet will indicate the problem within its terminationReason field.

At the start of the run, the Science Manager will fetch and telemeter the parameter blocks used for the run. In Timed Exposure Mode, the dump appears as:

dumpedTeBlock: TTAG_DUMP_TE
{
  dumped TE Block:
  loadTeBlock: CMDOP_LOAD_TE
  [
    ...
  }
  if windows were used, this is followed by:
  a dumped 2d Window Block, aligned to the next 32-bit word:
  load2dBlock: CMDOP_LOAD_2D
  {
    ...
  }
}

In Continuous Clocking Mode, the dump appears as:

dumpedCcBlock: TTAG_DUMP_CC
{
  dumped CC Block:
  loadCcBlock: CMDOP_LOAD_CC
  [
    ...
  }
  if windows were used, this is followed by:
  a dumped 1d Window Block, aligned to the next 32-bit word:
  load1dBlock: CMDOP_LOAD_1D
  {
    ...
  }
}

Once the parameter blocks have been dumped, the Science Manager acquires and telemeters the DEA Video Board housekeeping information for all CCDs used for the run (NOTE: Unless all 10 video boards are powered on, the analog values in the packet will be of marginal use. They will indicate if the given channel is completely broken, but won't really indicate the level that the DAC was set to). The content and form of this information is described in Section 3.4.6.6.

If the "trickleBias" flag was set in the parameter block, the system will telemeter the contents of the computed bias maps of each FEP, in FEP order (i.e. FEP_0 first, then FEP_1, etc.). The Timed Exposure Bias Map telemetry packets are of the form:

dataTeBiasMap: TTAG_SCI_TE_BIAS
{
  biasStartTime        = 100KHz time-stamp at start of bias
  biasParameterId      = Parameter Block Id used for bias
  ccdId                = CCD which produced the map
  fepId                = FEP used to produce the map
  dataPacketNumber     = packet sequence number within this map
  initialOverclocks[4] = DC-offset of bias values, by quadrant
  pixelsPerRow         = number of pixels in each bias map row
  rowsPerBias          = number of rows in the map
  ccdRow               = starting row of data in the packet
  ccdRowCount          = number of rows packed into the packet
  compressionTableSlotIndex = table slot value used to compress data
  pixelCount           = total number of pixels in the packet
  data[]               = packed or compressed data, as array of
                         32-bit words
}

The Continuous Clocking Bias Map telemetry packets are of the form:

dataCcBiasMap: TTAG_SCI_CC_BIAS
{
  biasStartTime        = 100KHz time-stamp at start of bias
  biasParameterId      = Parameter Block Id used for bias
  ccdId                = CCD which produced the map
  fepId                = FEP used to produce the map
  data[1024]           = packed 12-bit pixel bias values
}

NOTE:If column summing is used in Continuous Clocking, the bias values will not fill the "data" array, leaving garbage in the unused portion.

Once the bias is complete, the Science Manager terminates the run and produces a "Science Report" telemetry packet. Under normal circumstances, the "terminationReason" field will contain a SMTERM_BIASDONE.

scienceReport: TTAG_SCI_REPORT
{
  runStartTime          = will always be 0xffffffff
  parameterBlockId      = Parameter Block Id (see biasParameterId)
  windowBlockId         = Window Block Id specified in block
  biasStartTime         = 100KHz time-stamp when bias was computed
  biasParameterId       = Parameter Block Id used for bias
  exposuresProduced     = will always be 0
  exposuresSent         = will always be 0
  biasErrorCount        = will always be 0
  fepErrorCodes[6]      = FEP Error codes, indexed by FEP
  ccdErrorFlags[6]      = Video Board error flags, indexed by FEP
  deaInterfaceErrorFlag = DEA Interface board error flag
  terminationCode       = SMTERM_BIASDONE
}

Refer to Section 4.1.6 Science Telemetry for a description of the various error flags and other termination reason codes.

Warnings

1. See Section 4.1.5 Warnings

2. See Section 3.4.6.6 Warnings

3. CC Bias data array may contain some garbage

   The Continuous Clocking bias map telmetry always consists of a packed array of 1024, 12-bit elements. If column summing is used in Continuous Clocking mode, the unused portion will contain garbage.