void smurf_sc2clean( int *status ) {
smfArray *array = NULL; /* Data to be cleaned */
Grp *basegrp=NULL; /* Grp containing first file each chunk */
size_t basesize; /* Number of files in base group */
smfArray *bbms = NULL; /* Bad bolometer masks */
smfArray *concat=NULL; /* Pointer to a smfArray */
size_t contchunk; /* Continuous chunk counter */
smfArray *darks = NULL; /* Dark data */
int ensureflat; /* Flag for flatfielding data */
smfArray *flatramps = NULL;/* Flatfield ramps */
AstKeyMap *heateffmap = NULL; /* Heater efficiency data */
smfData *odata = NULL; /* Pointer to output data struct */
Grp *fgrp = NULL; /* Filtered group, no darks */
size_t gcount=0; /* Grp index counter */
size_t idx; /* Subarray counter */
Grp *igrp = NULL; /* Input group of files */
smfGroup *igroup=NULL; /* smfGroup corresponding to igrp */
dim_t maxconcat=0; /* Longest continuous chunk length in samples */
double maxlen=0; /* Constrain maxconcat to this many seconds */
size_t ncontchunks=0; /* Number continuous chunks outside iter loop */
Grp *ogrp = NULL; /* Output group of files */
size_t osize; /* Total number of NDF names in the output group */
dim_t padStart=0; /* How many samples padding at start */
dim_t padEnd=0; /* How many samples padding at end */
size_t size; /* Number of files in input group */
int temp; /* Temporary signed integer */
int usedarks; /* flag for using darks */
ThrWorkForce *wf = NULL; /* Pointer to a pool of worker threads */
int writecom; /* Write COMmon mode to NDF if calculated? */
int writegai; /* Write GAIns to NDF if calculated? */
/* 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 );
/* Read the input file */
kpg1Rgndf( "IN", 0, 1, "", &igrp, &size, status );
/* Filter out darks */
smf_find_science( wf, igrp, &fgrp, 1, NULL, NULL, 1, 1, SMF__NULL, &darks,
&flatramps, &heateffmap, NULL, status );
/* input group is now the filtered group so we can use that and
free the old input group */
size = grpGrpsz( fgrp, status );
grpDelet( &igrp, status);
igrp = fgrp;
fgrp = NULL;
if (size == 0) {
msgOutif(MSG__NORM, " ","All supplied input frames were filtered,"
" nothing to do", status );
goto CLEANUP;
}
/* --- Parse ADAM parameters ---------------------------------------------- */
/* Maximum length of a continuous chunk */
parGdr0d( "MAXLEN", 0, 0, VAL__MAXD, 1, &maxlen, status );
/* Padding */
parGdr0i( "PADSTART", 0, 0, VAL__MAXI, 1, &temp, status );
padStart = (dim_t) temp;
parGdr0i( "PADEND", 0, 0, VAL__MAXI, 1, &temp, status );
padEnd = (dim_t) temp;
/* Are we using darks? */
parGet0l( "USEDARKS", &usedarks, status );
/* Are we flatfielding? */
parGet0l( "FLAT", &ensureflat, status );
/* Write COM/GAI to NDFs if calculated? */
parGet0l( "COM", &writecom, status );
parGet0l( "GAI", &writegai, status );
/* Get group of bolometer masks and read them into a smfArray */
smf_request_mask( wf, "BBM", &bbms, status );
/* Group the input files by subarray and continuity ----------------------- */
smf_grp_related( igrp, size, 1, 0, maxlen-padStart-padEnd, NULL, NULL,
&maxconcat, NULL, &igroup, &basegrp, NULL, status );
/* Obtain the number of continuous chunks and subarrays */
if( *status == SAI__OK ) {
ncontchunks = igroup->chunk[igroup->ngroups-1]+1;
}
basesize = grpGrpsz( basegrp, status );
/* Get output file(s) */
kpg1Wgndf( "OUT", basegrp, basesize, basesize,
"More output files required...",
&ogrp, &osize, status );
/* Loop over continuous chunks and clean -----------------------------------*/
gcount = 1;
for( contchunk=0;(*status==SAI__OK)&&contchunk<ncontchunks; contchunk++ ) {
AstKeyMap *keymap=NULL;
int dkclean;
AstKeyMap *sub_instruments=NULL;
/* Place cleaning parameters into a keymap and set defaults. Do
this inside the loop in case we are cleaning files with
differing sub-instruments. Note that we use the map-maker
defaults file here (which loads the sc2clean defaults) 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 into sc2clean.
*/
sub_instruments = smf_subinst_keymap( SMF__SUBINST_NONE,
NULL, igrp,
igroup->subgroups[contchunk][0],
status );
keymap = kpg1Config( "CONFIG", "$SMURF_DIR/smurf_makemap.def",
sub_instruments, 1, status );
if( sub_instruments ) sub_instruments = astAnnul( sub_instruments );
/* Now rerun smf_grp_related to figure out how long each downsampled
chunk of data will be. */
if( basegrp ) grpDelet( &basegrp, status );
if( igroup ) smf_close_smfGroup( &igroup, status );
smf_grp_related( igrp, size, 1, 0, maxlen-padStart-padEnd, NULL, keymap,
&maxconcat, NULL, &igroup, &basegrp, NULL, status );
/* Concatenate this continuous chunk */
smf_concat_smfGroup( wf, NULL, igroup, usedarks ? darks:NULL, bbms, flatramps,
heateffmap, contchunk, ensureflat, 1, NULL, 0, NULL,
NULL, NO_FTS, padStart, padEnd, 0, &concat, NULL, status );
if( *status == SAI__OK) {
/* clean the dark squids now since we might need to use them
to clean the bolometer data */
smf_get_cleanpar( keymap, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
&dkclean, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
NULL, NULL, NULL, status );
for( idx=0; dkclean&&(*status==SAI__OK)&&idx<concat->ndat; idx++ ) {
odata = concat->sdata[idx];
if( odata && odata->da && odata->da->dksquid ) {
smfData *dksquid = odata->da->dksquid;
AstKeyMap *kmap=NULL;
msgOut("", TASK_NAME ": cleaning dark squids", status);
/* fudge the header so that we can get at JCMTState */
dksquid->hdr = odata->hdr;
/* clean darks using cleandk.* parameters */
astMapGet0A( keymap, "CLEANDK", &kmap );
array = smf_create_smfArray( status );
smf_addto_smfArray( array, dksquid, status );
smf_clean_smfArray( wf, array, NULL, NULL, NULL, kmap, status );
if( array ) {
array->owndata = 0;
smf_close_related( wf, &array, status );
}
if( kmap ) kmap = astAnnul( kmap );
/* Unset hdr pointer so that we don't accidentally close it */
dksquid->hdr = NULL;
}
}
/* Then the main data arrays */
if( *status == SAI__OK ) {
smfArray *com = NULL;
smfArray *gai = NULL;
char filename[GRP__SZNAM+1];
msgOut("", TASK_NAME ": cleaning bolometer data", status );
smf_clean_smfArray( wf, concat, NULL, &com, &gai, keymap, status );
/* If ADAM parameters for COM or GAI were specified, and the
common-mode was calculated, export to files here */
if( writecom && com ) {
for( idx=0; (*status==SAI__OK)&&(idx<com->ndat); idx++ ) {
smf_model_createHdr( com->sdata[idx], SMF__COM, concat->sdata[idx],
status );
smf_stripsuffix( com->sdata[idx]->file->name,
SMF__DIMM_SUFFIX, filename, status );
smf_dataOrder( wf, com->sdata[idx], 1, status );
smf_write_smfData( wf, com->sdata[idx], NULL, filename, NULL, 0,
NDF__NOID, MSG__NORM, 0, NULL, NULL, status );
}
}
if( writegai && gai ) {
for( idx=0; (*status==SAI__OK)&&(idx<gai->ndat); idx++ ) {
smf_model_createHdr( gai->sdata[idx], SMF__GAI, concat->sdata[idx],
status );
smf_stripsuffix( gai->sdata[idx]->file->name,
SMF__DIMM_SUFFIX, filename, status );
smf_dataOrder( wf, gai->sdata[idx], 1, status );
smf_write_smfData( wf, gai->sdata[idx], NULL, filename, NULL, 0,
NDF__NOID, MSG__NORM, 0, NULL, NULL, status );
}
}
/* Close com and gai */
if( com ) smf_close_related( wf, &com, status );
if( gai ) smf_close_related( wf, &gai, status );
}
/* Report statistics (currently need a smfArray for that) */
if (*status == SAI__OK) {
size_t last_qcount[SMF__NQBITS];
size_t last_nmap = 0;
smf_qualstats_report( wf, MSG__VERB, SMF__QFAM_TSERIES, 1, concat,
last_qcount, &last_nmap, 1, NULL, NULL, status );
}
/* Clean up for contchunk loop */
if( keymap ) keymap = astAnnul( keymap );
}
/* Export concatenated/cleaned data for each subarray to NDF file */
for( idx=0; (*status==SAI__OK)&&idx<concat->ndat; idx++ ) {
odata = concat->sdata[idx];
/* Complete the history information in the output NDF so that it
includes group parameters accessed since the default history
information was written to the NDF (in smf_open_and_flatfield). */
smf_puthistory( odata, "SMURF:SC2CLEAN", status );
/* Ensure ICD data order */
smf_dataOrder( wf, odata, 1, status );
if( odata->file && odata->file->name ) {
smf_write_smfData( wf, odata, NULL, NULL, ogrp, gcount, NDF__NOID,
MSG__VERB, 0, NULL, NULL, status );
} else {
*status = SAI__ERROR;
errRep( FUNC_NAME,
"Unable to determine file name for concatenated data.",
status );
}
/* Increment the group index counter */
gcount++;
}
/* Close the smfArray */
smf_close_related( wf, &concat, status );
}
/* Write out the list of output NDF names, annulling the error if a null
parameter value is supplied. */
if( *status == SAI__OK && ogrp ) {
grpList( "OUTFILES", 0, 0, NULL, ogrp, status );
if( *status == PAR__NULL ) errAnnul( status );
}
CLEANUP:
/* Tidy up after ourselves: release the resources used by the grp routines */
if( darks ) smf_close_related( wf, &darks, status );
if( flatramps ) smf_close_related( wf, &flatramps, status );
if (heateffmap) heateffmap = smf_free_effmap( heateffmap, status );
if( bbms ) smf_close_related( wf, &bbms, status );
if( igrp ) grpDelet( &igrp, status);
if( ogrp ) grpDelet( &ogrp, status);
if( basegrp ) grpDelet( &basegrp, status );
if( igroup ) smf_close_smfGroup( &igroup, status );
fftw_cleanup();
ndfEnd( status );
}
void smurf_sc2fft( int *status ) {
int avpspec=0; /* Flag for doing average power spectrum */
double avpspecthresh=0; /* Threshold noise for detectors in avpspec */
Grp * basegrp = NULL; /* Basis group for output filenames */
smfArray *bbms = NULL; /* Bad bolometer masks */
smfArray *concat=NULL; /* Pointer to a smfArray */
size_t contchunk; /* Continuous chunk counter */
smfArray *darks = NULL; /* dark frames */
int ensureflat; /* Flag for flatfielding data */
Grp *fgrp = NULL; /* Filtered group, no darks */
smfArray *flatramps = NULL;/* Flatfield ramps */
AstKeyMap *heateffmap = NULL; /* Heater efficiency data */
size_t gcount=0; /* Grp index counter */
size_t i; /* Loop counter */
smfGroup *igroup=NULL; /* smfGroup corresponding to igrp */
Grp *igrp = NULL; /* Input group of files */
int inverse=0; /* If set perform inverse transform */
int isfft=0; /* Are data fft or real space? */
dim_t maxconcat=0; /* Longest continuous chunk length in samples */
size_t ncontchunks=0; /* Number continuous chunks outside iter loop */
smfData *odata=NULL; /* Pointer to output smfData to be exported */
Grp *ogrp = NULL; /* Output group of files */
size_t outsize; /* Total number of NDF names in the output group */
int polar=0; /* Flag for FFT in polar coordinates */
int power=0; /* Flag for squaring amplitude coeffs */
size_t size; /* Number of files in input group */
smfData *tempdata=NULL; /* Temporary smfData pointer */
int weightavpspec=0; /* Flag for 1/noise^2 weighting */
ThrWorkForce *wf = NULL; /* Pointer to a pool of worker threads */
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 );
/* Filter out darks */
smf_find_science( igrp, &fgrp, 1, NULL, NULL, 1, 1, SMF__NULL, &darks,
&flatramps, &heateffmap, NULL, status );
/* input group is now the filtered group so we can use that and
free the old input group */
size = grpGrpsz( fgrp, status );
grpDelet( &igrp, status);
igrp = fgrp;
fgrp = NULL;
/* We now need to combine files from the same subarray and same sequence
to form a continuous time series */
smf_grp_related( igrp, size, 1, 0, 0, NULL, NULL, &maxconcat, NULL, &igroup,
&basegrp, NULL, status );
/* Get output file(s) */
size = grpGrpsz( basegrp, status );
if( size > 0 ) {
kpg1Wgndf( "OUT", basegrp, size, size, "More output files required...",
&ogrp, &outsize, status );
} else {
msgOutif(MSG__NORM, " ", TASK_NAME ": All supplied input frames were DARK,"
" nothing to do", status );
}
/* Get group of bolometer masks and read them into a smfArray */
smf_request_mask( "BBM", &bbms, status );
/* Obtain the number of continuous chunks and subarrays */
if( *status == SAI__OK ) {
ncontchunks = igroup->chunk[igroup->ngroups-1]+1;
}
msgOutiff( MSG__NORM, "", "Found %zu continuous chunk%s", status, ncontchunks,
(ncontchunks > 1 ? "s" : "") );
/* Are we flatfielding? */
parGet0l( "FLAT", &ensureflat, status );
/* Are we doing an inverse transform? */
parGet0l( "INVERSE", &inverse, status );
/* Are we using polar coordinates instead of cartesian for the FFT? */
parGet0l( "POLAR", &polar, status );
/* Are we going to assume amplitudes are squared? */
parGet0l( "POWER", &power, status );
/* Are we going to zero bad values first? */
parGet0l( "ZEROBAD", &zerobad, status );
/* Are we calculating the average power spectrum? */
parGet0l( "AVPSPEC", &avpspec, status );
if( avpspec ) {
power = 1;
parGet0d( "AVPSPECTHRESH", &avpspecthresh, status );
parGet0l( "WEIGHTAVPSPEC", &weightavpspec, status );
}
/* If power is true, we must be in polar form */
if( power && !polar) {
msgOutif( MSG__NORM, " ", TASK_NAME
": power spectrum requested so setting POLAR=TRUE", status );
polar = 1;
}
gcount = 1;
for( contchunk=0;(*status==SAI__OK)&&contchunk<ncontchunks; contchunk++ ) {
size_t idx;
/* Concatenate this continuous chunk but forcing a raw data read.
We will need quality. */
smf_concat_smfGroup( wf, NULL, igroup, darks, NULL, flatramps, heateffmap,
contchunk, ensureflat, 1, NULL, 0, NULL, NULL, 0, 0, 0,
&concat, NULL, status );
/* Now loop over each subarray */
/* Export concatenated data for each subarray to NDF file */
for( idx=0; (*status==SAI__OK)&&idx<concat->ndat; idx++ ) {
if( concat->sdata[idx] ) {
smfData * idata = concat->sdata[idx];
int provid = NDF__NOID;
dim_t nbolo; /* Number of detectors */
dim_t ndata; /* Number of data points */
/* Apply a mask to the quality array and data array */
smf_apply_mask( idata, bbms, SMF__BBM_QUAL|SMF__BBM_DATA, 0, status );
smf_get_dims( idata, NULL, NULL, &nbolo, NULL, &ndata, NULL, NULL,
status );
/* Check for double precision data */
if( idata->dtype != SMF__DOUBLE ) {
*status = SAI__ERROR;
errRep( "", FUNC_NAME ": data are not double precision.", status );
}
/* Are we zeroing VAL__BADD? */
if( (*status==SAI__OK) && zerobad ) {
double *data= (double *) idata->pntr[0];
for( i=0; i<ndata; i++ ) {
if( data[i] == VAL__BADD ) {
data[i] = 0;
}
}
}
/* Check whether we need to transform the data at all */
isfft = smf_isfft(idata,NULL,NULL,NULL,NULL,NULL,status);
if( isfft && avpspec && (*status == SAI__OK) ) {
*status = SAI__ERROR;
errRep( "", FUNC_NAME
": to calculate average power spectrum input data cannot "
"be FFT", status );
}
if( (*status == SAI__OK) && (isfft == inverse) ) {
if( avpspec ) {
/* If calculating average power spectrum do the transforms with
smf_bolonoise so that we can also measure the noise of
each detector */
double *whitenoise=NULL;
smf_qual_t *bolomask=NULL;
double mean, sig, freqlo;
size_t ngood, newgood;
whitenoise = astCalloc( nbolo, sizeof(*whitenoise) );
bolomask = astCalloc( nbolo, sizeof(*bolomask) );
freqlo = 1. / (idata->hdr->steptime * idata->hdr->nframes);
smf_bolonoise( wf, idata, 1, freqlo, SMF__F_WHITELO,
SMF__F_WHITEHI, 1, 0, whitenoise, NULL, &odata,
status );
/* Initialize quality */
for( i=0; i<nbolo; i++ ) {
if( whitenoise[i] == VAL__BADD ) {
bolomask[i] = SMF__Q_BADB;
} else {
/* smf_bolonoise returns a variance, so take sqrt */
whitenoise[i] = sqrt(whitenoise[i]);
}
}
ngood=-1;
newgood=0;
/* Iteratively cut n-sigma noisy outlier detectors */
while( ngood != newgood ) {
ngood = newgood;
smf_stats1D( whitenoise, 1, nbolo, bolomask, 1, SMF__Q_BADB,
&mean, &sig, NULL, NULL, status );
msgOutiff( MSG__DEBUG, "", TASK_NAME
": mean=%lf sig=%lf ngood=%li\n", status,
mean, sig, ngood);
newgood=0;
for( i=0; i<nbolo; i++ ) {
if( whitenoise[i] != VAL__BADD ){
if( (whitenoise[i] - mean) > avpspecthresh *sig ) {
whitenoise[i] = VAL__BADD;
bolomask[i] = SMF__Q_BADB;
} else {
newgood++;
}
}
}
}
msgOutf( "", TASK_NAME
": Calculating average power spectrum of best %li "
" bolometers.", status, newgood);
/* If using 1/noise^2 weights, calculate 1/whitenoise^2 in-place
to avoid allocating another array */
if( weightavpspec ) {
msgOutif( MSG__VERB, "", TASK_NAME ": using 1/noise^2 weights",
status );
for( i=0; i<nbolo; i++ ) {
if( whitenoise[i] && (whitenoise[i] != VAL__BADD) ) {
whitenoise[i] = 1/(whitenoise[i]*whitenoise[i]);
}
}
}
/* Calculate the average power spectrum of good detectors */
tempdata = smf_fft_avpspec( odata, bolomask, 1, SMF__Q_BADB,
weightavpspec ? whitenoise : NULL,
status );
smf_close_file( &odata, status );
whitenoise = astFree( whitenoise );
bolomask = astFree( bolomask );
odata = tempdata;
tempdata = NULL;
/* Store the number of good bolometers */
parPut0i( "NGOOD", newgood, status );
} else {
/* Otherwise do forward/inverse transforms here as needed */
/* If inverse transform convert to cartesian representation first */
if( inverse && polar ) {
smf_fft_cart2pol( wf, idata, 1, power, status );
}
/* Tranform the data */
odata = smf_fft_data( wf, idata, NULL, inverse, 0, status );
smf_convert_bad( wf, odata, status );
if( inverse ) {
/* If output is time-domain, ensure that it is ICD bolo-ordered */
smf_dataOrder( odata, 1, status );
} else if( polar ) {
/* Store FFT of data in polar form */
smf_fft_cart2pol( wf, odata, 0, power, status );
}
}
/* open a reference input file for provenance propagation */
ndgNdfas( basegrp, gcount, "READ", &provid, status );
/* Export the data to a new file */
smf_write_smfData( odata, NULL, NULL, ogrp, gcount, provid,
MSG__VERB, 0, status );
/* Free resources */
ndfAnnul( &provid, status );
smf_close_file( &odata, status );
} else {
msgOutif( MSG__NORM, " ",
"Data are already transformed. No output will be produced",
status );
}
}
/* Update index into group */
gcount++;
}
/* Close the smfArray */
smf_close_related( &concat, status );
}
/* Write out the list of output NDF names, annulling the error if a null
parameter value is supplied. */
if( *status == SAI__OK ) {
grpList( "OUTFILES", 0, 0, NULL, ogrp, status );
if( *status == PAR__NULL ) errAnnul( status );
}
/* Tidy up after ourselves: release the resources used by the grp routines */
grpDelet( &igrp, status);
grpDelet( &ogrp, status);
if (basegrp) grpDelet( &basegrp, status );
if( igroup ) smf_close_smfGroup( &igroup, status );
if( flatramps ) smf_close_related( &flatramps, status );
if (heateffmap) heateffmap = smf_free_effmap( heateffmap, status );
if (bbms) smf_close_related( &bbms, status );
ndfEnd( status );
/* Ensure that FFTW doesn't have any used memory kicking around */
fftw_cleanup();
}
int smf_dataOrder( ThrWorkForce *wf, smfData *data, int isTordered,
int *status ) {
/* Local Variables */
size_t bstr1; /* bolometer index stride input */
size_t bstr2; /* bolometer index stride output */
dim_t i; /* loop counter */
int inPlace=0; /* If set change array in-place */
dim_t nbolo; /* Number of bolometers */
dim_t ndata; /* Number of data points */
dim_t newdims[3]; /* Size of each dimension new buffer */
int newlbnd[3]; /* New pixel origin */
dim_t ntslice; /* Number of time slices */
size_t tstr1; /* time index stride input */
size_t tstr2; /* time index stride output */
int waschanged = 0; /* did we chagne the order? */
int writable; /* Is the NDF writable? */
int freeold; /* Free the old array if change is not in place? */
/* Main routine */
if (*status != SAI__OK) return waschanged;
/* Check for valid isTordered */
if( (isTordered != 0) && (isTordered != 1) ) {
*status = SAI__ERROR;
msgSeti("ISTORDERED",isTordered);
errRep( "", FUNC_NAME ": Invalid isTordered (0/1): ^ISTORDERED", status);
return waschanged;
}
/* Check for a valid data */
if( !data ) {
*status = SAI__ERROR;
errRep( "", FUNC_NAME ": NULL data supplied", status);
return waschanged;
}
/* If value of isTordered matches current value in smfData return */
if( data->isTordered == isTordered ) return waschanged;
/* Make sure we're looking at 3-dimensions of bolo data */
if( data->ndims != 3 ) {
*status = SMF__WDIM;
msgSeti("NDIMS",data->ndims);
errRep( "", FUNC_NAME
": Don't know how to handle ^NDIMS dimensions, should be 3.",
status);
return waschanged;
}
/* We shouldn't be trying to change the order of FFT'd data */
if( smf_isfft( data, NULL, NULL, NULL, NULL, NULL, status ) ) {
*status = SAI__ERROR;
errRep( "", FUNC_NAME
": Possible programming error, attempting to re-order FFT of a "
"2D map!", status );
return waschanged;
}
/* we are going to change */
waschanged = 1;
/* inPlace=1 if smfData was mapped! Free the old array if it was not
stored in a file. */
freeold = 1;
if( data->file ){
if (data->file->fd ){
inPlace = 1;
freeold = 0;
/* Only change NDF values in-place if write access is abvaialble for
the NDF. */
} else if( data->file->ndfid ) {
freeold = 0;
ndfIsacc( data->file->ndfid, "WRITE", &writable, status );
if( writable ) inPlace = 1;
}
}
/* Calculate input data dimensions (before changing order) */
smf_get_dims( data, NULL, NULL, &nbolo, &ntslice, &ndata, &bstr1, &tstr1,
status);
/* What will the dimensions/strides be in the newly-ordered array? */
if( isTordered ) {
newdims[0] = (data->dims)[1];
newdims[1] = (data->dims)[2];
newdims[2] = (data->dims)[0];
newlbnd[0] = (data->lbnd)[1];
newlbnd[1] = (data->lbnd)[2];
newlbnd[2] = (data->lbnd)[0];
bstr2 = 1;
tstr2 = nbolo;
} else {
newdims[0] = (data->dims)[2];
newdims[1] = (data->dims)[0];
newdims[2] = (data->dims)[1];
newlbnd[0] = (data->lbnd)[2];
newlbnd[1] = (data->lbnd)[0];
newlbnd[2] = (data->lbnd)[1];
bstr2 = ntslice;
tstr2 = 1;
}
/* Loop over elements of data->ptr and re-form arrays */
for( i=0; i<2; i++ ) {
data->pntr[i] = smf_dataOrder_array( wf, data->pntr[i], data->dtype,
data->dtype, ndata,
ntslice, nbolo, tstr1, bstr1, tstr2,
bstr2, inPlace, freeold, status );
}
/* And Quality */
data->qual = smf_dataOrder_array( wf, data->qual, SMF__QUALTYPE, SMF__QUALTYPE,
ndata, ntslice, nbolo, tstr1, bstr1, tstr2,
bstr2, inPlace, freeold, status );
/* If NDF associated with data, modify dimensions of the data */
if( data->file && (data->file->ndfid != NDF__NOID) ) {
msgOutif(MSG__DEBUG, " ", FUNC_NAME
": Warning - current implementation does not modify NDF "
"dimensions to match re-ordered data array", status);
}
/* If there is a LUT re-order it here */
data->lut = smf_dataOrder_array( wf, data->lut, SMF__INTEGER, SMF__INTEGER, ndata,
ntslice, nbolo, tstr1, bstr1, tstr2, bstr2,
inPlace, 1, status );
/* Set the new dimensions in the smfData */
if( *status == SAI__OK ) {
memcpy( data->dims, newdims, 3*sizeof(*newdims) );
memcpy( data->lbnd, newlbnd, 3*sizeof(*newlbnd) );
data->isTordered = isTordered;
}
/* Force any external quality to same ordering */
if (data->sidequal) {
int qchanged = 0;
qchanged = smf_dataOrder( wf, data->sidequal, isTordered, status );
/* and indicate if we changed anything (but not if we did not) */
if (qchanged) waschanged = qchanged;
}
/* Re-order the axes in the time-series WCS FrameSet */
if( data->hdr && data->hdr->tswcs ) {
smf_tswcsOrder( &(data->hdr->tswcs), isTordered, status );
}
/* If the re-ordering was not done in-place, then the new buffer must
have been allocated here. Set a flag so that smf_close_file knows to
deallocate the memory. */
if( ! inPlace ) data->isdyn = 1;
return waschanged;
}
void smf_calc_mapcoord( ThrWorkForce *wf, AstKeyMap *config, smfData *data,
AstFrameSet *outfset, int moving, int *lbnd_out,
int *ubnd_out, fts2Port fts_port, int flags,
int *status ) {
/* Local Variables */
AstSkyFrame *abskyfrm = NULL;/* Output SkyFrame (always absolute) */
AstMapping *bolo2map=NULL; /* Combined mapping bolo->map coordinates */
int bndndf=NDF__NOID; /* NDF identifier for map bounds */
void *data_pntr[1]; /* Array of pointers to mapped arrays in ndf */
int *data_index; /* Mapped DATA_ARRAY part of NDF */
int docalc=1; /* If set calculate the LUT */
int doextension=0; /* Try to write LUT to MAPCOORD extension */
smfFile *file=NULL; /* smfFile pointer */
AstObject *fstemp = NULL; /* AstObject version of outfset */
int ii; /* loop counter */
int indf_lat = NDF__NOID; /* Identifier for NDF to receive lat values */
int indf_lon = NDF__NOID; /* Identifier for NDF to receive lon values */
smfCalcMapcoordData *job_data=NULL; /* Array of job */
int lbnd[1]; /* Pixel bounds for 1d pointing array */
int lbnd_old[2]; /* Pixel bounds for existing LUT */
int lbnd_temp[1]; /* Bounds for bounds NDF component */
int lutndf=NDF__NOID; /* NDF identifier for coordinates */
AstMapping *map2sky_old=NULL;/* Existing mapping map->celestial coord. */
HDSLoc *mapcoordloc=NULL; /* HDS locator to the MAPCOORD extension */
int nw; /* Number of worker threads */
AstFrameSet *oldfset=NULL; /* Pointer to existing WCS info */
AstSkyFrame *oskyfrm = NULL; /* SkyFrame from the output WCS Frameset */
smfCalcMapcoordData *pdata=NULL; /* Pointer to job data */
double *lat_ptr = NULL; /* Pointer to array to receive lat values */
double *lon_ptr = NULL; /* Pointer to array to receive lon values */
int ubnd[1]; /* Pixel bounds for 1d pointing array */
int ubnd_old[2]; /* Pixel bounds for existing LUT */
int ubnd_temp[1]; /* Bounds for bounds NDF component */
int *lut = NULL; /* The lookup table */
dim_t nbolo=0; /* Number of bolometers */
dim_t ntslice=0; /* Number of time slices */
int nmap; /* Number of mapped elements */
AstMapping *sky2map=NULL; /* Mapping celestial->map coordinates */
size_t step; /* step size for dividing up work */
AstCmpMap *testcmpmap=NULL; /* Combined forward/inverse mapping */
AstMapping *testsimpmap=NULL;/* Simplified testcmpmap */
double *theta = NULL; /* Scan direction at each time slice */
int tstep; /* Time slices between full Mapping calculations */
int exportlonlat; /* Dump longitude and latitude values? */
/* Main routine */
if (*status != SAI__OK) return;
/* How many threads do we get to play with */
nw = wf ? wf->nworker : 1;
/* Initialize bounds to avoid compiler warnings */
lbnd_old[0] = 0;
lbnd_old[1] = 0;
ubnd_old[0] = 0;
ubnd_old[1] = 0;
/* Check for pre-existing LUT and de-allocate it. This will only waste
time if the MAPCOORD extension is found to be valid and it has
to be re-loaded from disk. */
smf_close_mapcoord( data, status );
/* Assert ICD data order */
smf_dataOrder( data, 1, status );
/* Get the data dimensions */
smf_get_dims( data, NULL, NULL, &nbolo, &ntslice, NULL, NULL, NULL, status );
/* If SMF__NOCREATE_FILE is not set, and file associated with an NDF,
map a new MAPCOORD extension (or verify an existing one) */
if( !(flags & SMF__NOCREATE_FILE) && data->file ) {
doextension = 1;
} else {
doextension = 0;
docalc = 1;
}
/* Create / check for existing MAPCOORD extension */
if( doextension ) {
file = data->file;
/* Check type of file before proceeding */
if( file->isSc2store ) {
*status = SAI__ERROR;
errRep(FUNC_NAME,
"File was opened by sc2store library (raw data?)",
status);
}
if( !file->isTstream ) {
*status = SAI__ERROR;
errRep(FUNC_NAME, "File does not contain time stream data",status);
}
/* Get HDS locator to the MAPCOORD extension */
mapcoordloc = smf_get_xloc( data, "MAPCOORD", "MAP_PROJECTION", "UPDATE",
0, 0, status );
/* Obtain NDF identifier/placeholder for LUT in MAPCOORD extension*/
lbnd[0] = 0;
ubnd[0] = nbolo*ntslice-1;
lutndf = smf_get_ndfid( mapcoordloc, "LUT", "UPDATE", "UNKNOWN",
"_INTEGER", 1, lbnd, ubnd, status );
if( *status == SAI__OK ) {
/* store the NDF identifier */
file->mapcoordid = lutndf;
/* Create sky to output grid mapping using the base coordinates to
get the coordinates of the tangent point if it hasn't been done
yet. */
sky2map = astGetMapping( outfset, AST__CURRENT, AST__BASE );
}
/* Before mapping the LUT, first check for existing WCS information
and LBND/UBND for the output map. If they are already correct don't
bother re-calculating the LUT! */
if( *status == SAI__OK ) {
/* Try reading in the WCS information */
kpg1Wread( mapcoordloc, "WCS", &fstemp, status );
oldfset = (AstFrameSet*)fstemp;
if( *status == SAI__OK ) {
/* Check that the old and new mappings are the same by
checking that combining one with the inverse of the other
reduces to a UnitMap. */
map2sky_old = astGetMapping( oldfset, AST__BASE, AST__CURRENT );
testcmpmap = astCmpMap( map2sky_old, sky2map, 1, " " );
testsimpmap = astSimplify( testcmpmap );
if( astIsAUnitMap( testsimpmap ) ) {
/* The mappings are the same, now just check the pixel
bounds in the output map */
lbnd_temp[0] = 1;
ubnd_temp[0] = 2;
bndndf = smf_get_ndfid( mapcoordloc, "LBND", "READ", "UNKNOWN",
"_INTEGER", 1, lbnd_temp, ubnd_temp,
status );
if( *status == SAI__OK ) {
ndfMap( bndndf, "DATA", "_INTEGER", "READ", data_pntr, &nmap,
status );
data_index = data_pntr[0];
if( *status == SAI__OK ) {
lbnd_old[0] = data_index[0];
lbnd_old[1] = data_index[1];
}
ndfAnnul( &bndndf, status );
}
bndndf = smf_get_ndfid( mapcoordloc, "UBND", "READ", "UNKNOWN",
"_INTEGER", 1, lbnd_temp, ubnd_temp,
status );
if( *status == SAI__OK ) {
ndfMap( bndndf, "DATA", "_INTEGER", "READ", data_pntr, &nmap,
status );
data_index = data_pntr[0];
if( *status == SAI__OK ) {
ubnd_old[0] = data_index[0];
ubnd_old[1] = data_index[1];
}
ndfAnnul( &bndndf, status );
}
if( *status == SAI__OK ) {
/* If we get this far finally do the bounds check! */
if( (lbnd_old[0] == lbnd_out[0]) &&
(lbnd_old[1] == lbnd_out[1]) &&
(ubnd_old[0] == ubnd_out[0]) &&
(ubnd_old[1] == ubnd_out[1]) ) {
docalc = 0; /* We don't have to re-calculate the LUT */
msgOutif(MSG__VERB," ",FUNC_NAME ": Existing LUT OK",
status);
}
}
}
/* Bad status / AST errors at this point due to problems with
MAPCOORD. Annul and continue calculating new MAPCOORD extension. */
astClearStatus;
errAnnul(status);
} else {
/* Bad status due to non-existence of MAPCOORD. Annul and continue */
errAnnul(status);
}
}
}
/* If we need to calculate the LUT do it here */
if( docalc && (*status == SAI__OK) ) {
msgOutif(MSG__VERB," ", FUNC_NAME ": Calculate new LUT",
status);
/* Get the increment in time slices between full Mapping calculations.
The Mapping for intermediate time slices will be approximated. */
dim_t dimval;
smf_get_nsamp( config, "TSTEP", data, &dimval, status );
tstep = dimval;
/* Get space for the LUT */
if( doextension ) {
/* Map the LUT array */
ndfMap( lutndf, "DATA", "_INTEGER", "WRITE", data_pntr, &nmap,
status );
data_index = data_pntr[0];
if( *status == SAI__OK ) {
lut = data_index;
} else {
errRep( FUNC_NAME, "Unable to map LUT in MAPCOORD extension",
status);
}
} else {
/* alloc the LUT and THETA arrays */
lut = astMalloc( (nbolo*ntslice)*sizeof(*(data->lut)) );
theta = astMalloc( ntslice*sizeof(*(data->theta)) );
}
/* Retrieve the sky2map mapping from the output frameset (actually
map2sky) */
oskyfrm = astGetFrame( outfset, AST__CURRENT );
sky2map = astGetMapping( outfset, AST__BASE, AST__CURRENT );
/* If the longitude and latitude is being dumped, create new NDFs to
hold them, and map them. */
if( config ) {
astMapGet0I( config, "EXPORTLONLAT", &exportlonlat );
if( exportlonlat ) {
lon_ptr = smf1_calc_mapcoord1( data, nbolo, ntslice, oskyfrm,
&indf_lon, 1, status );
lat_ptr = smf1_calc_mapcoord1( data, nbolo, ntslice, oskyfrm,
&indf_lat, 2, status );
}
}
/* Invert the mapping to get Output SKY to output map coordinates */
astInvert( sky2map );
/* Create a SkyFrame in absolute coordinates */
abskyfrm = astCopy( oskyfrm );
astClear( abskyfrm, "SkyRefIs" );
astClear( abskyfrm, "SkyRef(1)" );
astClear( abskyfrm, "SkyRef(2)" );
if( *status == SAI__OK ) {
/* --- Begin parellelized portion ------------------------------------ */
/* Start a new job context. Each call to thrWait within this
context will wait until all jobs created within the context have
completed. Jobs created in higher contexts are ignored by thrWait. */
thrBeginJobContext( wf, status );
/* Allocate job data for threads */
job_data = astCalloc( nw, sizeof(*job_data) );
if( *status == SAI__OK ) {
/* Set up job data, and start calculating pointing for blocks of
time slices in different threads */
if( nw > (int) ntslice ) {
step = 1;
} else {
step = ntslice/nw;
}
for( ii=0; (*status==SAI__OK)&&(ii<nw); ii++ ) {
pdata = job_data + ii;
/* Blocks of time slices */
pdata->t1 = ii*step;
pdata->t2 = (ii+1)*step-1;
/* Ensure that the last thread picks up any left-over tslices */
if( (ii==(nw-1)) && (pdata->t1<(ntslice-1)) ) {
pdata->t2=ntslice-1;
}
pdata->ijob = -1;
pdata->lut = lut;
pdata->theta = theta;
pdata->lbnd_out = lbnd_out;
pdata->moving = moving;
pdata->ubnd_out = ubnd_out;
pdata->tstep = tstep;
pdata->lat_ptr = lat_ptr;
pdata->lon_ptr = lon_ptr;
pdata->fts_port = fts_port;
/* Make deep copies of AST objects and unlock them so that each
thread can then lock them for their own exclusive use */
pdata->abskyfrm = astCopy( abskyfrm );
astUnlock( pdata->abskyfrm, 1 );
pdata->sky2map = astCopy( sky2map );
astUnlock( pdata->sky2map, 1 );
/* Similarly, make a copy of the smfData, including only the header
information which each thread will need in order to make calls to
smf_rebin_totmap */
pdata->data = smf_deepcopy_smfData( data, 0, SMF__NOCREATE_FILE |
SMF__NOCREATE_DA |
SMF__NOCREATE_FTS |
SMF__NOCREATE_DATA |
SMF__NOCREATE_VARIANCE |
SMF__NOCREATE_QUALITY, 0, 0,
status );
smf_lock_data( pdata->data, 0, status );
}
for( ii=0; ii<nw; ii++ ) {
/* Submit the job */
pdata = job_data + ii;
pdata->ijob = thrAddJob( wf, THR__REPORT_JOB, pdata,
smfCalcMapcoordPar, 0, NULL, status );
}
/* Wait until all of the jobs submitted within the current job
context have completed */
thrWait( wf, status );
}
/* End the current job context. */
thrEndJobContext( wf, status );
/* --- End parellelized portion -------------------------------------- */
/* Set the lut pointer in data to the buffer */
data->lut = lut;
data->theta = theta;
/* Write the WCS for the projection to the extension */
if( doextension ) {
kpg1Wwrt( (AstObject*)outfset, "WCS", mapcoordloc, status );
/* Write the pixel bounds for the map to the extension */
lbnd_temp[0] = 1; /* Don't get confused! Bounds for NDF that will */
ubnd_temp[0] = 2; /* contain the bounds for the output 2d map! */
bndndf = smf_get_ndfid( mapcoordloc, "LBND", "UPDATE", "UNKNOWN",
"_INTEGER", 1, lbnd_temp, ubnd_temp, status );
ndfMap( bndndf, "DATA", "_INTEGER", "WRITE", data_pntr, &nmap,
status );
data_index = data_pntr[0];
if( *status == SAI__OK ) {
data_index[0] = lbnd_out[0];
data_index[1] = lbnd_out[1];
} else {
errRep( FUNC_NAME, "Unable to map LBND in MAPCOORD extension",
status);
}
ndfAnnul( &bndndf, status );
bndndf = smf_get_ndfid( mapcoordloc, "UBND", "UPDATE", "UNKNOWN",
"_INTEGER", 1, lbnd_temp, ubnd_temp, status );
ndfMap( bndndf, "DATA", "_INTEGER", "WRITE", data_pntr, &nmap,
status );
data_index = data_pntr[0];
if( *status == SAI__OK ) {
data_index[0] = ubnd_out[0];
data_index[1] = ubnd_out[1];
} else {
errRep( FUNC_NAME, "Unable to map UBND in MAPCOORD extension",
status);
}
ndfAnnul( &bndndf, status );
}
}
}
/* Clean Up */
if( testsimpmap ) testsimpmap = astAnnul( testsimpmap );
if( testcmpmap ) testcmpmap = astAnnul( testcmpmap );
if( map2sky_old ) map2sky_old = astAnnul( map2sky_old );
if( oldfset ) oldfset = astAnnul( oldfset );
if (sky2map) sky2map = astAnnul( sky2map );
if (bolo2map) bolo2map = astAnnul( bolo2map );
if( abskyfrm ) abskyfrm = astAnnul( abskyfrm );
if( oskyfrm ) oskyfrm = astAnnul( oskyfrm );
if( mapcoordloc ) datAnnul( &mapcoordloc, status );
if( indf_lat != NDF__NOID ) ndfAnnul( &indf_lat, status );
if( indf_lon != NDF__NOID ) ndfAnnul( &indf_lon, status );
/* If we get this far, docalc=0, and status is OK, there must be
a good LUT in there already. Map it so that it is accessible to
the caller; "UPDATE" so that the caller can modify it if desired. */
if( (*status == SAI__OK) && (docalc == 0) ) {
smf_open_mapcoord( data, "UPDATE", status );
}
/* Clean up job data */
if( job_data ) {
for( ii=0; (*status==SAI__OK)&&(ii<nw); ii++ ) {
pdata = job_data + ii;
if( pdata->data ) {
smf_lock_data( pdata->data, 1, status );
smf_close_file( &(pdata->data), status );
}
astLock( pdata->abskyfrm, 0 );
pdata->abskyfrm = astAnnul( pdata->abskyfrm );
astLock( pdata->sky2map, 0 );
pdata->sky2map = astAnnul( pdata->sky2map );
}
job_data = astFree( job_data );
}
}
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 smf_clean_dksquid( smfData *indata, smf_qual_t mask, size_t window, smfData *model,
int calcdk, int nofit, int replacebad, int *status ) {
dim_t b; /* Bolometer index */
size_t bstride; /* Bolometer index stride */
double corr; /* Linear correlation coefficient */
double *corrbuf=NULL; /* Array of correlation coeffs all bolos this col */
int needDA=0; /* Do we need dksquids from the DA? */
int *dkgood=NULL; /* Flag for non-constant dark squid */
double *dksquid=NULL; /* Buffer for smoothed dark squid */
double *dkav=NULL; /* Buffer for average dark squid */
double firstdk; /* First value in dksquid signal */
double gain; /* Gain parameter from template fit */
double *gainbuf=NULL; /* Array of gains for all bolos in this col */
size_t i; /* Loop counter */
size_t jt1;
size_t jt2;
size_t jf1; /* Starting tslice that should be fit */
size_t jf2; /* Final tslice that should be fit */
size_t j; /* Loop counter */
size_t k; /* Loop counter */
size_t nbad=0; /* Number of new bad bolos due to bad dark squid */
dim_t nbolo; /* Number of bolometers */
dim_t ncol; /* Number of columns */
dim_t ndata; /* Number of data points */
size_t nfit; /* number of samples over good range to fit */
size_t ngood=0; /* number of good dark squids */
dim_t nrow; /* Number of rows */
size_t ntot;
dim_t ntslice; /* Number of time slices */
double offset; /* Offset parameter from template fit */
double *offsetbuf=NULL; /* Array of offsets for all bolos in this col */
int pass; /* two passes over data to get estimate of average */
smf_qual_t *qua=NULL;/* Pointer to quality array */
size_t tstride; /* Time slice index stride */
if (*status != SAI__OK) return;
/* Check for NULL smfData pointer */
if( !indata ) {
*status = SAI__ERROR;
errRep( " ", FUNC_NAME
": possible programming error, smfData pointer is NULL", status );
return;
}
/* Decide if we need the DA extension or not */
if( (!model) || (model && calcdk) ) {
needDA = 1;
if( !indata->da) {
/* Check for NULL smfDA */
*status = SAI__ERROR;
errRep( " ", FUNC_NAME
": possible programming error, no smfDA struct in smfData",
status);
return;
} else if( !indata->da->dksquid) {
/* Check for NULL dksquid */
*status = SAI__ERROR;
errRep( " ", FUNC_NAME
": possible programming error, no dksquid array in smfData",
status);
return;
}
/* Assert the correct data order here */
smf_dataOrder( indata->da->dksquid, 1, status );
}
/* Check for 3-d data and get dimensions */
smf_get_dims( indata, &nrow, &ncol, &nbolo, &ntslice, &ndata, &bstride,
&tstride, status );
/* Identify the range of data that should be fit using SMF__Q_BOUND */
if( qua ) {
smf_get_goodrange( qua, ntslice, tstride, SMF__Q_BOUND, &jf1, &jf2,
status );
} else {
jf1 = 0;
jf2 = ntslice-1;
}
nfit = jf2-jf1+1;
/* Total total range only using SMF__Q_PAD */
if( qua ) {
smf_get_goodrange( qua, ntslice, tstride, SMF__Q_BOUND, &jt1, &jt2,
status );
} else {
jt1 = 0;
jt2 = ntslice-1;
}
ntot = jt2-jt1+1;
if( model ) {
/* Check for valid model dimensions if supplied */
if( model->dtype != SMF__DOUBLE ) {
msgSetc("DT", smf_dtype_str(model->dtype, status) );
*status = SAI__ERROR;
errRep(" ", FUNC_NAME ": Data type ^DT for model not supported.",
status );
return;
}
if( (model->ndims != 2) ||
(model->dims[0] != ntslice+nrow*3) ||
(model->dims[1] != ncol) ) {
*status = SAI__ERROR;
errRep(" ", FUNC_NAME ": model has incorrect dimensions", status );
return;
}
} else {
/* Otherwise allocate space for local dksquid buffer */
dksquid = astCalloc( ntslice, sizeof(*dksquid) );
}
/* Pointer to quality */
qua = smf_select_qualpntr( indata, 0, status );
/* Two passes: in the first we calculate an average dark squid to use as
a surrogate for columns with dead dark squids. In the second we do the
actual cleaning etc. */
dkgood = astCalloc( ncol, sizeof(*dkgood) );
dkav = astCalloc( ntslice, sizeof(*dkav) );
for( pass=0; (*status==SAI__OK)&&(pass<2); pass++ ) {
/* Loop over columns */
for( i=0; (*status==SAI__OK)&&(i<ncol); i++ ) {
/* Point dksquid, gainbuf, offsetbuf and corrbuf to the right
place in model if supplied. */
if( model ) {
dksquid = model->pntr[0];
dksquid += i*(ntslice+nrow*3);
gainbuf = dksquid + ntslice;
offsetbuf = gainbuf + nrow;
corrbuf = offsetbuf + nrow;
}
/* First pass is just to copy the dark squid over to the model and replace
dead dark squids with the average */
if( pass==0 ) {
/* Copy dark squids from the DA extension into dksquid */
if( needDA && calcdk && model ) {
double *ptr = indata->da->dksquid->pntr[0];
for( j=0; j<ntslice; j++ ) {
dksquid[j] = ptr[i+ncol*j];
}
}
/* Check for a good dark squid by seeing if it ever changes */
firstdk = VAL__BADD;
for( j=jt1; j<=jt2; j++ ) {
if( dksquid[j] != VAL__BADD ) {
if( firstdk == VAL__BADD ) {
firstdk = dksquid[j];
} else if( dksquid[j] != firstdk ) {
dkgood[i] = 1;
ngood++;
/* Add good squid to average dksquid */
for( k=jt1; k<=jt2; k++ ) {
dkav[k] += dksquid[k];
}
break;
}
}
}
}
/* Second pass actually do the fitting / replace with average dksquid if
dksquid was dead */
if( pass==1 ) {
/* Do some dksquid initialization if requested */
if( (*status==SAI__OK) && needDA && calcdk && model && dkgood[i] ) {
/* Smooth the dark squid template */
smf_boxcar1D( &dksquid[jt1], ntot, window, NULL, 0, status );
}
/* Initialize fit coeffs to VAL__BADD */
if( (*status == SAI__OK) && model ) {
for( j=0; j<nrow; j++ ) {
gainbuf[j] = VAL__BADD;
offsetbuf[j] = VAL__BADD;
corrbuf[j] = VAL__BADD;
}
}
/* Loop over rows, removing the fitted dksquid template. */
for( j=0; (!nofit) && (*status==SAI__OK) && (j<nrow); j++ ) {
/* Calculate bolometer index from row/col counters */
if( SC2STORE__COL_INDEX ) {
b = i*nrow + j;
} else {
b = i + j*ncol;
}
/* If dark squid is bad, flag entire bolo as bad if it isn't already */
if( !dkgood[i] && qua && !(qua[b*bstride]&SMF__Q_BADB) ) {
nbad++;
for( k=0; k<ntslice; k++ ) {
qua[b*bstride+k*tstride] |= SMF__Q_BADB;
}
}
/* Try to fit if we think we have a good dark squid and bolo, and only
the goodrange of data (excluding padding etc.) */
if((!qua && dkgood[i]) ||
(qua && dkgood[i] && !(qua[b*bstride]&SMF__Q_BADB))) {
double *d_d;
int *d_i;
switch( indata->dtype ) {
case SMF__DOUBLE:
d_d = (double *) indata->pntr[0];
smf_templateFit1D( &d_d[b*bstride+jf1*tstride],
&qua[b*bstride+jf1*tstride], NULL, NULL,
mask, mask, nfit, tstride, &dksquid[jf1], 1,
1, &gain, &offset, &corr, status );
break;
case SMF__INTEGER:
d_i = (int *) indata->pntr[0];
smf_templateFit1I( &d_i[b*bstride+jf1*tstride],
&qua[b*bstride+jf1*tstride], NULL, NULL, mask,
mask, nfit, tstride, &dksquid[jf1], 1, 1,
&gain, &offset, &corr, status );
break;
default:
msgSetc( "DT", smf_dtype_string( indata, status ));
*status = SAI__ERROR;
errRep( " ", FUNC_NAME
": Unsupported data type for dksquid cleaning (^DT)",
status );
}
if( *status == SMF__INSMP || *status == SMF__DIVBZ ) {
int wasinsmp = (*status == SMF__INSMP ? 1 : 0 );
/* Annul SMF__INSMP as it was probably due to a bad bolometer */
errAnnul( status );
msgOutiff( MSG__DEBUG, "", FUNC_NAME
": ROW,COL (%zu,%zu) %s", status, j, i,
(wasinsmp ? "insufficient good samples" : "division by zero" ));
/* Flag entire bolo as bad if it isn't already */
if( qua && !(qua[b*bstride]&SMF__Q_BADB) ) {
for( k=0; k<ntslice; k++ ) {
qua[b*bstride+k*tstride] |= SMF__Q_BADB;
}
}
} else {
/* Store gain and offset in model */
if( model ) {
gainbuf[j] = gain;
offsetbuf[j] = offset;
corrbuf[j] = corr;
}
if( msgFlevok( MSG__DEBUG1, status ) ) {
msgSeti( "COL", i );
msgSeti( "ROW", j );
msgSetd( "GAI", gain );
msgSetd( "OFF", offset );
msgSetd( "CORR", corr );
msgOutif( MSG__DEBUG1, "", FUNC_NAME
": ROW,COL (^ROW,^COL) GAIN,OFFSET,CORR "
"(^GAI,^OFF,^CORR)", status );
}
}
}
}
}
}
/* Re-normalize the average dark-squid here at the end of pass 0 */
if( (pass==0) && (ngood) && (*status==SAI__OK) ) {
for( j=jt1; j<=jt2; j++ ) {
dkav[j] /= ngood;
}
}
/* Replace bad bolos in model with the average? */
if( replacebad && calcdk && needDA && model && (*status==SAI__OK) ) {
for( i=0; i<ncol; i++ ) {
dksquid = model->pntr[0];
dksquid += i*(ntslice+nrow*3);
if( !dkgood[i] ) {
memcpy( dksquid, dkav, sizeof(*dksquid)*ntslice );
dkgood[i] = 1;
}
}
}
}
/* Report number of new bad bolos that were flagged */
if( !replacebad && nbad ) {
msgOutiff( MSG__VERB, "", FUNC_NAME
": %zu new bolos flagged bad due to dead DKS", status, nbad );
}
/* Free dksquid only if it was a local buffer */
if( !model && dksquid ) dksquid = astFree( dksquid );
dkgood = astFree( dkgood );
dkav = astFree( dkav );
}
void smf_import_array( smfData *refdata, const char *name, int bad,
int expand, double *dataptr, int *status ) {
/* Local Variables: */
Grp *igrp; /* Group holding NDF name */
dim_t nbolo; /* Number of bolometers */
dim_t ntslice; /* Number of time slices */
double *pin; /* Pointer to next input value */
double *pout; /* Pointer to next output value */
double mean; /* Mean value int he plane */
double vsum; /* Sum of good data values */
int nbad; /* Number of bad data values */
int ngood; /* Number of good data values */
size_t bstride; /* Stride between bolometer values */
size_t i; /* Loop count */
size_t j; /* Loop count */
dim_t nel; /* Number of elements in array */
size_t tstride; /* Stride between time slices */
smfData *data; /* Model for one sub-array */
/* Check inherited status. */
if( *status != SAI__OK ) return;
/* Attempt to open the NDF. */
igrp = grpNew( " ", status );
grpPut1( igrp, name, 0, status );
smf_open_file( igrp, 1, "READ", 0, &data, status );
grpDelet( &igrp, status );
/* Ensure the smfData read from the NDF uses the same data ordering as the
reference smfData. */
smf_dataOrder( data, refdata->isTordered, status );
if( *status == SAI__OK ) {
/* Check the data type and dimensions of the NDF are the same as the
reference NDF. */
if( data->dtype != SMF__DOUBLE ) {
*status = SAI__ERROR;
errRepf( " ", "NDF '%s' has incorrect data type - should be "
"DOUBLE PRECISION.", status, name );
} else if( data->ndims != refdata->ndims ) {
*status = SAI__ERROR;
errRepf( " ", "NDF '%s' is %zu dimensional - must be %zu "
"dimensional.", status, name, data->ndims, refdata->ndims );
} else if( !expand || refdata->ndims != 3 ) {
expand = 0;
for( i = 0; i < refdata->ndims; i++ ) {
if( data->dims[i] != refdata->dims[i] &&
*status == SAI__OK ){
*status = SAI__ERROR;
errRepf( " ", "NDF '%s' has incorrect dimension %zu on "
"pixel axis %zu - should be %zu.", status,
name, data->dims[i], i + 1, refdata->dims[i] );
} else if( data->lbnd[i] != refdata->lbnd[i] &&
*status == SAI__OK ){
*status = SAI__ERROR;
errRepf( " ", "NDF '%s' has incorrect lower bound %d on "
"pixel axis %zu - should be %d.", status,
name, data->lbnd[i], i + 1, refdata->lbnd[i] );
}
}
} else {
for( i = 0; i < refdata->ndims; i++ ) {
if( data->dims[i] == 1 ) {
} else if( data->dims[i] != refdata->dims[i] &&
*status == SAI__OK ){
*status = SAI__ERROR;
errRepf( " ", "NDF '%s' has incorrect dimension %zu on "
"pixel axis %zu - should be %zu.", status,
name, data->dims[i], i + 1, refdata->dims[i] );
} else if( data->lbnd[i] != refdata->lbnd[i] &&
*status == SAI__OK ){
*status = SAI__ERROR;
errRepf( " ", "NDF '%s' has incorrect lower bound %d on "
"pixel axis %zu - should be %d.", status,
name, data->lbnd[i], i + 1, refdata->lbnd[i] );
}
}
}
/* Get the smfData dimensions and strides. */
smf_get_dims( refdata, NULL, NULL, &nbolo, &ntslice, &nel, &bstride,
&tstride, status );
/* Copy the values into the model array, replacing bad values as required. */
if( *status == SAI__OK ) {
pin = data->pntr[0];
pout = dataptr;
if( data->ndims < 3 ) data->dims[2] = 1;
if( data->ndims < 2 ) data->dims[1] = 1;
/* Copy the data into the returned array unchanged. */
if( expand ) {
pin = (double *) data->pntr[0];
for( i = 0; i < ntslice; i++,pin++ ) {
pout = dataptr + i*tstride;
for( j = 0; j < nbolo; j++ ) {
if( *pin != VAL__BADD ) {
*pout = *pin;
} else {
*pout = VAL__BADD;
}
pout += bstride;
}
}
} else {
memcpy( pout, pin, nel*sizeof(*pin) );
}
/* Retain bad values. */
if( bad == 0 ) {
/* Replace bad values with zero. */
} else if( bad == 1 ) {
pout = dataptr;
for( i = 0; i < nel; i++,pout++ ) {
if( *pout == VAL__BADD ) *pout = 0.0;
}
/* Replace bad values with the mean value in the time slice. */
} else if( bad == 2 ) {
pout = dataptr;
mean = VAL__BADD;
for( i = 0; i < ntslice; i++ ) {
vsum = 0.0;
ngood = 0;
nbad = 0;
pout = dataptr + i*tstride;
for( j = 0; j < nbolo; j++ ) {
if( *pout != VAL__BADD ) {
vsum += *pout;
ngood++;
} else {
nbad++;
}
pout += bstride;
}
if( ngood > 0 ) mean = vsum/ngood;
if( nbad > 0 ) {
if( mean != VAL__BADD ) {
pout = dataptr + i*tstride;
for( j = 0; j < nbolo; j++ ) {
if( *pout == VAL__BADD ) *pout = mean;
pout += bstride;
}
} else {
*status = SAI__ERROR;
errRepf( " ", "NDF '%s' has no good values in plane "
"%zu.", status, name, i );
break;
}
}
}
}
}
/* Close the NDF. */
smf_close_file( &data, status );
}
}
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 );
}
}
void smf_fit_qui( ThrWorkForce *wf, smfData *idata, smfData **odataq,
smfData **odatau, smfData **odatai, dim_t box, int ipolcrd,
int pasign, double paoff, double angrot, int north,
int *status ){
/* Local Variables: */
AstFrameSet *wcs; /* WCS FrameSet for current time slice */
JCMTState *instate=NULL; /* Pointer to input JCMTState */
JCMTState *outstate=NULL;/* Pointer to output JCMTState */
const char *usesys; /* Tracking system */
dim_t *box_starts; /* Array holding time slice at start of each box */
dim_t box_size; /* First time slice in box */
dim_t intslice; /* ntslice of idata */
dim_t istart; /* Input time index at start of fitting box */
dim_t itime; /* Time slice index */
dim_t nbolo; /* No. of bolometers */
dim_t ncol; /* No. of columns of bolometers in the array */
dim_t ntime; /* Time slices to check */
dim_t ondata; /* ndata of odata */
dim_t ontslice; /* ntslice of odata */
double scale; /* how much longer new samples are */
int bstep; /* Bolometer step between threads */
int iworker; /* Index of a worker thread */
int nworker; /* No. of worker threads */
size_t i; /* loop counter */
smfData *indksquid=NULL; /* Pointer to input dksquid data */
smfFitQUIJobData *job_data = NULL; /* Pointer to all job data */
smfFitQUIJobData *pdata = NULL;/* Pointer to next job data */
smfHead *hdr; /* Pointer to data header this time slice */
smf_qual_t *qua; /* Input quality pointer */
/* Check inherited status */
if( *status != SAI__OK ) return;
/* Check supplied arguments. */
if( !idata || !odataq || !odatau ) {
*status = SAI__ERROR;
errRep( "", "smf_fit_qui: NULL inputs supplied", status );
return;
}
if( idata->ndims != 3 ) {
*status = SAI__ERROR;
errRep( "", "smf_fit_qui: idata is not 3-dimensional", status );
return;
}
/* Ensure the supplied smfData is time-ordered. So "bstride" is 1 and "tstride"
is nbolo. */
smf_dataOrder( wf, idata, 1, status );
/* Dimensions of input. */
smf_get_dims( idata, NULL, &ncol, &nbolo, &intslice, NULL, NULL, NULL,
status );
/* Store a pointer to the quality array for the input smfData. */
qua = smf_select_qualpntr( idata, NULL, status );;
/* Go through the first thousand POL_ANG values to see if they are in
units of radians (new data) or arbitrary encoder units (old data).
They are assumed to be in radians if no POL_ANG value is larger than
20. This function can only handle new data. */
hdr = idata->hdr;
instate = hdr->allState;
ntime = ( intslice > 1000 ) ? 1000 : intslice;
for( itime = 0; itime < ntime; itime++,instate++ ) {
if( instate->pol_ang > 20 ) {
*status = SAI__ERROR;
errRep( " "," POL2 data contains POL_ANG values in encoder "
"units - connot fit to such old data.", status );
break;
}
}
/* Find the input time slice at which each fitting box starts, and the
length of the output time axis (in time-slices). */
smf1_find_boxes( intslice, hdr->allState, box, &ontslice, &box_starts,
status );
/* Time axis scaling factor. */
scale = (double) intslice / (double) ontslice;
/* First copy everything from input to output except for the data that needs
to be downsampled */
/* We want to copy everything in the smfHead except for allState. So we
make a copy of the allState pointer, and then set it to NULL in the
header before the copy */
if( idata->hdr ) {
instate = idata->hdr->allState;
idata->hdr->allState = NULL;
}
/* Similarly, we want everything in the smfDa except for the dksquid. */
if( idata->da ) {
indksquid = idata->da->dksquid;
idata->da->dksquid = NULL;
}
/* Create copies, storing them in the supplied output smfData
structures. Omit the header for U and I, as we will be copying the Q
header into them. */
*odataq = smf_deepcopy_smfData( wf, idata, 0, SMF__NOCREATE_DATA |
SMF__NOCREATE_VARIANCE | SMF__NOCREATE_QUALITY,
0, 0, status );
*odatau = smf_deepcopy_smfData( wf, idata, 0, SMF__NOCREATE_DATA |
SMF__NOCREATE_VARIANCE | SMF__NOCREATE_QUALITY |
SMF__NOCREATE_HEAD, 0, 0, status );
if( odatai ) {
*odatai = smf_deepcopy_smfData( wf, idata, 0, SMF__NOCREATE_DATA |
SMF__NOCREATE_VARIANCE | SMF__NOCREATE_QUALITY |
SMF__NOCREATE_HEAD, 0, 0, status );
}
/* Restore values in idata now that we're done */
if( instate ) idata->hdr->allState = instate;
if( indksquid ) idata->da->dksquid = indksquid;
/* Store the required length for the output time axis. The time axis is
axis two because the data is time-ordered. */
(*odataq)->dims[ 2 ] = ontslice;
(*odatau)->dims[ 2 ] = ontslice;
if( odatai) (*odatai)->dims[ 2 ] = ontslice;
/* Get output dimensions - assumed to be the same for all three outputs. */
ondata = ontslice*idata->dims[0]*idata->dims[1];
/* Allocate the data arrays for the outputs. */
(*odataq)->pntr[0] = astCalloc( ondata, sizeof(double) );
(*odatau)->pntr[0] = astCalloc( ondata, sizeof(double) );
if( odatai ) (*odatai)->pntr[0] = astCalloc( ondata, sizeof(double) );
/* Allocate arrays for the output variances. */
(*odataq)->pntr[1] = astCalloc( ondata, sizeof(double) );
(*odatau)->pntr[1] = astCalloc( ondata, sizeof(double) );
if( odatai ) (*odatai)->pntr[1] = astCalloc( ondata, sizeof(double) );
/* Create structures used to pass information to the worker threads. */
nworker = wf ? wf->nworker : 1;
job_data = astMalloc( nworker*sizeof( *job_data ) );
if( *status == SAI__OK ) {
/* Determine which bolometers are to be processed by which threads. */
bstep = nbolo/nworker;
if( bstep < 1 ) bstep = 1;
for( iworker = 0; iworker < nworker; iworker++ ) {
pdata = job_data + iworker;
pdata->b1 = iworker*bstep;
pdata->b2 = pdata->b1 + bstep - 1;
}
/* Ensure that the last thread picks up any left-over bolometers */
pdata->b2 = nbolo - 1;
/* Loop round all output time slices. */
for( itime = 0; itime < ontslice; itime++ ) {
/* Get the index of the first input time slice that contributes to the
current output time slice. */
istart = box_starts[ itime ];
/* Get the number of input time slices that contribute to the output time
slice. */
box_size = box_starts[ itime + 1 ] - istart;
/* If we are using north as the reference direction, get the WCS FrameSet
for the input time slice that is at the middle of the output time
slice, and set its current Frame to the tracking frame. */
if( north ) {
smf_tslice_ast( idata, istart + box_size/2, 1, NO_FTS, status );
wcs = idata->hdr->wcs;
usesys = sc2ast_convert_system( (idata->hdr->allState)[0].tcs_tr_sys,
status );
astSetC( wcs, "System", usesys );
} else {
wcs = NULL;
}
/* Now enter the parellel code in which each thread calculates the values
for a range of bolometers at the current output slice. */
for( iworker = 0; iworker < nworker; iworker++ ) {
pdata = job_data + iworker;
pdata->dat = ((double *) idata->pntr[0] ) + istart*nbolo;
pdata->qua = qua + istart*nbolo;
pdata->allstates = hdr->allState + istart;
pdata->ipi = odatai ? ( (double*) (*odatai)->pntr[0] ) + itime*nbolo : NULL;
pdata->ipq = ( (double*) (*odataq)->pntr[0] ) + itime*nbolo;
pdata->ipu = ( (double*) (*odatau)->pntr[0] ) + itime*nbolo;
pdata->ipv = ( (double*) (*odataq)->pntr[1] ) + itime*nbolo;
pdata->nbolo = nbolo;
pdata->ncol = ncol;
pdata->box_size = box_size;
pdata->ipolcrd = ipolcrd;
pdata->pasign = pasign ? +1: -1;
pdata->paoff = paoff;
pdata->angrot = angrot;
if( wcs ) {
pdata->wcs = astCopy( wcs );
astUnlock( pdata->wcs, 1 );
} else {
pdata->wcs = NULL;
}
/* Pass the job to the workforce for execution. */
thrAddJob( wf, THR__REPORT_JOB, pdata, smf1_fit_qui_job, 0, NULL,
status );
}
/* Wait for the workforce to complete all jobs. */
thrWait( wf, status );
/* Lock and annul the AST objects used by each thread. */
if( wcs ) {
for( iworker = 0; iworker < nworker; iworker++ ) {
pdata = job_data + iworker;
astLock( pdata->wcs, 0 );
pdata->wcs = astAnnul( pdata->wcs );
}
}
}
/* Down-sample the smfHead -------------------------------------------------*/
smfHead *hdr = (*odataq)->hdr;
hdr->curframe = (dim_t) (((double) hdr->curframe + 0.5) / scale);
hdr->nframes = ontslice;
hdr->steptime *= scale;
strcpy( hdr->dlabel, "Q" );
strncpy( hdr->title, "POL-2 Stokes parameter Q", SMF__CHARLABEL );
/* Down-sample all the JCMTState values using nearest neighbours */
instate = idata->hdr->allState;
if( instate ) {
hdr->allState = astCalloc( ontslice, sizeof(*instate) );
outstate = hdr->allState;
if( *status == SAI__OK ) {
size_t frame; /* index of nearest neighbour JCMTState */
for( i=0; i<ontslice; i++ ) {
frame = (size_t) round(((double) i + 0.5)*scale);
memcpy( outstate + i, instate + frame, sizeof(*instate) );
}
/* Then go back and properly down-sample the more important fast-changing
fields like pointing. Note that since there are approximate values there
already we need to explicitly re-initialize to 0. */
RESAMPSTATE(instate, outstate, rts_end, intslice, ontslice, 0);
RESAMPSTATE(instate, outstate, smu_az_jig_x, intslice, ontslice, 0);
RESAMPSTATE(instate, outstate, smu_az_jig_y, intslice, ontslice, 0);
RESAMPSTATE(instate, outstate, smu_az_chop_x, intslice, ontslice, 0);
RESAMPSTATE(instate, outstate, smu_az_chop_y, intslice, ontslice, 0);
RESAMPSTATE(instate, outstate, smu_tr_jig_x, intslice, ontslice, 0);
RESAMPSTATE(instate, outstate, smu_tr_jig_y, intslice, ontslice, 0);
RESAMPSTATE(instate, outstate, smu_tr_chop_x, intslice, ontslice, 0);
RESAMPSTATE(instate, outstate, smu_tr_chop_y, intslice, ontslice, 0);
RESAMPSTATE(instate, outstate, tcs_tai, intslice, ontslice, 0);
RESAMPSTATE(instate, outstate, tcs_airmass, intslice, ontslice, 0);
/* Second coordinates (Dec, El etc) can not wrap 0 to 360 so we do not need
to test for those cases */
RESAMPSTATE(instate, outstate, tcs_az_ang, intslice, ontslice, 1);
RESAMPSTATE(instate, outstate, tcs_az_ac1, intslice, ontslice, 1);
RESAMPSTATE(instate, outstate, tcs_az_ac2, intslice, ontslice, 0);
RESAMPSTATE(instate, outstate, tcs_az_dc1, intslice, ontslice, 1);
RESAMPSTATE(instate, outstate, tcs_az_dc2, intslice, ontslice, 0);
RESAMPSTATE(instate, outstate, tcs_az_bc1, intslice, ontslice, 1);
RESAMPSTATE(instate, outstate, tcs_az_bc2, intslice, ontslice, 0);
RESAMPSTATE(instate, outstate, tcs_tr_ang, intslice, ontslice, 1);
RESAMPSTATE(instate, outstate, tcs_tr_ac1, intslice, ontslice, 1);
RESAMPSTATE(instate, outstate, tcs_tr_ac2, intslice, ontslice, 0);
RESAMPSTATE(instate, outstate, tcs_tr_dc1, intslice, ontslice, 1);
RESAMPSTATE(instate, outstate, tcs_tr_dc2, intslice, ontslice, 0);
RESAMPSTATE(instate, outstate, tcs_tr_bc1, intslice, ontslice, 1);
RESAMPSTATE(instate, outstate, tcs_tr_bc2, intslice, ontslice, 0);
RESAMPSTATE(instate, outstate, tcs_en_dc1, intslice, ontslice, 1);
RESAMPSTATE(instate, outstate, tcs_en_dc2, intslice, ontslice, 0);
RESAMPSTATE(instate, outstate, tcs_dm_abs, intslice, ontslice, 1);
RESAMPSTATE(instate, outstate, tcs_dm_rel, intslice, ontslice, 0);
/* Wait for all the above smf_downsamp1 jobs to finish. */
thrWait( wf, status );
}
}
/* Add a keyword to the Q header indicating the polarimetric reference
direction. */
smf_fits_updateL( (*odataq)->hdr, "POLNORTH", north,
north ? "Pol ref dir is tracking north" :
"Pol ref dir is focal plane Y", status );
/* Copy the Q header to the other outputs. */
hdr = smf_deepcopy_smfHead( (*odataq)->hdr, status );
(*odatau)->hdr = hdr;
if( *status == SAI__OK ) {
strcpy( hdr->dlabel, "U" );
strncpy( hdr->title, "POL-2 Stokes parameter U", SMF__CHARLABEL );
}
if( odatai ) {
hdr = smf_deepcopy_smfHead( (*odataq)->hdr, status );
(*odatai)->hdr = hdr;
if( *status == SAI__OK ) {
strcpy( hdr->dlabel, "I" );
strncpy( hdr->title, "POL-2 Stokes parameter I", SMF__CHARLABEL );
}
}
}
/* Copy the variances from the Q smfData into the U and (and I) smfData. */
if( *odataq && *status == SAI__OK ) {
if( *odatau ) {
memcpy( (*odatau)->pntr[1], (*odataq)->pntr[1], ondata*sizeof(double));
}
if( odatai && *odatai ) {
memcpy( (*odatai)->pntr[1], (*odataq)->pntr[1], ondata*sizeof(double));
}
}
/* Ensure all smfDatas are time-ordered. */
smf_dataOrder( wf, idata, 1, status );
if( odatai && *odatai ) smf_dataOrder( wf, *odatai, 1, status );
if( *odataq ) smf_dataOrder( wf, *odataq, 1, status );
if( *odatau ) smf_dataOrder( wf, *odatau, 1, status );
/* Free resources. */
job_data = astFree( job_data );
box_starts = astFree( box_starts );
}
