void smurf_calcdark( int *status ) {
smfArray *bbms = NULL; /* Bad bolometer masks */
smfArray *darks = NULL; /* set of processed darks */
Grp *dgrp = NULL; /* Group of darks */
size_t i; /* Loop index */
int indf; /* NDF identifier for input file */
Grp *igrp = NULL; /* Input group of files */
Grp *ogrp = NULL; /* Output group of files */
size_t outsize; /* Total number of NDF names in the output group */
size_t size; /* Number of files in input group */
/* Main routine */
ndfBegin();
/* Get input file(s) */
kpg1Rgndf( "IN", 0, 1, "", &igrp, &size, status );
/* Filter out non-darks and reduce the darks themselves */
smf_find_science( igrp, NULL, 0, &dgrp, NULL, 1, 0, SMF__DOUBLE, &darks, NULL,
NULL, NULL, status );
/* no longer need the input group */
grpDelet( &igrp, status );
/* Get output file(s) */
size = grpGrpsz( dgrp, status );
kpg1Wgndf( "OUT", dgrp, size, size, "More output files required...",
&ogrp, &outsize, status );
/* Get group of bolometer masks and read them into a smfArray */
smf_request_mask( "BBM", &bbms, status );
for (i=1; i<=size && *status == SAI__OK; i++ ) {
smfData * dark = (darks->sdata)[i-1]; /* This dark */
/* Open input file and create output file. Do not propagate
since we do not want to get a large file the wrong size */
ndgNdfas( dgrp, i, "READ", &indf, status );
smf_apply_mask( dark, bbms, SMF__BBM_DATA, 0, status );
smf_write_smfData( dark, NULL, NULL, ogrp, i, indf, MSG__VERB, status );
ndfAnnul( &indf, status);
}
/* Tidy up after ourselves: release the resources used by the grp routines */
grpDelet( &dgrp, status);
grpDelet( &ogrp, status);
smf_close_related( &darks, status );
smf_close_related( &bbms, status );
ndfEnd( status );
}
void smurf_sc2expandmodel( int *status ) {
smf_expmodelptr expptr=NULL;/* Pointer to current model calc function */
size_t i=0; /* Counter, index */
smfData *idata=NULL; /* Input data */
Grp *igrp = NULL; /* Input group of files */
smfData *odata=NULL; /* Output data */
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 */
/* Main routine */
ndfBegin();
/* Read the input file */
kpg1Rgndf( "IN", 0, 1, "", &igrp, &size, status );
/* Get output file(s) */
kpg1Wgndf( "OUT", igrp, size, size, "More output files required...",
&ogrp, &outsize, status );
/* Loop over input files */
for( i=1; (*status==SAI__OK) && (i<=size); i++ ) {
/* Open file */
smf_open_file(NULL, igrp, i, "READ", 0, &idata, status);
/* Check to see if this is a DIMM model component before expanding */
if( idata && idata->hdr && (idata->hdr->mtype != SMF__NUL) ) {
expptr = smf_model_getexpptr( idata->hdr->mtype, status );
if( *status == SAI__OK ) {
(*expptr)( idata, &odata, status );
smf_write_smfData( NULL, odata, NULL, NULL, ogrp, i, 0,
MSG__VERB, 0, NULL, NULL, status );
}
}
}
/* Cleanup */
grpDelet( &igrp, status);
grpDelet( &ogrp, status);
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();
}
void smurf_sc2pca( int *status ) {
smfData *amplitudes=NULL; /* Amplitudes of each component */
smfArray *bbms=NULL; /* Bad bolometer masks */
smfData *components=NULL; /* Components */
smfArray *darks=NULL ; /* Dark data */
int ensureflat; /* Flag for flatfielding data */
smfData *data=NULL; /* Pointer to input smfData */
Grp *fgrp=NULL; /* Filtered group, no darks */
smfArray *flatramps=NULL; /* Flatfield ramps */
AstKeyMap *heateffmap = NULL; /* Heater efficiency data */
size_t i=0; /* Counter, index */
Grp *igrp=NULL; /* Input group of files */
Grp *outampgrp=NULL; /* Output amplitude group of files */
Grp *outcompgrp=NULL; /* Output component group of files */
size_t outampsize; /* Total number of NDF names in ocompgrp */
size_t outcompsize; /* Total number of NDF names in ocompgrp */
size_t size; /* Number of files in input group */
ThrWorkForce *wf=NULL; /* Pointer to a pool of worker threads */
/* 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 );
/* Are we flatfielding? */
parGet0l( "FLAT", &ensureflat, status );
/* Filter out useful data (revert to darks if no science data) */
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 ) {
/* Get output file(s) */
kpg1Wgndf( "OUTAMP", igrp, size, size, "More output files required...",
&outampgrp, &outampsize, status );
kpg1Wgndf( "OUTCOMP", igrp, size, size, "More output files required...",
&outcompgrp, &outcompsize, status );
} else {
msgOutif(MSG__NORM, " ","All supplied input frames were DARK,"
" nothing to flatfield", status );
}
/* Get group of bolometer masks and read them into a smfArray */
smf_request_mask( wf, "BBM", &bbms, status );
for( i=1; i<=size; i++ ) {
if( *status != SAI__OK ) break;
/* Load data, flatfielding and/or opening raw as double as necessary */
smf_open_asdouble( wf, igrp, i, darks, flatramps, heateffmap, ensureflat, &data, status );
/* Mask out bad bolometers */
smf_apply_mask( wf, data, bbms, SMF__BBM_DATA|SMF__BBM_QUAL, 0, status );
/* Sync quality with bad values */
smf_update_quality( wf, data, 1, NULL, 0, 0.05, status );
/* Calculate the PCA */
smf_clean_pca( wf, data, 0, 0, 0, &components, &litudes, 0, 1, NULL,
status );
/* Write out to the new files */
smf_write_smfData( wf, amplitudes, NULL, NULL, outampgrp, i, 0, MSG__VERB,
0, status );
smf_write_smfData( wf, components, NULL, NULL, outcompgrp, i, 0, MSG__VERB,
0, status );
/* Free resources for output data */
smf_close_file( wf, &data, status );
smf_close_file( wf, &litudes, status );
smf_close_file( wf, &components, status );
}
/* Write out the list of output NDF names, annulling the error if a null
parameter value is supplied. */
if( *status == SAI__OK && outampgrp ) {
grpList( "OUTAMPFILES", 0, 0, NULL, outampgrp, status );
if( *status == PAR__NULL ) errAnnul( status );
}
if( *status == SAI__OK && outcompgrp ) {
grpList( "OUTCOMPFILES", 0, 0, NULL, outcompgrp, status );
if( *status == PAR__NULL ) errAnnul( status );
}
/* Tidy up after ourselves: release the resources used by the grp routines */
if( igrp ) grpDelet( &igrp, status);
if( outampgrp ) grpDelet( &outampgrp, status);
if( outcompgrp ) grpDelet( &outcompgrp, status);
if( darks ) smf_close_related( wf, &darks, status );
if( bbms ) smf_close_related( wf, &bbms, status );
if( flatramps ) smf_close_related( wf, &flatramps, status );
if (heateffmap) heateffmap = smf_free_effmap( heateffmap, status );
ndfEnd( status );
}
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_sc2concat( int *status ) {
/* Local Variables */
Grp *basegrp=NULL; /* Grp containing first file each chunk */
size_t basesize; /* Number of files in base group */
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 idx; /* Subarray counter */
int usedarks; /* flag for using darks */
Grp *igrp = NULL; /* Group of input files */
smfGroup *igroup=NULL; /* smfGroup corresponding to igrp */
size_t isize; /* Number of files in input group */
dim_t maxconcat=0; /* Longest continuous chunk length in samples */
double maxlen; /* Constrain maxconcat to this many seconds */
size_t ncontchunks=0; /* Number continuous chunks outside iter loop */
Grp *ogrp = NULL; /* Output files */
size_t osize; /* Number of files in input group */
dim_t padStart=0; /* How many samples padding at start */
dim_t padEnd=0; /* How many samples padding at end */
int temp; /* Temporary signed integer */
ThrWorkForce *wf = NULL; /* Pointer to a pool of worker threads */
if (*status != SAI__OK) return;
/* 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, &isize, 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 */
isize = grpGrpsz( fgrp, status );
grpDelet( &igrp, status);
igrp = fgrp;
fgrp = NULL;
if (isize == 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 );
/* Group the input files by subarray and continuity */
smf_grp_related( igrp, isize, 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 */
gcount = 1;
for( contchunk=0;(*status==SAI__OK)&&contchunk<ncontchunks; contchunk++ ) {
/* Concatenate this continuous chunk */
smf_concat_smfGroup( wf, NULL, igroup, usedarks ? darks:NULL, NULL, flatramps,
heateffmap, contchunk, ensureflat, 1, NULL, 0, NULL, NULL,
NO_FTS, padStart, padEnd, 0, &concat, NULL, status );
/* Export concatenated data for each subarray to NDF file */
for( idx=0; (*status==SAI__OK)&&idx<concat->ndat; idx++ ) {
if( concat->sdata[idx]->file && concat->sdata[idx]->file->name ) {
smf_write_smfData( concat->sdata[idx], NULL, NULL, ogrp, gcount,
NDF__NOID, MSG__VERB, 0, 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( &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:
if( darks ) smf_close_related( &darks, status );
if( flatramps ) smf_close_related( &flatramps, status );
if (heateffmap) heateffmap = smf_free_effmap( heateffmap, status );
if( igrp ) grpDelet( &igrp, status);
if( basegrp ) grpDelet( &basegrp, status );
if( ogrp ) grpDelet( &ogrp, status );
if( igroup ) smf_close_smfGroup( &igroup, status );
ndfEnd( status );
if( *status == SAI__OK ) {
msgOutif(MSG__VERB," ","SC2CONCAT succeeded.", status);
} else {
msgOutif(MSG__VERB," ","SC2CONCAT failed.", status);
}
}
void smf_write_smfFilter( ThrWorkForce *wf, const smfFilter *filt, const char *filename,
const Grp * igrp, size_t grpindex, int *status ) {
double *d = NULL; /* Data array pointer */
smfData *data=NULL; /* smfData for output */
size_t i; /* Loop counter */
size_t nsamp; /* Number of samples in the filter */
if( *status != SAI__OK ) return;
if( !filt ) {
*status = SAI__ERROR;
errRep( "", FUNC_NAME ": NULL smfFilter supplied.", status );
return;
}
/* In case we change the data type of smfFilters in the future try
to catch that here */
if( sizeof(filt->real) != smf_dtype_sz(SMF__DOUBLE,status) ) {
*status = SAI__ERROR;
errRep( "", FUNC_NAME ": warning -- smfFilter seems to have changed type!",
status );
return;
}
/* We will pack the data into an array that has an extra dimension to
store the real/imaginary parts of the filter just like an FFT */
data = smf_create_smfData( 0, status );
if( *status == SAI__OK ) {
data->dtype = SMF__DOUBLE;
data->ndims = filt->ndims+1;
nsamp=1;
for( i=0; i<filt->ndims; i++ ) {
data->dims[i] = filt->fdims[i];
nsamp *= filt->fdims[i];
}
data->dims[data->ndims-1] = 2;
/* Copy the real and imaginary parts into our new array consecutively */
data->pntr[0] = astCalloc( nsamp*2, smf_dtype_sz(SMF__DOUBLE,status) );
if( *status == SAI__OK ) {
d = data->pntr[0];
memcpy( d, filt->real, nsamp*sizeof(d) );
if( filt->isComplex ) {
memcpy( d + nsamp, filt->imag, nsamp*sizeof(d) );
}
}
}
/* Write out the file */
smf_write_smfData( wf, data, NULL, filename, igrp, grpindex, 0, MSG__NORM,
0, NULL, NULL, status );
if( data ) smf_close_file( wf, &data, status );
}
void smurf_fts2_split(int* status)
{
if( *status != SAI__OK ) { return; }
const double STAGE_LENGTH = 450.0; /* mm */
int LR = 0; /* Treat as Low Resolution scan */
Grp* gIn = NULL; /* Input group */
Grp* gOut = NULL; /* Output group */
Grp* gTmp = NULL; /* Temporary group */
smfData* inData = NULL; /* Pointer to input data */
smfData* outData = NULL; /* Pointer to output data */
double* outData_pntr = NULL; /* Pointer to output data values array */
int nMirPos = 0; /* Number of frames where the mirror actually moves */
int nStart = 0; /* Frame index where the mirror starts moving */
int nStartNext = 0; /* Frame index where the mirror starts moving in the next scan */
int nStop = 0; /* Frame index where the mirror stops */
int lrStart = 0; /* Frame index where low resolution mirror limit starts */
int hrStop = 0; /* Frame index where high resolution mirror limit stops */
int hrStart = 0; /* Frame index where high resolution mirror limit starts */
int lrStop = 0; /* Frame index where low resolution mirror limit stops */
int lrCentre = 0; /* Frame index at centre of low resolution mirror positions */
int i = 0; /* Counter */
int j = 0; /* Counter */
int k = 0; /* Counter */
int n = 0; /* Counter */
double fNyquist = 0.0; /* Nyquist frequency */
double dz = 0.0; /* Step size in evenly spaced OPD grid */
double* MIRPOS = NULL; /* Mirror positions */
size_t nFiles = 0; /* Size of the input group */
size_t nOutFiles = 0; /* Size of the output group */
size_t fIndex = 0; /* File index */
size_t nWidth = 0; /* Data cube width */
size_t nHeight = 0; /* Data cube height */
size_t nFrames = 0; /* Data cube depth in input file */
size_t nFramesOut = 0; /* Data cube depth in output file */
size_t nFramesOutPrev = 0; /* Data cube depth in previous output file */
size_t hrFramesOut = 0; /* Data cube depth in high res output file */
size_t hrFramesOutPrev = 0; /* Data cube depth in previous high res output file */
size_t lrFramesOut = 0; /* Data cube depth in low res output file */
size_t lrFramesOutPrev = 0; /* Data cube depth in previous low res output file */
size_t nPixels = 0; /* Number of bolometers in the subarray */
char object[SZFITSTR];
char subarray[SZFITSTR];
char obsID[SZFITSTR];
char scanMode[SZFITSTR];
double scanVel = 0.0; /* Mirror speed in mm/sec */
double stepTime = 0.0; /* RTS step time, average sample rate */
double minOPD = 0; /* OPD minimum */
double maxOPD = 0; /* OPD maximum */
double ZPD = 0;
double lrmmBandPass = 0.0; /* low res mm +/- offset from centre */
int lrBandPassFrames = 0; /* Number of low res band pass frames from centre +/- length of lrmmBandPass */
int nTmp = 0;
int nMax = 0;
int nOPD = 0;
int bolIndex = 0;
int index = 0;
int indexIn = 0;
int indexOut = 0;
int badPixel = 0;
int k0 = 0;
int indexZPD = 0;
int done = 0; /* Track completion of extracting multiple scans */
int outDataCount = 0; /* The number of output data files being written */
double lenLeft,
lenRight,
minLenLeft,
minLenRight,
minLen,
minZPD,
maxZPD,
midZPD = 0.0; /* Mirror position half side measures */
int midZPDPos = 0; /* Middle ZPD position in mirror position array */
double EPSILON = 0.0;
char fileName[SMF_PATH_MAX+1];
char scanNumStr[5+1]; /* String form of scan number of the input file */
int scanNum = 0; /* Scan number of the input file */
int conNum = 0; /* Concatenation number of the input file (left shifted scanNum) */
int scanDir = 0; /* Scan direction: 1 -> back to front (positive), -1 -> front to back (negative) */
JCMTState *allState = NULL; /* Temporary buffer for reduced header allState array data */
/* Get Input, Output groups */
kpg1Rgndf("IN", 0, 1, "", &gIn, &nFiles, status);
kpg1Wgndf("OUT", gOut, nFiles, nFiles, "More output files expected!", &gOut, &nOutFiles, status);
/* Read in ADAM parameters */
parGet0d("BANDPASS", &lrmmBandPass, status); /* Low res mm band +/- offset from centre */
/* Treat as Low Resolution scan? */
if(lrmmBandPass > 0) {
LR = 1;
}
/* Eliminate the first record in the output group, since it will be replaced later */
gTmp = grpCopy(gOut, 1, 1, 1, status);
grpDelet(&gOut, status);
gOut = gTmp;
/* BEGIN NDF */
ndfBegin();
/* Loop through each input file */
for(fIndex = 1; fIndex <= nFiles; fIndex++) {
/* Open Observation file */
smf_open_file(gIn, fIndex, "READ", 0, &inData, status);
if(*status != SAI__OK) {
*status = SAI__ERROR;
errRep(FUNC_NAME, "Unable to open the source file!", status);
goto CLEANUP;
}
smf_fits_getS(inData->hdr, "OBJECT", object, sizeof(object), status);
smf_fits_getS(inData->hdr, "SUBARRAY", subarray, sizeof(subarray), status);
smf_fits_getS(inData->hdr, "OBSID", obsID, sizeof(obsID), status);
smf_fits_getS(inData->hdr, "FTS_MODE", scanMode, sizeof(scanMode), status);
smf_fits_getD(inData->hdr, "SCANVEL", &scanVel, status);
smf_fits_getD(inData->hdr, "STEPTIME", &stepTime, status);
/* Nyquist frequency */
fNyquist = 10.0 / (8.0 * scanVel * stepTime);
dz = 1.0 / (2.0 * fNyquist);
EPSILON = scanVel * stepTime / 2;
/* Extract the scan number from the input file to be incremented in the output files */
one_strlcpy(scanNumStr, &(inData->file->name[strlen(inData->file->name) - 8]),
astMIN(SMF_PATH_MAX + 1, 5), status);
if (*status == ONE__TRUNC) {
errRep(FUNC_NAME, "Error extracting scanNumStr!", status);
errAnnul(status);
}
/* Create a temporary base file name from input file name */
one_strlcpy(fileName, inData->file->name,
astMIN(SMF_PATH_MAX + 1, strlen(inData->file->name) - 7), status);
if (*status == ONE__TRUNC) {
errRep(FUNC_NAME, "Error extracting base fileName!", status);
errAnnul(status);
}
scanNum = (int) one_strtod(scanNumStr, status);
if (*status != SAI__OK) {
errRep(FUNC_NAME, "Error extracting scanNum!", status);
errAnnul(status);
}
/* Left shift scanNum to conNum as a prefix to make output scan number unique */
if(scanNum < 100) {
conNum = scanNum * 100;
} else if(scanNum < 1000) {
conNum = scanNum * 10;
}
/*printf("%s: Processing file: %s, having basename: %s and scanNumStr: %s, scanNum: %04d\n",
TASK_NAME, inData->file->name, fileName, scanNumStr, scanNum);*/
/* Data cube dimensions */
nWidth = inData->dims[0];
nHeight = inData->dims[1];
nFrames = inData->dims[2];
nPixels = nWidth * nHeight;
/* Mirror positions in mm */
nTmp = nFrames;
MIRPOS = astCalloc(nFrames, sizeof(*MIRPOS));
fts2_getmirrorpositions(inData, MIRPOS, &nTmp, status); // (mm)
if(*status != SAI__OK) {
*status = SAI__ERROR;
errRep( FUNC_NAME, "Unable to get the mirror positions!", status);
goto CLEANUP;
}
nStart = -1;
nStop = -1;
nStartNext = 0;
hrStart = -1;
hrStop = -1;
lrStart = -1;
lrStop = -1;
outDataCount = 0;
done = 0;
do {
/* Find the next range of single scan mirror positions for which to extract corresponding NDF data */
for(n=nStartNext; n<nFrames-1; n++){
if(hrStart < 0 && fabs(MIRPOS[n+1] - MIRPOS[n]) >= EPSILON) {
nStart = n;
hrStart = n;
/*printf("%s: Split nStart=%d\n", TASK_NAME, nStart);*/
}
if(hrStart >= 0 && hrStop < 0 && (fabs(MIRPOS[n+1] - MIRPOS[n]) < EPSILON || n+1 == nFrames-1)) {
hrStop = n+1;
hrFramesOutPrev = hrFramesOut;
hrFramesOut = abs(hrStop - hrStart) + 1;
outDataCount++;
nStop = hrStop;
nFramesOutPrev = hrFramesOutPrev;
nFramesOut = hrFramesOut;
/*printf("%s: Split: %d of %d frames found at hrStart=%d, hrStop=%d\n",
TASK_NAME, outDataCount, hrFramesOut, hrStart, hrStop);*/
break;
}
}
/* Determine scan direction */
if(MIRPOS[hrStart] < MIRPOS[hrStop]) {
scanDir = 1; /* Positive */
} else {
scanDir = -1; /* Negative */
}
/* Limit to specified mirror position range */
if(LR) {
/* Calculate how many frames correspond to the given +/- mm of LR bandpass */
lrBandPassFrames = lrmmBandPass / dz;
/* Find the centre of the current scan */
lrCentre = floor((abs(hrStop-hrStart)+1)/2);
/* Set low res start and stop values at corresponding frame offsets from centre */
lrStart = lrCentre - lrBandPassFrames;
lrStop = lrCentre + lrBandPassFrames;
lrFramesOutPrev = lrFramesOut;
lrFramesOut = abs(lrStop - lrStart) + 1;
nStart = lrStart;
nStop = lrStop;
nFramesOutPrev = lrFramesOutPrev;
nFramesOut = lrFramesOut;
/*printf("%s: LR Split: %d of %d frames found at lrStart=%d, lrStop=%d\n",
TASK_NAME, outDataCount, lrFramesOut, lrStart, lrStop);*/
}
/* Check for end of data condition */
if(hrStop < hrStart || hrStop >= nFrames-1) {
hrStop = nFrames-1;
done = 1;
}
/* Output scan if there is a start and stop position found,
and for the last scan if it's the only one
and if it's not too short (compared to the previous one) */
/*printf("%s: nStart=%d, nStop=%d, nFramesOutPrev=%d, nFramesOut=%d\n", TASK_NAME, nStart, nStop, nFramesOutPrev, nFramesOut);*/
if(nStart >=0 && nStop > 0 &&
(nFramesOutPrev == 0 ||
(nFramesOutPrev > 0 && nFramesOut > 0 && (double)hrFramesOut/(double)hrFramesOutPrev >= 0.5))) {
/* Copy single scan NDF data from input to output */
outData = smf_deepcopy_smfData(inData, 0, SMF__NOCREATE_DATA | SMF__NOCREATE_FTS, 0, 0, status);
outData->dtype = SMF__DOUBLE;
outData->ndims = 3;
outData->dims[0] = nWidth;
outData->dims[1] = nHeight;
outData->dims[2] = nFramesOut;
outData_pntr = (double*) astMalloc((nPixels * nFramesOut) * sizeof(*outData_pntr));
outData->pntr[0] = outData_pntr;
outData->hdr->nframes = nFramesOut;
for(i=0; i<nWidth; i++) {
for(j=0; j<nHeight; j++) {
bolIndex = i + j * nWidth;
for(k=nStart; k<=nStop; k++) {
indexIn = bolIndex + k * nPixels;
indexOut = bolIndex + (k-nStart) * nPixels;
*((double*)(outData->pntr[0]) + indexOut) = *((double*)(inData->pntr[0]) + indexIn);
}
}
}
/* Update the FITS headers */
outData->fts = smf_create_smfFts(status);
/* Update FITS component */
smf_fits_updateD(outData->hdr, "FNYQUIST", fNyquist, "Nyquist frequency (cm^-1)", status);
smf_fits_updateI(outData->hdr, "MIRSTART", 1, "Frame index in which the mirror starts moving", status);
smf_fits_updateI(outData->hdr, "MIRSTOP", nFramesOut, "Frame index in which the mirror stops moving", status);
smf_fits_updateI(outData->hdr, "SCANDIR", scanDir, "Scan direction", status);
smf_fits_updateD(outData->hdr, "OPDMIN", 0.0, "Minimum OPD", status);
smf_fits_updateD(outData->hdr, "OPDSTEP", 0.0, "OPD step size", status);
/* Update the JCMTSTATE header */
/* Reallocate outData header array memory to reduced size */
allState = (JCMTState*) astRealloc(outData->hdr->allState, nFramesOut * sizeof(*(outData->hdr->allState)));
if(*status == SAI__OK && allState) {
outData->hdr->allState = allState;
} else {
errRepf(TASK_NAME, "Error reallocating allState JCMTState header", status);
goto CLEANUP;
}
for(k=nStart; k<=nStop; k++) {
/* Copy over JCMTstate */
/*printf("%s: memcpy allState: %d to: %p from: %p size: %d\n",TASK_NAME, k,
(void *) &(outData->hdr->allState[k-nStart]), (void *) &(inData->hdr->allState[k]), sizeof(*(outData->hdr->allState)) );*/
memcpy( (void *) &(outData->hdr->allState[k-nStart]), (void *) &(inData->hdr->allState[k]), sizeof(*(outData->hdr->allState)) );
/*printf("%s: Scan: %d index: %d rts_num: %d\n", TASK_NAME, outDataCount, k-nStart, outData->hdr->allState[k-nStart].rts_num);*/
/*printf("%s: Scan: %d index: %d fts_pos: %f\n", TASK_NAME, outDataCount, k-nStart, outData->hdr->allState[k-nStart].fts_pos);*/
}
/* Write output */
/* Append unique suffix to fileName */
/* This must be modified by the concatenation file scan number to improve uniqueness */
n = one_snprintf(outData->file->name, SMF_PATH_MAX, "%s%04d_scn.sdf", status, fileName, conNum+outDataCount);
/*printf("%s: Writing outData->file->name: %s\n", TASK_NAME, outData->file->name);*/
if(n < 0 || n >= SMF_PATH_MAX) {
errRepf(TASK_NAME, "Error creating outData->file->name", status);
goto CLEANUP;
}
/* Update the list of output _scn file names */
grpPut1(gOut, outData->file->name, 0, status);
if(*status != SAI__OK) {
errRepf(TASK_NAME, "Error saving outData file name", status);
goto CLEANUP;
}
smf_write_smfData(outData, NULL, outData->file->name, gOut, fIndex, 0, MSG__VERB, 0, status);
if(*status != SAI__OK) {
errRepf(TASK_NAME, "Error writing outData file", status);
goto CLEANUP;
}
smf_close_file(&outData, status);
if(*status != SAI__OK) {
errRepf(TASK_NAME, "Error closing outData file", status);
goto CLEANUP;
}
if(*status != SAI__OK) {
errRepf(TASK_NAME, "Error closing outData file", status);
goto CLEANUP;
}
}/* else {
if(!(nStart >=0 && nStop)) printf("%s: Output scan condition failed: nStart(%d) >= nStop(%d) is FALSE\n",TASK_NAME, nStart, nStop);
if(!(nFramesOutPrev == 0 ||
(nFramesOutPrev > 0 && nFramesOut > 0 && (double)nFramesOut/(double)nFramesOutPrev >= 0.5))) printf("%s: Output scan condition failed: nFramesOutPrev(%d) == 0 || (nFramesOutPrev(%d) > 0 && nFramesOut(%d) > 0 && nFramesOut/nFramesOutPrev (%f) >= 0.5) is FALSE\n", TASK_NAME, nFramesOutPrev, nFramesOutPrev, nFramesOut, (double)nFramesOut/(double)nFramesOutPrev);
}*/
/* Prepare for next iteration */
nStartNext = hrStop + 1;
hrStart = -1;
hrStop = -1;
} while (!done);
/* Deallocate memory used by arrays */
if(MIRPOS) { MIRPOS = astFree(MIRPOS); }
/* Close the file */
smf_close_file(&inData, status);
}
CLEANUP:
/* Deallocate memory used by arrays */
if(inData) { smf_close_file(&inData, status); }
if(outData) { smf_close_file(&outData, status); }
/* END NDF */
ndfEnd(status);
/* Write out the list of output NDF names, annulling the error if a null
parameter value is supplied. */
if( *status == SAI__OK && gOut ) {
grpList( "OUTFILES", 0, 0, NULL, gOut, status );
if( *status == PAR__NULL ) {
errRep(FUNC_NAME, "Error writing OUTFILES!", status);
errAnnul( status );
}
}
/* Delete groups */
if(gIn) { grpDelet(&gIn, status); }
if(gOut) { grpDelet(&gOut, status); }
}
/* Main entry */
void smurf_fixsteps( int *status ) {
/* Local Variables */
AstKeyMap *keymap; /* Default config parameter values */
AstKeyMap *sub_instruments; /* Info about sub-instruments */
FILE *fd = NULL; /* File descriptor */
Grp *igrp = NULL; /* Input group of files */
Grp *ogrp = NULL; /* Output group of files */
dim_t dcfitbox; /* DCFITBOX config parameter */
dim_t dcsmooth; /* DCSMOOTH config parameter */
dim_t nx; /* Length of first pixel axis */
double dcthresh; /* DCTHRESH config parameter */
double sizetol; /* Tolerance allowed on step height */
int changed; /* Have any step fixes changed? */
int dclimcorr; /* DCLIMCORR config parameter */
int dcmaxsteps; /* DCMAXSTEPS config parameter */
int first; /* Index of first change to report */
int itemp; /* Intermediate value */
int meanshift; /* Use a mean shift filter? */
int nnew; /* Number of new step fixes */
int nold; /* Number of old step fixes */
size_t nrej; /* Number of rejected bolometers */
size_t outsize; /* Total number of NDF names in the output group */
size_t size; /* Number of files in input group */
smfData *data = NULL; /* Output smfData */
smfData *indata = NULL; /* Input smfData */
smfStepFix *newsteps = NULL; /* New step fix descriptions */
smfStepFix *oldsteps = NULL; /* Old step fix descriptions */
ThrWorkForce *wf = NULL; /* Pointer to a pool of worker threads */
/* Check inherited status */
if (*status != SAI__OK) return;
/* begin an NDF context. */
ndfBegin();
/* Get the name of the input NDF. */
kpg1Rgndf( "IN", 1, 1, "", &igrp, &size, status );
/* Get output file(s) */
kpg1Wgndf( "OUT", igrp, size, 0, "More output files required...",
&ogrp, &outsize, status );
/* Open the input data file, read-only. */
smf_open_file( igrp, 1, "Read", 0, &indata, status );
/* Since we will be modifying the data values, we need a deep copy. */
data = smf_deepcopy_smfData( indata, 0, 0, 0, 0, status );
/* Place cleaning parameters into a keymap and set defaults. Note that we
use the map-maker defaults file here so that we populate the locked
keymap with all the parameters that people may come across to allow
them to load their map-maker config directly this application. */
sub_instruments = smf_subinst_keymap( SMF__SUBINST_NONE, data, NULL, 0,
status );
keymap = kpg1Config( "CONFIG", "$SMURF_DIR/smurf_makemap.def",
sub_instruments, status );
sub_instruments = astAnnul( sub_instruments );
/* Set the default for each of the step fixing config parameters. */
astMapGet0I( keymap, "DCSMOOTH", &itemp );
parDef0i( "DCSMOOTH", itemp, status );
astMapGet0I( keymap, "DCFITBOX", &itemp );
parDef0i( "DCFITBOX", itemp, status );
astMapGet0I( keymap, "DCMAXSTEPS", &itemp );
parDef0i( "DCMAXSTEPS", itemp, status );
astMapGet0I( keymap, "DCLIMCORR", &itemp );
parDef0i( "DCLIMCORR", itemp, status );
astMapGet0D( keymap, "DCTHRESH", &dcthresh );
parDef0d( "DCTHRESH", dcthresh, status );
/* Get values for the config params */
parGet0i( "DCSMOOTH", &itemp, status );
dcsmooth = itemp;
parGet0i( "DCFITBOX", &itemp, status );
dcfitbox = itemp;
parGet0i( "DCMAXSTEPS", &itemp, status );
dcmaxsteps = itemp;
parGet0i( "DCLIMCORR", &itemp, status );
dclimcorr = itemp;
parGet0d( "DCTHRESH", &dcthresh, status );
parGet0l( "MEANSHIFT", &meanshift, status );
/* Find the number of cores/processors available and create a pool of
threads of the same size. */
wf = thrGetWorkforce( thrGetNThread( SMF__THREADS, status ), status );
/* Fix the steps. */
smf_fix_steps( wf, data, dcthresh, dcsmooth, dcfitbox, dcmaxsteps,
dclimcorr, meanshift, &nrej, &newsteps, &nnew, status );
/* Display a summary of what was done by the step fixer. */
msgBlank( status );
if( nrej == 0 ) {
msgOut( "", "No bolometers were rejected", status );
} else if( nrej == 1 ) {
msgOut( "", "One bolometer was rejected", status );
} else {
msgSeti( "NREJ", nrej );
msgOut( "", "^NREJ bolometers were rejected", status );
}
parPut0i( "NREJECTED", nrej, status );
if( nnew == 0 ) {
msgOut( "", "No steps were fixed", status );
} else if( nnew == 1 ) {
msgOut( "", "One step was fixed", status );
} else {
msgSeti( "NNEW", nnew );
msgOut( "", "^NNEW steps were fixed", status );
}
parPut0i( "NFIXED", nnew, status );
/* If required, write out to a text file details of the steps that were
fixed. */
fd = smf_open_textfile( "NEWSTEPS", "w", "<none>", status );
if( fd ) {
smf1_write_steps( fd, indata, nnew, newsteps, dcthresh, dcsmooth,
dcfitbox, dcmaxsteps, dclimcorr, nrej, status );
fclose( fd );
}
/* If required, create the output NDF. */
if( outsize > 0 && indata && indata->file ) {
smf_write_smfData( data, NULL, NULL, ogrp, 1,
indata->file->ndfid, MSG__VERB, 0, status );
}
/* Save the length of the first pixel axis. */
nx = data ? data->dims[ 0 ] : 0;
/* Close the NDFs. */
smf_close_file( &data, status );
smf_close_file( &indata, status );
/* Attempt to open a file containing descriptions of steps fixed by a
previous invocation of this program. */
fd = smf_open_textfile( "OLDSTEPS", "r", "<none>", status );
if( fd ) {
/* Get SIZETOL - the minimum significant fractional error in step sizes. */
parGet0d( "SIZETOL", &sizetol, status );
/* Read the contents of the file, issuing a warning if the global
properties read from the file (e.g. parameters used, no. of steps
found, etc) differ from those of the current invocation. */
msgBlank( status );
oldsteps = smf1_read_steps( fd, dcthresh, dcsmooth,
dcfitbox, dcmaxsteps, dclimcorr,
nrej, nnew, &nold, status );
/* Get the index of the first change to report. */
parGet0i( "FIRST", &first, status );
/* Compare the new step fixes with the old step fixes, issuing a warning
for the first step fix that has changed. */
changed = smf1_check_steps( "CONTINUE", first, nx, sizetol,
nold, nnew, oldsteps, newsteps, status );
/* Store a flag indicating if any sstep fixes have chnaged. */
parPut0l( "CHANGED", changed, status );
/* Tell the user if nothing has changed. */
if( ! changed ) {
msgOut( "", "There are no significant differences "
"between old and new step fixes.", status );
}
msgBlank( status );
/* Close the old steps file, and free the memory holding the old step
descriptions. */
fclose( fd );
oldsteps = astFree( oldsteps );
}
/* Free resources. */
newsteps = astFree( newsteps );
grpDelet( &igrp, status );
grpDelet( &ogrp, status );
/* End the NDF context. */
ndfEnd( status );
/* If anything went wrong issue a context message. */
if( *status != SAI__OK ) msgOutif( MSG__VERB, " ", "FIXSTEPS failed.",
status );
}
void smf_flat_write( smf_flatmeth flatmeth, const char * flatname,
double refres, const smfData * bolval,
const smfData * powref, const smfData * bolref,
const smfData * polyfit, const Grp * prvgrp, int * status ) {
size_t colsize; /* number of columns */
double *dbuf = NULL; /* input double buffer for mean data */
double *dvar = NULL; /* input double buffer for variance of data */
char fitsrec[SC2STORE__MAXFITS*SZFITSCARD+1]; /* Store for FITS records */
int *ibuf = NULL; /* int buffer for mean data */
int indf = NDF__NOID; /* NDF identifier for output file */
size_t ncards; /* number of fits cards */
size_t numbols; /* number of bolometers */
double *outvar = NULL; /* buffer for variance of data */
int place = NDF__NOPL; /* Dummy placeholder for NDF */
size_t rowsize; /* number of rows */
JCMTState *state = NULL; /* State for this flatfield */
sc2ast_subarray_t subnum; /* subarray number */
AstFrameSet *result, *spacefset;
AstLutMap *heatmap;
AstFrame *heatfrm;
int *dksquid; /* pointer to dummy dark SQUID data */
size_t j; /* loop counter */
int jig_vert[1][2]; /* dummy jiggle vertices */
double jig_path[1][2]; /* dummy jiggle path */
size_t nframes = 0; /* Number of frames in bolval */
int npath = 0; /* size of jiggle path */
int nvert = 0; /* number of jiggle vertices */
char *xmlfile = NULL; /* dummy xmlfile name */
if (*status != SAI__OK) return;
if (!bolval->da) {
*status = SAI__ERROR;
errRep( "", "No flatfield solution provided for writing",
status );
return;
}
if (!bolval->da->heatval) {
*status = SAI__ERROR;
errRep( "", "Must provide heater values in DA struct to smf_flat_write"
" (possible programming error)", status );
return;
}
/* note that colsize is the number of rows and rowsize is the number of
columns */
colsize = (bolval->dims)[SC2STORE__ROW_INDEX];
rowsize = (bolval->dims)[SC2STORE__COL_INDEX];
numbols = colsize * rowsize;
nframes = (bolval->dims)[2];
/* Make sure we have a FLAT header that reflects this file
as the flatfield solution */
smf_fits_updateS( bolval->hdr, "FLAT", flatname, "Name of flat-field file",
status );
/* Create a FITS header for DA */
smf_fits_export2DA( bolval->hdr->fitshdr, &ncards, fitsrec, status );
/* Copy the data as integers so it can be written to data file. To
prevent overflow in the variance we store that as doubles */
ibuf = astMalloc( (numbols * nframes)*sizeof(*ibuf) );
outvar = astMalloc( (numbols * nframes)*sizeof(*outvar) );
dbuf = (bolval->pntr)[0];
dvar = (bolval->pntr)[1];
if (*status == SAI__OK) {
for (j = 0; j < (nframes * numbols); j++) {
/* These started off as integers so the mean value must fit in
an integer */
if ( dbuf[j] == VAL__BADD) {
ibuf[j] = VAL__BADI;
} else {
ibuf[j] = (int)dbuf[j];
}
/* Same data type so no need to convert bad values */
if (dvar) {
outvar[j] = dvar[j];
} else {
outvar[j] = VAL__BADD;
}
}
}
/* get subarray number */
smf_find_subarray( bolval->hdr, NULL, 0, &subnum, status );
/* Create dummy components for output file */
dksquid = astCalloc ( rowsize* nframes, sizeof(*dksquid) );
jig_vert[0][0] = 0;
jig_vert[0][1] = 0;
jig_path[0][0] = 0.0;
jig_path[0][1] = 0.0;
sc2store_setcompflag ( SC2STORE__NONE, status );
sc2store_wrtstream ( flatname, subnum, ncards,
fitsrec, colsize, rowsize, nframes,
(bolref->dims)[2], refres, 0, smf_flat_methstring( flatmeth, status ),
bolval->hdr->allState, NULL,
ibuf, dksquid, (bolref->pntr)[0], (powref->pntr)[0],
"FLATCAL", NULL, NULL, jig_vert,
nvert, jig_path, npath, xmlfile, status );
sc2store_free ( status );
/* To copy in the variance and modify fix up the WCS we need to reopen
the file */
ndfOpen( NULL, flatname, "UPDATE", "OLD", &indf, &place, status );
/* make sure that history is not written twice */
ndfHsmod( "SKIP", indf, status );
if (outvar) {
void *pntr[3];
int el;
ndfStype( "_DOUBLE", indf, "VARIANCE", status );
ndfMap( indf, "VARIANCE", "_DOUBLE", "WRITE", pntr, &el, status );
if (*status == SAI__OK) {
memcpy( pntr[0], outvar, sizeof(*outvar)*el );
}
}
/* For the WCS a time frame is less relevant than heater settings */
astBegin;
/* Create frame for focal plane coordinates */
sc2ast_createwcs( subnum, NULL, NULL, NULL, NO_FTS, &spacefset, status );
/* Copy it to make sure we do not mess with the cache */
result = astCopy( spacefset );
/* and switch to BOLO frame which is best for bolometer analysis */
{
int frnum = AST__NOFRAME;
kpg1Asffr( result, "BOLO", &frnum, status );
if (frnum != AST__NOFRAME) astSetI( result, "CURRENT", frnum );
}
/* Create a simple frame for heater settings */
heatfrm = astFrame( 1, "Domain=HEATER,Label(1)=Heater Setting" );
heatmap = astLutMap( nframes, bolval->da->heatval, 1.0, 1.0, " " );
/* Append the heater axis to the spatial frameset */
atlAddWcsAxis( result, (AstMapping *)heatmap, (AstFrame *) heatfrm,
NULL, NULL, status );
/* write it to the NDF */
ndfPtwcs( result, indf, status );
/* Write provenance information */
if (prvgrp) {
size_t size = grpGrpsz( prvgrp, status );
char prvname[ 2 * PAR__SZNAM + 1];
smf_get_taskname( NULL, prvname, status );
for (j=1; j<=size; j++) {
smf_accumulate_prov( NULL, prvgrp, j, indf, prvname, NULL, status );
}
}
/* Write the polynomial expansion into an extension */
if (polyfit) {
char fitfile[GRP__SZNAM+1];
int fndf = NDF__NOID;
place = NDF__NOPL;
one_strlcpy( fitfile, flatname, sizeof(fitfile), status );
one_strlcat( fitfile, ".MORE.SMURF.FLATFIT", sizeof(fitfile), status );
/* create the file */
smf_write_smfData( polyfit, NULL, fitfile, NULL, 0, NDF__NOID,
MSG__VERB, 0, status );
/* Same WCS as the main file */
ndfOpen( NULL, fitfile, "UPDATE", "OLD", &fndf, &place, status );
ndfPtwcs( result, fndf, status );
ndfAnnul( &fndf, status );
}
astEnd;
ndfAnnul( &indf, status);
if (ibuf) ibuf = astFree( ibuf );
if (outvar) outvar = astFree( outvar );
if (dksquid) dksquid = astFree( dksquid );
if (state) state = astFree( state );
}
void smurf_fts2_transcorr(int* status)
{
if( *status != SAI__OK ) { return; }
char filename[GRP__SZNAM+1]; /* Filename */
char *pname = NULL; /* Pointer to filename */
int bolCount = 0; /* Number of bolometers */
int bolIndex = 0; /* Bolometer index */
int count;
int dims[NDF__MXDIM];
int debug = 0; /* If not debug, include dry component */
int ftsExists = 0;
int index = 0;
int indf; /* NDF identifier for TAU file */
int KERNELLENGTH = 101;
int nbolX = 0; /* Width of the source subarray */
int nbolY = 0; /* Height of the source subarray */
int ndfTau;
int ndim;
int nPWV = 0;
int nWN = 0;
int N = 0; /* Sample count */
int i = 0; /* Index */
int j = 0; /* Index */
int k = 0; /* Index */
int place;
double AM = 0.0; /* Airmass at ZPD */
double DELTAPWV = 0.0;
double PWV0 = 0.0;
double PWV = 0.0; /* PWV at ZPD */
double wnFact = 0.0; /* Wave number factor */
double* inPntr = NULL; /* Pointer to the input data */
double* outPntr = NULL; /* Pointer to the output data */
double* wnScan = NULL;
double* wnTau = NULL;
double* TAtm = NULL;
double* TAtmNew = NULL;
double* GAUSSIANKERNEL = NULL;
double* PWVARR = NULL;
double* PWVNEW = NULL;
double* TAUNEW = NULL;
double* TAUWET = NULL;
double* TMPARR = NULL;
Grp* inGrp = NULL; /* Input group */
Grp* outGrp = NULL; /* Output group */
Grp* tauGrp = NULL; /* TAU WET group */
HDSLoc* loc = NULL; /* HDS location */
size_t fIndex = 0; /* File loop counter */
size_t inSize = 0; /* Size of the input group */
size_t outSize = 0; /* Size of the output group */
size_t tauSize = 0; /* Size of the tau group */
smfData* inData = NULL; /* Pointer to input data */
smfData* outData = NULL; /* Pointer to output data */
smfData* tauData = NULL; /* Pointer to tau dry data */
void* TAU[] = {NULL, NULL}; /* {dry, wet} */
const double SQRT2PI = 2.50662827463100050242;
const double SQRT2LN2 = 1.17741002251547469101;
// GET INPUT GROUP
kpg1Rgndf("IN", 0, 1, "", &inGrp, &inSize, status);
// GET OUTPUT GROUP
kpg1Wgndf("OUT", outGrp, inSize, inSize,
"Equal number of input and output files expected!",
&outGrp, &outSize, status);
// GET TAU GROUP
kpg1Gtgrp("TAU", &tauGrp, &tauSize, status);
parGet0l("DEBUG", &debug, status);
ndfBegin();
// ===========================================================================
// GET TAU INFORMATION
// ===========================================================================
int dryOK = 0;
int wetOK = 0;
pname = filename;
grpGet(tauGrp, 1, 1, &pname, sizeof(filename), status);
ndgNdfas(tauGrp, 1, "READ", &indf, status );
if (indf == NDF__NOID) {
*status = SAI__ERROR;
msgSetc("FILE", filename);
errRep("", FUNC_NAME ": Could not locate file ^FILE", status);
return;
}
ndfXstat(indf, "FTS2", &ftsExists, status);
if(*status == SAI__OK && ftsExists) {
ndfXloc(indf, "FTS2", "READ", &loc, status);
if(*status == SAI__OK && loc != NULL) {
// DRY COMPONENT
ndfOpen(loc, "DRY", "READ", "UNKNOWN", &ndfTau, &place, status);
if(*status == SAI__OK && ndfTau != NDF__NOID) {
ndfDim(ndfTau, NDF__MXDIM, dims, &ndim, status);
if(*status == SAI__OK && ndim == 1) {
ndfMap(ndfTau, "DATA", "_DOUBLE", "READ", &TAU[0], &count, status);
dryOK = 1;
}
}
// WET COMPONENT
ndfOpen(loc, "WET", "READ", "UNKNOWN", &ndfTau, &place, status);
if(*status == SAI__OK && ndfTau != NDF__NOID) {
ndfDim(ndfTau, NDF__MXDIM, dims, &ndim, status);
if(*status == SAI__OK && ndim == 2) {
ndfMap(ndfTau, "DATA", "_DOUBLE", "READ", &TAU[1], &count, status);
wetOK = 1;
}
}
}
}
if(loc) { datAnnul(&loc, status); }
if(!(dryOK && wetOK)) {
*status = SAI__ERROR;
errRep("", FUNC_NAME ": Unable to obtain TAU values!", status);
return;
}
smf_open_file(NULL, tauGrp, 1, "READ", 0, &tauData, status);
smf_fits_getD(tauData->hdr, "PWV0", &PWV0, status);
smf_fits_getD(tauData->hdr, "DELTAPWV", &DELTAPWV, status);
if(*status != SAI__OK) {
*status = SAI__ERROR;
errRep("", FUNC_NAME ": Unable to obtain PWV value(s)!", status);
return;
}
nWN = dims[0];
nPWV = dims[1];
PWVARR = astMalloc(nPWV * sizeof(*PWVARR));
for(i = 0; i < nPWV; i++) {
PWVARR[i] = PWV0 + i * DELTAPWV;
}
PWVNEW = astMalloc(1 * sizeof(*PWVNEW));
TAUNEW = astMalloc(1 * sizeof(*TAUNEW));
// ===========================================================================
// LOOP THROUGH EACH NDF FILE IN THE INPUT GROUP
// ===========================================================================
for(fIndex = 1; fIndex <= inSize; fIndex++) {
// OPEN INPUT FILE
smf_open_file(NULL, inGrp, fIndex, "READ", 0, &inData, status);
if(*status != SAI__OK) {
*status = SAI__ERROR;
errRep(FUNC_NAME, "Unable to open source file!", status);
break;
}
outData = smf_deepcopy_smfData(NULL, inData, 0, SMF__NOCREATE_DATA, 0, 0, status);
if(*status == SAI__OK) {
inPntr = inData->pntr[0];
nbolX = inData->dims[0];
nbolY = inData->dims[1];
N = inData->dims[2];
bolCount = nbolX * nbolY;
outData->dtype = SMF__DOUBLE;
outData->ndims = 3;
outData->dims[0] = inData->dims[0];
outData->dims[1] = inData->dims[1];
outData->dims[2] = inData->dims[2];
outData->lbnd[0] = outData->lbnd[0];
outData->lbnd[1] = outData->lbnd[1];
outData->lbnd[2] = outData->lbnd[2];
outData->pntr[0] = (double*) astMalloc( (N * bolCount)*sizeof(double) );
outPntr = outData->pntr[0];
// DETERMINE WAVENUMBER FACTOR FROM FITS
smf_fits_getD(inData->hdr, "WNFACT", &wnFact, status);
if(*status != SAI__OK) {
errRep(FUNC_NAME, "Unable to find wave number factor!", status);
smf_close_file( NULL,&inData, status);
break;
}
// TODO
// DETERMINE AIRMASS AT ZPD
// TODO
// DETERMINE PWV AT ZPD
PWVNEW[0] = PWV;
// GET TAU WET FOR CORRESPONDING PWV
TAUWET = astMalloc(nWN * sizeof(*TAUWET));
TMPARR = astMalloc(nWN * sizeof(*TMPARR));
for(k = 0; k < nWN; k++) {
for(j = 0; j < nPWV; j++) {
TMPARR[j] = *((double*) TAU[1] + j);
}
fts2_naturalcubicsplineinterpolator(PWVARR, TMPARR, nPWV, PWVNEW, TAUNEW, 1);
TAUWET[k] = TAUNEW[0];
}
astFree(TMPARR);
// COMPUTE ATMOSPHERIC TRANSMISSION
// TATM = EXP(-AIRMASS * (PWV * TAUWET + TAUDRY))
TAtm = astMalloc(nWN * sizeof(*TAtm));
if(!debug) {
for(i = 0; i < nWN; i++) {
TAtm[i] = exp(-AM * (PWV * TAUWET[i] + (*((double*) TAU[0] + i))));
}
} else {
for(i = 0; i < nWN; i++) {
TAtm[i] = exp(-AM * PWV * TAUWET[i]);
}
}
// SMOOTH ATMOSPHERIC TRANSMISSION VIA GAUSSIAN CONVOLUTION
// NEED TO TRIM FROM BOTH ENDS BY HALF OF (KERNELLENGTH - 1)
double OPDMAX = 1.0;
double FWHM = 1.0 / (2.0 * OPDMAX); // FWHM = 1 / (2 x OPDMAX)
double SDEV = 0.5 * FWHM / SQRT2LN2; // FWHM = 2 x SQRT(2ln2) x SDEV
double VAR = SDEV * SDEV;
double VAR2 = 2.0 * VAR;
double NORM = 1.0 / (SDEV * SQRT2PI);
double XMIN = -6 * SDEV;
double XMAX = 6 * SDEV;
double DX = (XMAX - XMIN) / (KERNELLENGTH - 1);
double X = XMIN;
for(i = 0; i < KERNELLENGTH; i++) {
X = XMIN + i * DX;
GAUSSIANKERNEL[i] = NORM * exp(-(X * X) / VAR2);
}
int M = nWN + KERNELLENGTH - 1;
TMPARR = astMalloc(M * sizeof(*TMPARR));
for(i = 0; i < nWN; i++) {
for(j = 0; j < KERNELLENGTH; j++) {
TMPARR[i + j] += (TAtm[i] * GAUSSIANKERNEL[j]);
}
}
int OFFSET = (KERNELLENGTH - 1) >> 1;
for(i = 0; i < nWN; i++) {
TAtm[i] = TMPARR[i + OFFSET];
}
astFree(TMPARR);
// INTERPOLATE ATMOSPHERIC TRANSMISSION ONTO SCAN RESOLUTION
wnTau = astMalloc(nWN * sizeof(*wnTau));
wnScan = astMalloc(N * sizeof(*wnScan));
TAtmNew = astMalloc(N * sizeof(*TAtmNew));
for(i = 0; i < N; i++) {
wnScan[i] = i * wnFact;
}
for(i = 0; i < nWN; i++) {
wnTau[i] = i;
}
fts2_naturalcubicsplineinterpolator(wnTau, TAtm, nWN, wnScan, TAtmNew, N);
// TSOURCE = TOBS / TATM
for(i = 0; i < nbolY; i++) {
for(j = 0; j < nbolX; j++) {
bolIndex = i + j * nbolY;
for(k = 0; k < N; k++) {
index = bolIndex + bolCount * k;
outPntr[index] = inPntr[index] / TAtmNew[k];
}
}
}
astFree(wnTau);
astFree(wnScan);
astFree(TAtm);
astFree(TAtmNew);
smf_write_smfData(NULL, outData, NULL, NULL, outGrp, fIndex, 0, MSG__VERB,
0, status);
smf_close_file( NULL,&outData, status);
smf_close_file( NULL,&inData, status);
} else {
void smurf_fts2_spectrum(int* status)
{
if( *status != SAI__OK ) { return; }
const char* dataLabel = "Spectrum"; /* Data label */
Grp* gIn = NULL; /* Input group */
Grp* gOut = NULL; /* Output group */
Grp* gSfp = NULL; /* SFP group */
smfData* inData = NULL; /* Pointer to input data */
smfData* outData = NULL; /* Pointer to output data */
smfData* sfpData = NULL; /* Pointer to SFP data */
/*smfData* sfp = NULL;*/ /* Pointer to SFP index data */
int doSFP = 0; /* Only apply SFP if given */
int zeropad = 1; /* Determines whether to zeropad */
double resolution = 0.0; /* Spectral Resolution */
double resolutionin = 0.0; /* Spectral Resolution input */
double resolutionzp = 0.0; /* Spectral Resolution zero padded */
double resolution_override= 0.0; /* Spectral Resolution override */
int i = 0; /* Counter */
int j = 0; /* Counter */
int k = 0; /* Counter */
int l = 0; /* Counter */
double fNyquist = 0.0; /* Nyquist frequency */
double fNyquistin = 0.0; /* Nyquist frequency input */
double fNyquistzp = 0.0; /* Nyquist frequency zero padded */
double dSigma = 0.0; /* Spectral Sampling Interval */
double dSigmain = 0.0; /* Spectral Sampling Interval zero padded */
double dSigmazp = 0.0; /* Spectral Sampling Interval zero padded */
double* IFG = NULL; /* Interferogram */
double* SFP = NULL; /* Spectral Filter Profile for all pixels */
double* SFPij = NULL; /* Spectral Filter Profile for a single pixel */
double wavelen = 0.0; /* The central wave length of the subarray filter (m) */
double wnSfpFirst = 10.600; /* Starting 850 band SFP wave number */
double wnSfpLast = 12.800; /* Ending 850 band SFP wave number */
double wnSfp850First = 11.220; /* Starting 850 band SFP wave number */
double wnSfp850Last = 12.395; /* Ending 850 band SFP wave number */
/*double wnSfp850First = 10.600;*/ /* Starting 850 band SFP wave number */
/*double wnSfp850Last = 12.800;*/ /* Ending 850 band SFP wave number */
double wnSfp450First = 21.630; /* Starting 450 band SFP wave number */
double wnSfp450Last = 23.105; /* Ending 450 band SFP wave number */
double wnSfpFirst_override= 0.0; /* Starting SFP wave number override */
double wnSfpLast_override = 0.0; /* Ending SFP wave number override */
double wnSfpResolution = 0.025; /* The resolution of the SFP wave numbers (1/cm) */
double wnSfpF = 0.0; /* Starting SFP wave number */
double wnSfpL = 0.0; /* Ending SFP wave number */
double* WN = NULL; /* Wave Numbers from SFP */
double* DS = NULL; /* Double Sided Interferogram */
fftw_complex* DSIN = NULL; /* Double-Sided interferogram, FFT input */
fftw_complex* SPEC = NULL; /* Spectrum */
fftw_plan plan = NULL; /* fftw plan */
gsl_interp_accel* ACC = NULL; /* SFP interpolator */
gsl_spline* SPLINE = NULL; /* SFP interpolation spline */
size_t nFiles = 0; /* Size of the input group */
size_t nOutFiles = 0; /* Size of the output group */
size_t nSFPFiles = 0; /* Size of the SFP group */
size_t nSfp = 89; /* Number of SFP calibration file values */
size_t fIndex = 0; /* File index */
size_t nWidth = 32; /* Data cube width */
size_t nHeight = 40; /* Data cube height */
size_t nFrames = 0; /* Data cube depth */
size_t nPixels = nWidth*nHeight; /* Number of bolometers in the subarray */
double dIntensity = 0;
int N = 0;
int Nin = 0; /* N input */
int Nzp = 0; /* N zero padded */
int N2 = 0;
int N2in = 0; /* N/2 input */
int N2zp = 0; /* N/2 zero padded */
int bolIndex = 0;
int cubeIndex = 0;
int badPixel = 0;
int indexZPD = 0;
int indexZPDin = 0;
int indexZPDzp = 0;
int pad = 0; /* zero padding (difference between input and zero padded interferogram length) */
int pad2 = 0; /* zero padding / 2 */
double dx = 0.0; /* Delta x */
double dxin = 0.0; /* Delta x input */
double dxzp = 0.0; /* Delta x zero padded */
double OPDMax = 0.0; /* OPD max in cm */
double OPDMaxin = 0.0; /* OPD max in cm input */
double OPDMaxzp = 0.0; /* OPD max in cm zero padded */
double s = 0.0; /* spectrum value */
double f = 0.0; /* filter value */
#define DEBUG 0
/* Get Input & Output groups */
kpg1Rgndf("IN", 0, 1, "", &gIn, &nFiles, status);
kpg1Wgndf("OUT", gOut, nFiles, nFiles, "Equal number of input and output files expected!", &gOut, &nOutFiles, status);
kpg1Gtgrp("SFP", &gSfp, &nSFPFiles, status);
if(*status != SAI__OK) {
/* TODO: Check for any other possible error conditions */
/* Assume SFP calibration file not given, and proceed without it */
doSFP = 0;
*status = SAI__OK;
} else {
if(nSFPFiles > 0) doSFP = 1;
}
/* Read in ADAM parameters */
parGet0i("ZEROPAD", &zeropad, status);
/* Resolution */
parGet0d("RESOLUTION", &resolution_override, status);
if(doSFP) {
/* SFP WN Range overrides */
parGet0d("WNSFPFIRST", &wnSfpFirst_override, status);
if(*status != SAI__OK) {
*status = SAI__OK; /* Allow null */
wnSfpFirst_override = 0.0;
}
parGet0d("WNSFPLAST", &wnSfpLast_override, status);
if(*status != SAI__OK) {
*status = SAI__OK; /* Allow null */
wnSfpLast_override = 0.0;
}
}
/* BEGIN NDF */
ndfBegin();
/* Loop through each input file */
for(fIndex = 1; fIndex <= nFiles; fIndex++) {
/* Open Observation file */
smf_open_file(NULL, gIn, fIndex, "READ", SMF__NOFIX_METADATA, &inData, status);
if(*status != SAI__OK) {
*status = SAI__ERROR;
errRep(FUNC_NAME, "Unable to open the source file!", status);
goto CLEANUP;
}
/* Data cube dimensions */
nWidth = inData->dims[0];
nHeight = inData->dims[1];
nFrames = inData->dims[2];
nPixels = nWidth * nHeight;
/*printf("%s: nWidth=%d, nHeight=%d, nPixels=%d, nFrames=%d\n", TASK_NAME, nWidth, nHeight, nPixels, nFrames);*/
/* Check if the file is initialized for FTS2 processing */
if(!(inData->fts)) {
*status = SAI__ERROR;
errRep( FUNC_NAME, "The file is NOT initialized for FTS2 data reduction!", status);
goto CLEANUP;
}
/* Read in the Nyquist frequency from FITS component */
smf_fits_getD(inData->hdr, "FNYQUIST", &fNyquist, status);
if(*status != SAI__OK) {
*status = SAI__ERROR;
errRep(FUNC_NAME, "Unable to find the Nyquist frequency in FITS component!", status);
goto CLEANUP;
}
/* Read in the wave length (m) from the FITS header to determine the band */
smf_fits_getD(inData->hdr, "WAVELEN", &wavelen, status);
if(*status != SAI__OK) {
*status = SAI__ERROR;
errRep(FUNC_NAME, "Unable to find the wavelen in the FITS header!", status);
goto CLEANUP;
}
/* Set WN SFP range according to band */
if(wavelen == 0.00085) {
wnSfpFirst = wnSfp850First;
wnSfpLast = wnSfp850Last;
} else if(wavelen == 0.00045) {
wnSfpFirst = wnSfp450First;
wnSfpLast = wnSfp450Last;
}
/*printf("%s: wnSfpFirst_override=%f, wnSfpLast_override=%f\n", TASK_NAME, wnSfpFirst_override, wnSfpLast_override);*/
/*printf("%s: wnSfpFirst=%f, wnSfpLast=%f\n", TASK_NAME, wnSfpFirst, wnSfpLast);*/
if(wnSfpFirst_override) {
wnSfpF = wnSfpFirst_override;
} else {
wnSfpF = wnSfpFirst;
}
if(wnSfpLast_override) {
wnSfpL = wnSfpLast_override;
} else {
wnSfpL = wnSfpLast;
}
/*printf("%s: wnSfpF=%f, wnSfpL=%f\n", TASK_NAME, wnSfpF, wnSfpL);*/
fNyquistin = fNyquistzp = 0.0;
dx = dxin = dxzp = 0.0;
N2 = N2in = N2zp = 0;
indexZPD = indexZPDin = indexZPDzp = 0;
N = Nin = Nzp = 0;
dSigma = dSigmain = dSigmazp = 0.0;
fNyquistin = fNyquist;
dxin = (1/(2*fNyquistin));
N2in = (nFrames / 2);
indexZPDin = N2in - 1;
Nin = 2 * N2in;
OPDMaxin = N2in * dxin;
if(resolution_override > 0.0) {
resolution = resolution_override;
resolutionin = resolution_override;
} else {
resolution = 1 / (2 * OPDMaxin);
resolutionin = resolution;
}
dSigmain = fNyquistin / N2in;
if(zeropad) {
if(DEBUG) {
/* Make the zero-padded array twice the size of the input */
fNyquistzp = fNyquist;
Nzp = N2in * 4;
N2zp = Nzp / 2;
dxzp = 1 / (2 * fNyquistzp);
OPDMaxzp = N2zp * dxzp;
dSigmazp = fNyquistzp / N2zp;
resolutionzp = 1 / (2 * OPDMaxzp);
} else {
/* Round Nyquist frequency down to nearest integer, for calculation convenience
fNyquistzp = floor(fNyquist);
smf_fits_updateD(inData->hdr, "FNYQUIST", fNyquistzp, "Nyquist frequency (cm^-1)", status);*/
/* Never change nyquist when zero padding */
fNyquistzp = fNyquist;
/* If resolution > 0.05, then round down to nearest 0.05 value, else set to 0.005 */
/* Calculate resolution as 1 / (2*OPDMax) */
/* Calculate OPDMax as N2 * dx */
if(resolution_override) {
resolutionzp = resolution_override;
} else {
if(resolution > 0.05) {
resolutionzp = floor(resolution/0.05) * 0.05;
} else {
resolutionzp = 0.005;
}
}
/* Calculate OPDMaxOut as 1 / (2 * resolutionzp) */
OPDMaxzp = 1 / (2 * resolutionzp);
/* Calculate N2 */
dxzp = (1/(2*fNyquistzp));
N2zp = (OPDMaxzp / dxzp);
indexZPDzp = N2zp - 1;
Nzp = 2 * N2zp;
dSigmazp = fNyquistzp / N2zp;
}
}
/*printf("%s: Nin=%d, Nzp=%d, N2in=%d, N2zp=%d, indexZPDin=%d, indexZPDzp=%d, dSigmain=%f, dSigmazp=%f, fNyquistin=%f, fNyquistzp=%f, dxin=%f, dxzp=%f, OPDMaxin=%f, OPDMaxzp=%f, resolutionin=%f, resolutionzp=%f\n",
TASK_NAME, Nin, Nzp, N2in, N2zp, indexZPDin, indexZPDzp, dSigmain, dSigmazp, fNyquistin, fNyquistzp, dxin, dxzp, OPDMaxin, OPDMaxzp, resolutionin, resolutionzp);*/
if(zeropad) {
N = Nzp;
N2 = N2zp;
indexZPD = indexZPDzp;
dSigma = dSigmazp;
fNyquist = fNyquistzp;
dx = dxzp;
OPDMax = OPDMaxzp;
resolution = resolutionzp;
} else {
N = Nin;
N2 = N2in;
indexZPD = indexZPDin;
dSigma = dSigmain;
fNyquist = fNyquistin;
dx = dxin;
OPDMax = OPDMaxin;
resolution = resolutionin;
}
/* Save wavenumber factor to FITS extension */
smf_fits_updateD(inData->hdr, "WNFACT", dSigma, "Wavenumber factor cm^-1", status);
/* TODO: Update mirror positions */
smf_fits_updateI(inData->hdr, "MIRSTART", 0, "Frame index in which the mirror starts moving", status);
smf_fits_updateI(inData->hdr, "MIRSTOP", N2, "Frame index in which the mirror stops moving", status);
/*smf_fits_updateD(inData->hdr, "OPDMIN", OPD_EVEN[0], "Minimum OPD", status);
smf_fits_updateD(inData->hdr, "OPDSTEP", dx, "OPD step size", status);*/
/* Copy input data into output data */
outData = smf_deepcopy_smfData(NULL, inData, 0, SMF__NOCREATE_DATA, 0, 0, status);
outData->dtype = SMF__DOUBLE;
outData->ndims = 3;
outData->dims[0] = nWidth;
outData->dims[1] = nHeight;
outData->dims[2] = N2+1;
outData->pntr[0] = (double*) astMalloc((nPixels * (N2+1)) * sizeof(double));
if (dataLabel) { one_strlcpy(outData->hdr->dlabel, dataLabel, sizeof(outData->hdr->dlabel), status ); }
/* Allocate memory for arrays */
IFG = astCalloc(N, sizeof(*IFG));
DS = astCalloc(N, sizeof(*DS));
DSIN = fftw_malloc(N * sizeof(*DSIN));
SPEC = fftw_malloc(N * sizeof(*SPEC));
/* Initialize arrays */
for(k = 0; k < N; k++) { SPEC[k][0] = SPEC[k][1] = DSIN[k][0] = DSIN[k][1] = DS[k] = IFG[k] = 0.0; }
/* Open the SFP calibration file, if given */
if(doSFP) {
smf_open_file(NULL, gSfp, 1, "READ", SMF__NOCREATE_QUALITY, &sfpData, status);
if(*status != SAI__OK) {
*status = SAI__ERROR;
errRep(FUNC_NAME, "Unable to open the SFP calibration file!", status);
goto CLEANUP;
}
/* Read in the number of data elements */
nSfp = sfpData->dims[1] / nPixels;
/* Allocate memory for arrays */
SFP = astCalloc(nSfp*nPixels, sizeof(*SFP));
SFPij = astCalloc(nSfp, sizeof(*SFP));
WN = astCalloc(nSfp, sizeof(*WN));
/* DEBUG: Dispay SFP data */
/*printf("smurf_fts2_spectrum ([%d,%d,%d] elements): WN, SFP\n", (int)sfpData->dims[0],(int)sfpData->dims[1],(int)sfpData->dims[2]);*/
for(k=0;k<nSfp;k++){
/* printf("WN:%.3f,SFP:%.10f\n", *((double*) (sfpData->pntr[0]) + i), *((double*) (sfpData->pntr[0]) + i+1)); */
/* Adjust starting and ending wave number ranges for 450 or 850 bands */
if(wavelen == 0.00085 || wavelen == 0.00045) {
WN[k] = wnSfpFirst + k * wnSfpResolution;
} else {
*status = SAI__ERROR;
errRep(FUNC_NAME, "Unexpected WAVELEN value found in the FITS header!", status);
goto CLEANUP;
}
/*printf("SFP WN[%d]=%f\n",k,WN[k]);*/
for(j=0;j<nHeight;j++) {
for(i=0;i<nWidth;i++) {
bolIndex = i + j * nWidth;
cubeIndex = bolIndex + k * nPixels;
SFP[cubeIndex] = *((double*) (sfpData->pntr[0]) + cubeIndex);
/*if(i==10 && j==20) printf("SFP i:%d,j:%d,k:%d,bolIndex:%d,cubeIndex:%d=%f\n",i,j,k,bolIndex,cubeIndex,SFP[cubeIndex]);*/
}
}
}
/*printf("smurf_fts2_spectrum DEBUG: early exiting!\n");
exit(0); */
/* Create a 2D SFP index array and store it in the file, if given
sfp = smf_create_smfData(SMF__NOCREATE_DA | SMF__NOCREATE_FTS, status);
sfp->dtype = SMF__INTEGER;
sfp->ndims = 2;
sfp->dims[0] = nSfp;
sfp->dims[1] = 2;
sfp->pntr[0] = (int*) astCalloc(nSfp*2, sizeof(double));
// By default set ZPD indices to a bad value
for(i = 0; i < nSfp; i++) {
for(j = 0; j < 2; j++) {
bolIndex = i + j * 2;
*((int*) (sfp->pntr[0]) + bolIndex) = VAL__BADI;
}
} */
/* Prepare GSL interpolator to convert SFP data to this spectrum's resolution */
ACC = gsl_interp_accel_alloc();
SPLINE = gsl_spline_alloc(gsl_interp_cspline, nSfp);
}
for(i = 0; i < nWidth; i++) {
for(j = 0; j < nHeight; j++) {
bolIndex = i + j * nWidth;
badPixel = 0;
for(k = 0; k < Nin; k++) {
dIntensity = *((double*)(inData->pntr[0]) + (bolIndex + k * nPixels));
if(dIntensity == VAL__BADD) {
badPixel = 1;
break;
}
}
/* If this is a bad pixel, go to next */
if(badPixel) {
for(k = 0; k <= N2in; k++) {
*((double*)(outData->pntr[0]) + (bolIndex + k * nPixels)) = VAL__BADD;
}
continue;
}
/* Double-Sided interferogram */
if(zeropad) {
pad = Nzp - Nin;
pad2 = pad / 2;
/* Copy the right half of the input into the left half of this IFG, zero padded in the middle */
for(k=indexZPDin; k<Nin; k++) {
/*printf("%s: IFG: indexZPDin=%d, indexZPDzp=%d, Nin=%d, Nzp=%d, k=%d, l=%d\n", TASK_NAME, indexZPDin, indexZPDzp, Nin, Nzp, k, l);*/
IFG[k - indexZPDin] = *((double*)(inData->pntr[0]) + (bolIndex + k * nPixels));
/*if(i==16 && j==25) {
printf("%s: Pixel[%d,%d]: (L<-R) IFG[k(%d)-indexZPDin(%d)=%d] = inData->pntr[bolIndex(%d)+k(%d)*nPixels(%d)=%d] = %g\n",
TASK_NAME, i, j, k, indexZPDin, (k - indexZPDin), bolIndex, k, nPixels, (bolIndex + k * nPixels), IFG[k - indexZPDin]);
}*/
}
/* Copy the left half of the input into the right half of this IFG, zero padded in the middle */
for(k=0,l=0; k<indexZPDin; k++) {
IFG[Nzp - indexZPDin + k] = *((double*)(inData->pntr[0]) + (bolIndex + k * nPixels));
/*if(i==16 && j==25) {
printf("%s: Pixel[%d,%d]: (L->R) IFG[Nzp(%d)-indexZPDin(%d)+k(%d)=%d] = inData->pntr[bolIndex(%d)+k(%d)*nPixels(%d)=%d] = %g\n",
TASK_NAME, i, j, Nzp, indexZPDin, k, (Nzp-indexZPDin+k), bolIndex, k, nPixels, (bolIndex+k*nPixels), IFG[Nzp-indexZPDin+k]);
}*/
}
} else {
/* Copy the right half of the input into the left half of this IFG */
for(k=indexZPD; k<N; k++) {
IFG[k - indexZPD] = *((double*)(inData->pntr[0]) + (bolIndex + k * nPixels));
/*if(i==16 && j==25) {
printf("%s: Pixel[%d,%d]: (L<-R) IFG[k(%d)-indexZPD(%d)=%d] = inData->pntr[bolIndex(%d)+k(%d)*nPixels(%d)=%d] = %f\n",
TASK_NAME, i, j, k, indexZPD, (k - indexZPD), bolIndex, k, nPixels, (bolIndex + k * nPixels), IFG[k - indexZPD]);
}*/
}
/* Copy the left half of the input into the right half of this IFG */
for(k=0; k<indexZPD; k++) {
IFG[N - indexZPD + k] = *((double*)(inData->pntr[0]) + (bolIndex + k * nPixels));
/*if(i==16 && j==25) {
printf("%s: Pixel[%d,%d]: (L->R) IFG[N(%d)-indexZPD(%d)+k(%d)=%d] = inData->pntr[bolIndex(%d)+k(%d)*nPixels(%d)=%d] = %f\n",
TASK_NAME, i, j, N, indexZPD, k, (N - indexZPD + k), bolIndex, k, nPixels, (bolIndex + k * nPixels), IFG[N - indexZPD + k]);
}*/
}
}
/* DEBUG: Write out input data
for(k = 0; k < Nin; k++) {
*((double*)(outData->pntr[0]) + (bolIndex + nPixels * k)) =
*((double*)( inData->pntr[0]) + (bolIndex + nPixels * k));
if(i==16 && j==25) {
printf("%s: inData[%d,%d,%d]=%g\n",TASK_NAME, i, j, k, *((double*)( inData->pntr[0]) + (bolIndex + nPixels * k)));
}
} */
/* DEBUG: Write out the shifted IFG
for(k = 0; k < N; k++) {
*((double*)(outData->pntr[0]) + (bolIndex + k* nPixels)) = IFG[k];
if(i==16 && j==25) {
printf("%s: IFG[%d,%d,%d]=%g\n",TASK_NAME, i, j, k, IFG[k]);
}
} */
/* Convert real-valued interferogram to complex-valued interferogram */
for(k = 0; k < N; k++) { DSIN[k][0] = IFG[k]; DSIN[k][1] = 0.0; }
/* DEBUG: Write out DSIN
for(k = 0; k < N; k++) {
*((double*)(outData->pntr[0]) + (bolIndex + k * nPixels)) = DSIN[k][0];
if(i==16 && j==25) {
printf("%s: DSIN[%d,%d,%d]=%g\n",TASK_NAME, i, j, k, DSIN[k][0]);
}
} */
/* FFT Double-sided complex-valued interferogram */
plan = fftw_plan_dft_1d(N, DSIN, SPEC, FFTW_FORWARD, FFTW_ESTIMATE);
fftw_execute(plan);
/* Normalize spectrum */
for(k=0;k<N;k++) { SPEC[k][0] = SPEC[k][0] / (double)(N * resolution); }
/* Apply SFP calibration, if given */
if(doSFP){
/* Get the SFP for this pixel */
for(k=0;k<nSfp;k++) { SFPij[k] = SFP[i + j*nWidth + k*nPixels]; }
/* Interpolate the SFP values from its original WN scale to the current spectrum scale */
gsl_spline_init(SPLINE, WN, SFPij, nSfp);
/* Divide the spectrum in the band pass region by the interpolated SFP value at each position */
for(k = 0; k < N; k++) {
/*if(k*dSigma >= WN[0] && k*dSigma <= WN[nSfp-1]) {*/
if(k*dSigma >= wnSfpF && k*dSigma <= wnSfpL) {
f = gsl_spline_eval(SPLINE, k*dSigma, ACC);
/*index = bolIndex + nPixels * k;*/
s = SPEC[k][0];
SPEC[k][0] = s / f;
/*if(i==10 && j==20) { printf("SFP i=%d, j=%d, k=%d, dSigma=%f, k*dSigma=%f, s=%f, f=%f, s/f=%f, \n", i, j, k, dSigma, k*dSigma, s, f, s/f); }*/
}
}
}
/* Write out the positive real component of the spectrum */
for(k = 0; k <= N2; k++) {
*((double*)(outData->pntr[0]) + (bolIndex + k * nPixels)) = SPEC[k][0];
/*if(i==16 && j==25) {
printf("%s: SPEC[%d,%d,%d]=%E\n",TASK_NAME, i, j, k, SPEC[k][0] / (double)(N * resolution));
}*/
}
/* Destroy each allocated plan */
if(plan) { fftw_destroy_plan(plan); }
}
}
/* Deallocate memory used by arrays */
if(IFG) { IFG = astFree(IFG); }
if(DS) { DS = astFree(DS); }
if(SFP) { SFP = astFree(SFP); }
if(SFPij) { SFPij = astFree(SFPij); }
if(WN) { WN = astFree(WN); }
if(DSIN) { fftw_free(DSIN); DSIN = NULL; }
if(SPEC) { fftw_free(SPEC); SPEC = NULL; }
if(ACC) { gsl_interp_accel_free(ACC); ACC = NULL; }
if(SPLINE) { gsl_spline_free(SPLINE); SPLINE = NULL; }
/* Close the file */
if(inData) {
smf_close_file( NULL,&inData, status);
if(*status != SAI__OK) {
*status = SAI__ERROR;
errRep(FUNC_NAME, "Unable to close the input file!", status);
goto CLEANUP;
}
}
/* Write output */
/* outData->fts = smf_construct_smfFts(NULL, sfp, fpm, sigma, status); // TODO: Add interpolated SFP to FITS header */
smf_write_smfData(NULL, outData, NULL, NULL, gOut, fIndex, 0,
MSG__VERB, 0, NULL, NULL, status);
if(*status != SAI__OK) {
*status = SAI__ERROR;
errRep(FUNC_NAME, "Unable to write the output file!", status);
goto CLEANUP;
}
smf_close_file( NULL,&outData, status);
if(*status != SAI__OK) {
*status = SAI__ERROR;
errRep(FUNC_NAME, "Unable to close the output file!", status);
goto CLEANUP;
}
}
CLEANUP:
if(IFG) { IFG = astFree(IFG); }
if(DS) { DS = astFree(DS); }
if(SFP) { SFP = astFree(SFP); }
if(SFPij) { SFPij = astFree(SFPij); }
if(WN) { WN = astFree(WN); }
if(DSIN) { fftw_free(DSIN); DSIN = NULL; }
if(SPEC) { fftw_free(SPEC); SPEC = NULL; }
if(ACC) { gsl_interp_accel_free(ACC); ACC = NULL; }
if(SPLINE) { gsl_spline_free(SPLINE); SPLINE = NULL; }
/* Close files if still open */
if(inData) {
smf_close_file( NULL,&inData, status);
if(*status != SAI__OK) {
*status = SAI__ERROR;
errRep(FUNC_NAME, "CLEANUP: Unable to close the input file!", status);
}
}
if(outData) {
smf_close_file( NULL,&outData, status);
if(*status != SAI__OK) {
*status = SAI__ERROR;
errRep(FUNC_NAME, "CLEANUP: Unable to close the output file!", status);
}
}
if(sfpData) {
smf_close_file( NULL,&sfpData, status);
if(*status != SAI__OK) {
*status = SAI__ERROR;
errRep(FUNC_NAME, "CLEANUP: Unable to close the SFP file!", status);
}
}
/* END NDF */
ndfEnd(status);
/* Delete Groups */
if(gIn) grpDelet(&gIn, status);
if(gOut) grpDelet(&gOut, status);
if(gSfp) grpDelet(&gSfp, status);
}
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();
}
