/* Main entry */
void smurf_fixsteps( int *status ) {
/* Local Variables */
AstKeyMap *keymap; /* Default config parameter values */
AstKeyMap *sub_instruments; /* Info about sub-instruments */
FILE *fd = NULL; /* File descriptor */
Grp *igrp = NULL; /* Input group of files */
Grp *ogrp = NULL; /* Output group of files */
dim_t dcfitbox; /* DCFITBOX config parameter */
dim_t dcsmooth; /* DCSMOOTH config parameter */
dim_t nx; /* Length of first pixel axis */
double dcthresh; /* DCTHRESH config parameter */
double sizetol; /* Tolerance allowed on step height */
int changed; /* Have any step fixes changed? */
int dclimcorr; /* DCLIMCORR config parameter */
int dcmaxsteps; /* DCMAXSTEPS config parameter */
int first; /* Index of first change to report */
int itemp; /* Intermediate value */
int meanshift; /* Use a mean shift filter? */
int nnew; /* Number of new step fixes */
int nold; /* Number of old step fixes */
size_t nrej; /* Number of rejected bolometers */
size_t outsize; /* Total number of NDF names in the output group */
size_t size; /* Number of files in input group */
smfData *data = NULL; /* Output smfData */
smfData *indata = NULL; /* Input smfData */
smfStepFix *newsteps = NULL; /* New step fix descriptions */
smfStepFix *oldsteps = NULL; /* Old step fix descriptions */
ThrWorkForce *wf = NULL; /* Pointer to a pool of worker threads */
/* Check inherited status */
if (*status != SAI__OK) return;
/* begin an NDF context. */
ndfBegin();
/* Get the name of the input NDF. */
kpg1Rgndf( "IN", 1, 1, "", &igrp, &size, status );
/* Get output file(s) */
kpg1Wgndf( "OUT", igrp, size, 0, "More output files required...",
&ogrp, &outsize, status );
/* Open the input data file, read-only. */
smf_open_file( igrp, 1, "Read", 0, &indata, status );
/* Since we will be modifying the data values, we need a deep copy. */
data = smf_deepcopy_smfData( indata, 0, 0, 0, 0, status );
/* Place cleaning parameters into a keymap and set defaults. Note that we
use the map-maker defaults file here so that we populate the locked
keymap with all the parameters that people may come across to allow
them to load their map-maker config directly this application. */
sub_instruments = smf_subinst_keymap( SMF__SUBINST_NONE, data, NULL, 0,
status );
keymap = kpg1Config( "CONFIG", "$SMURF_DIR/smurf_makemap.def",
sub_instruments, status );
sub_instruments = astAnnul( sub_instruments );
/* Set the default for each of the step fixing config parameters. */
astMapGet0I( keymap, "DCSMOOTH", &itemp );
parDef0i( "DCSMOOTH", itemp, status );
astMapGet0I( keymap, "DCFITBOX", &itemp );
parDef0i( "DCFITBOX", itemp, status );
astMapGet0I( keymap, "DCMAXSTEPS", &itemp );
parDef0i( "DCMAXSTEPS", itemp, status );
astMapGet0I( keymap, "DCLIMCORR", &itemp );
parDef0i( "DCLIMCORR", itemp, status );
astMapGet0D( keymap, "DCTHRESH", &dcthresh );
parDef0d( "DCTHRESH", dcthresh, status );
/* Get values for the config params */
parGet0i( "DCSMOOTH", &itemp, status );
dcsmooth = itemp;
parGet0i( "DCFITBOX", &itemp, status );
dcfitbox = itemp;
parGet0i( "DCMAXSTEPS", &itemp, status );
dcmaxsteps = itemp;
parGet0i( "DCLIMCORR", &itemp, status );
dclimcorr = itemp;
parGet0d( "DCTHRESH", &dcthresh, status );
parGet0l( "MEANSHIFT", &meanshift, status );
/* Find the number of cores/processors available and create a pool of
threads of the same size. */
wf = thrGetWorkforce( thrGetNThread( SMF__THREADS, status ), status );
/* Fix the steps. */
smf_fix_steps( wf, data, dcthresh, dcsmooth, dcfitbox, dcmaxsteps,
dclimcorr, meanshift, &nrej, &newsteps, &nnew, status );
/* Display a summary of what was done by the step fixer. */
msgBlank( status );
if( nrej == 0 ) {
msgOut( "", "No bolometers were rejected", status );
} else if( nrej == 1 ) {
msgOut( "", "One bolometer was rejected", status );
} else {
msgSeti( "NREJ", nrej );
msgOut( "", "^NREJ bolometers were rejected", status );
}
parPut0i( "NREJECTED", nrej, status );
if( nnew == 0 ) {
msgOut( "", "No steps were fixed", status );
} else if( nnew == 1 ) {
msgOut( "", "One step was fixed", status );
} else {
msgSeti( "NNEW", nnew );
msgOut( "", "^NNEW steps were fixed", status );
}
parPut0i( "NFIXED", nnew, status );
/* If required, write out to a text file details of the steps that were
fixed. */
fd = smf_open_textfile( "NEWSTEPS", "w", "<none>", status );
if( fd ) {
smf1_write_steps( fd, indata, nnew, newsteps, dcthresh, dcsmooth,
dcfitbox, dcmaxsteps, dclimcorr, nrej, status );
fclose( fd );
}
/* If required, create the output NDF. */
if( outsize > 0 && indata && indata->file ) {
smf_write_smfData( data, NULL, NULL, ogrp, 1,
indata->file->ndfid, MSG__VERB, 0, status );
}
/* Save the length of the first pixel axis. */
nx = data ? data->dims[ 0 ] : 0;
/* Close the NDFs. */
smf_close_file( &data, status );
smf_close_file( &indata, status );
/* Attempt to open a file containing descriptions of steps fixed by a
previous invocation of this program. */
fd = smf_open_textfile( "OLDSTEPS", "r", "<none>", status );
if( fd ) {
/* Get SIZETOL - the minimum significant fractional error in step sizes. */
parGet0d( "SIZETOL", &sizetol, status );
/* Read the contents of the file, issuing a warning if the global
properties read from the file (e.g. parameters used, no. of steps
found, etc) differ from those of the current invocation. */
msgBlank( status );
oldsteps = smf1_read_steps( fd, dcthresh, dcsmooth,
dcfitbox, dcmaxsteps, dclimcorr,
nrej, nnew, &nold, status );
/* Get the index of the first change to report. */
parGet0i( "FIRST", &first, status );
/* Compare the new step fixes with the old step fixes, issuing a warning
for the first step fix that has changed. */
changed = smf1_check_steps( "CONTINUE", first, nx, sizetol,
nold, nnew, oldsteps, newsteps, status );
/* Store a flag indicating if any sstep fixes have chnaged. */
parPut0l( "CHANGED", changed, status );
/* Tell the user if nothing has changed. */
if( ! changed ) {
msgOut( "", "There are no significant differences "
"between old and new step fixes.", status );
}
msgBlank( status );
/* Close the old steps file, and free the memory holding the old step
descriptions. */
fclose( fd );
oldsteps = astFree( oldsteps );
}
/* Free resources. */
newsteps = astFree( newsteps );
grpDelet( &igrp, status );
grpDelet( &ogrp, status );
/* End the NDF context. */
ndfEnd( status );
/* If anything went wrong issue a context message. */
if( *status != SAI__OK ) msgOutif( MSG__VERB, " ", "FIXSTEPS failed.",
status );
}
void smf_calcmodel_noi( ThrWorkForce *wf, smfDIMMData *dat, int chunk,
AstKeyMap *keymap, smfArray **allmodel, int flags,
int *status) {
/* Local Variables */
dim_t bolostep; /* Number of bolos per thread */
dim_t boxsize; /* No. of time slices in each noise box */
smfData *box = NULL; /* SmfData holding one box of input data */
size_t bstride; /* bolometer stride */
int calcfirst=0; /* Were bolo noises already measured? */
int dclimcorr; /* Min number of correlated steps */
int dcmaxsteps; /* Maximum allowed number of dc jumps */
dim_t dcfitbox; /* Width of box for DC step detection */
double dcthresh; /* Threshold for DC step detection */
dim_t dcsmooth; /* Width of median filter in DC step detection*/
double *din; /* Pointer to next input value */
double *dout; /* Pointer to next output value */
int fillgaps; /* If set perform gap filling */
dim_t i; /* Loop counter */
dim_t ibolo; /* Bolometer index */
int ibox; /* Index of current noise box */
dim_t itime; /* Time slice index */
dim_t idx=0; /* Index within subgroup */
JCMTState *instate=NULL; /* Pointer to input JCMTState */
int iw; /* Thread index */
dim_t j; /* Loop counter */
AstKeyMap *kmap=NULL; /* Local keymap */
size_t mbstride; /* model bolometer stride */
dim_t mntslice; /* Number of model time slices */
size_t mtstride; /* model time slice stride */
smfArray *model=NULL; /* Pointer to model at chunk */
double *model_data=NULL; /* Pointer to DATA component of model */
dim_t nbolo; /* Number of bolometers */
int nbox = 0; /* Number of noise boxes */
size_t nchisq; /* Number of data points in chisq calc */
dim_t nelbox; /* Number of data points in a noise box */
dim_t ndata; /* Total number of data points */
size_t nflag; /* Number of new flags */
int nleft; /* Number of samples not in a noise box */
dim_t ntslice; /* Number of time slices */
int nw; /* Number of worker threads */
size_t pend; /* Last non-PAD sample */
size_t pstart; /* First non-PAD sample */
smf_qual_t *qin; /* Pointer to next input quality value */
smf_qual_t *qout; /* Pointer to next output quality value */
smfArray *qua=NULL; /* Pointer to RES at chunk */
smf_qual_t *qua_data=NULL; /* Pointer to RES at chunk */
smfArray *res=NULL; /* Pointer to RES at chunk */
double *res_data=NULL; /* Pointer to DATA component of res */
dim_t spikebox=0; /* Box size for spike detection */
double spikethresh=0; /* Threshold for spike detection */
size_t tend; /* Last input sample to copy */
size_t tstart; /* First input sample to copy */
size_t tstride; /* time slice stride */
double *var=NULL; /* Sample variance */
size_t xbstride; /* Box bolometer stride */
int zeropad; /* Pad with zeros? */
/* Main routine */
if (*status != SAI__OK) return;
/* Obtain pointer to sub-keymap containing NOI parameters */
astMapGet0A( keymap, "NOI", &kmap );
/* Assert bolo-ordered data */
smf_model_dataOrder( dat, allmodel, chunk, SMF__RES|SMF__QUA, 0, status );
/* Obtain pointers to relevant smfArrays for this chunk */
res = dat->res[chunk];
qua = dat->qua[chunk];
model = allmodel[chunk];
/* Obtain parameters for NOI */
/* Data-cleaning parameters */
smf_get_cleanpar( kmap, res->sdata[0], NULL, &dcfitbox, &dcmaxsteps, &dcthresh,
&dcsmooth, &dclimcorr, NULL, &fillgaps, &zeropad, NULL,
NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
&spikethresh, &spikebox, NULL, NULL, NULL, NULL, NULL, NULL,
NULL, NULL, NULL, NULL, status );
/* Did we already calculate the noise on each detector? */
astMapGet0I( kmap, "CALCFIRST", &calcfirst );
/* Initialize chisquared */
dat->chisquared[chunk] = 0;
nchisq = 0;
/* Loop over index in subgrp (subarray) */
for( idx=0; idx<res->ndat; idx++ ) {
/* Get pointers to DATA components */
res_data = (res->sdata[idx]->pntr)[0];
model_data = (model->sdata[idx]->pntr)[0];
qua_data = (qua->sdata[idx]->pntr)[0];
if( (res_data == NULL) || (model_data == NULL) || (qua_data == NULL) ) {
*status = SAI__ERROR;
errRep( "", FUNC_NAME ": Null data in inputs", status);
} else {
/* Get the raw data dimensions */
smf_get_dims( res->sdata[idx], NULL, NULL, &nbolo, &ntslice, &ndata,
&bstride, &tstride, status );
/* NOI model dimensions */
smf_get_dims( model->sdata[idx], NULL, NULL, NULL, &mntslice, NULL,
&mbstride, &mtstride, status );
/* Only estimate the white noise level once at the beginning - the
reason for this is to make measurements of the convergence
easier. We either do it prior to the start of iterations (in which
case the relative weights will be influeced by low-frequency noise,
this is initialized in smf_model_create), or else we calculate
the noise after the first iteration. */
if( (flags & SMF__DIMM_FIRSTITER) && (!calcfirst) ) {
/* There are two forms for the NOI model: one constant noise value
for each bolometer, or "ntslice" noise values for each bolometer.
Handle the first case now. */
if( mntslice == 1 ) {
var = astMalloc( nbolo*sizeof(*var) );
if (var) {
/* Measure the noise from power spectra */
smf_bolonoise( wf, res->sdata[idx], 0, 0.5, SMF__F_WHITELO,
SMF__F_WHITEHI, 0, zeropad ? SMF__MAXAPLEN : SMF__BADSZT,
var, NULL, NULL, status );
for( i=0; i<nbolo; i++ ) if( !(qua_data[i*bstride]&SMF__Q_BADB) ) {
/* Loop over time and store the variance for each sample */
for( j=0; j<mntslice; j++ ) {
model_data[i*mbstride+(j%mntslice)*mtstride] = var[i];
}
}
var = astFree( var );
}
/* If the NOI model is of the second form, the noise is estimated
in boxes of samples lasting "NOI.BOX_SIZE" seconds, and then the
noise level in the box is assigned to all samples in the box. */
} else if( mntslice == ntslice ) {
/* If not already done, get NOI.BOX_SIZE and convert from seconds to
samples. */
if( idx == 0 ) {
boxsize = 0;
smf_get_nsamp( kmap, "BOX_SIZE", res->sdata[0], &boxsize, status );
msgOutf( "", FUNC_NAME ": Calculating a NOI variance for each "
"box of %d samples.", status, (int) boxsize );
/* Find the indices of the first and last non-PAD sample. */
smf_get_goodrange( qua_data, ntslice, tstride, SMF__Q_PAD,
&pstart, &pend, status );
/* How many whole boxes fit into this range? */
nbox = ( pend - pstart + 1 ) / boxsize;
if( nbox == 0 ) nbox = 1;
/* How many samples would be left over at the end if we used this
many boxes? */
nleft = ( pend - pstart + 1 ) - nbox*boxsize;
/* Increase "boxsize" to reduce this number as far as possible.
Any samples that are left over after this increase of boxsize
will not be used when calculating the noise levels in each
bolometer. */
boxsize += nleft/nbox;
/* Create a smfData to hold one box-worth of input data. We
do not need to copy jcmtstate information. */
if( res->sdata[idx]->hdr ) {
instate = res->sdata[idx]->hdr->allState;
res->sdata[idx]->hdr->allState = NULL;
}
box = smf_deepcopy_smfData( res->sdata[idx], 0,
SMF__NOCREATE_DATA |
SMF__NOCREATE_VARIANCE |
SMF__NOCREATE_QUALITY,
0, 0, status );
if( instate ) res->sdata[idx]->hdr->allState = instate;
/* Set the length of the time axis to the box size plus padding,
and create empty data and quality arrays for it. */
if( *status == SAI__OK ) {
box->dims[ box->isTordered?2:0 ] = boxsize + pstart + (ntslice - pend - 1);
smf_get_dims( box, NULL, NULL, NULL, NULL, &nelbox,
&xbstride, NULL, status );
box->pntr[0] = astMalloc( sizeof( double )*nelbox );
box->qual = astMalloc( sizeof( smf_qual_t )*nelbox );
/* For every bolometer, flag the start and end of the quality
array as padding, and store zeros in the data array. */
for( ibolo = 0; ibolo < nbolo; ibolo++ ) {
dout = ((double *) box->pntr[0]) + xbstride*ibolo;
qout = box->qual + xbstride*ibolo;
for( itime = 0; itime < pstart; itime++ ) {
*(qout++) = SMF__Q_PAD;
*(dout++) = 0.0;
}
dout = ((double *) box->pntr[0]) + xbstride*ibolo + pstart + boxsize;;
qout = box->qual + xbstride*ibolo + pstart + boxsize;
for( itime = pend + 1; itime < ntslice; itime++ ) {
*(qout++) = SMF__Q_PAD;
*(dout++) = 0.0;
}
}
}
}
/* Work space to hold the variance for each bolometer in a box */
var = astMalloc( nbolo*sizeof(*var) );
if( *status == SAI__OK ) {
/* Index of the first time slice within the input smfData
that is included in the first box. */
tstart = pstart;
/* Loop round each noise box */
for( ibox = 0; ibox < nbox; ibox++ ) {
/* Copy the data and quality values for this box from the
input smfData into "box", leaving room for padding at
both ends of box. Note, data is bolo-ordered so we
can assume that "tstride" is 1. */
din = ((double *)(res->sdata[idx]->pntr[0])) + tstart;
dout = ((double *)(box->pntr[0])) + pstart;
qin = qua_data + tstart;
qout = box->qual + pstart;
for( ibolo = 0; ibolo < nbolo; ibolo++ ) {
memcpy( dout, din, boxsize*sizeof( *din ) );
memcpy( qout, qin, boxsize*sizeof( *qin ) );
din += bstride;
dout += xbstride;
qin += bstride;
qout += xbstride;
}
/* Measure the noise from power spectra in the box. */
smf_bolonoise( wf, box, 0, 0.5, SMF__F_WHITELO, SMF__F_WHITEHI,
0, zeropad ? SMF__MAXAPLEN : SMF__BADSZT, var,
NULL, NULL, status );
/* Loop over time and store the variance for each sample in
the NOI model. On the last box, pick up any left over time
slices. */
if( ibox < nbox - 1 ) {
tend = tstart + boxsize - 1;
} else {
tend = pend;
}
for( ibolo = 0; ibolo < nbolo; ibolo++ ) {
if( !( qua_data[ ibolo*bstride ] & SMF__Q_BADB ) ) {
dout = model_data + ibolo*bstride + tstart;
for( itime = tstart; itime <= tend; itime++ ) {
*(dout++) = var[ ibolo ];
}
}
}
/* Update the index of the first time slice within the input
smfData that is included in the next box. */
tstart += boxsize;
}
var = astFree( var );
}
/* Report an error if the number of samples for each bolometer in
the NOI model is not 1 or "ntslice". */
} else if( *status == SAI__OK ) {
*status = SAI__ERROR;
errRepf( "", FUNC_NAME ": NOI model has %d samples - should be "
"%d or 1.", status, (int) mntslice, (int) ntslice);
}
}
if( kmap ) {
/* Flag spikes in the residual after first iteration */
if( spikethresh && !(flags&SMF__DIMM_FIRSTITER) ) {
/* Now re-flag */
smf_flag_spikes( wf, res->sdata[idx], SMF__Q_MOD,
spikethresh, spikebox, &nflag, status );
msgOutiff(MSG__VERB," ", " flagged %zu new %lf-sig spikes",
status, nflag, spikethresh );
}
if( dcthresh && dcfitbox ) {
smf_fix_steps( wf, res->sdata[idx], dcthresh, dcsmooth,
dcfitbox, dcmaxsteps, dclimcorr, 1, &nflag, NULL,
NULL, status );
msgOutiff(MSG__VERB, ""," detected %zu bolos with DC steps\n",
status, nflag);
}
}
/* Now calculate contribution to chi^2. This bit takes along time
if there is a lot of data so share the work out amongst the available
worker threads. How many threads do we get to play with */
nw = wf ? wf->nworker : 1;
/* Find how many bolometers to process in each worker thread. */
bolostep = nbolo/nw;
if( bolostep == 0 ) bolostep = 1;
/* Allocate job data for threads, and store the range of bolos to be
processed by each one. Ensure that the last thread picks up any
left-over bolos. */
SmfCalcModelNoiData *job_data = astCalloc( nw, sizeof(*job_data) );
if( *status == SAI__OK ) {
SmfCalcModelNoiData *pdata;
for( iw = 0; iw < nw; iw++ ) {
pdata = job_data + iw;
pdata->b1 = iw*bolostep;
if( iw < nw - 1 ) {
pdata->b2 = pdata->b1 + bolostep - 1;
} else {
pdata->b2 = nbolo - 1 ;
}
/* Store other values common to all jobs. */
pdata->ntslice = ntslice;
pdata->mntslice = mntslice;
pdata->qua_data = qua_data;
pdata->model_data = model_data;
pdata->res_data = res_data;
pdata->bstride = bstride;
pdata->tstride = tstride;
pdata->mbstride = mbstride;
pdata->mtstride = mtstride;
/* Submit the job to the workforce. */
thrAddJob( wf, 0, pdata, smf1_calcmodel_noi, 0, NULL, status );
}
/* Wait for all jobs to complete. */
thrWait( wf, status );
/* Accumulate the results from all the worker threads. */
for( iw = 0; iw < nw; iw++ ) {
pdata = job_data + iw;
dat->chisquared[chunk] += pdata->chisquared;
nchisq += pdata->nchisq;
}
/* Free the job data. */
job_data = astFree( job_data );
}
}
}
/* Free resources */
if( box ) {
box->pntr[0] = astFree( box->pntr[0] );
box->qual = astFree( box->qual );
smf_close_file( &box, status );
}
/* Normalize chisquared for this chunk */
if( (*status == SAI__OK) && (nchisq >0) ) {
dat->chisquared[chunk] /= (double) nchisq;
}
/* Clean Up */
if( kmap ) kmap = astAnnul( kmap );
}
void smf_clean_smfArray( ThrWorkForce *wf, smfArray *array,
smfArray **noisemaps, smfArray **com, smfArray **gai,
AstKeyMap *keymap, int *status ) {
/* Local Variables */
double badfrac; /* Fraction of bad samples to flag bad bolo */
smfData *data=NULL; /* Pointer to individual smfData */
int compreprocess; /* COMmon-mode cleaning as pre-processing step */
dim_t dcfitbox; /* width of box for measuring DC steps */
int dclimcorr; /* Min number of correlated steps */
int dcmaxsteps; /* number of DC steps/min. to flag bolo bad */
dim_t dcsmooth; /* median filter width before finding DC steps */
double dcthresh; /* n-sigma threshold for primary DC steps */
int dofft; /* are we doing a freq.-domain filter? */
int dkclean; /* Flag for dark squid cleaning */
smfFilter *filt=NULL; /* Frequency domain filter */
double flagfast; /* Threshold for flagging slow slews */
double flagslow; /* Threshold for flagging slow slews */
dim_t idx; /* Index within subgroup */
size_t nflag; /* Number of elements flagged */
double noisecliphigh = 0; /* Sigma clip high-noise outlier bolos */
double noisecliplow = 0; /* Sigma clip low-noise outlier bolos */
int noiseclipprecom = 0; /* Noise clipping before common-mode cleaning? */
const char *opteff=NULL; /* Pointer to optical efficiency NDF file name*/
int opteffdiv; /* Divide data by the optical efficiencies? */
int order; /* Order of polynomial for baseline fitting */
char param[ 20 ]; /* Buffer for config parameter name */
dim_t pcalen; /* Chunk length for PCA cleaning */
double pcathresh; /* n-sigma threshold for PCA cleaning */
double spikethresh; /* Threshold for finding spikes */
dim_t spikebox=0; /* Box size for spike finder */
struct timeval tv1, tv2; /* Timers */
int whiten; /* Apply whitening filter? */
int zeropad; /* Pad with zeros? */
/* Main routine */
if (*status != SAI__OK) return;
/*** TIMER ***/
smf_timerinit( &tv1, &tv2, status );
/* Check for valid inputs */
if( !array || (array->ndat < 1) ) {
*status = SAI__ERROR;
errRep( "", FUNC_NAME ": No data supplied", status );
}
if( array->sdata[0]->ndims != 3 ) {
*status = SMF__WDIM;
errRepf( "", FUNC_NAME ": Supplied smfData has %zu dims, needs 3", status,
data->ndims );
return;
}
if( !keymap ) {
*status = SAI__ERROR;
errRep( "", FUNC_NAME ": NULL AstKeyMap supplied", status );
return;
}
/* Get cleaning parameters */
smf_get_cleanpar( keymap, array->sdata[0], &badfrac, &dcfitbox, &dcmaxsteps,
&dcthresh, &dcsmooth, &dclimcorr, &dkclean,
NULL, &zeropad, NULL, NULL, NULL, NULL, NULL,
NULL, NULL, NULL, &flagslow, &flagfast, &order,
&spikethresh, &spikebox, &noisecliphigh, &noisecliplow,
NULL, &compreprocess, &pcalen, &pcathresh, NULL, NULL, NULL,
&noiseclipprecom, status );
/* Loop over subarray */
for( idx=0; (idx<array->ndat)&&(*status==SAI__OK); idx++ ) {
data = array->sdata[idx];
/* Update quality by synchronizing to the data array VAL__BADD values */
msgOutif(MSG__VERB,"", FUNC_NAME ": update quality", status);
smf_update_quality( data, 1, NULL, 0, badfrac, status );
/*** TIMER ***/
msgOutiff( SMF__TIMER_MSG, "", FUNC_NAME ": ** %f s updating quality",
status, smf_timerupdate(&tv1,&tv2,status) );
/* Fix DC steps */
if( dcthresh && dcfitbox ) {
msgOutiff(MSG__VERB, "", FUNC_NAME
": Flagging bolos with %lf-sigma DC steps in %" DIM_T_FMT " "
"samples as bad, using %" DIM_T_FMT
"-sample median filter and max %d "
"DC steps per min before flagging entire bolo bad...", status,
dcthresh, dcfitbox, dcsmooth, dcmaxsteps);
smf_fix_steps( wf, data, dcthresh, dcsmooth, dcfitbox, dcmaxsteps,
dclimcorr, 0, &nflag, NULL, NULL, status );
msgOutiff(MSG__VERB, "", FUNC_NAME": ...%zd flagged\n", status, nflag);
/*** TIMER ***/
msgOutiff( SMF__TIMER_MSG, "", FUNC_NAME ": ** %f s fixing DC steps",
status, smf_timerupdate(&tv1,&tv2,status) );
}
/* Flag Spikes */
if( spikethresh ) {
msgOutif(MSG__VERB," ", FUNC_NAME ": flag spikes...", status);
smf_flag_spikes( wf, data, SMF__Q_FIT, spikethresh, spikebox,
&nflag, status );
msgOutiff(MSG__VERB,"", FUNC_NAME ": ...found %zd", status, nflag );
/*** TIMER ***/
msgOutiff( SMF__TIMER_MSG, "", FUNC_NAME ": ** %f s flagging spikes",
status, smf_timerupdate(&tv1,&tv2,status) );
}
/* Flag periods of stationary pointing, and update scanspeed to more
accurate value */
if( flagslow || flagfast ) {
if( data->hdr && data->hdr->allState ) {
double scanvel=0;
if( flagslow ) {
msgOutiff( MSG__VERB, "", FUNC_NAME
": Flagging regions with slew speeds < %.2lf arcsec/sec",
status, flagslow );
}
if( flagfast ) {
msgOutiff( MSG__VERB, "", FUNC_NAME
": Flagging regions with slew speeds > %.2lf arcsec/sec",
status, flagfast );
/* Check to see if this was a sequence type that involved
motion. If not, skip this section */
if( data && data->hdr && (
(data->hdr->seqtype==SMF__TYP_SCIENCE) ||
(data->hdr->seqtype==SMF__TYP_POINTING) ||
(data->hdr->seqtype==SMF__TYP_FOCUS) ||
(data->hdr->seqtype==SMF__TYP_SKYDIP))
&& (data->hdr->obsmode!=SMF__OBS_STARE) ) {
smf_flag_slewspeed( data, flagslow, flagfast, &nflag, &scanvel,
status );
msgOutiff( MSG__VERB,"", "%zu new time slices flagged", status,
nflag);
if( msgIflev( NULL, status ) >= MSG__VERB ) {
msgOutf( "", FUNC_NAME ": mean SCANVEL=%.2lf arcsec/sec"
" (was %.2lf)", status, scanvel, data->hdr->scanvel );
}
data->hdr->scanvel = scanvel;
/*** TIMER ***/
msgOutiff( SMF__TIMER_MSG, "", FUNC_NAME
": ** %f s flagging outlier slew speeds",
status, smf_timerupdate(&tv1,&tv2,status) );
} else {
msgOutif( MSG__VERB, "", FUNC_NAME
": not a moving sequence or missing header, "
"skipping slew speed flagging", status );
}
}
} else {
msgOutif( MSG__DEBUG, "", FUNC_NAME
": Skipping flagslow/flagfast because no header present",
status );
}
}
/* Clean out the dark squid signal */
if( dkclean ) {
msgOutif(MSG__VERB, "", FUNC_NAME
": Cleaning dark squid signals from data.", status);
smf_clean_dksquid( data, 0, 100, NULL, 0, 0, 0, status );
/*** TIMER ***/
msgOutiff( SMF__TIMER_MSG, "", FUNC_NAME ": ** %f s DKSquid cleaning",
status, smf_timerupdate(&tv1,&tv2,status) );
}
/* Apply optical efficiency corrections. */
one_strlcpy( param, "OPTEFF", sizeof(param), status );
smf_find_subarray( data->hdr, param + strlen(param),
sizeof(param) - strlen(param), NULL, status );
astChrCase( NULL, param, 1, 0 );
if( astMapHasKey( keymap, param ) ) {
astMapGet0I( keymap, "OPTEFFDIV", &opteffdiv );
if ( astMapGet0C( keymap, param, &opteff ) ) {
msgOutiff( MSG__VERB,"", FUNC_NAME ": %s bolometer values "
"by factors read from NDF %s", status,
opteffdiv ? "Dividing" : "Multiplying", opteff );
smf_scale_bols( wf, data, NULL, opteff, param, opteffdiv, status );
}
}
/* Remove baselines */
if( order >= 0 ) {
msgOutiff( MSG__VERB,"", FUNC_NAME
": Fitting and removing %i-order polynomial baselines",
status, order );
smf_fit_poly( wf, data, order, 1, NULL, status );
/*** TIMER ***/
msgOutiff( SMF__TIMER_MSG, "", FUNC_NAME
": ** %f s removing poly baseline",
status, smf_timerupdate(&tv1,&tv2,status) );
}
}
/* Mask noisy bolos here if happening before common-mode cleaning */
if( (*status == SAI__OK) && ((noisecliphigh>0.0) || (noisecliplow>0.0)) &&
noiseclipprecom ) {
smf__noisymask( wf, data, noisemaps, noisecliphigh, noisecliplow,
zeropad, &tv1, &tv2, status );
}
/* Optionally call smf_calcmodel_com to perform a subset of the following
tasks as a pre-processing step:
- remove the common-mode
- flag outlier data using common-mode rejection
- determine relative flatfields using amplitude of common-mode
In order to do this we need to set up some temporary model container
files so that the routine can be called properly. All of the same
COMmon-mode and GAIn model parameters (e.g. com.* and gai.*) will be
used here. However, in addition the "compreprocess" flag must be set
for this operation to be performed. */
if( compreprocess ) {
smfArray *comdata = NULL;
smfGroup *comgroup = NULL;
smfDIMMData dat;
smfArray *gaidata = NULL;
smfGroup *gaigroup = NULL;
smfArray *quadata = NULL;
smfData *thisqua=NULL;
msgOutif(MSG__VERB," ", FUNC_NAME ": Remove common-mode", status);
/* Create model containers for COM, GAI */
smf_model_create( wf, NULL, &array, NULL, NULL, NULL, NULL, NULL, 1, SMF__COM,
0, NULL, 0, NULL, NULL, &comgroup, &comdata, keymap,
status );
smf_model_create( wf, NULL, &array, NULL, NULL, NULL, NULL, NULL, 1, SMF__GAI,
0, NULL, 0, NULL, NULL, &gaigroup, &gaidata, keymap,
status );
/* Manually create quadata to share memory with the quality already
stored in array */
quadata = smf_create_smfArray( status );
for( idx=0; (*status==SAI__OK) && (idx<array->ndat); idx++ ) {
/* Create several new smfDatas, but they will all be freed
properly when we close quadata */
thisqua = smf_create_smfData( SMF__NOCREATE_DA | SMF__NOCREATE_HEAD |
SMF__NOCREATE_FILE, status );
/* Probably only need pntr->[0], but fill in the dimensionality
information to be on the safe side */
thisqua->dtype = SMF__QUALTYPE;
thisqua->ndims = array->sdata[idx]->ndims;
thisqua->isTordered = array->sdata[idx]->isTordered;
memcpy( thisqua->dims, array->sdata[idx]->dims, sizeof(thisqua->dims) );
memcpy( thisqua->lbnd, array->sdata[idx]->lbnd, sizeof(thisqua->lbnd) );
thisqua->pntr[0] = smf_select_qualpntr( array->sdata[idx], NULL, status );
smf_addto_smfArray( quadata, thisqua, status );
}
/* Set up the smfDIMMData and call smf_calcmodel_com */
memset( &dat, 0, sizeof(dat) );
dat.res = &array;
dat.gai = &gaidata;
dat.qua = &quadata;
dat.noi = NULL;
smf_calcmodel_com( wf, &dat, 0, keymap, &comdata, SMF__DIMM_FIRSTITER,
status );
/*** TIMER ***/
msgOutiff( SMF__TIMER_MSG, "", FUNC_NAME
": ** %f s removing common-mode",
status, smf_timerupdate(&tv1,&tv2,status) );
/* Clean up and/or return values */
if( com ) {
*com = comdata;
} else {
if( comdata ) smf_close_related( &comdata, status );
}
if( gai ) {
*gai = gaidata;
} else {
if( gaidata ) smf_close_related( &gaidata, status );
}
if( comgroup ) smf_close_smfGroup( &comgroup, status );
if( gaigroup ) smf_close_smfGroup( &gaigroup, status );
/* Before closing quadata unset all the pntr[0] since this is shared
memory with the quality associated with array */
if( quadata ) {
for( idx=0; idx<quadata->ndat; idx++ ) {
quadata->sdata[idx]->pntr[0] = NULL;
}
if( quadata ) smf_close_related( &quadata, status );
}
}
/* PCA cleaning */
if( pcathresh ) {
/* Loop over subarray */
for( idx=0; (idx<array->ndat)&&(*status==SAI__OK); idx++ ) {
data = array->sdata[idx];
smf_clean_pca_chunks( wf, data, pcalen, pcathresh, keymap, status );
}
/*** TIMER ***/
msgOutiff( SMF__TIMER_MSG, "", FUNC_NAME ": ** %f s PCA cleaning",
status, smf_timerupdate(&tv1,&tv2,status) );
}
/* Allocate space for noisemaps if required */
if( noisemaps ) {
*noisemaps = smf_create_smfArray( status );
}
/* Loop over subarray */
for( idx=0; (idx<array->ndat)&&(*status==SAI__OK); idx++ ) {
data = array->sdata[idx];
/* Filter the data. Note that we call smf_filter_execute to apply
a per-bolometer whitening filter even if there is no
explicitly requested smfFilter (in which case the
smf_filter_fromkeymap call will leave the real/imaginary parts
of the filter as NULL pointers and they will get ignored inside
smf_filter_execute). */
filt = smf_create_smfFilter( data, status );
smf_filter_fromkeymap( filt, keymap, data->hdr, &dofft, &whiten, status );
if( (*status == SAI__OK) && dofft ) {
msgOutif( MSG__VERB, "", FUNC_NAME ": frequency domain filter", status );
smf_filter_execute( wf, data, filt, 0, whiten, status );
/*** TIMER ***/
msgOutiff( SMF__TIMER_MSG, "", FUNC_NAME ": ** %f s filtering data",
status, smf_timerupdate(&tv1,&tv2,status) );
}
filt = smf_free_smfFilter( filt, status );
/* Mask noisy bolos here if happening after common-mode cleaning */
if( (*status == SAI__OK) && ((noisecliphigh>0.0) || (noisecliplow>0.0)) &&
!noiseclipprecom ) {
smf__noisymask( wf, data, noisemaps, noisecliphigh, noisecliplow,
zeropad, &tv1, &tv2, status );
}
}
}
