std::string DurationMeasure::collectAndReset( std::string timeStamp )
{
//Calculate Avg and dispersion
double mean = getMean();
double dispersion = getDispersion(mean);
std::stringstream ss;
ss << std::noskipws;
ss << "<" << name << " mean=\"" << mean << "\" disp=\"" << dispersion << "\" />";
std::string retVal = ss.str();
//Reset
durationVect.clear();
return retVal;
}
int AbsFlux6 (StisInfo6 *sts, RowContents *out,
PhotInfo *phot, PhotInfo *photc, ApInfo *slit, TdsInfo *tds,
CTICorrInfo *cti, double hfactor, double atodgain, int optimal,
double *pfactor, double *blazeshift)
{
/* arguments:
StisInfo6 *sts i: calibration switches and info
RowContents *out io: output data
PhotInfo *phot i: photometry info
PhotInfo *photc i: for extraction box height correction
ApInfo *slit i: slit info (for throughput)
TdsInfo *tds i: time-dependent sensitivity info
double hfactor i: divide to convert back to observed wavelength
double atodgain i: CCD ATODGAIN value
int optimal i: is optimal extraction ?
double *pfactor; i: flux normalization factor from opt. extr.
profile
double *blazeshift; o: blaze shift value actually used
*/
double wl; /* observed wavelength at a pixel */
double response; /* instrumental response at a wavelength */
double pct_factor; /* correction to infinite extr box height */
double pct_factor2; /* correction for current extr box height */
double tds_factor; /* correction for time-dependent sens. */
double gac_factor; /* grating-aperture correction */
double throughput; /* factor to correct for slit throughput */
double photfactor; /* to get inverse sensitivity */
double dispersion; /* dispersion in A/pix */
float correction; /* combined correction factor */
float ecorrection; /* combined correction factor for the error */
int i;
int status;
int abs_starti; /* index to begin search in interp1d */
int pct_starti;
int thr_starti;
int gac_starti;
int tds_starti;
double hf;
double *tds_factors; /* array with time-dependent sensitivity
correction factors */
double *wl_no_blaze; /* phot->wl before blaze shift correction */
void BlazeCorr (PhotInfo *, double, double, int, double, double *,
double);
void TdsCorrection (TdsInfo *, double, double, double *);
abs_starti = 1; /* initial values */
pct_starti = 1;
thr_starti = 1;
gac_starti = 1;
tds_starti = 1;
/* Get the CCD halo factor (haloterm), for opt_elem G750L or G750M. */
cti->allocated = 0;
if ((status = getHalo (sts,
out->npts, out->wave, out->net, cti)) != 0) {
return (status);
}
photfactor = H_PLANCK * C_LIGHT / HST_AREA;
if (sts->heliocorr == PERFORM)
hf = sts->hfactor;
else
hf = 1.0;
/* Generate time-dependent sensitivity correction factors. */
if (sts->tdscorr == PERFORM) {
tds_factors = (double *) malloc (tds->nwl * sizeof (double));
if (tds_factors == NULL)
return (OUT_OF_MEMORY);
TdsCorrection (tds, sts->expstart, sts->detector_temp,
tds_factors);
}
/* Apply MSM/blaze correction to throughput array. Dispersion
is required in the case the reference values from the _pht
table are invalid, AND we are passing a blazeshift value
thru the command line. In this case, we use the dispersion
at the mid point in the current spectral order.
First we have to save the phot->wl array, because when we
interpolate to get pct_factor we must use wavelengths that
do not include the blaze shift correction.
*/
wl_no_blaze = malloc (phot->nelem * sizeof (double));
if (wl_no_blaze == NULL)
return (OUT_OF_MEMORY);
for (i = 0; i < phot->nelem; i++)
wl_no_blaze[i] = phot->wl[i];
if (phot->wpos != 0.0 || sts->blazeshift != NO_VALUE) {
i = out->npts / 2;
dispersion = getDispersion (out, i);
dispersion /= hf;
BlazeCorr (phot, sts->expstart, sts->expend, out->sporder,
sts->blazeshift, blazeshift, dispersion);
}
/* Loop over flux array. */
for (i = 0; i < out->npts; i++) {
/* Convert back to observed wavelength. */
wl = out->wave[i] / hfactor;
/* Interpolate in the reference tables. */
response = extrap1d (wl, phot->wl, phot->thru, phot->nelem,
&abs_starti);
pct_factor = interp1d (wl, wl_no_blaze, phot->pcorr, phot->nelem,
&pct_starti);
pct_factor2 = interp1d (wl, photc->wl, photc->pcorr, photc->nelem,
&pct_starti);
throughput = interp1d (wl, slit->wl, slit->thr, slit->nelem,
&thr_starti);
if (sts->gaccorr == PERFORM) {
gac_factor = interp1d (wl, slit->gac_wl, slit->gac_thr,
slit->gac_nelem, &gac_starti);
} else {
gac_factor = 1.;
}
if (sts->tdscorr == PERFORM)
tds_factor = interp1d (wl, tds->wl, tds_factors,
tds->nwl, &tds_starti);
else
tds_factor = 1.;
/* Check for zeroed throughput (OPR 38749) */
if (throughput <= 0.0) {
out->flux[i] = 0.0F;
out->error[i] = 0.0F;
out->dq[i] |= CALIBDEFECT;
continue;
}
/* Compute dispersion at current pixel. */
dispersion = getDispersion (out, i);
if (dispersion <= 0.0) {
out->flux[i] = 0.0F;
out->error[i] = 0.0F;
out->dq[i] |= CALIBDEFECT;
continue;
}
dispersion /= hf;
/* Compute flux. */
if (response <= 0.0) {
out->flux[i] = 0.0F;
out->error[i] = 0.0F;
out->dq[i] |= CALIBDEFECT;
} else {
float qfactor = 1.0;
float net = out->net[i];
correction = (float) (photfactor / (response * throughput *
wl * dispersion * CM_PER_ANGSTROM));
correction *= atodgain; /* added 9/3/97 (IB) */
correction *= pct_factor / pct_factor2;
correction /= gac_factor;
correction /= tds_factor;
ecorrection = correction;
if (sts->detector == CCD_DETECTOR) {
qfactor = QFactor(sts, wl, out->extrsize, out->gross[i]);
if (sts->ctecorr == PERFORM) {
if (out->gross[i] > 0.0) {
net = out->gross[i] *
CtiCorr(sts, cti, cti->haloterm[i],
out->extrsize, out->extrlocy[i],
out->gross[i], out->back[i])
- out->back[i];
} else {
out->dq[i] |= NOT_CTI_CORR;
}
}
}
if (optimal)
correction *= pfactor[i];
if (ecorrection <= 0.) {
out->flux[i] = 0.0F;
out->error[i] = 0.0F;
out->dq[i] |= CALIBDEFECT;
} else {
out->flux[i] = net * correction;
out->error[i] *= ecorrection * qfactor;
out->net_error[i] *= qfactor;
}
}
}
if (sts->tdscorr == PERFORM)
free (tds_factors);
if (cti->allocated)
free (cti->haloterm);
free (wl_no_blaze);
return (0);
}