void smf_filter2d_execute( ThrWorkForce *wf, smfData *data, smfFilter *filt,
int complement, int *status ) {
double *data_i=NULL; /* Imaginary part of the transformed data */
double *data_r=NULL; /* Real part of the transformed data */
smfData *fdata=NULL; /* Transform of data */
dim_t fdims[2]={0,0}; /* Frequency dimensions */
size_t i; /* loop counter */
size_t ndims=0; /* Number of real-space dimensions */
size_t nfdata; /* Total number of frequency data points */
smfData *varfilt=NULL; /* real-space square of supplied filter for var */
AstFrameSet *wcs=NULL; /* Copy of real-space WCS */
/* Main routine */
if (*status != SAI__OK) return;
/* Check for NULL pointers */
if( !data ) {
*status = SAI__ERROR;
errRep( "", FUNC_NAME ": NULL smfData pointer", status );
return;
}
if( !filt ) {
*status = SAI__ERROR;
errRep( "", FUNC_NAME ": NULL smfFilter pointer", status );
return;
}
if( filt->ndims != 2 ) {
*status = SAI__ERROR;
errRep( "", FUNC_NAME ": Filter must be 2-dimensional", status );
return;
}
if( smf_isfft( data, NULL, NULL, fdims, NULL, &ndims, status ) ) {
*status = SAI__ERROR;
errRep( "", FUNC_NAME ": FFT'd data supplied!", status );
return;
}
if( ndims != 2 ) {
*status = SAI__ERROR;
errRep( "", FUNC_NAME ": supplied data are not a 2-d map", status );
return;
}
/* Check that the filter dimensions are appropriate for the data */
for( i=0; i<ndims; i++ ) {
if( fdims[i] != filt->fdims[i] ) {
*status = SAI__ERROR;
errRepf( "", FUNC_NAME
": Filter axis %zu has length %zu, doesn't match data %zu",
status, i, filt->fdims[i], fdims[i] );
return;
}
}
/* Dimensions of the transformed data */
nfdata = 1;
for( i=0; i<ndims; i++ ) {
if( filt->fdims[i] != fdims[i] ) {
*status = SAI__ERROR;
errRepf( "", FUNC_NAME
": Filter axis %zu has dim %zu doesn't match data dim %zu",
status, i, filt->fdims[i], fdims[i]);
return;
}
nfdata *= fdims[i];
}
/* Using complement of the filter? */
if( complement ) smf_filter_complement( filt, status );
/* Get a copy of the wcs of the input map */
if( data->hdr && data->hdr->wcs ) {
wcs = astCopy( data->hdr->wcs );
}
/* Transform the data */
fdata = smf_fft_data( wf, data, NULL, 0, 0, status );
/* Copy the FFT of the data if we will also be filtering the VARIANCE
since this will get us a useful container of the correct dimensions
for the squared filter */
if( data->pntr[1] ) {
varfilt = smf_deepcopy_smfData( wf, fdata, 0, SMF__NOCREATE_VARIANCE |
SMF__NOCREATE_QUALITY |
SMF__NOCREATE_FILE |
SMF__NOCREATE_DA, 0, 0, status );
}
/* Apply the frequency-domain filter. */
if( *status == SAI__OK ) {
data_r = fdata->pntr[0];
data_i = data_r + nfdata;
if( filt->isComplex ) {
double ac, bd, aPb, cPd;
for( i=0; i<nfdata; i++ ) {
ac = data_r[i] * filt->real[i];
bd = data_i[i] * filt->imag[i];
aPb = data_r[i] + data_i[i];
cPd = filt->real[i] + filt->imag[i];
}
} else {
for( i=0; i<nfdata; i++ ) {
data_r[i] *= filt->real[i];
data_i[i] *= filt->real[i];
}
}
}
/* Transform back */
smf_fft_data( wf, fdata, data, 1, 0, status );
/* Insert the copy of original real-space WCS into the smfHead since
smf_fft_data does not currently calculate it for inverse
transforms. */
if( data->hdr ) {
/* Annul current wcs if it exists */
if( data->hdr->wcs ) {
data->hdr->wcs = astAnnul( data->hdr->wcs );
}
data->hdr->wcs = wcs;
}
/* If we have a VARIANCE component we also need to smooth it. This
is slightly complicated because we have to do the equivalent of a
real-space convolution between the variance map and the
element-wise square of the real-space filter. So we first stuff
the supplied filter into a smfData (frequency space), take its
inverse to real space and square it. We then transform back to
frequency space, and run it through smf_filter2d_execute to apply
it to the VARIANCE map (which is also stuffed into its own
smfData and then copied into the correct location of the supplied
smfData when finished. */
if( (data->pntr[1]) && (*status==SAI__OK) ) {
dim_t ndata;
double *ptr=NULL;
smfData *realfilter=NULL; /* Real space smfData container for var filter */
smfData *vardata=NULL; /* smfData container for variance only */
smfFilter *vfilt=NULL; /* The var filter */
/* Copy the filter into the smfData container and transform into the
time domain. */
ptr = varfilt->pntr[0];
memcpy(ptr, filt->real, nfdata*sizeof(*ptr));
if( filt->imag) {
memcpy(ptr+nfdata, filt->imag, nfdata*sizeof(*ptr));
} else {
memset(ptr+nfdata, 0, nfdata*sizeof(*ptr));
}
realfilter = smf_fft_data( wf, varfilt, NULL, 1, 0, status );
smf_close_file( wf, &varfilt, status );
/* Square each element of the real-space filter and then transform
back to the frequency domain and stuff into a smfFilter
(vfilt). We just point the real and imaginary parts of the
smfFilter to the respective regions of the smfData to save
memory/time, but we need to be careful when freeing at the
end. */
if( *status == SAI__OK ) {
ptr = realfilter->pntr[0];
smf_get_dims( realfilter, NULL, NULL, NULL, NULL, &ndata, NULL, NULL,
status );
if( *status == SAI__OK ) {
double norm = 1. / (double) ndata;
for(i=0; i<ndata; i++) {
/* Note that we need an additional normalization of N samples */
ptr[i] *= ptr[i] * norm;
}
}
}
varfilt = smf_fft_data( wf, realfilter, NULL, 0, 0, status );
if( *status == SAI__OK ) {
ptr = varfilt->pntr[0];
vfilt = smf_create_smfFilter( data, status );
vfilt->real = ptr;
if( filt->isComplex ) {
/* Only worry about imaginary part if the original filter was
complex. */
vfilt->isComplex = 1;
vfilt->imag = ptr + nfdata;
}
}
/* Now stuff the variance array into a smfData and filter it. */
vardata = smf_deepcopy_smfData( wf, data, 0, SMF__NOCREATE_VARIANCE |
SMF__NOCREATE_QUALITY |
SMF__NOCREATE_FILE |
SMF__NOCREATE_DA, 0, 0, status );
if( *status == SAI__OK ) {
ptr = vardata->pntr[0];
memcpy( ptr, data->pntr[1], ndata*sizeof(*ptr) );
smf_filter2d_execute( wf, vardata, vfilt, 0, status );
}
/* Finally, copy the filtered variance into our output filtered smfData */
if( *status == SAI__OK ) {
ptr = data->pntr[1];
memcpy( ptr, vardata->pntr[0], ndata*sizeof(*ptr) );
}
/* Clean up */
if( realfilter ) smf_close_file( wf, &realfilter, status );
if( vardata ) smf_close_file( wf, &vardata, status );
if( vfilt ) {
vfilt->real = NULL;
vfilt->imag = NULL;
vfilt = smf_free_smfFilter( vfilt, status );
}
}
/* Return the filter to its original state if required */
if( complement == -1 ) smf_filter_complement( filt, status );
/* Clean up */
if( varfilt ) smf_close_file( wf, &varfilt, status );
if( fdata ) smf_close_file( wf, &fdata, status );
}
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 );
}
}
}
void smfParallelTime( void *job_data_ptr, int *status ) {
smfArray **array=NULL; /* array of smfArrays that we're working on */
smfTimeChunkData *data=NULL; /* Pointer to job data */
smfFilter *filt=NULL; /* Frequency domain filter */
size_t i; /* Loop counter */
size_t j; /* Loop counter */
size_t k; /* Loop counter */
dim_t nbolo; /* Number of bolos in smfData */
dim_t ndata; /* Size of DATA component in smfData */
dim_t ntslice; /* Number of time slices in smfData */
dim_t nsub; /* Number of subarrays */
double *val=NULL; /* Pointer to DATA component of smfData */
if( *status != SAI__OK ) return;
/* Pointer to the data that this thread will process */
data = job_data_ptr;
/* Check for valid inputs */
if( !data ) {
*status = SAI__ERROR;
errRep( "", "smfParallelTime: job_data_ptr is NULL.", status );
return;
}
if( !(array=data->data) ) {
*status = SAI__ERROR;
errRep( "", "smfParallelTime: data array is NULL.", status );
return;
}
/* Message indicating the thread started */
msgSeti( "C1", data->chunk1);
msgSeti( "C2", data->chunk2);
msgOutif( MSG__DEBUG, "",
"-- parallel time: thread starting on chunks ^C1 -- ^C2",
status );
/* Loop over time chunk. Some chunks may be flagged to skip if
chunk1=nchunks */
for( i=data->chunk1; (i<=data->chunk2)&&(i<data->nchunks)&&(*status==SAI__OK);
i++ ) {
nsub = array[i]->ndat;
/* Initialize filter -- assume same data dimensions for all subarrays */
if( data->type == 2 ) {
filt = smf_create_smfFilter( array[i]->sdata[0], status );
smf_filter_ident( filt, 1, status );
}
/* Loop over subarray */
for( j=0; (j<nsub)&&(*status==SAI__OK); j++ ) {
/* Change to bolo-ordered data */
if( data->type == 0 ) {
/* --- Re-order the data --- */
smf_dataOrder( array[i]->sdata[j], 0, status );
}
smf_get_dims( array[i]->sdata[j], NULL, NULL, &nbolo, &ntslice, &ndata,
NULL, NULL, status );
if( data->type == 1 ) {
/* --- Boxcar smooth the data --- */
for( k=0; (*status==SAI__OK)&&(k<nbolo); k++ ) {
val = array[i]->sdata[j]->pntr[0];
val += k*ntslice;
/* Boxcar smooth each bolometer by 500 samples */
smf_boxcar1D( val, ntslice, 500, NULL, 0, status );
}
}
if( data->type == 2 ) {
/* --- FFT filter the data --- */
smf_filter_execute( NULL, array[i]->sdata[j], filt, 0, 0, status );
}
}
if( filt ) filt = smf_free_smfFilter( filt, status );
}
/* Message indicating the thread started */
msgSeti( "C1", data->chunk1);
msgSeti( "C2", data->chunk2);
msgOutif( MSG__DEBUG, "",
"-- parallel time: thread finished chunks ^C1 -- ^C2",
status );
/* Try setting some status in thread to test merging mechanism */
*status = SMF__INSMP;
errRepf( " ", "Set SMF__INSMP in thread chunks %zu -- %zu", status,
data->chunk1, data->chunk2 );
}
void smurf_sc2threadtest( int *status ) {
/* Local Variables */
smfArray **res=NULL; /* array of smfArrays of test data */
smfData *data=NULL; /* Pointer to SCUBA2 data struct */
dim_t datalen; /* Number of data points */
smfFilter *filt=NULL; /* Frequency domain filter */
size_t i; /* Loop counter */
size_t j; /* Loop counter */
smfTimeChunkData *job_data=NULL; /* Array of pointers for job data */
size_t joblen; /* Number of chunks per job */
size_t k; /* Loop counter */
size_t nchunks; /* Number of chunks */
size_t nsub; /* Number of subarrays */
int nthread; /* Number of threads */
smfTimeChunkData *pdata=NULL; /* Pointer to data for single job */
int temp; /* Temporary integer */
size_t tsteps; /* How many time steps in chunk */
struct timeval tv1, tv2; /* Timers */
ThrWorkForce *wf = NULL; /* Pointer to a pool of worker threads */
double *dat=NULL;
dim_t nbolo;
dim_t ntslice;
dim_t ndata;
size_t bstride;
size_t tstride;
dim_t offset;
if (*status != SAI__OK) return;
/* Get input parameters */
parGdr0i( "NTHREAD", 1, 1, NUM__MAXI, 1, &nthread, status );
parGdr0i( "TSTEPS", 6000, 0, NUM__MAXI, 1, &temp, status );
tsteps = (size_t) temp;
parGdr0i( "NCHUNKS", 1, 1, NUM__MAXI, 1, &temp, status );
nchunks = (size_t) temp;
parGdr0i( "NSUB", 1, 1, 4, 1, &temp, status );
nsub = (size_t) temp;
msgSeti("N",nthread);
msgOut( "", TASK_NAME ": Running test with ^N threads", status );
/*** TIMER ***/
smf_timerinit( &tv1, &tv2, status );
/* Create some fake test data in the form of an array of smfArrays */
msgSeti("T",tsteps);
msgSeti("C",nchunks);
msgSeti("NS",nsub);
msgOut( "", TASK_NAME
": Creating ^NS subarrays of data with ^C chunks * ^T samples",
status );
res = astCalloc( nchunks, sizeof(*res) );
for( k=0; (*status==SAI__OK)&&(k<nchunks); k++ ) {
res[k] = smf_create_smfArray( status );
for( i=0; (*status==SAI__OK)&&(i<nsub); i++ ) {
/* Create individual smfDatas and add to array */
data = smf_create_smfData( SMF__NOCREATE_FILE |
SMF__NOCREATE_DA |
SMF__NOCREATE_FTS, status );
if( *status==SAI__OK ) {
data->dtype=SMF__DOUBLE;
data->ndims=3;
data->dims[0]=40;
data->dims[1]=32;
data->dims[2]=(dim_t) tsteps;
datalen=1;
data->isFFT=-1;
for( j=0; j<data->ndims; j++ ) datalen *= data->dims[j];
data->hdr->steptime = 0.005;
data->pntr[0] = astCalloc( datalen, smf_dtype_sz(data->dtype,status) );
data->qual = astCalloc( datalen, sizeof(*data->qual) );
}
smf_addto_smfArray( res[k], data, status );
}
}
/*** TIMER ***/
msgOutf( "", "** %f seconds generating data", status,
smf_timerupdate(&tv1,&tv2,status) );
msgOut( "", TASK_NAME
": Starting test 1 __parallel time: dataOrder__", status );
/* Create a pool of threads. */
wf = thrGetWorkforce( nthread, status );
/* Work out number of chunks per thread */
joblen = nchunks/nthread;
if( joblen == 0 ) joblen = 1; /* At least one chunk per thread */
/* The first test will process separate time chunks of data in
parallel, re-ordering each to bolo-ordered format. All subarrays
and an integer number of input file chunks all go into a single
thread. Start by allocating and initializing a number of
smfTimeChunkData's that hold the information required for each
thread */
job_data = astCalloc( nthread, sizeof(*job_data) );
for( i=0; (i<(size_t)nthread) && (*status==SAI__OK); i++ ) {
pdata = job_data + i;
pdata->type = 0; /* Start with a data re-order */
pdata->data = res; /* Pointer to main data array */
pdata->chunk1 = i*joblen; /* Index of first chunk for job */
pdata->nchunks = nchunks; /* Total number of time chunks in data */
pdata->ijob = -1; /* Flag job as available to do work */
/* The last thread has to pick up the remainder of chunks */
if( i==(size_t)(nthread-1) ) pdata->chunk2=nchunks-1;
else pdata->chunk2 = (i+1)*joblen-1; /* Index of last chunk for job */
/* Ensure a valid chunk range, or set to a length that we know to ignore */
if( pdata->chunk1 >= nchunks ) {
pdata->chunk1 = nchunks;
pdata->chunk2 = nchunks;
} else if( pdata->chunk2 >= nchunks ) {
pdata->chunk2 = nchunks-1;
}
if( pdata->chunk1 >= nchunks ) {
/* Nothing for this thread to do */
msgSeti( "W", i+1);
msgOutif( MSG__DEBUG, "",
"-- parallel time: skipping thread ^W, nothing to do",
status);
} else {
/* Since we know there is one job_data per thread, just submit jobs
immediately */
pdata->ijob = thrAddJob( wf, THR__REPORT_JOB, pdata, smfParallelTime,
0, NULL, status );
}
}
/* Wait until all of the submitted jobs have completed */
thrWait( wf, status );
/* Annul the bad status that we set in smfParallelTime */
if( *status == SMF__INSMP ) {
errAnnul( status );
msgOut( "", " *** Annulled SMF__INSMP set in smfParallelTime *** ",
status );
} else {
msgOut( "", " *** Flushing good status *** ", status );
errFlush( status );
}
/*** TIMER ***/
msgOutf( "", "** %f seconds to complete test", status,
smf_timerupdate(&tv1,&tv2,status) );
/* The second test will boxcar smooth bolometers from time chunks in
parallel */
msgOut( "", TASK_NAME
": Starting test 2 __parallel time: boxcar smooth__", status );
for( i=0; (i<(size_t)nthread) && (*status==SAI__OK); i++ ) {
pdata = job_data + i;
pdata->type = 1; /* Boxcar smooth */
if( pdata->chunk1 >= nchunks ) {
/* Nothing for this thread to do */
msgSeti( "W", i+1);
msgOutif( MSG__DEBUG, "",
"-- parallel time: skipping thread ^W, nothing to do",
status);
} else {
/* Since we know there is one job_data per thread, just submit jobs
immediately */
pdata->ijob = thrAddJob( wf, THR__REPORT_JOB, pdata, smfParallelTime,
0, NULL, status );
}
}
/* Wait until all of the submitted jobs have completed */
thrWait( wf, status );
/*** TIMER ***/
msgOutf( "", "** %f seconds to complete test", status,
smf_timerupdate(&tv1,&tv2,status) );
msgOut( "", TASK_NAME
": *** Next 2 tests will be done twice due to FFTW planning *****",
status );
for( k=0; k<2; k++ ) {
/* The third test will FFT filter bolometers from time chunks in
parallel */
msgOut( "", TASK_NAME
": Starting test 3 __parallel time: FFT filter__", status );
for( i=0; (i<(size_t)nthread) && (*status==SAI__OK); i++ ) {
pdata = job_data + i;
pdata->type = 2; /* FFT filter */
if( pdata->chunk1 >= nchunks ) {
/* Nothing for this thread to do */
msgSeti( "W", i+1);
msgOutif( MSG__DEBUG, "",
"-- parallel time: skipping thread ^W, nothing to do",
status);
} else {
/* Since we know there is one job_data per thread, just submit jobs
immediately */
pdata->ijob = thrAddJob( wf, THR__REPORT_JOB, pdata, smfParallelTime,
0, NULL, status );
}
}
/* Wait until all of the submitted jobs have completed */
thrWait( wf, status );
/*** TIMER ***/
msgOutf( "", "** %f seconds to complete test", status,
smf_timerupdate(&tv1,&tv2,status) );
msgOut( "", TASK_NAME
": Starting test 4 __FFTW filter using internal threading__",
status );
for( i=0; (*status==SAI__OK)&&(i<nchunks); i++ ) {
filt = smf_create_smfFilter( res[i]->sdata[0], status );
smf_filter_ident( filt, 1, status );
for( j=0; (*status==SAI__OK)&&(j<nsub); j++ ) {
msgOutiff( MSG__DEBUG, "", " filter chunk %zu/%zu, bolo %zu/%zu",
status, i+1, nchunks, j+1, nsub );
smf_filter_execute( wf, res[i]->sdata[j], filt, 0, 0, status );
}
if( filt ) filt = smf_free_smfFilter( filt, status );
}
/*** TIMER ***/
msgOutf( "", "** %f seconds to complete test", status,
smf_timerupdate(&tv1,&tv2,status) );
}
msgOut( "", TASK_NAME
": **************************************************************",
status );
/* Series of short single-thread array index tests */
data = res[0]->sdata[0];
dat = data->pntr[0];
smf_get_dims( data, NULL, NULL, &nbolo, &ntslice, &ndata, &bstride,
&tstride, status );
msgOut("","Array index test #1: two multiplies in inner loop",status);
smf_timerinit( &tv1, &tv2, status );
for( i=0; i<nbolo; i++ ) {
for( j=0; j<ntslice; j++ ) {
dat[i*bstride + j*tstride] += 5;
}
}
msgOutf( "", "** %f seconds to complete test", status,
smf_timerupdate(&tv1,&tv2,status) );
msgOut("","Array index test #2: only index increments",status);
smf_timerinit( &tv1, &tv2, status );
for( i=0; i<nbolo*bstride; i+=bstride ) {
for( j=i; j<(i+ntslice*tstride); j+=tstride ) {
dat[j] += 5;
}
}
msgOutf( "", "** %f seconds to complete test", status,
smf_timerupdate(&tv1,&tv2,status) );
msgOut("","Array index test #3: one multiply in outer loop",status);
smf_timerinit( &tv1, &tv2, status );
offset = 0;
for( i=0; i<nbolo; i++ ) {
offset = i*bstride;
for( j=0; j<ntslice; j++ ) {
dat[offset] += 5;
offset += tstride;
}
}
msgOutf( "", "** %f seconds to complete test", status,
smf_timerupdate(&tv1,&tv2,status) );
/* Clean up */
if( res ) {
for( i=0; i<nchunks; i++ ) {
if( res[i] ) {
smf_close_related( &res[i], status );
}
}
res = astFree( res );
}
job_data = astFree( job_data );
/* Ensure that FFTW doesn't have any used memory kicking around */
fftw_cleanup();
}
void smurf_sc2filtermap( int *status ) {
Grp *fgrp = NULL; /* Output filter group */
smfFilter *filt=NULL; /* Filter */
double filt_edgehigh=0; /* High-pass filter */
double filt_edgelow=0; /* Low-pass filter */
size_t fsize; /* Number of files in fgrp */
size_t i; /* Loop (grp) counter */
smfData *idata; /* Pointer to input smfData */
Grp *igrp = NULL; /* Input group of files */
int isfft=0; /* Are data fft or real space? */
int *mask=NULL; /* Mask indicating where bad data are */
size_t ndata=0; /* Number of pixels in the map */
size_t ndims; /* Number of real space dimensions */
smfData *odata=NULL; /* Pointer to output smfData to be exported */
Grp *ogrp = NULL; /* Output group of files */
size_t outsize; /* Number of files in output group */
size_t size; /* Number of files in input group */
ThrWorkForce *wf = NULL; /* Pointer to a pool of worker threads */
smfData *wrefmap=NULL; /* Whitening reference map */
int whiten; /* Applying whitening filter? */
Grp *wgrp = NULL; /* Whitening reference map group */
size_t wsize; /* Size of wgrp */
int zerobad; /* Zero VAL__BADD before taking FFT? */
/* Main routine */
ndfBegin();
/* Find the number of cores/processors available and create a pool of
threads of the same size. */
wf = thrGetWorkforce( thrGetNThread( SMF__THREADS, status ), status );
/* Get input file(s) */
kpg1Rgndf( "IN", 0, 1, "", &igrp, &size, status );
size = grpGrpsz( igrp, status );
if (size > 0) {
int parstate=0; /* ADAM parameter state */
/* Get output file(s) */
kpg1Wgndf( "OUT", igrp, size, size, "More output files required...",
&ogrp, &outsize, status );
/* Write out the filter? */
parState( "OUTFILTER", &parstate, status );
if( parstate != PAR__GROUND ) {
kpg1Wgndf( "OUTFILTER", igrp, size, size,
"More output filter files required...",
&fgrp, &fsize, status );
}
}
/* Are we going to zero bad values first? */
parGet0l( "ZEROBAD", &zerobad, status );
/* High/low-pass filters? */
parGet0d( "FILT_EDGEHIGH", &filt_edgehigh, status );
parGet0d( "FILT_EDGELOW", &filt_edgelow, status );
/* Are we applying a spatial whitening filter? */
parGet0l( "WHITEN", &whiten, status );
if( whiten ) {
/* We also need the reference map to measure the whitening filter. We
make a deep copy of it so that we can set bad values to 0 etc. */
smfData *tempdata=NULL;
kpg1Rgndf( "whiterefmap", 0, 1, "", &wgrp, &wsize, status );
if( (*status == SAI__OK) && (wsize != 1) ) {
*status = SAI__ERROR;
errRep( "", FUNC_NAME ": WHITEREFMAP must be a single reference map",
status );
}
smf_open_file( wgrp, 1, "READ", SMF__NOTTSERIES, &tempdata, status );
wrefmap = smf_deepcopy_smfData( tempdata, 0, 0, 0, 0, status );
smf_close_file( &tempdata, status );
/* Set VAL__BADD to zero if requested */
if( (*status==SAI__OK) && zerobad ) {
double *d=NULL;
size_t j;
ndata=1;
for( j=0; j<wrefmap->ndims; j++ ) ndata *= wrefmap->dims[j];
d = wrefmap->pntr[0];
if( d ) {
for( j=0; j<ndata; j++ ) {
if( d[j] == VAL__BADD ) {
d[j] = 0;
}
}
}
}
}
for( i=1;(*status==SAI__OK)&&i<=size; i++ ) {
smf_open_file( igrp, i, "READ", SMF__NOTTSERIES, &idata, status );
isfft = smf_isfft( idata, NULL, NULL, NULL, NULL, &ndims, status);
if( (*status==SAI__OK) && isfft ) {
*status = SAI__ERROR;
errRep( "", FUNC_NAME ": Input data are FFT, not real-space!\n",
status );
break;
}
if( (*status==SAI__OK) && (ndims != 2) ) {
*status = SAI__ERROR;
errRep( "", FUNC_NAME ": Input data not a 2D map!\n",
status );
break;
}
/* smf_filter_execute operates in-place, so first create the output
data as a copy of the input */
odata = smf_deepcopy_smfData( idata, 0, 0, 0, 0, status );
/* Set VAL__BADD to zero if requested */
if( (*status==SAI__OK) && zerobad ) {
double *d=NULL;
size_t j, k;
ndata=1;
for( j=0; j<odata->ndims; j++ ) ndata *= odata->dims[j];
mask = astCalloc( ndata, sizeof(*mask) );
/* Do both DATA and VARIANCE */
if( *status == SAI__OK ) {
for( k=0; k<2; k++ ) {
d = odata->pntr[k];
if( d ) {
for( j=0; j<ndata; j++ ) {
if( d[j] == VAL__BADD ) {
d[j] = 0;
mask[j] = 1;
}
}
}
}
}
}
/* Measure and apply the whitening filter. We need to do this
every time because the dimensions of filt need to match idata
(not the wrefmap) and they might be different each time. We
could try to be more clever in the future if this is too slow. */
filt = smf_create_smfFilter( idata, status );
/* Set to the identity in case no whitening is applied */
msgOut( "", TASK_NAME ": initializing filter", status );
smf_filter_ident( filt, 0, status );
if( whiten ) {
msgOut( "", TASK_NAME ": whitening the filter", status );
smf_filter2d_whiten( wf, filt, wrefmap, 0, 0, 3, status );
}
if( filt_edgelow ) {
msgOutf( "", TASK_NAME ": applying low-pass at < %lg 1/arcsec", status,
filt_edgelow );
smf_filter2d_edge( filt, filt_edgelow, 1, status );
}
if( filt_edgehigh ) {
msgOutf( "", TASK_NAME ": applying high-pass at >= %lg 1/arcsec", status,
filt_edgehigh );
smf_filter2d_edge( filt, filt_edgehigh, 0, status );
}
smf_filter_execute( wf, odata, filt, 0, 0, status );
/* Set bad values from the mask */
if( mask ) {
double *d=NULL;
size_t j, k;
/* Do both DATA and VARIANCE */
for( k=0; k<2; k++ ) {
d = odata->pntr[k];
if( d ) {
for( j=0; j<ndata; j++ ) {
if( mask[j] ) {
d[j] = VAL__BADD;
}
}
}
}
}
/* Export the data to a new file */
smf_write_smfData( odata, NULL, NULL, ogrp, i, 0, MSG__NORM, status );
/* Write out filters? */
if( fgrp ) smf_write_smfFilter( filt, NULL, fgrp, i, status );
if( filt ) smf_free_smfFilter( filt, status );
}
/* Tidy up after ourselves */
if( fgrp ) grpDelet( &fgrp, status);
if( igrp ) grpDelet( &igrp, status);
if( ogrp ) grpDelet( &ogrp, status);
if( wgrp ) grpDelet( &wgrp, status );
if( odata ) smf_close_file( &odata, status );
if( wrefmap ) smf_close_file( &wrefmap, status );
if( mask ) mask = astFree( mask );
ndfEnd( status );
/* Ensure that FFTW doesn't have any used memory kicking around */
fftw_cleanup();
}
