예제 #1
0
파일: main.c 프로젝트: JoeWeate/Embedded
DbState Debouncer(SwitchDefine *Switch) {	//Debouncer method moves states according to the state machine provided in the notes.

    DbState MyState = Switch->ControlState;							//Save current control state
    unsigned int time = Switch->prev;								//Save last recorded time to calculate delay
    Switch->CurrentSwitchReading = GetSwitch(Switch->SwitchSelect);	//Set current switch reading to the switch select

    switch (MyState) {												//Initialize switch cases
    case DbExpectHigh:												//If MyState is DbExpectHigh:
        if (!(Switch->CurrentSwitchReading == On)) {				//And if the current reading is not "on"..
            Switch->ControlState = DbValidateHigh;					//Set the co00ntrol state to DbValidateHigh
        } else {
            time = counter;											//else update with new time
        }
        break;
    case DbValidateHigh:											//If MyState is DbValidateHigh
        if (Switch->CurrentSwitchReading == On) {					//And if the current switch reading is "on"...
            time = counter;											//Update recorded time
            Switch->ControlState = DbExpectHigh;					//Move to next state
        } else if ((counter - time) >= Switch->RELEASEBOUNCETIME) {	//Else if the different in times is greate than the release time
            Switch->PreviousValidState = On;						//Previous valud state toggled on
            Switch->CurrentValidState = Off;						//Current valid state toggled on
            Switch->ControlState = DbExpectLow;						//Move control state to next state of machine.
            time = counter;											//And update time
        }
        break;
    case DbExpectLow:												//If MyState is DbExpectLow
        if (Switch->CurrentSwitchReading == On) {					//Set current switch reading on
            Switch->ControlState = DbValidateLow;					//Move along state machine
        } else {
            time = counter;											//If not, update time
        }

        break;
    case DbValidateLow:												//If MyState is DbValidateLow
        if (!(Switch->CurrentSwitchReading == On)) {				//And if current switch reading is not "on"
            time = counter;											//Update time
            Switch->ControlState = DbExpectLow;						//Move along state machine
        } else if ((counter - time) >= Switch->MAKEDEBOUNCETIME) {	//If not, check if time difference is greater than makedebounce time. If it is:
            Switch->PreviousValidState = Off;						//Previous valid state off
            Switch->CurrentValidState = On;							//Current valid state on
            Switch->ControlState = DbExpectHigh;					//Move along state machine
            time = counter;											//Update time
        }

        break;
    default:
        MyState = DbExpectHigh;
    }
    MyState = Switch->ControlState;									//Update MyState with the current control state and return it for debugging
    return MyState;
}
예제 #2
0
static int checkShad (Hdr *phdr, WF3Info *wf32d, int *missing, int *nsteps) {

/* arguments:
Hdr *phdr        i: primary header
WF3Info *wf32d   i: switches, file names, etc
int *missing     io: incremented if the file is missing
int *nsteps      io: incremented if this step can be performed
*/

	extern int status;

	int calswitch;
	int GetSwitch (Hdr *, char *, int *);
	int GetImageRef (RefFileInfo *, Hdr *, char *, RefImage *, int *);
	void MissingFile (char *, char *, int *);
	void CheckImgType (RefImage *, char *, char *, int *);
	int  CheckDetector (char *, int, char *, int *);

	if (wf32d->shadcorr == PERFORM) {

	    if (GetSwitch (phdr, "SHADCORR", &calswitch))
		return (status);
	    if (calswitch == COMPLETE) {
		wf32d->shadcorr = OMIT;
		return (status);
	    }

	    if (GetImageRef (wf32d->refnames, phdr, "SHADFILE", &wf32d->shad,
			     &wf32d->shadcorr))
		return (status);
	    if (wf32d->shad.exists != EXISTS_YES) {
		MissingFile ("SHADFILE", wf32d->shad.name, missing);

	    } else {

		/* Is the FILETYPE appropriate for a SHAD file? */
		CheckImgType (&wf32d->shad, "SHUTTER SHADING", "SHADFILE",
			      missing);

		/* Does it have the correct DETECTOR value? */
		if (CheckDetector(wf32d->shad.name, wf32d->detector, "DETECTOR",
				  missing))
		    return (status);
	    }

	    if (wf32d->shadcorr == PERFORM)
		(*nsteps)++;
	}

	return (status);
}
예제 #3
0
파일: main.c 프로젝트: JoeWeate/Embedded
//---initializing buttons and rotary
void InitializeVariables(void) {

    rotaryEncoder.SwitchA.ControlState = DbExpectHigh;			   		//Set up SwitchA(clockwise turns) defaults. Start at DbExpectHigh
    rotaryEncoder.SwitchA.CurrentSwitchReading = GetSwitch(Switch1);	//Set current switch reading
    rotaryEncoder.SwitchA.CurrentValidState = Off;						//Set current valid state to off
    rotaryEncoder.SwitchA.MAKEDEBOUNCETIME = 5;							//Debounce time set to 5ms both ways (rise and fall).
    rotaryEncoder.SwitchA.RELEASEBOUNCETIME = 5;
    rotaryEncoder.SwitchA.SwitchSelect = Switch1;						//Set switch 1 as available.


    rotaryEncoder.SwitchB.ControlState = DbExpectHigh;   				//Set up SwitchB (counter-clockswise turns) defaults. Start at DbExpectHigh
    rotaryEncoder.SwitchB.CurrentSwitchReading = GetSwitch(Switch2);	//Set current switch reading
    rotaryEncoder.SwitchB.CurrentValidState = Off;						//Set current valid state off
    rotaryEncoder.SwitchB.MAKEDEBOUNCETIME = 5;							//Debounce time set to 5ms both ways.
    rotaryEncoder.SwitchB.RELEASEBOUNCETIME = 5;
    rotaryEncoder.SwitchB.SwitchSelect = Switch2;						//Set switch 2 as available.


    cwDesired=Num*48;
    ccwDesired=Num*48;


}
예제 #4
0
static int GetSw (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 (0 or 1) of calibration switch
*/

	extern int status;

	int GetSwitch (Hdr *, char *, int *);

	if (GetSwitch (phdr, calswitch, flag))
	    return (status);

	if (*flag != PERFORM) {
        if (*flag != COMPLETE)
	        *flag = OMIT;
    }

	return (status);
}
예제 #5
0
파일: acsrej_do.c 프로젝트: pllim/hstcal
/*  acsrej_do -- Perform the cosmic ray rejection for ACS images

  Description:
  ------------
  This is mostly a file bookkeeping routine for the cosmic ray rejection task.
  It takes care of input/output files open/close, check for dimensions, read/
  write data from/to files, allocate memory spaces etc.

    Date          Author          Description
    ----          ------          -----------
    06-May-1996   J.-C. Hsu       Adapt from the SPP code crrej_do.x
    05-Aug-1998   W. Hack         Modified to handle ACS data
    11-Feb-1999   W. Hack         EXPTIME now in Pri. Hdr.
    18-Mar-1999   W.J. Hack       Revised to read EXPTIMEs from Primary headers
                                  for cr_scaling using tpin directly
    14-Sep-1999   W.J. Hack       Cleaned up SHADCORR usage. Added check for max
                                  number of files here.
*/
int acsrej_do (IRAFPointer tpin, char *outfile, char *mtype, clpar *par, int newpar[])
{
    extern int  status;

    IODescPtr   ipsci[MAX_FILES];   /* science image descriptor */
    IODescPtr   ipdq[MAX_FILES];    /* data quality image descriptor */
    float       skyval[MAX_FILES];  /* background DN values */
    float       efac[MAX_FILES];    /* exposure factors */
    multiamp    noise;              /* readout noise */
    multiamp    gain;               /* A-to-D gain factors */
    float       exptot;
    float       texpt;
    int         nimgs;
    SingleGroup sg;
    int         niter = 0;
    float       sigma[MAX_ITER];

    Hdr         phdr;               /* primary header */
    int         extver;             /* Current extension being processed*/
    int         numext;             /* Number of extensions in each image */
    int         nextend;            /* Number of output extensions */
    char        imgname[MAX_FILES][CHAR_FNAME_LENGTH];
    char        fimage[CHAR_FNAME_LENGTH];  /* Name of first image in list */
    char        root[CHAR_FNAME_LENGTH];    /* ROOTNAME for output CRJ file */
    char        uroot[CHAR_FNAME_LENGTH];   /* Upper case version of rootname */
    char        *shadrefname;

    int         ext[MAX_FILES];
    int         dim_x, dim_y;       /* image dimensions */
    int         i, j, n;            /* loop indices */
    float       *efacsum, *work;
    int         nrej;               /* total number of rejected pixels */
    float       skysum;             /* total sky level */
    int         logit;
    RefImage    shadref;
    int         shadswitch;
    double      expend, expstart;
    int         non_zero;           /* number of input images with EXPTIME>0.*/
    int         found;
    char        imgdefault[CHAR_FNAME_LENGTH];  /* name of first input image with EXPTIME > 0. */

    int     GetSwitch (Hdr *, char *, int *);
    int     UpdateSwitch (char *, int, Hdr *, int *);

    void    InitRefImg (RefImage *);
    int     ImgHistory (const RefImage *, Hdr *);
    int     ImgPedigree (RefImage *);

    int     acsrej_check (IRAFPointer, int, int, clpar *, int [],  char [][CHAR_FNAME_LENGTH],
                int [], IODescPtr [], IODescPtr [],
                multiamp *, multiamp *, int *,
                int *, int);
    int     cr_scaling (char *, IRAFPointer, float [], int *, double *, double *);
    int     rejpar_in(clpar *, int [], int, float,   int *, float []);
    void    acsrej_sky (char *, IODescPtr [], IODescPtr [], int, short, float []);
    void    cr_history (SingleGroup *, clpar *, int);
    int     acsrej_init (IODescPtr [], IODescPtr [], clpar *, int, int, int,
                multiamp, multiamp, float [], float [],
                SingleGroup *,   float *);
    int     acsrej_loop (IODescPtr [], IODescPtr [], char [][CHAR_FNAME_LENGTH],
                int [], int, clpar *, int, int, int, float [],
                multiamp, multiamp, float [], float [],
                FloatTwoDArray *, FloatTwoDArray *, float *,
                ShortTwoDArray *, int *, char *);
    int     PutKeyFlt (Hdr *, char *, float, char *);
    int     PutKeyDbl (Hdr *, char *, double, char *);
    int     PutKeyStr (Hdr *, char *, char *, char *);
    int     GetKeyStr (Hdr *, char *, int, char *, char *, int);
    int     PutKeyInt (Hdr *, char *, int, char *);
    int     GetKeyInt (Hdr *, char *, int, int, int *);
    void    UFilename (char *, Hdr *);
    void    UMemType (char *, Hdr *);
    void    UExpname (char *, Hdr *);
    int     LoadHdr (char *, Hdr *);
    void    UpperAll (char *, char *, int);
    void    TimeStamp (char *, char *);
    void    WhichError (int);
    void    PrSwitch (char *, int);
    void    FindAsnRoot (char *, char *);
    void    initmulti (multiamp *);
    /* -------------------------------- begin ---------------------------------- */
    /* Initialize necessary structures */
    InitRefImg (&shadref);
    root[0] = '\0';
    uroot[0] = '\0';
    initmulti (&noise);
    initmulti (&gain);

    numext = 0;
    nextend = 0;


    /* Since CR-SPLIT images are in separate files, we need to
        combine the same chip's exposure from each file.  Therefore
        we will loop over each extension in the first image, determine
        what chip that corresponds to, and get the same chip from the
        rest of the images (which could be in any arbitrary
        extension in each of the images).
    */

    /* First, let's determine how many extensions/chips in each file */
    c_imtgetim (tpin, fimage, CHAR_FNAME_LENGTH);

    if (LoadHdr (fimage, &phdr) )
        return (status = ERROR_RETURN);

    if (GetKeyInt (&phdr, "NEXTEND", NO_DEFAULT, 0, &nextend) == 0)
        numext = nextend / EXT_PER_GROUP;
    else
        numext = 1;

    shadswitch = 0;
    /* Check to see if SHADCORR was set to PERFORM in image header */
    if (GetSwitch (&phdr, "SHADCORR", &shadswitch) )
        return(status);

    /* If shadcorr was set either by the user on the command line
        or in the image header, initialize shadcorr processing.
    */
    if (par->shadcorr == PERFORM || shadswitch == PERFORM) {

        /* Use par->shadcorr as switch for performing shading correction */
        par->shadcorr = PERFORM;
        shadrefname = calloc(CHAR_FNAME_LENGTH, sizeof(char));

        if (GetKeyStr (&phdr, "SHADFILE", NO_DEFAULT, "", shadrefname, CHAR_FNAME_LENGTH) )
            return(status);
        strcpy (shadref.name, shadrefname);
        /* Read in PEDIGREE and DESCRIPTION for SHADFILE */
        if (ImgPedigree (&shadref) )
            return (status);
        /* If a DUMMY shadfile was specified, turn off shadcorr */
        if (shadref.goodPedigree == DUMMY)
            par->shadcorr = OMIT;
        free (shadrefname);
    }

    freeHdr (&phdr);

    /* Initialize efac */
    for (n = 0; n < MAX_FILES; n++) efac[n] = 1.0;

    /* calculate the scaling factors due to different exposure time */
    strcpy (par->expname, "EXPTIME");
    if (cr_scaling (par->expname, tpin, efac, &nimgs, &expend, &expstart) ){
        WhichError (status);
        return (status);
    }

    /* make sure there is more than one image to process */
    if (nimgs < 2) {
        trlmessage ("Needs more than one input image.");
        return (status = NOTHING_TO_DO);
    }

    /* calculate the total exposure time */
    exptot = 0.;
    non_zero = 0;
    for (n = 0; n < nimgs; ++n) {
        exptot += efac[n];
        /* Count how many inputs have non-zero(valid) EXPTIME */
        if (efac[n] > 0.) non_zero++;
    }
    /* for the case of all images have zero exposure time, use equal
        exposure time of 1. */
    if (exptot == 0.) {
        for (n = 0; n < nimgs; ++n) {
            efac[n] = 1.;
        }
        texpt = (float) nimgs;
        non_zero = nimgs;
    } else {
        texpt = exptot;
    }

    /* Now, start the loop. */
    for (extver = 1; extver <= numext; extver++) {

        if (par->printtime) {
            TimeStamp ("Start cosmic ray rejection","");
        }

        /* open input files and temporary files, check the parameters */
        if (acsrej_check (tpin, extver, numext, par, newpar, imgname, ext,
            ipsci, ipdq, &noise, &gain, &dim_x, &dim_y, nimgs)) {
            WhichError (status);
            return(status);
        }

        /* Now that we have read in SHADCORR, report if it will be performed */
        PrSwitch ("shadcorr", par->shadcorr);

        /* read in the parameters */
        if (rejpar_in (par, newpar, nimgs, exptot,   &niter, sigma) )
            return(status);

        /* allocate array space */
        efacsum = calloc (dim_x*dim_y, sizeof(float));
        work    = calloc (nimgs*dim_x, sizeof(float));

        /* calculate the sky levels */
        acsrej_sky (par->sky, ipsci, ipdq, nimgs, par->badinpdq, skyval);
        if (status != ACS_OK) {
            WhichError (status);
            return (status);
        }
        if (par->verbose) {
            for (n = 0; n < nimgs; n++) {
                sprintf (MsgText, "sky of '%s[sci,%d]' is %0.3f DN", imgname[n], ext[n], skyval[n]);
                trlmessage (MsgText);
            }
        }

        /* use the first input image to set up the data structure */
        initSingleGroup (&sg);

        /* Find the first image in the input list which has an
            EXPTIME > 0. to use for initializing the output SingleGroup.
        */
        found = 0;
        n = 0;
        /* By default, simply use the first one, so initialize accordingly.*/
        strcpy (imgdefault, imgname[0]);
        do {
            if (efac[n] > 0.) {
                strcpy(imgdefault,imgname[n]);
                found = 1;
            }
            n++;
        } while (found == 0);

        getSingleGroup (imgdefault, extver, &sg);

        if (non_zero > 1){
            /* compute the initial pixel values to be used to compare against all
               images. */
            if (non_zero < nimgs){
                trlwarn ("Some input exposures had EXPTIME = 0.");
            }

            if (acsrej_init (ipsci, ipdq, par, nimgs, dim_x, dim_y,
                    noise, gain, efac, skyval, &sg, work) ) {
                WhichError(status);
                closeSciDq(nimgs, ipsci, ipdq, par);
                return (status);
            }

            if (par->printtime)
                TimeStamp ("Calculated initial guess for extension", "");

            /* do the iterative cosmic ray rejection calculations */
            if (acsrej_loop (ipsci, ipdq, imgname, ext, nimgs, par, niter, dim_x, dim_y,
                    sigma, noise, gain, efac, skyval,
                    &sg.sci.data, &sg.err.data, efacsum, &sg.dq.data,
                    &nrej, shadref.name) ) {
                WhichError(status);
                closeSciDq(nimgs, ipsci, ipdq, par);
                return (status);
            }
        } else {
            trlwarn ("Cosmic-ray rejection NOT performed!");
            if (non_zero > 0) {
                trlwarn ("Some input exposures had EXPTIME = 0.");
                trlwarn ("Output product will not be cosmic-ray cleaned!");
            } /*else {
                trlwarn ("ALL input exposures had EXPTIME = 0.");
                trlwarn ("Output product will be BLANK!");
            } */
        } /* End if(non_zero) block */


        /* must close all images, now that we are done reading them */
        closeSciDq(nimgs, ipsci, ipdq, par);

        /* calculate the total sky ... */
        skysum = 0.;
        for (n = 0; n < nimgs; ++n) {
            skysum += skyval[n];
        }
        /* ... and force it to be non-negative */
        if (skysum < 0.) skysum = 0.;

        if (par->printtime){
            if (non_zero > 1){
                TimeStamp ("Finished detecting cosmic rays on extension", "");
            } else {
                TimeStamp ("Done checking this extension","");
            }
        }

        /* write to the output image */
        if (non_zero > 0){
            for (j = 0; j < dim_y; ++j) {
                for (i = 0; i < dim_x; ++i) {
                    PPix(&sg.sci.data,i,j) = PPix(&sg.sci.data,i,j)*texpt + skysum;
                    PPix(&sg.err.data,i,j) *= texpt;
                }
            }
        } else {
            for (j = 0; j < dim_y; ++j) {
                for (i = 0; i < dim_x; ++i) {
                    PPix(&sg.sci.data,i,j) = par->fillval;
                    PPix(&sg.err.data,i,j) = 0.;
                    /* Set DQ value to one which will always be considered BAD */
                    PPix(&sg.dq.data,i,j) = 1;
                }
            }
                    /* Set at least one pixel to a different value to insure
                      that an image array actually gets produced. */
                    PPix(&sg.err.data,0,0) = -1.;
                    PPix(&sg.dq.data,0,0) = 8;
        }

        /* update the exposure time of the output images */
        PutKeyFlt (sg.globalhdr, "TEXPTIME", exptot, "");
        PutKeyFlt (sg.globalhdr, "SKYSUM", skysum, "Total sky level (DN)");
        PutKeyDbl (sg.globalhdr, "EXPSTART", expstart, "computed exposure start time (Modified Julian Date)");
        PutKeyDbl (sg.globalhdr, "EXPEND", expend, "exposure end time (Modified Julian Date)");
        /*
            Updated REJ_RATE to use 'texpt' as a safe value when
            EXPTIME=0 for all members. WJH, 24 Feb 2003
        */
        PutKeyFlt (sg.globalhdr, "REJ_RATE", (float)nrej/texpt,
                "Cosmic ray impact rate (pixels/sec)");
        PutKeyFlt (sg.globalhdr, "EXPTIME", exptot, "");
        if (par->shadcorr) {
            logit = 0;
            if (UpdateSwitch ("SHADCORR", par->shadcorr, sg.globalhdr, &logit) )
                return (status);

                PrSwitch ("shadcorr", COMPLETE);

            if (logit) {
                /*Records SHADFILE information in header comments... */
                if (ImgHistory (&shadref, sg.globalhdr))
                    return (status);

            }
        }

        /* record parameters to the output file */
        cr_history (&sg, par, nextend);
        PutKeyInt (&sg.sci.hdr, "NCOMBINE", nimgs, "");
        UFilename (outfile, sg.globalhdr);
        UMemType (mtype, sg.globalhdr);
        FindAsnRoot (outfile, root);
        UpperAll (root, uroot, strlen(root)+1 );
        /*  EXPNAME values modified for all extensions in a SingleGroup.
                   WJH 7 July 1999
        */
        UExpname (root, &sg.sci.hdr);
        UExpname (root, &sg.err.hdr);
        UExpname (root, &sg.dq.hdr);

        PutKeyStr (sg.globalhdr, "ROOTNAME", uroot,"Rootname of the observation set");

        /* Output CHIP to the same EXTVER as the CHIP ID */
        putSingleGroup (outfile, extver, &sg, 0);
        freeSingleGroup (&sg);

        if (par->printtime)
            TimeStamp ("Finished writing out extension", "");

        /* deallocate memories */
        free (efacsum);
        free (work);

    }
    /* Set status to a value which will be understood by
        CALACS to turn off subsequent processing. */
    if (non_zero == 0) status = NO_GOOD_DATA;

    return (status);
}
예제 #6
0
static int checkFlat (Hdr *phdr, WF3Info *wf32d, int *missing, int *nsteps) {

/* arguments:
Hdr *phdr        i: primary header
WF3Info *wf32d   i: switches, file names, etc
int *missing     io: incremented if a file is missing
int *nsteps      io: incremented if this step can be performed
*/

	extern int status;

	int calswitch;
	int GetSwitch (Hdr *, char *, int *);
	int GotFileName (char *);
	int GetImageRef (RefFileInfo *, Hdr *, char *, RefImage *, int *);
	void MissingFile (char *, char *, int *);
	void CheckImgType (RefImage *, char *, char *, int *);
	int  CheckFilter  (char *, char *, char *, int *);
	int  CheckDetector (char *, int, char *, int *);

	/* Are we supposed to do this step? */
	if (wf32d->flatcorr == PERFORM) {

	    if (GetSwitch (phdr, "FLATCORR", &calswitch))
		return (status);
	    if (calswitch == COMPLETE) {
		wf32d->flatcorr = OMIT;
		return (status);
	    }

	    /* Initial values; may be reset below. */
	    wf32d->pfltcorr = PERFORM;
	    wf32d->dfltcorr = PERFORM;
	    wf32d->lfltcorr = PERFORM;

	    if (GetImageRef (wf32d->refnames, phdr, "PFLTFILE", &wf32d->pflt,
			     &wf32d->pfltcorr))
		return (status);
	    if (wf32d->pflt.exists != EXISTS_YES) {
		if (GotFileName (wf32d->pflt.name)) {	/* name specified? */
		    MissingFile ("PFLTFILE", wf32d->pflt.name, missing);
		} else {
		    wf32d->pfltcorr = OMIT;	/* name was blank or "N/A" */
		}
	    } else {
		/* Is the FILETYPE appropriate for a PFLT file? */
		CheckImgType (&wf32d->pflt, "PIXEL-TO-PIXEL FLAT", "PFLTFILE", 
			      missing);
		/* Does it have the correct FILTER value? */
		if (CheckFilter(wf32d->pflt.name, wf32d->filter, "FILTER",
				missing))
		    return (status);
		/* Does it have the correct DETECTOR value? */
		if (CheckDetector(wf32d->pflt.name, wf32d->detector, "DETECTOR",
				  missing))
		    return (status);
	    }

	    if (GetImageRef (wf32d->refnames, phdr, "DFLTFILE", &wf32d->dflt,
			     &wf32d->dfltcorr))
		return (status);
	    if (wf32d->dflt.exists != EXISTS_YES) {
		if (GotFileName (wf32d->dflt.name)) {
		    MissingFile ("DFLTFILE", wf32d->dflt.name, missing);
		} else {
		    wf32d->dfltcorr = OMIT;
		}
	    } else {
		/* Is the FILETYPE appropriate for a DFLT file? */
		CheckImgType (&wf32d->dflt, "DELTA FLAT", "DFLTFILE", 
			      missing);
		/* Does it have the correct FILTER value? */
		if (CheckFilter(wf32d->dflt.name, wf32d->filter, "FILTER",
				missing))
		    return (status);
		/* Does it have the correct DETECTOR value? */
		if (CheckDetector(wf32d->dflt.name, wf32d->detector, "DETECTOR",
				  missing))
		    return (status);
	    }

	    if (GetImageRef (wf32d->refnames, phdr, "LFLTFILE", &wf32d->lflt,
			     &wf32d->lfltcorr))
		return (status);
	    if (wf32d->lflt.exists != EXISTS_YES) {
		if (GotFileName (wf32d->lflt.name)) {
		    MissingFile ("LFLTFILE", wf32d->lflt.name, missing);
		} else {
		    wf32d->lfltcorr = OMIT;
		}
	    } else {
		/* Is the FILETYPE appropriate for a LFLT file? */
		CheckImgType (&wf32d->lflt, "LARGE SCALE FLAT", "LFLTFILE", 
			      missing);
		/* Does it have the correct FILTER value? */
		if (CheckFilter(wf32d->lflt.name, wf32d->filter, "FILTER",
				missing))
		    return (status);
		/* Does it have the correct DETECTOR value? */
		if (CheckDetector(wf32d->lflt.name, wf32d->detector, "DETECTOR",
				  missing))
		    return (status);
	    }

	    /* If any of the three parts of flat fielding is set to
		PERFORM, then we can do this step.  If not, and if any
		part is DUMMY because of the reference file, reset the
		flat field flag to DUMMY; this will mean that all the
		files that were specified have pedigree=dummy.
	    */
	    if (wf32d->pfltcorr == PERFORM || wf32d->dfltcorr == PERFORM ||
		wf32d->lfltcorr == PERFORM) {
                (*nsteps)++;
	    } else if (wf32d->pfltcorr == OMIT && wf32d->dfltcorr == OMIT &&
		wf32d->lfltcorr == OMIT) {
                (*missing)++;
                trlerror ("PFLTFILE, DFLTFILE, and LFLTFILE are all blank.");
	    } else if (wf32d->pfltcorr == DUMMY || wf32d->dfltcorr == DUMMY ||
		wf32d->lfltcorr == DUMMY) {
                wf32d->flatcorr = DUMMY;
	    }
	}

	return (status);
}
예제 #7
0
static int checkDark (Hdr *phdr, WF3Info *wf32d, int *missing, int *nsteps) {

/* arguments:
Hdr *phdr        i: primary header
WF3Info *wf32d   i: switches, file names, etc
int *missing     io: incremented if the file is missing
int *nsteps      io: incremented if this step can be performed
*/

	extern int status;

	int calswitch; 
	int GetSwitch (Hdr *, char *, int *);
	int GetImageRef (RefFileInfo *, Hdr *, char *, RefImage *, int *);
	void MissingFile (char *, char *, int *);
	void CheckImgType (RefImage *, char *, char *, int *);
	int  CheckDetector (char *, int, char *, int *);
    char *darktouse;
    char *darktype;
    
	if (wf32d->darkcorr == PERFORM) {
	    if (GetSwitch (phdr, "DARKCORR", &calswitch))
		    return (status);
	    if (calswitch == COMPLETE) {
		    wf32d->darkcorr = OMIT;
		    return (status);
	    } else {
        
            if (GetSwitch (phdr, "PCTECORR", &calswitch))   
                return(status);
            if (calswitch == COMPLETE){
                darktouse="DRKCFILE";
                darktype="CTEDARK";
            } else {
                darktouse="DARKFILE";
                darktype="DARK";
            }
        }

            
	    if (GetImageRef (wf32d->refnames, phdr, darktouse, &wf32d->dark,
			     &wf32d->darkcorr))
		    return (status);

	    if (wf32d->dark.exists != EXISTS_YES) {
		    MissingFile (darktouse, wf32d->dark.name, missing);

	    } else {

		    /* Is the FILETYPE appropriate for a DARK file? */
		    CheckImgType (&wf32d->dark, darktype, darktouse, missing);

		    /* Does it have the correct DETECTOR value? */
		    if (CheckDetector(wf32d->dark.name, wf32d->detector, "DETECTOR",
				  missing))
		        return (status);
	    }

	    if (wf32d->darkcorr == PERFORM)
	        (*nsteps)++;
	 }

	return (status);
}
예제 #8
0
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;
}