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 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 CalAcsRun (char *input, int printtime, int save_tmp, int verbose, int debug, const unsigned nThreads, const unsigned cteAlgorithmGen, const char * pcteTabNameFromCmd) {
/* arguments:
char *input i: name of the FITS file/table to be processed
int printtime i: true --> print time stamps at intermediate steps
int *save_tmp i: true --> save temporary files
int verbose i: true --> print info during processing
int debug i: true --> print debugging info during processing
int onecpu i: true --> turn off use of OpenMP during processing
*/
extern int status;
ACSInfo acshdr; /* calibration switches, etc */
AsnInfo asn; /* association table data */
char *acsdth_input; /* Input list for ACSDTH */
int prod;
void PrBegin (char *);
void PrEnd (char *);
void PrFileName (char *, char *);
void TimeStamp (char *, char *);
/* Association table routines */
void initAsnInfo (AsnInfo *);
void freeAsnInfo (AsnInfo *);
int LoadAsn (AsnInfo *);
int ProcessACSCCD (AsnInfo *, ACSInfo *, int *, int, const unsigned nThreads, const unsigned cteAlgorithmGen, const char * pcteTabNameFromCmd);
int ProcessMAMA (AsnInfo *, ACSInfo *, int);
int AcsDth (char *, char *, int, int, int);
char *BuildDthInput (AsnInfo *, int);
void InitDthTrl (char *, char *);
/* Post error handler */
push_hstioerr (errchk);
PrBegin ("CALACS"); /* *** CALACS -- Version ... *** */
if (printtime)
TimeStamp ("CALACS started", "");
/* Determine if input is a single file or an association
table, then populate ASN structure with appropriate
information to control processing.
*/
initAsnInfo(&asn);
if (debug) {
trlmessage ("Initialized Association data ... ");
}
/* Copy Input filename to ASN structure */
strcpy (asn.input, input);
/* Print image name. */
trlmessage ("\n");
PrFileName ("input", asn.input);
/* Set verbose flag... */
asn.verbose = verbose;
asn.debug = debug;
/* LoadAsn will determine whether input is a single file or an
Association table. If a single image, it will look in that images
association table to see what products are associated with it, and
process them accordingly. If it is just a single image as its
own output, it will proceed as a 1 element table.
Based on routines from n_getAsnTable() and n_setup() in CALNICB
*/
if(LoadAsn(&asn)) {
freeAsnInfo (&asn);
return (status);
}
/* Check to see that detector is known, as it could come through with a
value of 0 or UNKNOWN_DETECTOR.
WJH 2Mar99
*/
if (asn.detector == UNKNOWN_DETECTOR || asn.detector == 0) {
trlwarn ("Unknown detector type for observations.");
freeAsnInfo(&asn);
return (status = NOTHING_TO_DO);
}
if (asn.verbose) {
sprintf (MsgText,"CALACS: Detector %s, type %d ",asn.instr, asn.detector);
trlmessage (MsgText);
}
/* Determine what detector we are working with... */
if (asn.detector != MAMA_DETECTOR ) { /* Process CCD data ... */
if (asn.verbose) {
trlmessage ("CALACS: processing a CCD product");
}
if (ProcessACSCCD(&asn, &acshdr, &save_tmp, printtime, nThreads, cteAlgorithmGen, pcteTabNameFromCmd)) {
if (status == NOTHING_TO_DO) {
trlwarn ("No processing desired for CCD data.");
} else {
trlerror ("Couldn't process CCD data");
}
freeAsnInfo(&asn);
return (status);
}
trlmessage("Finished CCD processing...");
} else { /* Process MAMA observations here */
trlmessage("Starting to process MAMA data now...");
if (ProcessMAMA(&asn, &acshdr, printtime)) {
if (status == NOTHING_TO_DO){
trlwarn ("No processing desired for MAMA data.");
} else{
trlerror ("Couldn't process MAMA data");
}
freeAsnInfo(&asn);
return (status);
}
trlmessage("Finished MAMA processing...");
}
/* Add DTH processing here... */
/* For each DTH product... */
if (asn.process == FULL){
if (asn.verbose) {
trlmessage ("CALACS: Building DTH products");
}
acsdth_input = NULL;
for (prod = 0; prod < asn.numprod; prod++) {
/* Create empty DTH product, header only */
/* This uses only one sub-product for the header template,
but later versions should use a function similar to
BuildSumInput to create list of subproducts as inputs...
*/
acsdth_input = BuildDthInput (&asn, prod);
/* We always want to create a final concatenated trailer file for
the entire association whether there is a product or not. So, we
set up the trailer file based on the association file name itself.
*/
/* If desired, we could optionally use the full _drz.tra filename
as the trailer filename, based on the output dither product name.
if (strcmp(asn.product[prod].prodname,"") != 0) {
InitDthTrl (acsdth_input, asn.product[prod].prodname);
} else { */
InitDthTrl(acsdth_input, asn.rootname);
/* End brace for optional dither product name assignment...
} */
/* Check if we have a PROD-DTH specified...*/
if (strcmp(asn.product[prod].prodname, "") != 0) {
if ((asn.dthcorr == PERFORM || asn.dthcorr == DUMMY)) {
if (AcsDth (acsdth_input, asn.product[prod].prodname, asn.dthcorr, printtime, asn.verbose) )
return (status);
/* Pass posid of 0 to indicate a PRODUCT is to be updated */
updateAsnTable(&asn, prod, NOPOSID);
}
} else {
trlwarn ("No DTH product name specified. No product created.");
/*status = ACS_OK; */
}
}
free (acsdth_input);
}
if (asn.verbose) {
trlmessage ("CALACS: Finished processing product ");
}
freeAsnInfo(&asn);
trlmessage ("\n");
PrEnd ("CALACS"); /* *** CALACS complete *** */
if (printtime)
TimeStamp ("CALACS completed", acshdr.rootname);
/* Return the final value of status, which should be ACS_OK if
all went well or some error condition otherwise. */
return (status);
}
