int ImgHistory (RefImage *ref, Hdr *phdr) {
/* arguments:
RefImage *ref i: info about reference image
Hdr *phdr io: header to receive history records
*/
char history[STIS_LINE];
strcpy (history, " reference image ");
strcat (history, ref->name);
addHistoryKw (phdr, history);
if (hstio_err())
return (HEADER_PROBLEM);
if (ref->pedigree[0] != '\0') {
strcpy (history, " ");
strcat (history, ref->pedigree);
addHistoryKw (phdr, history);
if (hstio_err())
return (HEADER_PROBLEM);
}
if (ref->descrip[0] != '\0') {
strcpy (history, " ");
strcat (history, ref->descrip);
addHistoryKw (phdr, history);
if (hstio_err())
return (HEADER_PROBLEM);
}
return (0);
}
int GetAsnName (char *filename, char *asn_name) {
extern int status;
IODescPtr im; /* descriptor for an image */
Hdr phdr; /* primary header */
/* Function definitions */
int GetKeyStr (Hdr *, char *, int, char *, char *, int);
/* Read primary header of ASN file into hdr. */
initHdr (&phdr);
im = openInputImage (filename, "", 0);
if (hstio_err())
return (status = OPEN_FAILED);
getHeader (im, &phdr); /* get primary header */
if (hstio_err())
return (status = OPEN_FAILED);
closeImage (im);
asn_name[0] = '\0';
if (GetKeyStr (&phdr, "ASN_TAB", 0, "", asn_name, SZ_FITS_REC)) {
trlkwerr ("ASN_TAB", asn_name);
return (status = KEYWORD_MISSING);
}
/* Close the file's primary header. */
freeHdr (&phdr);
/* Successful return */
return (status);
}
int CheckDetector (char *image, int detector, char *keyword, int *badtype) {
extern int status;
FitsKw key; /* location of keyword in header */
IODescPtr im; /* descriptor for primary header unit */
Hdr phdr; /* primary header */
char keyval[SZ_FITS_REC+1];
keyval[0] = '\0';
initHdr (&phdr);
/* Open the primary header of the reference file. */
im = openInputImage (image, "", 0);
getHeader (im, &phdr);
if (hstio_err())
return (status = HEADER_PROBLEM);
/* Get the DETECTOR keyword. */
key = findKw (&phdr, keyword);
if (key == NotFound) {
trlkwerr (keyword, image);
return (status = KEYWORD_MISSING);
} else {
getStringKw (key, keyval, SZ_FITS_REC);
if (hstio_err()) {
trlkwerr (keyword, image);
return (status = KEYWORD_MISSING);
}
}
/* Does the ref file DETECTOR value match the science image? */
if (detector == IR_DETECTOR) {
if (strncmp (keyval, "IR", strlen(keyval)) != 0) {
sprintf (MsgText, "%s %s='%s' does not match science data",
image, keyword, keyval);
trlerror (MsgText);
(*badtype)++;
}
} else {
if (strncmp (keyval, "UVIS", strlen(keyval)) != 0) {
sprintf (MsgText, "%s %s='%s' does not match science data",
image, keyword, keyval);
trlerror (MsgText);
(*badtype)++;
}
}
/* Close the reference file. */
closeImage (im);
freeHdr (&phdr);
return (status);
}
int UpdateSwitch (char *calSwitch, int flag, Hdr *phdr, int *logit) {
/* arguments:
char *calSwitch i: name of calibration switch
int flag i: value of calibration switch
Hdr *phdr o: primary header
int *logit o: true if we should log reference file names
*/
extern int status;
char *history;
int PutKeyStr (Hdr *, char *, char *, char *);
if ((history = (char *) calloc (CHAR_LINE_LENGTH+1, sizeof (char))) == NULL)
return (status = OUT_OF_MEMORY);
strcpy (history, calSwitch);
*logit = 0;
if (flag == PERFORM) {
if (PutKeyStr (phdr, calSwitch, "COMPLETE", ""))
return (status);
strcat (history, " complete ...");
addHistoryKw (phdr, history);
if (hstio_err())
return (status = HEADER_PROBLEM);
*logit = 1;
} else if (flag == DUMMY) {
if (PutKeyStr (phdr, calSwitch, "SKIPPED", ""))
return (status);
strcat (history, " skipped due to dummy reference file ...");
addHistoryKw (phdr,history);
if (hstio_err())
return (status = HEADER_PROBLEM);
*logit = 1;
} else if (flag == IGNORED) {
if (PutKeyStr (phdr, calSwitch, "SKIPPED", ""))
return (status);
strcat (history, " not performed ..."); /* for some other reason */
addHistoryKw (phdr,history);
if (hstio_err())
return (status = HEADER_PROBLEM);
*logit = 1;
}
free (history);
return (status);
}
static int PutSumHdrInfo (SingleGroup *out, double sumexptime, double expend, int nimages, int nimsets) {
/* arguments:
SingleGroup *out i: current imset
double *exptime i: accumulated exposure time
double *expend i: last exposure end time read from input file
int nimages i: the number of imsets that were combined
*/
extern int status;
int PutKeyDbl (Hdr *, char *, double, char *);
int PutKeyInt (Hdr *, char *, int, char *);
int PutKeyStr (Hdr *, char *, char *, char *);
/* Set the switch to indicate that rptcorr has been done. */
if (PutKeyStr (out->globalhdr, "RPTCORR", "COMPLETE",
"add individual repeat observations"))
return (status);
/* Write history records. */
addHistoryKw (out->globalhdr, "RPTCORR complete");
if (hstio_err())
return (status = HEADER_PROBLEM);
addHistoryKw (out->globalhdr, "Statistics computed after rptcorr.");
if (hstio_err())
return (status = HEADER_PROBLEM);
/* Update NEXTEND in primary header, to indicate only one imset. */
if (PutKeyInt (out->globalhdr, "NEXTEND", EXT_PER_GROUP * nimsets,
"number of extensions"))
return (status);
/* Update NCOMBINE in primary header, to tell how many imsets were
combined into this one output imset.
*/
if (PutKeyInt (out->globalhdr, "NCOMBINE", nimages,
"number of imsets combined"))
return (status);
/* Update exposure time info in SCI extension header. */
if (PutKeyDbl (out->globalhdr, "EXPTIME", sumexptime, "exposure time"))
return (status);
if (PutKeyDbl (out->globalhdr, "EXPEND", expend, "exposure end time"))
return (status);
return (status);
}
static int UpdateHdr (char *output) {
extern int status;
Hdr phdr; /* primary header */
IODescPtr im; /* descriptor for output image */
int PutKeyBool (Hdr *, char *, Bool, char *);
sprintf(MsgText, "Trying to open %s...",output);
trlmessage (MsgText);
initHdr (&phdr);
/* Open input image in order to read its primary header. */
im = openUpdateImage (output, "", 0, &phdr);
if (hstio_err()) {
trlopenerr (output);
closeImage(im);
return (status = OPEN_FAILED);
}
if (PutKeyBool (&phdr, "ASN_PROD", True, "") ) {
freeHdr (&phdr);
trlerror ("Couldn't update ASN_PROD keyword in ASN table header");
return(status = KEYWORD_MISSING);
}
/* write out primary header */
if (putHeader (im))
status = HEADER_PROBLEM;
if (hstio_err() || status) {
trlreaderr (output);
closeImage (im);
return (status = OPEN_FAILED);
}
closeImage (im);
/* Close the ASN table's primary header. */
freeHdr (&phdr);
sprintf(MsgText, "Updated Global Header for %s...",output);
trlmessage (MsgText);
return (status);
}
int CheckGain (char *image, float gain, char *keyword, int *badtype) {
extern int status;
FitsKw key; /* location of keyword in header */
IODescPtr im; /* descriptor for primary header unit */
Hdr phdr; /* primary header */
float keyval;
initHdr (&phdr);
/* Open the primary header of the reference file. */
im = openInputImage (image, "", 0);
getHeader (im, &phdr);
if (hstio_err())
return (status = HEADER_PROBLEM);
/* Get the CCDGAIN keyword. */
key = findKw (&phdr, keyword);
if (key == NotFound) {
trlkwerr (keyword, image);
return (status = KEYWORD_MISSING);
} else {
keyval = getFloatKw (key);
if (hstio_err()) {
trlkwerr (keyword, image);
return (status = KEYWORD_MISSING);
}
}
/* Does the ref file CCDGAIN value match the science image? */
/* A value of -1 is considered to be OK */
if ((keyval != -1) && (gain != keyval)) {
sprintf (MsgText, "%s %s=%g does not match science data",
image, keyword, keyval);
trlerror (MsgText);
(*badtype)++;
}
/* Close the reference file. */
closeImage (im);
freeHdr (&phdr);
return (status);
}
int TabHistory (RefTab *ref, Hdr *phdr) {
/* arguments:
RefImage *ref i: info about reference image
Hdr *phdr io: header to receive history records
*/
extern int status;
char history[ACS_LINE];
strcpy (history, " reference table ");
strcat (history, ref->name);
addHistoryKw (phdr, history);
if (hstio_err())
return (status = HEADER_PROBLEM);
if (ref->pedigree[0] != '\0') {
strcpy (history, " ");
strcat (history, ref->pedigree);
addHistoryKw (phdr, history);
if (hstio_err())
return (status = HEADER_PROBLEM);
}
if (ref->descrip[0] != '\0') { /* descrip from the header */
strcpy (history, " ");
strcat (history, ref->descrip);
addHistoryKw (phdr, history);
if (hstio_err())
return (status = HEADER_PROBLEM);
}
if (ref->descrip2[0] != '\0') { /* descrip from the row */
strcpy (history, " ");
strcat (history, ref->descrip2);
addHistoryKw (phdr, history);
if (hstio_err())
return (status = HEADER_PROBLEM);
}
return (status);
}
int noiseHistory (Hdr *phdr) {
extern int status;
addHistoryKw (phdr, "Uncertainty array initialized.");
if (hstio_err())
return (status = HEADER_PROBLEM);
return (status);
}
int blevHistory (WF3Info *wf3, Hdr *phdr, int done, int driftcorr) {
extern int status;
int OmitStep (int);
int PutKeyStr (Hdr *, char *, char *, char *);
int TabHistory (RefTab *, Hdr *);
if (OmitStep (wf3->blevcorr))
return (status);
if (PutKeyStr (phdr, "BLEVCORR", "COMPLETE", ""))
return (status);
if (done) {
addHistoryKw (phdr,
"BLEVCORR complete; bias level from overscan was subtracted.");
} else {
addHistoryKw (phdr,
"BLEVCORR complete, but default bias level was subtracted.");
}
if (hstio_err())
return (status = HEADER_PROBLEM);
if (driftcorr) {
addHistoryKw (phdr,
"BLEVCORR includes correction for drift along lines.");
} else {
addHistoryKw (phdr,
"BLEVCORR does not include correction for drift along lines.");
}
addHistoryKw (phdr, " Overscan region table: ");
if (TabHistory (&wf3->oscn, phdr))
return (status);
if (hstio_err())
return (status = HEADER_PROBLEM);
return (status);
}
int GetSwitch (Hdr *phdr, char *calswitch, int *flag) {
/* arguments:
Hdr *phdr i: primary header
char *calswitch i: name of keyword (e.g. FLATCORR)
int *flag o: value of switch: PERFORM, OMIT, or COMPLETE
*/
extern int status;
FitsKw key; /* keyword location in header */
char *word; /* scratch space for header keyword value */
int streq_ic (char *, char *); /* strings equal? (case insensitive) */
key = findKw (phdr, calswitch);
if (key == NotFound) {
*flag = OMIT;
return (status);
}
if ((word = (char *) calloc (CHAR_FNAME_LENGTH+1, sizeof(char))) == NULL)
return (status = OUT_OF_MEMORY);
getStringKw (key, word, CHAR_FNAME_LENGTH);
if (hstio_err()) {
free (word);
sprintf (MsgText, "Error getting keyword `%s'.", calswitch);
trlerror (MsgText);
return (status = HEADER_PROBLEM);
}
if (streq_ic (word, "perform")) {
*flag = PERFORM;
} else if (streq_ic (word, "complete")) {
*flag = COMPLETE;
} else if (streq_ic (word, "skipped")) {
*flag = OMIT;
} else if (streq_ic (word, "omit")) {
*flag = OMIT;
} else {
*flag = OMIT;
sprintf (MsgText, "Keyword %s = %s is invalid.", calswitch, word);
trlerror (MsgText);
free (word);
return (status = HEADER_PROBLEM);
}
free (word);
return (status);
}
int LoadHdr (char *input, Hdr *phdr) {
extern int status;
IODescPtr im; /* descriptor for input image */
sprintf(MsgText, "Trying to open %s...",input);
trlmessage (MsgText);
/* Open input image in order to read its primary header. */
im = openInputImage (input, "", 0);
if (hstio_err()) {
trlopenerr (input);
return (status = OPEN_FAILED);
}
initHdr (phdr);
/* get primary header */
if (getHeader (im, phdr) )
status = HEADER_PROBLEM;
if (hstio_err() || status) {
trlreaderr (input);
closeImage (im);
freeHdr (phdr);
return (status = OPEN_FAILED);
}
closeImage (im);
sprintf(MsgText, "Read in Primary header from %s...",input);
trlmessage (MsgText);
return (status);
}
int GetCCDInfo (WF3Info *wf3, CCD_Switch *sci_sw, RefFileInfo *sciref) {
/* arguments:
WF3Info *wf3 i: calibration flags and other info
CCD_Switch *sci_sw o: all calibration switches (0 or 1) for science file
RefFileInfo *sciref io: list of keyword,filename pairs for science file
*/
extern int status;
IODescPtr im; /* descriptor for an image */
Hdr phdr; /* primary header */
int nextend; /* number of FITS extensions in rawfile */
int GetKeyInt (Hdr *, char *, int, int, int *);
int GetKeyFlt (Hdr *, char *, int, float, float *);
int GetCCDSws (CCD_Switch *, Hdr *);
int GetCCDRef (WF3Info *, CCD_Switch *, Hdr *, RefFileInfo *);
/* Open input raw data file. */
initHdr (&phdr);
im = openInputImage (wf3->rawfile, "", 0);
if (hstio_err()) {
sprintf (MsgText, "Member \"%s\" is not present", wf3->rawfile);
trlerror (MsgText);
freeHdr(&phdr);
return (status = OPEN_FAILED);
}
/* Read primary header into pdhr. */
getHeader (im, &phdr);
if (hstio_err()) {
sprintf (MsgText, "Could not open PRIMARY header for \"%s\" ",
wf3->rawfile);
trlmessage (MsgText);
closeImage(im);
freeHdr(&phdr);
return (status = OPEN_FAILED);
}
closeImage (im);
/* Get generic parameters: */
/* Find out how many extensions there are in this file. */
if (GetKeyInt (&phdr, "NEXTEND", USE_DEFAULT, EXT_PER_GROUP, &nextend)){
freeHdr(&phdr);
closeImage(im);
return (status = KEYWORD_MISSING);
}
wf3->nchips = nextend / EXT_PER_GROUP;
/* Get binning and gain info. We really only need this for the CCD. */
if (GetKeyInt (&phdr, "BINAXIS1", USE_DEFAULT, 1, &wf3->scibin[0])) {
closeImage(im);
freeHdr(&phdr);
return (status = KEYWORD_MISSING);
}
if (GetKeyInt (&phdr, "BINAXIS2", USE_DEFAULT, 1, &wf3->scibin[1])){
closeImage(im);
freeHdr(&phdr);
return (status = KEYWORD_MISSING);
}
if (GetKeyFlt (&phdr, "CCDGAIN", USE_DEFAULT, 1.5, &wf3->scigain)){
closeImage(im);
freeHdr(&phdr);
return (status = KEYWORD_MISSING);
}
wf3->samebin = 1; /* default */
/* Get calibration switches, and check that reference files exist. */
if (GetCCDSws (sci_sw, &phdr))
return (status = KEYWORD_MISSING);
if (GetCCDRef (wf3, sci_sw, &phdr, sciref))
return (status = CAL_FILE_MISSING);
freeHdr (&phdr);
return (status);
}
int doFlat (StisInfo1 *sts, SingleGroup *x) {
/* arguments:
StisInfo1 *sts i: calibration switches, etc
SingleGroup *x io: image to be calibrated; written to in-place
*/
int status;
SingleGroup w, y, z; /* scratch space */
float *ds; /* Doppler smearing array */
int nds; /* size of ds */
int d0; /* index in ds of Doppler = 0 */
int border; /* = doppmag, unless obsmode = time-tag */
int extver = 1; /* get this group from flat field images */
int rx, ry; /* for binning dark down to size of x */
int x0, y0; /* offsets of sci image */
int same_size; /* true if no binning of ref image required */
int high_res; /* true if high-res pixels in dispersion dir */
int avg = 1; /* bin2d should average within each bin */
int nx, ny; /* how large to make y for lfltfile */
int dummy;
int FindBin (StisInfo1 *, SingleGroup *, SingleGroup *,
int *, int *, int *, int *, int *, int *);
int MakeDopp (double, double, double, double, double, int,
float *, int *, int *);
int DoppConv (SingleGroup *, int, float *, int, int);
initSingleGroup (&w);
initSingleGroup (&y);
initSingleGroup (&z);
/* pixel-to-pixel flat */
if (sts->pfltcorr == PERFORM) {
getSingleGroup (sts->pflt.name, extver, &y);
if (hstio_err())
return (OPEN_FAILED);
}
/* delta flat */
if (sts->dfltcorr == PERFORM) {
if (sts->pfltcorr == PERFORM) {
getSingleGroup (sts->dflt.name, extver, &z);
if (y.sci.data.nx != z.sci.data.nx ||
y.sci.data.ny != z.sci.data.ny) {
printf (
"ERROR Pixel-to-pixel flat and delta flat are not the same size.\n");
return (SIZE_MISMATCH);
}
if ((status = mult2d (&y, &z))) /* y is the product */
return (status);
freeSingleGroup (&z);
} else {
getSingleGroup (sts->dflt.name, extver, &y);
}
if (hstio_err())
return (OPEN_FAILED);
}
/* low-order flat */
if (sts->lfltcorr == PERFORM) {
/* Get lflt into a scratch area because lflt is smaller than y. */
if (sts->pfltcorr == PERFORM || sts->dfltcorr == PERFORM) {
/* This is the normal case; we already have a product in y. */
getSingleGroup (sts->lflt.name, extver, &w);
if (hstio_err())
return (OPEN_FAILED);
allocSingleGroup (&z, y.sci.data.nx, y.sci.data.ny, True);
if (hstio_err())
return (ALLOCATION_PROBLEM);
/* Resample w to z by linear interpolation. */
if ((status = unbin2d (&w, &z))) /* unbin w --> z */
return (status);
freeSingleGroup (&w); /* we won't need w again */
if ((status = mult2d (&y, &z))) /* y is the product */
return (status);
freeSingleGroup (&z);
} else {
/* We have neither a pixel-to-pixel flat nor a delta flat. */
getSingleGroup (sts->lflt.name, extver, &z);
/* figure out how much to expand the low-order flat. */
FindBin (sts, x, &z, &dummy, &dummy, &rx, &ry, &dummy, &dummy);
status = 0; /* ignore status = REF_TOO_SMALL */
/* Create y. We don't need to assign any initial values
because y is strictly output from unbin2d.
*/
nx = rx * z.sci.data.nx;
ny = ry * z.sci.data.ny;
allocSingleGroup (&y, nx, ny, True);
if (hstio_err())
return (ALLOCATION_PROBLEM);
if ((status = unbin2d (&z, &y))) /* unbin z --> y */
return (status);
freeSingleGroup (&z);
}
}
/* Now y contains the product of (up to) three flats. */
/* Compare binning of science image and product of flat fields;
get same_size and high_res flags, and get info about binning
and offset for use by bin2d.
*/
if ((status = FindBin (sts, x, &y,
&same_size, &high_res, &rx, &ry, &x0, &y0)))
return (status);
/* Do we need to do Doppler convolution? */
if (sts->doppcorr == PERFORM) {
if (!high_res) {
printf (
"ERROR Doppler convolution (DOPPCORR) was specified, \\\n");
printf (
"ERROR but the flat fields are binned to low-res pixels.\n");
return (SIZE_MISMATCH);
}
/* Allocate space for the Doppler smearing array, making it
larger than we will need. The actual size nds will be
updated by MakeDopp.
*/
nds = 2 * (sts->doppmag + 1) + 21;
ds = (float *) calloc (nds, sizeof (float));
if ((status = MakeDopp (sts->doppzero, sts->doppmag, sts->orbitper,
sts->expstart, sts->exptime, sts->dispsign,
ds, &nds, &d0)))
return (status);
/* Convolve y with the Doppler smearing function. */
if (strcmp (sts->obsmode, "TIME-TAG") == 0)
border = 0;
else
border = NINT(sts->doppmag);
if ((status = DoppConv (&y, border, ds, nds, d0)))
return (status);
free (ds);
}
/* Now we've got the complete flat field in y, convolved with
the Doppler smearing function if necessary. Divide x by y.
*/
if (same_size) {
/* No binning required. */
if ((status = div2d (x, &y))) {
printf ("ERROR (doFlat) size mismatch\n");
return (status);
}
freeSingleGroup (&y);
} else {
/* Bin the flat field down to the actual size of x. */
allocSingleGroup (&z, x->sci.data.nx, x->sci.data.ny, True);
if ((status = bin2d (&y, x0, y0, rx, ry, avg, &z))) {
printf ("ERROR (doFlat) size mismatch\n");
return (status);
}
freeSingleGroup (&y); /* done with y */
if ((status = div2d (x, &z)))
return (status);
freeSingleGroup (&z); /* done with z */
}
return (0);
}
/*
Description:
------------
If using the exposure time, the scaling factors are normalized to ratios
relative to the max exposure.
Date Author Description
---- ------ -----------
24-Sep-1998 W.J. Hack Initial Version
18-Mar-1999 W.J. Hack Revised to read EXPTIMEs from Primary headers
using image-template list directly
20-Oct-1999 W.J. Hack Revised to compute number of good input images
and insure they are less than MAX_FILES.
14-Apr-2000 W.J. Hack Revised to also return final EXPEND appropriate
for output CR-combined product
14-Mar-2002 W.J. Hack Added computation of cumulative DARKTIME
4-Apr-2002 W.J. Hack added initialization of 'totd'
24-Apr-2002 W.J. Hack removed darktime altogether, find initial EXPSTART
*/
int cr_scaling (char *expname, IRAFPointer tpin, float efac[], int *nimgs, double *expend, double *expstart)
{
extern int status;
Hdr prihdr;
int nzero, k;
char fdata[CHAR_FNAME_LENGTH + 1];
IODescPtr ip;
int numimgs; /* How many good input images are there? */
double end, keyend, keystart, start;
int GetKeyFlt (Hdr *, char *, int, float, float *);
int GetKeyDbl (Hdr *, char *, int, double, double *);
/* -------------------------------- begin ---------------------------------- */
/* Rewind the image template pointer */
c_imtrew(tpin);
*nimgs = c_imtlen(tpin);
end = 0.0;
keyend = 0.0;
start = 1e+10;
keystart = 0.0;
/* Check to make sure there are not too many images to work with... */
if (*nimgs > MAX_FILES) {
trlerror("There are too many input images to combine. ");
return(status = NOTHING_TO_DO);
}
/* if the parameter scaling is null, all images have equal weight.
If no keyword name is given for the exposure time, assume equal
weights of 1 for all images.
*/
if (expname[0] == '\0') {
return (status);
}
/* Use exposure time as scaling factor */
nzero = 0;
/* loop all input files counting how many usable inputs there are */
numimgs = 0;
for (k = 0; k < *nimgs; ++k) {
/* read the next input image name in the template list */
c_imtgetim (tpin, fdata, CHAR_FNAME_LENGTH);
/* open the primary header */
ip = openInputImage (fdata, "", 0);
if (hstio_err()) {
sprintf (MsgText, "Cannot open data file '%s'", fdata);
trlerror (MsgText);
return (status = OPEN_FAILED);
}
initHdr (&prihdr);
/* read in primary header from image */
getHeader (ip, &prihdr);
if (GetKeyFlt (&prihdr, expname, USE_DEFAULT, 0., &efac[k]) != 0) {
sprintf (MsgText, "cannot read '%s' from the primary header of '%s'", expname, fdata);
trlerror (MsgText);
freeHdr (&prihdr);
return(status = KEYWORD_MISSING);
}
if (efac[k] < 0.) {
sprintf (MsgText, "exposure time of file '%s' is negative", fdata);
trlerror (MsgText);
freeHdr (&prihdr);
return(status = INVALID_VALUE);
}
if (efac[k] == 0.) {
nzero++;
}
numimgs++;
if (GetKeyDbl (&prihdr, "EXPEND", USE_DEFAULT, 0., &keyend) != 0) {
sprintf (MsgText, "cannot read 'EXPEND' from the primary header of '%s'", fdata);
trlerror (MsgText);
freeHdr (&prihdr);
return(status = KEYWORD_MISSING);
}
if (GetKeyDbl (&prihdr, "EXPSTART", USE_DEFAULT, 0., &keystart) != 0) {
sprintf (MsgText, "cannot read 'EXPSTART' from the primary header of '%s'", fdata);
trlerror (MsgText);
freeHdr (&prihdr);
return(status = KEYWORD_MISSING);
}
end = (keyend > end) ? keyend: end;
start = (keystart < start) ? keystart : start;
closeImage (ip);
freeHdr (&prihdr);
}
if (nzero > 0 && nzero < *nimgs) {
trlwarn ("Some (but not all) input imsets have zero exposure time.");
trlwarn ("Final product will be compromised!");
/* This type of error will need to be handled differently in order
to allow pipeline processing of this type of dataset.
return (status = INVALID_VALUE);
*/
}
/* Only return the number of valid input images,
initial EXPSTART and final EXPEND value
*/
*nimgs = numimgs;
*expend = end;
*expstart = start;
return (status);
}
static int FluxToNet (StisInfo6 *sts, IntensArray *inta, int sporder) {
/* This is used to store information from the fflux file in a
form suitable for the reference file input routines.
*/
StisInfo6 fsts;
ApInfo slit;
PhotInfo phot;
IODescPtr im;
Hdr phdr;
double photfactor, throughput, response, dispersion;
double atodgain, readnoise;
float correction;
int i, dispc, helc, status;
int abs_starti, thr_starti;
int dummy;
void FreePhot6 (PhotInfo *);
void FreeThroughput6 (ApInfo *);
int GetAbsPhot6 (StisInfo6 *, int, PhotInfo *, int, int *);
int GetApDes6 (StisInfo6 *, ApInfo *);
int GetApThr6 (StisInfo6 *, ApInfo *);
int Get_KeyD (Hdr *, char *, int, double, double *);
int Get_KeyS (Hdr *, char *, int, char *, char *, int);
int GetSwitch (Hdr *, char *, int *);
double interp1d (double, double *, double *, int, int *);
void StisInit6 (StisInfo6 *);
photfactor = H_PLANCK * C_LIGHT / HST_AREA;
/* Initialize local data structures. */
StisInit6 (&fsts);
InitRefTab (&fsts.phottab);
InitRefTab (&fsts.apertab);
InitRefTab (&fsts.apdestab);
slit.allocated = 0;
slit.gac_allocated = 0;
phot.allocated = 0;
phot.pcorr = NULL;
/* Handling the primary header here is not efficient. But keeps
this new code manageable since everything new is added at a
single point. In the future we may move this to outside the
main loop and pass the necessary values as part of the sts
structure.
*/
initHdr (&phdr);
im = openInputImage (sts->pxtab.name, "", 0);
if (hstio_err())
return (OPEN_FAILED);
getHeader (im, &phdr);
if (hstio_err())
return (OPEN_FAILED);
closeImage (im);
/* Abort if both helcorr and dispcorr weren't performed.
The criterion is: if a keyword is set to either COMPLETE
or PERFORM, we assume that the operation was performed.
This is because UpdHdrSwitch in Do1Dx only updates the
keywords to COMPLETE if they are set to PERFORM in the
input file. (note: UpdHdrSwitch is no longer used)
*/
if ((status = GetSwitch (&phdr, "DISPCORR", &dispc)))
return (status);
if ((status = GetSwitch (&phdr, "HELCORR", &helc)))
return (status);
if (!((dispc == PERFORM || dispc == COMPLETE) &&
(helc == PERFORM || helc == COMPLETE))) {
printf ("ERROR No DISPCORR/HELCORR in fflux file.\n");
return (ERROR_RETURN);
}
/* Read header keywords. */
if ((status = Get_KeyD (&phdr, "READNSE", 1, 0., &readnoise)))
return (status);
if ((status = Get_KeyD (&phdr, "ATODGAIN", 1, 1., &atodgain)))
return (status);
if ((status = Get_KeyS (&phdr, "PHOTTAB", FATAL, "",
fsts.phottab.name, STIS_LINE)))
return (status);
if ((status = Get_KeyS (&phdr, "APDESTAB", FATAL, "",
fsts.apdestab.name, STIS_LINE)))
return (status);
if ((status = Get_KeyS (&phdr, "APERTAB", FATAL, "",
fsts.apertab.name, STIS_LINE)))
return (status);
/* Copy stuff from primary data structure into local one. */
fsts.x1d_o = sts->x1d_o;
fsts.dispcorr = sts->dispcorr;
fsts.fluxcorr = sts->fluxcorr;
fsts.pctcorr = sts->pctcorr;
fsts.cenwave = sts->cenwave;
strcpy (fsts.opt_elem, sts->opt_elem);
strcpy (fsts.aperture, sts->aperture);
/* Read the required reference info. */
dummy = 0;
if ((status = GetAbsPhot6 (&fsts, sporder, &phot, 0, &dummy)))
return (status);
if ((status = GetApDes6 (&fsts, &slit)))
return (status);
if ((status = GetApThr6 (&fsts, &slit)))
return (status);
abs_starti = 1; /* initial values */
thr_starti = 1;
/* Loop over flux array. */
for (i = 0; i < inta->nelem; i++) {
response = interp1d (inta->wave[i], phot.wl, phot.thru,
phot.nelem, &abs_starti);
throughput = interp1d (inta->wave[i], slit.wl, slit.thr,
slit.nelem, &thr_starti);
if (i > 0)
dispersion = inta->wave[i] - inta->wave[i-1];
else
dispersion = inta->wave[1] - inta->wave[0];
/* This check is provisional; final version awaits IS's words. */
if (response <= 0.0 ||
dispersion <= 0.0 ||
throughput <= 0.0) {
printf ("ERROR Error in fflux file contents.\n");
return (ERROR_RETURN);
}
correction = (float) (photfactor / (response * throughput *
inta->wave[i] * dispersion * atodgain *
CM_PER_ANGSTROM));
inta->intens[i] = inta->intens[i] / correction;
}
FreeThroughput6 (&slit);
FreePhot6 (&phot);
freeHdr (&phdr);
return STIS_OK;
}
/* remove stripes from post-SM4 full frame WFC data using information in
* the prescan regions. chip2 is amps C & D, chip1 is amps A & B. */
int doDestripe(ACSInfo *acs, SingleGroup *chip2, SingleGroup *chip1) {
extern int status;
/* iteration variables */
int i, j, k;
/* amp array size variables */
int arr_rows, arr_cols;
/* array of arrays for each amp's data in order of AMPSORDER */
double * ampdata[NAMPS];
/* arrays of bias column means and standard deviation */
double bias_col_means[NBIAS_COLS];
double bias_col_stds[NBIAS_COLS];
/* array of arrays designating whether a row is usable or not. 0: bad, 1:good */
char * good_rows[NAMPS];
/* array of number of good rows for each amp */
int num_good_rows[NAMPS];
/* number of rows ultimately worked on and fixed */
int rows_fixed;
int rows_skipped;
/* character array for holding history messages */
char history[ACS_LINE];
/* bias pixel mean, standard deviation, and number of good pixels */
double bias_mean, bias_std;
int good_bias_pix;
/* holder of bias means from each amp, saved here so I can put the
* MEANBLEV keyword in the science extension headers */
double bias_mean_arr[NAMPS];
int PutKeyFlt(Hdr *, char *, float, char *);
int blevHistory(ACSInfo *, Hdr *, int, int);
int MkName (char *, char *, char *, char *, char *, int);
/* figure out the size of individual amp arrays
* should be 2068 rows by 2072 columns */
arr_rows = chip2->sci.data.ny;
arr_cols = chip2->sci.data.nx/2;
/* allocate space for the amp arrays */
for (i = 0; i < NAMPS; i++) {
ampdata[i] = malloc(arr_rows * arr_cols * sizeof(double));
good_rows[i] = malloc(arr_rows * sizeof(char));
}
/* copy data from SingleGroup structs to amp arrays */
for (i = 0; i < NAMPS; i++) {
if (i < 2) {
make_amp_array(arr_rows, arr_cols, chip1, i, ampdata[i]);
} else {
make_amp_array(arr_rows, arr_cols, chip2, i, ampdata[i]);
}
}
/* subtract each column's mean as computed after removing the mean of each
* bias row, ignoring bias rows near saturated pixels, and doing
* sigma rejection of outlying bias pixels. */
for (i = 0; i < NAMPS; i++) {
if (bias_col_mean_std(arr_rows, arr_cols, ampdata[i],
bias_col_means, bias_col_stds)) {
return status;
}
if (sub_bias_col_means(arr_rows, arr_cols, NBIAS_COLS, bias_col_means,
ampdata[i])) {
return status;
}
}
/* for each amp figure out which rows to use and how many good rows there are */
for (i = 0; i < NAMPS; i++) {
find_good_rows(arr_rows, arr_cols, ampdata[i], good_rows[i], &num_good_rows[i]);
}
/* for each amp, figure out the mean of the good bias pixels with "sigma"
* clipping, then subtract that mean from all that amp's data. */
for (i = 0; i < NAMPS; i++) {
if (calc_bias_mean_std(arr_rows, arr_cols, ampdata[i], good_rows[i],
&bias_mean, &bias_std, &good_bias_pix)) {
return status;
}
/* subtract the mean from all the pixels in the image. */
for (j = 0; j < arr_rows; j++) {
for (k = 0; k < arr_cols; k++) {
ampdata[i][arr_cols*j + k] -= bias_mean;
}
}
/* report bias level subtracted to user */
sprintf(MsgText, " bias level of %.6g electrons was subtracted for AMP %c.",
bias_mean, AMPSORDER[i]);
trlmessage(MsgText);
acs->blev[i] += bias_mean;
bias_mean_arr[i] = bias_mean;
}
/* add MEANBLEV keyword to science extension headers */
if (PutKeyFlt (&chip1->sci.hdr, "MEANBLEV", (bias_mean_arr[0] + bias_mean_arr[1])/2.,
"mean of bias levels subtracted in electrons")) {
return (status);
}
if (PutKeyFlt (&chip2->sci.hdr, "MEANBLEV", (bias_mean_arr[2] + bias_mean_arr[3])/2.,
"mean of bias levels subtracted in electrons")) {
return (status);
}
/* remove stripes */
if (remove_stripes(arr_rows, arr_cols, good_rows, ampdata, &rows_fixed, &rows_skipped)) {
return status;
}
/* add history keywords about rows fixed and rows skipped */
sprintf(history, "DESTRIPE: number of rows fixed per amp: %i", rows_fixed);
addHistoryKw(chip2->globalhdr, history);
if (hstio_err()) {
return (status = HEADER_PROBLEM);
}
sprintf(history, "DESTRIPE: number of rows skipped per amp: %i", rows_skipped);
addHistoryKw(chip2->globalhdr, history);
if (hstio_err()) {
return (status = HEADER_PROBLEM);
}
/* copy modified data back to SingleGroup structs */
for (i = 0; i < NAMPS; i++) {
if (i < 2) {
unmake_amp_array(arr_rows, arr_cols, chip1, i, ampdata[i]);
} else {
unmake_amp_array(arr_rows, arr_cols, chip2, i, ampdata[i]);
}
}
/* free allocated arrays */
for (i = 0; i < NAMPS; i++) {
free(ampdata[i]);
free(good_rows[i]);
}
return status;
}
int ImgPedigree (RefImage *ref) {
FitsKw key; /* location of keyword in header */
IODescPtr im; /* descriptor for primary header unit */
Hdr phdr; /* primary header */
initHdr (&phdr);
ref->goodPedigree = GOOD_PEDIGREE; /* initial value */
if (!GotFileName (ref->name)) {
ref->exists = EXISTS_NO;
return (0);
}
/* Open the primary header of the reference file. */
im = openInputImage (ref->name, "", 0);
if (hstio_err()) {
ref->exists = EXISTS_NO;
clear_hstioerr();
return (0);
}
ref->exists = EXISTS_YES;
getHeader (im, &phdr);
if (hstio_err())
return (HEADER_PROBLEM);
/* Get pedigree and descrip. If either or both are missing,
that's not an error in this case.
*/
key = findKw (&phdr, "PEDIGREE");
if (key == NotFound) {
ref->pedigree[0] = '\0';
} else {
getStringKw (key, ref->pedigree, STIS_FITS_REC);
if (hstio_err()) {
printf ("ERROR Trying to get PEDIGREE.\n");
return (HEADER_PROBLEM);
}
}
key = findKw (&phdr, "DESCRIP");
if (key == NotFound) {
ref->descrip[0] = '\0';
} else {
getStringKw (key, ref->descrip, STIS_FITS_REC);
if (hstio_err()) {
printf ("ERROR Trying to get DESCRIP.\n");
return (HEADER_PROBLEM);
}
}
/* Is this a dummy reference file? */
if (strncmp (ref->pedigree, "DUMMY", 5) == 0)
ref->goodPedigree = DUMMY_PEDIGREE; /* dummy, so pedigree is bad */
else
ref->goodPedigree = GOOD_PEDIGREE; /* pedigree is good */
/* Done with this image for the time being. */
closeImage (im);
freeHdr (&phdr);
return (0);
}
int History7 (StisInfo7 *sts, Hdr *phdr) {
/* arguments:
StisInfo7 *sts i: calibration switches and info
Hdr *phdr io: header to receive history records
*/
int status;
int logit; /* true if we log history info */
logit = 0;
if (sts->obstype == SPECTROSCOPIC_TYPE) {
if (sts->x2dcorr == PERFORM) {
Put_KeyS (phdr, "X2DCORR", "COMPLETE", "");
Put_KeyS (phdr, "DISPCORR", "COMPLETE", "");
addHistoryKw (phdr, "X2DCORR complete ...");
logit = 1;
} else if (sts->x2dcorr == DUMMY) {
Put_KeyS (phdr, "X2DCORR", "SKIPPED", "");
addHistoryKw (phdr,
"X2DCORR skipped due to dummy reference file ...");
logit = 1;
}
} else {
if (sts->x2dcorr == PERFORM) {
Put_KeyS (phdr, "GEOCORR", "COMPLETE", "");
addHistoryKw (phdr, "GEOCORR complete ...");
logit = 1;
} else if (sts->x2dcorr == DUMMY) {
Put_KeyS (phdr, "GEOCORR", "SKIPPED", "");
addHistoryKw (phdr,
"GEOCORR skipped due to dummy reference file ...");
logit = 1;
}
}
if (logit) {
if (hstio_err())
return (HEADER_PROBLEM);
if ((status = TabHistory (&sts->distntab, phdr)))
return (status);
if (sts->obstype == SPECTROSCOPIC_TYPE) {
if ((status = TabHistory (&sts->apdestab, phdr)))
return (status);
if ((status = TabHistory (&sts->disptab, phdr)))
return (status);
if ((status = TabHistory (&sts->inangtab, phdr)))
return (status);
if ((status = TabHistory (&sts->sptrctab, phdr)))
return (status);
if (sts->wx2dcorr == COMPLETE) {
addHistoryKw (phdr,
"spectral trace was applied earlier, by wx2d");
}
}
}
logit = 0;
if (sts->sgeocorr == PERFORM) {
Put_KeyS (phdr, "SGEOCORR", "COMPLETE", "");
addHistoryKw (phdr, "SGEOCORR complete ...");
logit = 1;
} else if (sts->sgeocorr == DUMMY) {
Put_KeyS (phdr, "SGEOCORR", "SKIPPED", "");
addHistoryKw (phdr,
"SGEOCORR skipped due to dummy reference file ...");
logit = 1;
}
if (logit) {
if (hstio_err())
return (HEADER_PROBLEM);
if ((status = ImgHistory (&sts->sdstfile, phdr)))
return (status);
}
if (sts->heliocorr == PERFORM) {
Put_KeyS (phdr, "HELCORR", "COMPLETE", "");
addHistoryKw (phdr, "HELCORR complete");
if (hstio_err())
return (HEADER_PROBLEM);
}
logit = 0;
if (sts->fluxcorr == PERFORM) {
Put_KeyS (phdr, "FLUXCORR", "COMPLETE", "");
addHistoryKw (phdr, "FLUXCORR complete ...");
logit = 1;
} else if (sts->fluxcorr == DUMMY) {
Put_KeyS (phdr, "FLUXCORR", "SKIPPED", "");
addHistoryKw (phdr,
"FLUXCORR skipped due to dummy reference file ...");
logit = 1;
}
if (logit) {
if (hstio_err())
return (HEADER_PROBLEM);
if ((status = TabHistory (&sts->phottab, phdr)))
return (status);
if ((status = TabHistory (&sts->apertab, phdr)))
return (status);
/* pctcorr is not independent; it's associated with fluxcorr. */
if (sts->pctcorr == PERFORM) {
if ((status = TabHistory (&sts->pctab, phdr)))
return (status);
} else {
addHistoryKw (phdr,
" Note: PCTAB correction was not included in DIFF2PT");
if (hstio_err())
return (HEADER_PROBLEM);
}
/* tdscorr is not independent; it's associated with fluxcorr. */
if (sts->tdscorr == PERFORM) {
if ((status = TabHistory (&sts->tdstab, phdr)))
return (status);
} else {
addHistoryKw (phdr,
" Note: TDSTAB correction was not included in fluxcorr");
if (hstio_err())
return (HEADER_PROBLEM);
}
}
if (sts->statcorr == PERFORM) {
addHistoryKw (phdr, "Statistics computed");
if (hstio_err())
return (HEADER_PROBLEM);
}
return (0);
}
int CalStis11 (char *inwav, char *insci, char *output,
int printtime, int verbose) {
int status;
StisInfo11 wavecal, scidata; /* calibration switches, etc. */
IODescPtr imWav; /* descriptor for input wavecal */
IODescPtr imSci; /* descriptor for input science file */
Hdr phdrWav; /* primary header for input wavecal */
Hdr phdrSci; /* primary header for input science file */
int subscicorr; /* PERFORM if CCD and sclamp is HITM1 or 2 */
int GetKeyInfo11 (StisInfo11 *, Hdr *);
int SubSci (StisInfo11 *, StisInfo11 *);
PrBegin (11);
if (printtime)
TimeStamp ("CALSTIS-11 started", "");
/* Initialize structure containing calstis information. */
StisInit11 (&wavecal, &scidata);
/* Copy command-line arguments into wavecal & scidata. */
strcpy (wavecal.input, inwav);
strcpy (scidata.input, insci);
strcpy (wavecal.output, output);
wavecal.printtime = printtime;
scidata.printtime = printtime;
wavecal.verbose = verbose;
scidata.verbose = verbose;
PrFileName ("wavecal", wavecal.input);
PrFileName ("science", scidata.input);
PrFileName ("output", wavecal.output);
initHdr (&phdrWav);
initHdr (&phdrSci);
/* Check whether the output file already exists. */
if ((status = FileExists (wavecal.output)))
return (status);
/* Read primary header of input wavecal. */
imWav = openInputImage (wavecal.input, "", 0);
if (hstio_err())
return (OPEN_FAILED);
getHeader (imWav, &phdrWav);
if (hstio_err())
return (OPEN_FAILED);
closeImage (imWav);
/* Get keyword values from wavecal primary header. */
if ((status = GetKeyInfo11 (&wavecal, &phdrWav)))
return (status);
freeHdr (&phdrWav);
/* Print information about the input wavecal. */
PrHdrInfo (wavecal.obsmode, wavecal.aperture,
wavecal.opt_elem, wavecal.det);
/* Do we need to subtract the science image from the wavecal? */
subscicorr = PERFORM; /* initial value */
if (wavecal.detector != CCD_DETECTOR) {
subscicorr = OMIT;
printf ("Warning Detector is %s\n", wavecal.det);
}
if (strcmp (wavecal.sclamp, "HITM1") != 0 &&
strcmp (wavecal.sclamp, "HITM2") != 0) {
subscicorr = OMIT;
printf ("Warning Wavecal SCLAMP is `%s', not HITM1 or HITM2\n",
wavecal.sclamp);
}
if (wavecal.texpstrt >= EXT_SHUTTER_CLOSED) {
subscicorr = OMIT;
printf (
"Warning TEXPSTRT=%.2f implies external shutter is closed.\n",
wavecal.texpstrt);
}
if (subscicorr != PERFORM) {
printf (
"Warning Science data will not be subtracted from wavecal.\n");
return (NOTHING_TO_DO);
}
/* Read primary header of input science file. */
imSci = openInputImage (scidata.input, "", 0);
if (hstio_err())
return (OPEN_FAILED);
getHeader (imSci, &phdrSci);
if (hstio_err())
return (OPEN_FAILED);
closeImage (imSci);
if (wavecal.printtime)
TimeStamp ("Begin processing", wavecal.rootname);
/* Get keyword values from science file primary header. */
if ((status = GetKeyInfo11 (&scidata, &phdrSci)))
return (status);
freeHdr (&phdrSci);
/* Detector, central wavelength, grating, and aperture must be
the same in the wavecal and science file.
*/
if (wavecal.detector != scidata.detector ||
wavecal.cenwave != scidata.cenwave ||
strcmp (wavecal.opt_elem, scidata.opt_elem) != 0 ||
strcmp (wavecal.aperture, scidata.aperture) != 0) {
printf ("Warning Wavecal and science file do not match; \\\n");
printf ("Warning the science file will not be subtracted.\n");
return (NOTHING_TO_DO);
}
/* Subtract the science image from the wavecal. */
if ((status = SubSci (&wavecal, &scidata)))
return (status);
printf ("\n");
PrEnd (11);
if (wavecal.printtime)
TimeStamp ("CALSTIS-11 completed", wavecal.rootname);
return (0);
}
int TargPos (StisInfo12 *sci, int extver, double shift1, double shift2) {
/* arguments:
StisInfo12 *sci i: info about science data file
int extver i: EXTVER number of extensions to update
double shift1, shift2 i: shift to be assigned to SHIFTAi keywords
*/
int status;
IODescPtr im; /* descriptor for an image */
Hdr hdr; /* header for an extension */
/* Update SCI extension. */
initHdr (&hdr);
im = openUpdateImage (sci->input, "SCI", extver, &hdr);
if (hstio_err())
return (OPEN_FAILED);
/* Update SHIFTAi. */
if ((status = UpdateShift (&hdr, shift1, shift2)))
return (status);
putHeader (im);
if (hstio_err())
return (OPEN_FAILED);
closeImage (im);
freeHdr (&hdr);
/* Update ERR extension. */
im = openUpdateImage (sci->input, "ERR", extver, &hdr);
if (hstio_err())
return (OPEN_FAILED);
if ((status = UpdateShift (&hdr, shift1, shift2)))
return (status);
putHeader (im);
if (hstio_err())
return (OPEN_FAILED);
closeImage (im);
freeHdr (&hdr);
/* Update DQ extension. */
im = openUpdateImage (sci->input, "DQ", extver, &hdr);
if (hstio_err())
return (OPEN_FAILED);
if ((status = UpdateShift (&hdr, shift1, shift2)))
return (status);
putHeader (im);
if (hstio_err())
return (OPEN_FAILED);
closeImage (im);
freeHdr (&hdr);
/* write to trailer */
if (fabs (shift1) < MUCH_TOO_BIG) /* shift is OK */
printf (" SHIFTA1 set to %.6g\n", shift1);
if (fabs (shift2) < MUCH_TOO_BIG)
printf (" SHIFTA2 set to %.6g\n", shift2);
return (0);
}
int doDark (WF3Info *wf32d, SingleGroup *x, float *meandark) {
/* arguments:
WF3Info *wf3 i: calibration switches, etc
SingleGroup *x io: image to be calibrated; written to in-place
float *meandark o: mean of dark image values subtracted
*/
extern int status;
SingleGroupLine y, z; /* y and z are scratch space */
int extver = 1; /* get this imset from dark image */
int rx, ry; /* for binning dark down to size of x */
int x0, y0; /* offsets of sci image */
int same_size; /* true if no binning of ref image required */
int avg = 0; /* bin2d should sum values within each bin */
int scilines; /* number of lines in science image */
int i, j;
float mean, dark;
float weight, wdark; /* weights for line averages */
int update;
float gain[NAMPS];
float rn2[NAMPS]; /* only need this to call get_nsegn */
int FindLine (SingleGroup *, SingleGroupLine *, int *, int *, int *,
int *, int *);
int sub1d (SingleGroup *, int, SingleGroupLine *);
int trim1d (SingleGroupLine *, int, int, int, int, int, SingleGroupLine *);
int DetCCDChip (char *, int, int, int *);
void get_nsegn (int, int, int, int, float *, float*, float *, float *);
void AvgSciValLine (SingleGroupLine *, short, float *, float *);
void multgn1d (SingleGroupLine *, int, int, int, float *, float);
initSingleGroupLine (&y);
scilines = x->sci.data.ny;
/* Compute correct extension version number to extract from
reference image to correspond to CHIP in science data. */
if (DetCCDChip(wf32d->dark.name, wf32d->chip, wf32d->nimsets, &extver))
return (status);
if (wf32d->verbose) {
sprintf (MsgText,
"Performing dark subtraction on chip %d in imset %d",
wf32d->chip, extver);
trlmessage(MsgText);
}
/* Get the dark image data. */
openSingleGroupLine (wf32d->dark.name, extver, &y);
if (hstio_err())
return (status = OPEN_FAILED);
/* Compare binning of science image and reference image;
get same_size flag, and get info about binning and offset
for use by bin2d.
*/
if (FindLine (x, &y, &same_size, &rx, &ry, &x0, &y0))
return (status);
/* Return with error if reference data not binned same as input */
if (rx != 1 || ry != 1) {
closeSingleGroupLine (&y);
freeSingleGroupLine (&y);
sprintf (MsgText,
"DARK image and input are not binned to the same pixel size!");
trlerror(MsgText);
return (status = SIZE_MISMATCH);
}
if (wf32d->verbose){
sprintf(MsgText,"Image has an offset of %d,%d",x0,y0);
trlmessage(MsgText);
}
mean = 0.0;
weight = 0.0;
/* Multiply the dark image by the exposure time and divide by the
atodgain (or just by exposure time for the MAMAs), and
subtract it from x.
*/
for (i = 0; i < NAMPS; i++) {
gain[i] = 0.;
rn2[i] = 0.;
}
get_nsegn (wf32d->detector, wf32d->chip, wf32d->ampx, wf32d->ampy,
wf32d->atodgain, wf32d->readnoise, gain, rn2);
initSingleGroupLine (&z);
allocSingleGroupLine (&z, x->sci.data.nx);
for (i=0, j=y0; i < scilines; i++,j++) {
/* We are working with a sub-array and need to apply the
proper section from the reference image to the science image.
*/
getSingleGroupLine (wf32d->dark.name, j, &y);
update = NO;
if (trim1d (&y, x0, y0, rx, avg, update, &z)) {
trlerror ("(darkcorr) size mismatch.");
return (status);
}
multgn1d(&z, j, wf32d->ampx, wf32d->ampy, gain, wf32d->exptime[0]);
AvgSciValLine (&z, wf32d->sdqflags, &dark, &wdark);
/* Sum the contribution from each line */
mean += dark * wdark;
weight += wdark;
status = sub1d (x, i, &z);
if (status)
return (status);
}
freeSingleGroupLine (&z); /* done with z */
closeSingleGroupLine (&y);
freeSingleGroupLine (&y);
/* Compute the mean for the entire image */
if (scilines > 0)
*meandark = mean / weight;
else
*meandark = 0.;
return (status);
}
int doDQI (StisInfo1 *sts, SingleGroup *x) {
/* arguments:
StisInfo1 *sts i: calibration switches, etc
SingleGroup *x io: image to be calibrated; DQ array written to in-place
*/
int status;
TblInfo tabinfo; /* pointer to table descriptor, etc */
TblRow tabrow; /* values read from a table row */
ShortTwoDArray ydq; /* scratch space */
/* mappings from one coordinate system to another */
double ri_m[2], ri_v[2]; /* reference to image */
double rs_m[2], rs_v[2]; /* reference to scratch */
double si_m[2], si_v[2]; /* scratch to image */
/* for copying from scratch array (only copy overlap region): */
int first[2], last[2]; /* corners of overlap region in image coords */
int sfirst[2]; /* lower left corner of overlap in scratch */
int rbin[2]; /* bin size of image relative to ref bin size */
int snpix[2]; /* size of scratch array */
int npix[2]; /* size of current image */
float *ds; /* Doppler smearing array */
int nds, d0; /* size of ds and index in ds of zero point */
int k, kmin, kmax; /* loop index; range of indexes in ds */
int doppmin, doppmax; /* Doppler offsets relative to d0 */
int in_place; /* true if same bin size and no Doppler */
int high_res; /* true if Doppler or either axis is high-res */
int i, j, i0, j0; /* indexes for scratch array ydq */
int m, n; /* indexes for data quality array in x */
short sum_dq; /* for binning data quality array */
int row; /* loop index for row number */
void FlagFilter (StisInfo1 *, ShortTwoDArray *,
int, int, double *, double *);
int MakeDopp (double, double, double, double, double, int,
float *, int *, int *);
/* We could still flag saturation even if the bpixtab was dummy. */
if (sts->dqicorr != PERFORM && sts->dqicorr != DUMMY)
return (0);
/* For the CCD, check for and flag saturation. */
if (sts->detector == CCD_DETECTOR) {
for (j = 0; j < x->sci.data.ny; j++) {
for (i = 0; i < x->sci.data.nx; i++) {
if ((int) Pix (x->sci.data, i, j) > sts->saturate) {
sum_dq = DQPix (x->dq.data, i, j) | SATPIXEL;
DQSetPix (x->dq.data, i, j, sum_dq); /* saturated */
}
}
}
}
/* Get the linear transformation between reference and input image. */
if ((status = GetLT0 (&x->sci.hdr, ri_m, ri_v))) /* zero indexed LTV */
return (status);
/* Flag regions beyond the bounderies of the aperture, for CCD data. */
if (sts->detector == CCD_DETECTOR) {
FlagFilter (sts, &x->dq.data, x->dq.data.nx, x->dq.data.ny,
ri_m, ri_v);
}
/* There might not be any bad pixel table. If not, quit now. */
if (sts->bpix.exists == EXISTS_NO || sts->dqicorr != PERFORM)
return (0);
initShortData (&ydq);
/* In some cases we can set the data quality flags directly in
the DQ array, but in other cases we must create a scratch
array and copy back to the original. Either the original or
the scratch may be in high-res mode.
*/
if (sts->detector == CCD_DETECTOR) {
if (sts->bin[0] == 1 && sts->bin[1] == 1)
in_place = 1; /* no binning */
else
in_place = 0;
high_res = 0;
} else { /* MAMA */
if (sts->doppcorr == PERFORM) {
high_res = 1;
if (sts->bin[0] == 1 && sts->bin[1] == 1)
in_place = 1; /* high-res in both axes */
else
in_place = 0;
} else { /* no Doppler convolution */
if (sts->bin[0] == 2 && sts->bin[1] == 2) {
high_res = 0; /* both axes low-res */
in_place = 1;
} else if (sts->bin[0] == 1 && sts->bin[1] == 1) {
high_res = 1; /* both axes high-res */
in_place = 1;
} else {
high_res = 1; /* low-res in one axis */
in_place = 0;
}
}
}
/* Get the other linear transformations (ri_m & ri_v were gotten
earlier, just after checking for saturation.)
*/
if (!in_place) {
if (high_res) {
/* DQ array is binned finer than reference coords */
rs_m[0] = 2.;
rs_m[1] = 2.;
rs_v[0] = 0.5;
rs_v[1] = 0.5;
/* assumes rs_m = 2, rs_v = 0.5 */
si_m[0] = ri_m[0] * 0.5;
si_m[1] = ri_m[1] * 0.5;
si_v[0] = ri_v[0] - ri_m[0] * 0.25;
si_v[1] = ri_v[1] - ri_m[1] * 0.25;
} else {
/* scratch is in reference coords */
rs_m[0] = 1.;
rs_m[1] = 1.;
rs_v[0] = 0.;
rs_v[1] = 0.;
/* assumes rs_m = 1, rs_v = 0 */
si_m[0] = ri_m[0];
si_m[1] = ri_m[1];
si_v[0] = ri_v[0];
si_v[1] = ri_v[1];
}
}
if (sts->doppcorr == PERFORM) {
/* Compute the Doppler smearing array, if we need it. We need
the size (nds) and zero point (d0), not the array itself.
*/
nds = 2 * (sts->doppmag + 1) + 21; /* reassigned by makeDopp */
ds = (float *) calloc (nds, sizeof (float));
if ((status = MakeDopp (sts->doppzero, sts->doppmag, sts->orbitper,
sts->expstart, sts->exptime, sts->dispsign,
ds, &nds, &d0)))
return (status);
/* Find the range of non-zero elements in ds. */
kmin = nds - 1; /* initial values */
kmax = 0;
for (k = 0; k < nds; k++) {
if (ds[k] > 0.) { /* there will be no negative values */
if (k < kmin)
kmin = k;
if (k > kmax)
kmax = k;
}
}
/* It's the indexes relative to d0 that are important. */
doppmin = kmin - d0;
doppmax = kmax - d0;
free (ds);
} else {
doppmin = 0;
doppmax = 0;
}
/* Open the data quality initialization table, find columns, etc. */
if ((status = OpenBpixTab (sts->bpix.name, &tabinfo)))
return (status);
/* Size of scratch image */
if (high_res) {
snpix[0] = 2 * tabinfo.axlen1;
snpix[1] = 2 * tabinfo.axlen2;
} else {
snpix[0] = tabinfo.axlen1;
snpix[1] = tabinfo.axlen2;
}
/* size of current image */
npix[0] = x->dq.data.nx;
npix[1] = x->dq.data.ny;
if (!in_place) {
/* Allocate space for a scratch array. */
allocShortData (&ydq, snpix[0], snpix[1], True);
if (hstio_err()) {
printf (
"ERROR (doDQI) couldn't allocate data quality array.\n");
return (OUT_OF_MEMORY);
}
for (j = 0; j < snpix[1]; j++)
for (i = 0; i < snpix[0]; i++)
DQSetPix (ydq, i, j, 0); /* initially OK */
}
/* Read each row of the table, and fill in data quality values. */
for (row = 1; row <= tabinfo.nrows; row++) {
if ((status = ReadBpixTab (&tabinfo, row, &tabrow))) {
printf ("ERROR Error reading BPIXTAB.\n");
return (status);
}
if (!SameString (tabrow.opt_elem, sts->opt_elem))
continue;
if (tabrow.xstart < 0 || tabrow.xstart >= tabinfo.axlen1 ||
tabrow.ystart < 0 || tabrow.ystart >= tabinfo.axlen2) {
printf (
"Warning Starting pixel (%d,%d) in BPIXTAB is out of range.\n",
tabrow.xstart+1, tabrow.ystart+1);
continue; /* ignore this row */
}
/* Assign the flag value to all relevant pixels. */
if (in_place) {
if (high_res)
DQIHigh (&x->dq.data, ri_v, &tabrow, doppmin, doppmax);
else
DQINormal (&x->dq.data, ri_v, &tabrow);
} else { /* use scratch array */
if (high_res)
DQIHigh (&ydq, rs_v, &tabrow, doppmin, doppmax);
else
DQINormal (&ydq, rs_v, &tabrow);
}
}
if ((status = CloseBpixTab (&tabinfo))) /* done with the table */
return (status);
if (!in_place) {
/* Get corners of region of overlap between image and
scratch array.
*/
FirstLast (si_m, si_v, snpix, npix, rbin, first, last, sfirst);
/* We have been writing to a scratch array ydq. Now copy or
bin the values down to the actual size of x.
*/
j0 = sfirst[1];
for (n = first[1]; n <= last[1]; n++) {
i0 = sfirst[0];
for (m = first[0]; m <= last[0]; m++) {
sum_dq = DQPix (x->dq.data, m, n);
for (j = j0; j < j0+rbin[1]; j++)
for (i = i0; i < i0+rbin[0]; i++)
sum_dq |= DQPix (ydq, i, j);
DQSetPix (x->dq.data, m, n, sum_dq);
i0 += rbin[0];
}
j0 += rbin[1];
}
freeShortData (&ydq); /* done with ydq */
}
return (0);
}
static int SumGrps (AcsSumInfo *acs, char *mtype) {
extern int status;
SingleGroup x; /* first imset */
SingleGroupLine y; /* line from Nth imset */
double exptime; /* exposure time of current image */
double sumexptime = 0.; /* accumulated exposure time */
char *message; /* for printtime info */
int extver; /* imset number */
int i; /* counter for current image */
int chip, ychip; /*Chip being summed */
int extchip; /* Extension of chip being summed */
int line; /* Line of chip being summed */
char uroot[CHAR_FNAME_LENGTH]; /* Upper case version of rootname */
int doStat (SingleGroup *, short);
void TimeStamp (char *, char *);
void PrGrpBegin (char *, int);
void PrGrpEnd (char *, int);
void PrSwitch (char *, int);
void UCalVer (Hdr *);
void UFilename (char *, Hdr *);
void UMemType (char *, Hdr *);
void UExpname (char *, Hdr *);
int DetCCDChip (char *, int, int, int *);
void UpperAll (char *, char *, int);
int GetKeyInt (Hdr *, char *, int, int, int *);
int GetKeyDbl (Hdr *, char *, int, double, double *);
int PutKeyStr (Hdr *, char *, char *, char *);
initSingleGroup (&x);
initSingleGroupLine (&y);
if (acs->printtime) {
if ((message = calloc (CHAR_LINE_LENGTH+1, sizeof (char))) == NULL)
return (status = OUT_OF_MEMORY);
}
for (extver = 1; extver <= acs->nimsets; extver++) {
PrGrpBegin ("imset", extver);
getSingleGroup (acs->input[0], extver, &x);
if (hstio_err())
return (status = OPEN_FAILED);
if (acs->printtime)
TimeStamp ("first imset read", acs->input[0]);
/* get from x */
if (GetKeyInt (&x.sci.hdr, "CCDCHIP", USE_DEFAULT, 1, &chip))
return (status);
if (GetKeyDbl (x.globalhdr, "EXPEND", NO_DEFAULT, 0., &acs->expend))
return (status);
sumexptime = acs->exptime;
/* Square the errors to convert to variance. */
SquareErr (&x); /* operate on x */
/* For each imset/extver, loop over all images */
for (i = 1; i < acs->nimages; i++) {
/* Determine which extension corresponds to desired chip
** for the remainder of the images.
*/
extchip = 0;
if (DetCCDChip(acs->input[i], chip, acs->nimsets, &extchip) ) {
return (status);
}
/* Get the first line of bias image data. */
openSingleGroupLine (acs->input[i], extchip, &y);
if (hstio_err())
return (status = OPEN_FAILED);
/* Update exposure time info. */
/* get from y */
if (GetKeyInt (&y.sci.hdr, "CCDCHIP", USE_DEFAULT, 1, &ychip))
return (status);
if (GetKeyDbl (y.globalhdr, "EXPTIME", NO_DEFAULT, 0., &exptime))
return (status);
if (GetKeyDbl (y.globalhdr, "EXPEND", NO_DEFAULT, 0., &acs->expend))
return (status);
sumexptime += exptime;
/*Loop over lines in each subsequent image */
for (line = 0; line < x.sci.data.ny; line++) {
status = getSingleGroupLine (acs->input[i], line, &y);
if (status) {
sprintf(MsgText,"Could not read line %d from image %d.",line+1,i+1);
trlerror(MsgText);
return (status = OPEN_FAILED);
}
SquareErrLine (&y); /* operate on y */
/* Add current imset to sum (i.e. add y to x). This differs
from add2d in that RptSum adds variances, rather than
adding errors in quadrature.
*/
if (RptSumLine (&x, line, &y))
return (status);
} /*End loop over lines */
if (acs->printtime) {
if (i == 1)
strcpy (message, "1st imset added");
else if (i == 2)
strcpy (message, "2nd imset added");
else if (i == 3)
strcpy (message, "3rd imset added");
else
sprintf (message, "%dth imset added", i);
TimeStamp (message, acs->input[i]);
}
closeSingleGroupLine (&y);
} /* End loop over images */
freeSingleGroupLine (&y);
/* Take the square root of variance to convert back to errors. */
SqrtErr (&x);
/* Compute statistics and update keywords in output headers. */
trlmessage ("\n");
if (doStat (&x, acs->sdqflags))
return (status);
if (acs->printtime)
TimeStamp ("Image statistics computed", acs->rootname);
/* Update header info in output. */
if (PutSumHdrInfo (&x, sumexptime, acs->expend, acs->nimages, acs->nimsets))
return (status);
/* Update CAL_VER and FILENAME, then write output file.
EXPNAME values modified for all extensions in a SingleGroup.
WJH 7 July 1999
*/
UCalVer (x.globalhdr);
UFilename (acs->output, x.globalhdr);
UMemType (mtype, x.globalhdr);
UExpname (acs->rootname, &x.sci.hdr);
UExpname (acs->rootname, &x.err.hdr);
UExpname (acs->rootname, &x.dq.hdr);
UpperAll (acs->rootname, uroot, strlen(acs->rootname)+1 );
PutKeyStr (x.globalhdr, "ROOTNAME", uroot,"Rootname of the observation set");
putSingleGroup (acs->output, extver, &x, 0);
if (hstio_err())
return (status = 1001);
freeSingleGroup (&x);
PrGrpEnd ("imset", extver);
if (acs->printtime)
TimeStamp ("Output written to disk", acs->rootname);
} /* End loop over imsets */
if (acs->printtime)
free (message);
return (status);
}
int doDark (ACSInfo *acs2d, SingleGroup *x, float *meandark) {
/* arguments:
ACSInfo *acs i: calibration switches, etc
SingleGroup *x io: image to be calibrated; written to in-place
float *meandark o: mean of dark image values subtracted
*/
extern int status;
const float darkscaling = 3.0; /* Extra idle time */
SingleGroupLine y, z; /* y and z are scratch space */
int extver = 1; /* get this imset from dark image */
int rx, ry; /* for binning dark down to size of x */
int x0, y0; /* offsets of sci image */
int same_size; /* true if no binning of ref image required */
int avg = 0; /* bin2d should sum values within each bin */
int scilines; /* number of lines in science image */
int i, j;
float mean, dark;
float weight, wdark; /* weights for line averages */
int update;
float darktime;
int FindLine (SingleGroup *, SingleGroupLine *, int *, int *, int *, int *, int *);
int sub1d (SingleGroup *, int, SingleGroupLine *);
int trim1d (SingleGroupLine *, int, int, int, int, int, SingleGroupLine *);
int DetCCDChip (char *, int, int, int *);
void AvgSciValLine (SingleGroupLine *, short, float *, float *);
int multk1d (SingleGroupLine *, float);
initSingleGroupLine (&y);
scilines = x->sci.data.ny;
/* Compute DARKTIME */
/* SBC does not have FLASH keywords */
if (acs2d->detector == MAMA_DETECTOR)
darktime = acs2d->exptime;
else {
darktime = acs2d->exptime + acs2d->flashdur;
/* Post-SM4 non-BIAS WFC only */
/* TARGNAME unavailable, assume EXPTIME=0 means BIAS */
if (acs2d->detector == WFC_CCD_DETECTOR && acs2d->expstart > SM4MJD && acs2d->exptime > 0)
darktime += darkscaling;
}
/* Compute correct extension version number to extract from
reference image to correspond to CHIP in science data.
*/
if (acs2d->pctecorr == PERFORM) {
if (DetCCDChip (acs2d->darkcte.name, acs2d->chip, acs2d->nimsets, &extver) )
return (status);
} else {
if (DetCCDChip (acs2d->dark.name, acs2d->chip, acs2d->nimsets, &extver) )
return (status);
}
if (acs2d->verbose) {
sprintf(MsgText,"Performing dark subtraction on chip %d in imset %d",acs2d->chip, extver);
trlmessage(MsgText);
}
/* Get the dark image data. */
if (acs2d->pctecorr == PERFORM) {
openSingleGroupLine (acs2d->darkcte.name, extver, &y);
} else {
openSingleGroupLine (acs2d->dark.name, extver, &y);
}
if (hstio_err())
return (status = OPEN_FAILED);
/* Compare binning of science image and reference image;
get same_size and high_res flags, and get info about
binning and offset for use by bin2d.
*/
if (FindLine (x, &y, &same_size, &rx, &ry, &x0, &y0))
return (status);
if (rx != 1 || ry != 1) {
sprintf(MsgText,"Reference image and input are not binned to the same pixel size!");
trlmessage(MsgText);
}
if (acs2d->verbose){
sprintf(MsgText,"Image has an offset of %d,%d",x0,y0);
trlmessage(MsgText);
}
mean = 0.0;
weight = 0.0;
/* Bin the dark image down to the actual size of x. */
initSingleGroupLine (&z);
allocSingleGroupLine (&z, x->sci.data.nx);
for (i=0, j=y0; i < scilines; i++,j++) {
/* We are working with a sub-array and need to apply the
proper section from the reference image to the science image.
*/
if (acs2d->pctecorr == PERFORM) {
getSingleGroupLine (acs2d->darkcte.name, j, &y);
} else {
getSingleGroupLine (acs2d->dark.name, j, &y);
}
/*
rx = 1;
*/
update = NO;
if (trim1d (&y, x0, y0, rx, avg, update, &z)) {
trlerror ("(darkcorr) size mismatch.");
return (status);
}
multk1d(&z, darktime);
AvgSciValLine (&z, acs2d->sdqflags, &dark, &wdark);
/* Sum the contribution from each line */
mean += dark * wdark;
weight += wdark;
status = sub1d (x, i, &z);
if (status)
return (status);
}
freeSingleGroupLine (&z); /* done with z */
/* } */
closeSingleGroupLine (&y);
freeSingleGroupLine (&y);
/* Compute the mean for the entire image */
if (scilines > 0)
*meandark = mean / weight;
else
*meandark = 0.;
return (status);
}
int AcsSum (char *input, char *output, char *mtype, int printtime, int verbose)
{
extern int status;
IRAFPointer tpin;
AcsSumInfo acs;
IODescPtr im; /* descriptor for input image */
Hdr phdr; /* primary header for input image */
int nimgs;
int i;
char acs_input[CHAR_FNAME_LENGTH];
int FileExists (char *);
void TimeStamp (char *, char *);
void PrBegin (char *);
void PrEnd (char *);
void PrFileName (char *, char *);
void PrHdrInfo (char *, char *, char *, char *);
int MkName (char *, char *, char *, char *, char *, int);
void WhichError (int);
void InitSumTrl (char *input, char *output);
void FindAsnRoot (char *, char *);
int mkNewSpt (char *, char *, char *);
/* Determine input and output trailer files, then initialize
output file by combining inputs into output file */
InitSumTrl (input, output);
PrBegin ("ACSSUM");
nimgs = 0;
if (printtime)
TimeStamp ("ACSSUM started", "");
/* open the input file template */
tpin = c_imtopen (input);
nimgs = c_imtlen(tpin);
/* Initialize structure containing acssum information. */
AcsInit (&acs,nimgs);
/* Copy command-line arguments into acs. */
for (i = 0; i < nimgs; i++) {
c_imtgetim (tpin, acs.input[i], CHAR_FNAME_LENGTH);
PrFileName ("input", acs.input[i]);
}
/* close file template */
c_imtclose (tpin);
strcpy (acs.output, output);
acs.printtime = printtime;
acs.verbose = verbose;
PrFileName ("output", acs.output);
FindAsnRoot (output, acs.rootname);
initHdr (&phdr);
/* Check whether the output file already exists. */
if (FileExists (acs.output)) {
FreeAcsInput (acs.input, nimgs);
return (status);
}
strcpy(acs_input,acs.input[0]);
/* Open input image in order to read its primary header. */
im = openInputImage (acs_input, "", 0);
if (hstio_err()) {
FreeAcsInput (acs.input, nimgs);
return (status = OPEN_FAILED);
}
getHeader (im, &phdr); /* get primary header */
if (hstio_err()) {
FreeAcsInput (acs.input, nimgs);
return (status = OPEN_FAILED);
}
closeImage (im);
/* Get keyword values from primary header. */
if (GetSumKeyInfo (&acs, &phdr)) {
FreeAcsInput (acs.input, nimgs);
return (status);
}
freeHdr (&phdr);
/* Print information about this image. */
PrHdrInfo (acs.aperture, acs.filter1, acs.filter2, acs.det);
if (acs.printtime)
TimeStamp ("Begin processing", acs.rootname);
/* Sum all imsets. */
if (SumGrps (&acs,mtype)){
FreeAcsInput (acs.input, nimgs);
return (status);
}
/* create new SPT file for output product */
if (mkNewSpt (input, mtype, output)) {
return(status);
}
/* Done... */
trlmessage ("\n");
PrEnd ("ACSSUM");
if (acs.printtime)
TimeStamp ("ACSSUM completed", acs.rootname);
/* Write out temp trailer file to final file */
WriteTrlFile ();
FreeAcsInput (acs.input, nimgs);
return (status);
}
int WF3cte (char *input, char *output, CCD_Switch *cte_sw,
RefFileInfo *refnames, int printtime, int verbose, int onecpu) {
/*
input: filename
output: filename
cte_sw: the calibration flags
refnames: the names of the calibration reference files
onecpu: use parallel processing?
The following are new primary header keywords which will be added to the data
so that they can be updated by the code. They are also specified in the PCTETAB
reference file.
These are taken from the PCTETAB
CTE_NAME - name of cte algorithm
CTE_VER - version number of cte algorithm
CTEDATE0 - date of wfc3/uvis installation in HST, in MJD
CTEDATE1 - reference date of CTE model pinning, in MJD
PCTETLEN - max length of CTE trail
PCTERNOI - readnoise amplitude for clipping
PCTESMIT - number of iterations used in CTE forward modeling
PCTESHFT - number of iterations used in the parallel transfer
PCTENSMD - readnoise mitigation algorithm
PCTETRSH - over-subtraction threshold
PCTEFRAC - cte scaling frac calculated from expstart
PCTERNOI - the readnoise clipping level to use
#These are taken from getreffiles.c
DRKCFILE is a new dark reference file used only in the CTE branch *_DRC.fits
BIACFILE is a new super-bias reference file used only in the CTE branch *_BIC.fits
PCTETAB is a new reference file FITS table which will contain the software parameter switches for the CTE correction *_CTE.fit
This is the main workhorse function for removing the CTE from WFC3 UVIS images
Unfortunately this happens before anything else in wfc3, so there's a lot of reading files
at the beginning in order to populate needed information. The rest of the pipeline works
on one chip at a time and the structures are all defined to support that. None of these
structures are defined until the code enters the single chip loops. This differs from the
CTE correction in ACS which occurs later in the process after basic structures are defined.
*/
extern int status;
WF3Info wf3; /*structure with calibration switches and reference files for passing*/
Hdr phdr; /*primary header for input image, all output information saved here*/
CTEParams cte_pars; /*STRUCTURE HOLDING THE MODEL PARAMETERS*/
SingleGroup cd; /*SCI 1*/
SingleGroup ab; /*SCI 2*/
SingleGroup raz; /* THE LARGE FORMAT COMBINATION OF CDAB*/
SingleGroup rsz; /* LARGE FORMAT READNOISE CORRECTED IMAGE */
SingleGroup rsc; /* CTE CORRECTED*/
SingleGroup rzc; /* FINAL CTE CORRECTED IMAGE */
SingleGroup chg; /* THE CHANGE DUE TO CTE */
SingleGroup raw; /* THE RAW IMAGE IN RAZ FORMAT */
int i,j; /*loop vars*/
int max_threads=1;
clock_t begin;
double time_spent;
float hardset=0.0;
begin = (double)clock();
Bool subarray; /* to verify that no subarray is being used, it's not implemented yet*/
/*CONTAIN PARALLEL PROCESSING TO A SINGLE THREAD AS USER OPTION*/
# ifdef _OPENMP
trlmessage("Using parallel processing provided by OpenMP inside CTE routine");
if (onecpu){
omp_set_dynamic(0);
max_threads=1;
sprintf(MsgText,"onecpu == TRUE, Using only %i threads/cpu", max_threads);
} else {
omp_set_dynamic(0);
max_threads = omp_get_num_procs(); /*be nice, use 1 less than avail?*/
sprintf(MsgText,"Setting max threads to %i of %i cpus",max_threads, omp_get_num_procs());
}
omp_set_num_threads(max_threads);
trlmessage(MsgText);
# endif
/* COPY COMMAND-LINE ARGUMENTS INTO WF3. */
WF3Init (&wf3);
strcpy (wf3.input, input);
strcpy (wf3.output, output);
PrBegin ("WFC3CTE");
if (wf3.printtime)
TimeStamp("WFC3CTE Started: ",wf3.rootname);
/* CHECK WHETHER THE OUTPUT FILE ALREADY EXISTS. */
if (FileExists (wf3.output)){
WhichError(status);
return (ERROR_RETURN);
}
wf3.pctecorr = cte_sw->pctecorr;
wf3.darkcorr = cte_sw->darkcorr;
wf3.biascorr = cte_sw->biascorr;
wf3.blevcorr = cte_sw->blevcorr;
wf3.printtime = printtime;
wf3.verbose = verbose;
wf3.refnames = refnames;
PrFileName ("input", wf3.input);
PrFileName ("output", wf3.output);
if (wf3.biascorr == COMPLETE){
trlmessage("BIASCORR complete for input image, CTE can't be performed");
return(ERROR_RETURN);
}
if (wf3.darkcorr == COMPLETE){
trlmessage("DARKCORR complete for input image, CTE can't be performed");
return(ERROR_RETURN);
}
if (wf3.blevcorr == COMPLETE){
trlmessage("BLEVCORR complete for input image, CTE can't be performed");
return(ERROR_RETURN);
}
/* DETERMINE THE NAMES OF THE TRAILER FILES BASED ON THE INPUT
AND OUTPUT FILE NAMES, THEN INITIALIZE THE TRAILER FILE BUFFER
WITH THOSE NAMES.
*/
if (initCTETrl (input, output))
return (status);
/* OPEN INPUT IMAGE IN ORDER TO READ ITS PRIMARY HEADER. */
if (LoadHdr (wf3.input, &phdr) ){
WhichError(status);
return (ERROR_RETURN);
}
/* GET KEYWORD VALUES FROM PRIMARY HEADER. */
if (GetKeys (&wf3, &phdr)) {
freeHdr (&phdr);
return (status);
}
if (GetCTEFlags (&wf3, &phdr)) {
freeHdr(&phdr);
return (status);
}
/* OPEN THE INPUT IMAGES AND GET THE SCIENCE EXTENSIONS */
initSingleGroup (&cd);
getSingleGroup (wf3.input, 1, &cd);
if (hstio_err())
return (status = OPEN_FAILED);
/*** MAKE SURE THIS IS NOT A SUBARRAY ***/
if (GetKeyBool (cd.globalhdr, "SUBARRAY", NO_DEFAULT, 0, &subarray))
return (status=KEYWORD_MISSING);
if (subarray) {
sprintf(MsgText,"**SUBARRAY FOUND!; SUBARRAY images are not yet supported for CTE**");
trlmessage(MsgText);
status=ERROR_RETURN;
return(status);
}
initSingleGroup (&ab);
getSingleGroup (wf3.input, 2, &ab);
if (hstio_err())
return (status = OPEN_FAILED);
if (GetKeyBool (ab.globalhdr, "SUBARRAY", NO_DEFAULT, 0, &subarray))
return (status=KEYWORD_MISSING);
if (subarray) {
sprintf(MsgText,"SUBARRAY FOUND; **SUBARRAY images are not yet supported for CTE**");
trlmessage(MsgText);
status=ERROR_RETURN;
return(status);
}
/*READ IN THE CTE PARAMETER TABLE*/
initCTEParams(&cte_pars);
if (GetCTEPars (wf3.pctetab.name,&cte_pars))
return (status);
if (verbose){
PrRefInfo ("pctetab", wf3.pctetab.name, wf3.pctetab.pedigree,
wf3.pctetab.descrip, wf3.pctetab.descrip2);
}
/*SAVE THE PCTETABLE INFORMATION TO THE HEADER OF THE SCIENCE IMAGE
AFTER CHECKING TO SEE IF THE USER HAS SPECIFIED ANY CHANGES TO THE
CTE CODE VARIABLES.
*/
if (CompareCTEParams(&cd, &cte_pars)){
return (status);
}
/*SET UP THE ARRAYS WHICH WILL BE PASSED AROUND*/
initSingleGroup(&raz);
allocSingleGroup(&raz, RAZ_COLS, RAZ_ROWS);
initSingleGroup(&rsz);
allocSingleGroup(&rsz, RAZ_COLS, RAZ_ROWS);
initSingleGroup(&rsc);
allocSingleGroup(&rsc, RAZ_COLS, RAZ_ROWS);
initSingleGroup(&rzc);
allocSingleGroup(&rzc, RAZ_COLS, RAZ_ROWS);
initSingleGroup(&raw);
allocSingleGroup(&raw, RAZ_COLS, RAZ_ROWS);
initSingleGroup(&chg);
allocSingleGroup(&chg, RAZ_COLS, RAZ_ROWS);
for (i=0;i<RAZ_COLS;i++){
for(j=0;j<RAZ_ROWS;j++){
Pix(raw.sci.data,i,j)=hardset;
Pix(rsz.sci.data,i,j)=hardset;
Pix(raz.sci.data,i,j)=hardset;
Pix(rsc.sci.data,i,j)=hardset;
Pix(rzc.sci.data,i,j)=hardset;
Pix(chg.sci.data,i,j)=hardset;
}
}
/* SAVE A COPY OF THE RAW IMAGE FOR LATER */
makesciRAZ(&cd,&ab,&raw);
/***SUBTRACT THE CTE BIAS FROM BOTH CHIPS IN PLACE***/
if (doCteBias(&wf3,&cd)){
freeSingleGroup(&cd);
return(status);
}
if (doCteBias(&wf3,&ab)){
freeSingleGroup(&ab);
return(status);
}
/*CONVERT TO RAZ FORMAT AND CORRECT FOR GAIN*/
if (raw2raz(&wf3, &cd, &ab, &raz))
return (status);
/***CALCULATE THE SMOOTH READNOISE IMAGE***/
trlmessage("CTE: Calculating smooth readnoise image");
/***CREATE THE NOISE MITIGATION MODEL ***/
if (cte_pars.noise_mit == 0) {
if (raz2rsz(&wf3, &raz, &rsz, cte_pars.rn_amp, max_threads))
return (status);
} else {
trlmessage("Only noise model 0 implemented!");
return (status=ERROR_RETURN);
}
/***CONVERT THE READNOISE SMNOOTHED IMAGE TO RSC IMAGE
THIS IS WHERE THE CTE GETS CALCULATED ***/
if (rsz2rsc(&wf3, &rsz, &rsc, &cte_pars))
return (status);
/*** SAVE USEFULL HEADER INFORMATION ***/
if (cteHistory (&wf3, cd.globalhdr))
return (status);
/*** CREATE THE FINAL CTE CORRECTED IMAGE, PUT IT BACK INTO ORIGNAL RAW FORMAT***/
for (i=0;i<RAZ_COLS;i++){
for(j=0; j<RAZ_ROWS; j++){
Pix(chg.sci.data,i,j) = (Pix(rsc.sci.data,i,j) - Pix(rsz.sci.data,i,j))/wf3.ccdgain;
Pix(rzc.sci.data,i,j) = Pix(raw.sci.data,i,j) + Pix(chg.sci.data,i,j);
}
}
/*BACK TO NORMAL FORMATTING*/
undosciRAZ(&cd,&ab,&rzc);
/*UPDATE THE OUTPUT HEADER ONE FINAL TIME*/
PutKeyDbl(cd.globalhdr, "PCTEFRAC", cte_pars.scale_frac,"CTE scaling fraction based on expstart");
trlmessage("PCTEFRAC saved to header");
/*SAVE THE NEW RAW FILE WITH UPDATED SCIENCE ARRAYS AND PRIMARY HEADER TO RAC*/
putSingleGroup(output,cd.group_num, &cd,0);
putSingleGroup(output,ab.group_num, &ab,0);
/** CLEAN UP **/
freeSingleGroup(&rzc);
freeSingleGroup(&rsc);
freeSingleGroup(&chg);
freeSingleGroup(&raz);
freeSingleGroup(&rsz);
freeSingleGroup(&raw);
time_spent = ((double) clock()- begin +0.0) / CLOCKS_PER_SEC;
if (verbose){
sprintf(MsgText,"CTE run time: %.2f(s) with %i procs/threads\n",time_spent,max_threads);
trlmessage(MsgText);
}
PrSwitch("pctecorr", COMPLETE);
if(wf3.printtime)
TimeStamp("PCTECORR Finished",wf3.rootname);
return (status);
}
