void smf_filter_execute( ThrWorkForce *wf, smfData *data, smfFilter *filt,
int complement, int whiten, int *status ) {
/* Local Variables */
size_t apod_length=0; /* apodization length */
fftw_iodim dims; /* I/O dimensions for transformations */
size_t first; /* First sample apodization at start */
int i; /* Loop counter */
smfFilterExecuteData *job_data=NULL;/* Array of job data for each thread */
size_t last; /* Last sample apodization at end */
dim_t nbolo=0; /* Number of bolometers */
dim_t ndata=0; /* Total number of data points */
int nw; /* Number of worker threads */
dim_t ntslice=0; /* Number of time slices */
smf_qual_t *qua=NULL; /* Pointer to quality flags */
smfFilterExecuteData *pdata=NULL; /* Pointer to current job data */
size_t step; /* step size for dividing up work */
/* 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 ) {
smf_filter2d_execute( wf, data, filt, complement, status );
return;
}
/* How many threads do we get to play with */
nw = wf ? wf->nworker : 1;
/* Ensure that the smfData is ordered correctly (bolo ordered) */
smf_dataOrder( wf, data, 0, status );
/* Obtain the dimensions of the array being filtered */
smf_get_dims( data, NULL, NULL, &nbolo, &ntslice, &ndata, NULL, NULL, status);
if( *status != SAI__OK ) return;
/* Using complement of the filter? */
if( complement ) smf_filter_complement( filt, status );
/* Pointers to quality */
qua = smf_select_qualpntr( data, NULL, status );
/* Determine the first and last samples to apodize (after padding), if
any. Assumed to be the same for all bolometers. */
if( qua ) {
smf_get_goodrange( qua, ntslice, 1, SMF__Q_PAD, &first, &last, status );
} else {
first = 0;
last = ntslice - 1;
}
/* Can we apodize? */
apod_length = filt->apod_length;
if( *status == SAI__OK ) {
if( apod_length == SMF__MAXAPLEN ) {
apod_length = (last-first+1)/2;
msgOutiff( MSG__DEBUG, "", FUNC_NAME
": Using maximum apodization length, %zu samples.",
status, apod_length );
} else if( (last-first+1) < (2*apod_length) && apod_length != SMF__BADSZT ){
*status = SAI__ERROR;
errRepf("", FUNC_NAME
": Can't apodize, not enough samples (%zu < %zu).", status,
last-first+1, 2*apod_length);
}
}
/* If apodising is switched off, fill gaps in the data and re-create
the artifical data used for padding based on the current contents of
the smfData. */
if( apod_length == SMF__BADSZT ) {
smf_fillgaps( wf, data, SMF__Q_PAD | SMF__Q_GAP, status );
/* If apodising is switched on, fill the data (retaining the zero padding)
and apodise the data. */
} else {
smf_fillgaps( wf, data, SMF__Q_GAP, status );
if( apod_length > 0 ) smf_apodize( data, apod_length, 1, status );
}
/* Describe the input and output array dimensions for FFTW guru interface.
- dims describes the length and stepsize of time slices within a bolometer
*/
dims.n = ntslice;
dims.is = 1;
dims.os = 1;
/* Set up the job data */
if( nw > (int) nbolo ) {
step = 1;
} else {
step = nbolo/nw;
}
job_data = astCalloc( nw, sizeof(*job_data) );
for( i=0; (*status==SAI__OK)&&i<nw; i++ ) {
pdata = job_data + i;
pdata->b1 = i*step;
pdata->b2 = (i+1)*step-1;
/* Ensure that the last thread picks up any left-over bolometers */
if( (i==(nw-1)) && (pdata->b1<(nbolo-1)) ) {
pdata->b2=nbolo-1;
}
pdata->data = data;
pdata->qua = qua;
pdata->data_fft_r = astMalloc(filt->fdims[0]*sizeof(*pdata->data_fft_r));
pdata->data_fft_i = astMalloc(filt->fdims[0]*sizeof(*pdata->data_fft_i));
pdata->filt = filt;
pdata->whiten = whiten;
pdata->complement = complement;
pdata->ijob = -1; /* Flag job as ready to start */
/* Setup forward FFT plan using guru interface. Requires protection
with a mutex */
thrMutexLock( &smf_filter_execute_mutex, status );
if( *status == SAI__OK ) {
/* Just use the data_fft_* arrays from the first chunk of job data since
the guru interface allows you to use the same plans for multiple
transforms. */
pdata->plan_forward = fftw_plan_guru_split_dft_r2c( 1, &dims, 0, NULL,
data->pntr[0],
pdata->data_fft_r,
pdata->data_fft_i,
FFTW_ESTIMATE |
FFTW_UNALIGNED );
}
thrMutexUnlock( &smf_filter_execute_mutex, status );
if( !pdata->plan_forward && (*status == SAI__OK) ) {
*status = SAI__ERROR;
errRep( "", FUNC_NAME
": FFTW3 could not create plan for forward transformation",
status);
}
/* Setup inverse FFT plan using guru interface */
thrMutexLock( &smf_filter_execute_mutex, status );
if( *status == SAI__OK ) {
pdata->plan_inverse = fftw_plan_guru_split_dft_c2r( 1, &dims, 0, NULL,
pdata->data_fft_r,
pdata->data_fft_i,
data->pntr[0],
FFTW_ESTIMATE |
FFTW_UNALIGNED);
}
thrMutexUnlock( &smf_filter_execute_mutex, status );
if( !pdata->plan_inverse && (*status==SAI__OK) ) {
*status = SAI__ERROR;
errRep( "", FUNC_NAME
": FFTW3 could not create plan for inverse transformation",
status);
}
}
/* Execute the filter */
for( i=0; (*status==SAI__OK)&&i<nw; i++ ) {
pdata = job_data + i;
pdata->ijob = thrAddJob( wf, THR__REPORT_JOB, pdata,
smfFilterExecuteParallel, 0,
NULL, status );
}
/* Wait until all of the submitted jobs have completed */
thrWait( wf, status );
/* Clean up the job data array */
if( job_data ) {
for( i=0; i<nw; i++ ) {
pdata = job_data + i;
if( pdata->data_fft_r ) pdata->data_fft_r = astFree( pdata->data_fft_r );
if( pdata->data_fft_i ) pdata->data_fft_i = astFree( pdata->data_fft_i );
/* Destroy the plans */
thrMutexLock( &smf_filter_execute_mutex, status );
fftw_destroy_plan( pdata->plan_forward );
fftw_destroy_plan( pdata->plan_inverse );
thrMutexUnlock( &smf_filter_execute_mutex, status );
}
job_data = astFree( job_data );
}
/* Return the filter to its original state if required */
if( complement == -1 ) smf_filter_complement( filt, status );
/* Remove the effects of the apodisation from the filtered data. */
if( apod_length != SMF__BADSZT && apod_length > 0 ) {
smf_apodize( data, apod_length, 0, status );
}
}
size_t smf_clean_pca( ThrWorkForce *wf, smfData *data, size_t t_first,
size_t t_last, double thresh, size_t ncomp,
smfData **components, smfData **amplitudes,
int flagbad, int sub, AstKeyMap *keymap,
smf_qual_t mask, int *status ){
double *amp=NULL; /* matrix of components amplitudes for each bolo */
size_t abstride; /* bolo stride in amp array */
size_t acompstride; /* component stride in amp array */
size_t bstride; /* bolo stride */
double *comp=NULL; /* data cube of components */
size_t ccompstride; /* component stride in comp array */
size_t ctstride; /* time stride in comp array */
gsl_matrix *cov=NULL; /* bolo-bolo covariance matrix */
size_t i; /* Loop counter */
int ii; /* Loop counter */
size_t j; /* Loop counter */
smfPCAData *job_data=NULL;/* job data */
size_t k; /* Loop counter */
size_t *goodbolo=NULL; /* Indices of the good bolometers for analysis */
dim_t nbolo; /* number of bolos */
dim_t ndata; /* number of samples in data */
size_t ngoodbolo; /* number good bolos = number principal components */
dim_t ntslice; /* number of time slices */
int nw; /* total available worker threads */
smfPCAData *pdata=NULL; /* Pointer to job data */
smf_qual_t *qua=NULL; /* Pointer to quality array */
gsl_vector *s=NULL; /* singular values for SVD */
size_t bstep; /* Bolo step size for job division */
size_t step; /* step size for job division */
size_t tlen; /* Length of the time-series used for PCA */
size_t tstride; /* time slice stride */
gsl_vector *work=NULL; /* workspace for SVD */
if (*status != SAI__OK) return 0;
/* How many threads do we get to play with */
nw = wf ? wf->nworker : 1;
/* Check for NULL smfData pointer */
if( !data || !data->pntr[0]) {
*status = SAI__ERROR;
errRep( " ", FUNC_NAME
": possible programming error, NULL data supplied", status );
return 0;
}
smf_get_dims( data, NULL, NULL, &nbolo, &ntslice, &ndata, &bstride, &tstride,
status );
if( data->ndims != 3 ) {
*status = SAI__ERROR;
errRep( " ", FUNC_NAME
": possible programming error, smfData should be 3-dimensional",
status );
return 0;
}
if( data->dtype != SMF__DOUBLE ) {
*status = SAI__ERROR;
errRep( " ", FUNC_NAME
": possible programming error, smfData should be double precision",
status );
return 0;
}
if( ntslice <= 2 ) {
*status = SAI__ERROR;
errRep( " ", FUNC_NAME ": fewer than 2 time slices!", status );
goto CLEANUP;
}
/* If the range of time slices has not been specified, us the total
range excluding padding and apodizing. */
qua = smf_select_qualpntr( data, 0, status );
if( !t_last ) {
if( qua ) {
smf_get_goodrange( qua, ntslice, tstride, (SMF__Q_PAD | SMF__Q_APOD),
&t_first, &t_last, status );
} else {
t_last = ntslice-1;
}
}
if( t_last > (ntslice-1) ) {
*status = SAI__ERROR;
errRep( " ", FUNC_NAME ": t_last is set past the last time slice!",
status );
goto CLEANUP;
}
if( (t_last < t_first) || ( (t_last - t_first) < 1 ) ) {
*status = SAI__ERROR;
errRep( " ", FUNC_NAME ": t_last - t_first must be > 1", status );
goto CLEANUP;
}
tlen = t_last - t_first + 1;
if( flagbad && (tlen != ntslice ) ) {
*status = SAI__ERROR;
errRep( " ", FUNC_NAME
": flagbad unsupported if t_first/last do not span full data",
status );
goto CLEANUP;
}
if( qua ) {
/* If quality supplied, identify good bolometers */
ngoodbolo = 0;
for( i=0; i<nbolo; i++ ) {
if( !(qua[i*bstride]&SMF__Q_BADB) ) {
ngoodbolo++;
}
}
/* Now remember which were the good bolometers */
goodbolo = astCalloc( ngoodbolo, sizeof(*goodbolo) );
ngoodbolo = 0;
for( i=0; i<nbolo; i++ ) {
if( !(qua[i*bstride]&SMF__Q_BADB) ) {
goodbolo[ngoodbolo] = i;
ngoodbolo++;
}
}
} else {
/* Otherwise assume all bolometers are good */
ngoodbolo = nbolo;
goodbolo = astCalloc( ngoodbolo, sizeof(*goodbolo) );
for( i=0; i<ngoodbolo; i++ ) {
goodbolo[i] = i;
}
}
if( ngoodbolo <= 2 ) {
*status = SAI__ERROR;
errRep( " ", FUNC_NAME ": fewer than 2 working bolometers!", status );
goto CLEANUP;
}
/* Fill bad values and values flagged via "mask" (except entirely bad
bolometers) with interpolated data values. */
mask &= ~SMF__Q_BADB;
smf_fillgaps( wf, data, mask, status );
/* Allocate arrays */
amp = astCalloc( nbolo*ngoodbolo, sizeof(*amp) );
comp = astCalloc( ngoodbolo*tlen, sizeof(*comp) );
cov = gsl_matrix_alloc( ngoodbolo, ngoodbolo );
s = gsl_vector_alloc( ngoodbolo );
work = gsl_vector_alloc( ngoodbolo );
/* These strides will make comp time-ordered */
ccompstride = 1;
ctstride = ngoodbolo;
/* These strides will also make amp look time-ordered (sort-of: the time
axis is now the component number */
abstride = 1;
acompstride = nbolo;
/* Allocate job data for threads */
job_data = astCalloc( nw, sizeof(*job_data) );
/* Set up the division of labour for threads: independent blocks of time */
if( nw > (int) tlen ) {
step = 1;
} else {
step = tlen/nw;
}
if( nw > (int) ngoodbolo ) {
bstep = 1;
} else {
bstep = ngoodbolo/nw;
}
for( ii=0; (*status==SAI__OK)&&(ii<nw); ii++ ) {
pdata = job_data + ii;
/* Blocks of time slices */
pdata->t1 = ii*step + t_first;
pdata->t2 = (ii+1)*step + t_first - 1;
/* Blocks of bolometers. */
pdata->b1 = ii*bstep;
pdata->b2 = (ii+1)*bstep - 1;
/* Ensure that the last thread picks up any left-over tslices */
if( (ii==(nw-1)) ) {
pdata->t2 = t_first + tlen - 1;
pdata->b2 = ngoodbolo - 1;
}
/* initialize work data */
pdata->amp = NULL;
pdata->abstride = abstride;
pdata->acompstride = acompstride;
pdata->bstride = bstride;
pdata->comp = comp;
pdata->cov = NULL;
pdata->covwork = NULL;
pdata->ccompstride = ccompstride;
pdata->ctstride = ctstride;
pdata->data = data;
pdata->goodbolo = NULL;
pdata->ijob = -1;
pdata->nbolo = nbolo;
pdata->ngoodbolo = ngoodbolo;
pdata->t_first = t_first;
pdata->t_last = t_last;
pdata->tlen = tlen;
pdata->operation = 0;
pdata->tstride = tstride;
/* Each thread will accumulate the projection of its own portion of
the time-series. We'll add them to the master amp at the end */
pdata->amp = astCalloc( nbolo*ngoodbolo, sizeof(*(pdata->amp)) );
/* Each thread will accumulate sums of x, y, and x*y for each bolo when
calculating the covariance matrix */
pdata->covwork = astCalloc( ngoodbolo*ngoodbolo,
sizeof(*(pdata->covwork)) );
/* each thread gets its own copy of the goodbolo lookup table */
pdata->goodbolo = astCalloc( ngoodbolo, sizeof(*(pdata->goodbolo)) );
if( *status == SAI__OK ) {
memcpy( pdata->goodbolo, goodbolo,
ngoodbolo*sizeof(*(pdata->goodbolo)) );
}
}
if( *status == SAI__OK ) {
/* Remove the mean from each gap-filled bolometer time stream ---------------------*/
msgOutif( MSG__VERB, "", FUNC_NAME ": removing bolometer means...",
status );
for( ii=0; ii<nw; ii++ ) {
pdata = job_data + ii;
pdata->operation = -1;
thrAddJob( wf, 0, pdata, smfPCAParallel, 0, NULL, status );
}
/* Wait until all of the submitted jobs have completed */
thrWait( wf, status );
/* Measure the covariance matrix using parallel code ---------------------*/
msgOutif( MSG__VERB, "", FUNC_NAME
": measuring bolo-bolo covariance matrix...", status );
/* Set up the jobs to calculate sums for each time block and submit */
for( ii=0; ii<nw; ii++ ) {
pdata = job_data + ii;
pdata->operation = 0;
pdata->ijob = thrAddJob( wf, THR__REPORT_JOB, pdata, smfPCAParallel,
0, NULL, status );
}
/* Wait until all of the submitted jobs have completed */
thrWait( wf, status );
/* We now have to add together all of the sums from each thread and
normalize */
if( *status == SAI__OK ) {
for( i=0; i<ngoodbolo; i++ ) {
for( j=i; j<ngoodbolo; j++ ) {
double c;
double *covwork=NULL;
double sum_xy;
sum_xy = 0;
for( ii=0; ii<nw; ii++ ) {
pdata = job_data + ii;
covwork = pdata->covwork;
sum_xy += covwork[ i + j*ngoodbolo ];
}
c = sum_xy / ((double)tlen-1);
gsl_matrix_set( cov, i, j, c );
gsl_matrix_set( cov, j, i, c );
}
}
}
}
/* Factor cov = u s v^T, noting that the SVD routine calculates v^T in
in-place of cov. --------------------------------------------------------*/
msgOutif( MSG__VERB, "", FUNC_NAME
": perfoming singular value decomposition...", status );
smf_svd( wf, ngoodbolo, cov->data, s->data, NULL, 10*VAL__EPSD,
1, status );
if( CHECK ) {
double check=0;
for( i=0; i<ngoodbolo; i++ ) {
for( j=0; j<ngoodbolo; j++ ) {
check += gsl_matrix_get( cov, j, i );
}
}
printf("--- check inverted: %lf\n", check);
}
/* Calculate normalized eigenvectors with parallel code --------------------*/
msgOutif( MSG__VERB, "", FUNC_NAME
": calculating statistically-independent components...", status );
/* The above calculation tells us what linear combinations of the original
bolometer time series will give us the statistically independent new
set of basis vectors (components), which we then normalize by their RMS. */
/* Set up the jobs to calculate sums for each time block and submit */
if( *status == SAI__OK ) {
for( ii=0; ii<nw; ii++ ) {
pdata = job_data + ii;
pdata->cov = cov;
pdata->operation = 1;
pdata->ijob = thrAddJob( wf, THR__REPORT_JOB, pdata, smfPCAParallel,
0, NULL, status );
}
}
/* Wait until all of the submitted jobs have completed */
thrWait( wf, status );
/* Then normalize. Some of the components may have zero amplitude and
so cannot be used (i.e. we are trying to use more components than
there is evidence for in the data). So we check for zero sigma. In
fact, we check for silly small sigma, not just zero sigma. Any
component for which the sigma is less than 1E-10 of the log-mean
sigma is excluded. */
{
double *sigmas = astMalloc( ngoodbolo*sizeof( *sigmas ) );
double check = 0;
double s1 = 0.0;
int s2 = 0;
int nlow = 0;
for( i=0; (*status==SAI__OK)&&(i<ngoodbolo); i++ ) {
double sigma;
smf_stats1D( comp + i*ccompstride, ctstride, tlen, NULL, 0,
0, NULL, &sigma, NULL, NULL, status );
/* Apparently we need this to get the normalization right */
sigma *= sqrt((double) tlen);
if( *status == SAI__OK ) {
if( sigma > 0.0 ) {
for( k=0; k<tlen; k++ ) {
comp[i*ccompstride + k*ctstride] /= sigma;
sigmas[ i ] = sigma;
s1 += log10( sigma );
s2++;
}
} else {
for( k=0; k<tlen; k++ ) {
comp[i*ccompstride + k*ctstride] = VAL__BADD;
sigmas[ i ] = VAL__BADD;
}
nlow++;
}
}
}
/* Exclude any components that have a silly small standard deviation
(less that 1E-10 of the logmean of all components). Any with zero
standard deviation will already have been excluded. */
if( s2 > 0 ) {
double logmean = s1/s2;
for( i=0; i<ngoodbolo; i++ ) {
if( sigmas[ i ] != VAL__BADD && sigmas[ i ] < 1E-10*logmean ) {
for( k=0; k<tlen; k++ ) {
comp[i*ccompstride + k*ctstride] = VAL__BADD;
nlow++;
}
}
}
}
msgOutiff( MSG__DEBUG, "", FUNC_NAME ": rejecting %d (out of %zu) components"
" because they are too weak to normalise", status, nlow, ngoodbolo );
for( i=0; i<ngoodbolo*tlen; i++ ) {
if( comp[i] != VAL__BADD ) check += comp[i];
}
sigmas = astFree( sigmas );
//printf("--- check component: %lf\n", check);
}
/* Now project the data along each of these normalized basis vectors
to figure out the amplitudes of the components in each bolometer
time series. ------------------------------------------------------------*/
msgOutif( MSG__VERB, "", FUNC_NAME
": calculating component amplitudes in each bolo...", status );
/* Set up the jobs */
if( *status == SAI__OK ) {
for( ii=0; ii<nw; ii++ ) {
pdata = job_data + ii;
pdata->operation = 2;
pdata->ijob = thrAddJob( wf, THR__REPORT_JOB, pdata, smfPCAParallel,
0, NULL, status );
}
}
/* Wait until all of the submitted jobs have completed */
thrWait( wf, status );
/* Add all of the amp arrays together from the threads */
if( *status == SAI__OK ) {
size_t index;
for( ii=0; ii<nw; ii++ ) {
pdata = job_data + ii;
for( i=0; i<ngoodbolo; i++ ) { /* Loop over good bolo */
for( j=0; j<ngoodbolo; j++ ) { /* Loop over component */
index = goodbolo[i]*abstride + j*acompstride;
amp[index] += pdata->amp[index];
}
}
}
}
if( CHECK ){
double check=0;
for( i=0; i<nbolo*ngoodbolo; i++ ) {
check += amp[i];
}
printf("--- check combined amp: %lf\n", check);
}
if( CHECK ){
double check=0;
for( i=0; i<ngoodbolo*tlen; i++ ) {
if( comp[i] != VAL__BADD ) check += comp[i];
}
printf("--- check component A: %lf\n", check);
}
/* Check to see if the amplitudes are mostly negative or positive. If
mostly negative, flip the sign of both the component and amplitudes */
if( *status == SAI__OK ) {
double total;
for( j=0; j<ngoodbolo; j++ ) { /* loop over component */
total = 0;
for( i=0; i<ngoodbolo; i++ ) { /* loop over bolometer */
total += amp[goodbolo[i]*abstride + j*acompstride];
}
/* Are most amplitudes negative for this component? */
if( total < 0 ) {
/* Flip sign of the amplitude */
for( i=0; i<ngoodbolo; i++ ) { /* loop over bolometer */
amp[goodbolo[i]*abstride + j*acompstride] =
-amp[goodbolo[i]*abstride + j*acompstride];
}
/* Flip sign of the component */
for( k=0; k<tlen; k++ ) {
if( comp[j*ccompstride + k*ctstride] != VAL__BADD ) {
comp[j*ccompstride + k*ctstride] *= -1;
}
}
}
}
}
/* Finally, copy the master amp array back into the workspace for
each thread */
if( *status == SAI__OK ) {
for( ii=0; ii<nw; ii++ ) {
pdata = job_data + ii;
memcpy( pdata->amp, amp, sizeof(*(pdata->amp))*nbolo*ngoodbolo );
}
}
if( CHECK ){
double check=0;
for( i=0; i<ngoodbolo*tlen; i++ ) {
if( comp[i] != VAL__BADD ) check += comp[i];
}
printf("--- check component B: %lf\n", check);
}
/* Flag outlier bolometers if requested ------------------------------------*/
if( (*status==SAI__OK) && flagbad ) {
smfArray *data_array=NULL;
smfArray *gain_array=NULL;
smfGroup *gain_group=NULL;
AstKeyMap *kmap=NULL; /* Local keymap */
AstObject *obj=NULL; /* Used to avoid compiler warnings */
double *template=NULL;
