void smf_flatfield ( ThrWorkForce *wf, const smfData *idata, const smfArray * flats, AstKeyMap * heateffmap,
smfData **odata, const int flags, int *status ) {
if ( *status != SAI__OK ) return;
/* See if data are flatfielded */
smf_check_flat( idata, status );
/* Data are flatfielded if status set to SMF__FLATN */
if ( *status == SMF__FLATN ) {
errAnnul(status);
/* check *odata */
if ( *odata == NULL) {
msgOutif(MSG__DEBUG1," ",
"OK, data are flatfielded and output struct is NULL: cloning input",
status);
/* If NULL then we need to clone idata to odata i.e. copy the
pointer ONLY */
smf_clone_data( idata, odata, status );
} else {
msgOutif(MSG__DEBUG1," ",
"OK, data are flatfielded and odata exists", status);
/* Check and set */
smf_check_smfData( idata, *odata, flags, status );
}
} else if ( *status == SAI__OK ) {
/* OK data are not flatfielded: create smfData based on input and
apply flatfield */
/* Check if *odata exists */
if ( *odata == NULL) {
msgOutif(MSG__DEBUG1," ","Data not flatfielded, no output data file.", status);
/* If NULL then we need create odata not associated with a file
(i.e. leave smfFile NULL) */
/* Allocate space for *odata and all necessary cpts */
/* Set the rawconvert flag to return doubles in the DATA array */
*odata = smf_deepcopy_smfData( wf, idata, 1, flags, 0, 0, status );
} else {
/* OK, *odata exists */
msgOutif(MSG__DEBUG1," ","Data not flatfielded, output data file exists.", status);
/* Check and set */
smf_check_smfData( idata, *odata, flags, status );
}
/* Disable the check because we know that we have just checked */
smf_flatfield_smfData( *odata, flats, heateffmap, 1, status );
}
}
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 smf_filter2d_execute( ThrWorkForce *wf, smfData *data, smfFilter *filt,
int complement, int *status ) {
double *data_i=NULL; /* Imaginary part of the transformed data */
double *data_r=NULL; /* Real part of the transformed data */
smfData *fdata=NULL; /* Transform of data */
dim_t fdims[2]={0,0}; /* Frequency dimensions */
size_t i; /* loop counter */
size_t ndims=0; /* Number of real-space dimensions */
size_t nfdata; /* Total number of frequency data points */
smfData *varfilt=NULL; /* real-space square of supplied filter for var */
AstFrameSet *wcs=NULL; /* Copy of real-space WCS */
/* Main routine */
if (*status != SAI__OK) return;
/* Check for NULL pointers */
if( !data ) {
*status = SAI__ERROR;
errRep( "", FUNC_NAME ": NULL smfData pointer", status );
return;
}
if( !filt ) {
*status = SAI__ERROR;
errRep( "", FUNC_NAME ": NULL smfFilter pointer", status );
return;
}
if( filt->ndims != 2 ) {
*status = SAI__ERROR;
errRep( "", FUNC_NAME ": Filter must be 2-dimensional", status );
return;
}
if( smf_isfft( data, NULL, NULL, fdims, NULL, &ndims, status ) ) {
*status = SAI__ERROR;
errRep( "", FUNC_NAME ": FFT'd data supplied!", status );
return;
}
if( ndims != 2 ) {
*status = SAI__ERROR;
errRep( "", FUNC_NAME ": supplied data are not a 2-d map", status );
return;
}
/* Check that the filter dimensions are appropriate for the data */
for( i=0; i<ndims; i++ ) {
if( fdims[i] != filt->fdims[i] ) {
*status = SAI__ERROR;
errRepf( "", FUNC_NAME
": Filter axis %zu has length %zu, doesn't match data %zu",
status, i, filt->fdims[i], fdims[i] );
return;
}
}
/* Dimensions of the transformed data */
nfdata = 1;
for( i=0; i<ndims; i++ ) {
if( filt->fdims[i] != fdims[i] ) {
*status = SAI__ERROR;
errRepf( "", FUNC_NAME
": Filter axis %zu has dim %zu doesn't match data dim %zu",
status, i, filt->fdims[i], fdims[i]);
return;
}
nfdata *= fdims[i];
}
/* Using complement of the filter? */
if( complement ) smf_filter_complement( filt, status );
/* Get a copy of the wcs of the input map */
if( data->hdr && data->hdr->wcs ) {
wcs = astCopy( data->hdr->wcs );
}
/* Transform the data */
fdata = smf_fft_data( wf, data, NULL, 0, 0, status );
/* Copy the FFT of the data if we will also be filtering the VARIANCE
since this will get us a useful container of the correct dimensions
for the squared filter */
if( data->pntr[1] ) {
varfilt = smf_deepcopy_smfData( wf, fdata, 0, SMF__NOCREATE_VARIANCE |
SMF__NOCREATE_QUALITY |
SMF__NOCREATE_FILE |
SMF__NOCREATE_DA, 0, 0, status );
}
/* Apply the frequency-domain filter. */
if( *status == SAI__OK ) {
data_r = fdata->pntr[0];
data_i = data_r + nfdata;
if( filt->isComplex ) {
double ac, bd, aPb, cPd;
for( i=0; i<nfdata; i++ ) {
ac = data_r[i] * filt->real[i];
bd = data_i[i] * filt->imag[i];
aPb = data_r[i] + data_i[i];
cPd = filt->real[i] + filt->imag[i];
}
} else {
for( i=0; i<nfdata; i++ ) {
data_r[i] *= filt->real[i];
data_i[i] *= filt->real[i];
}
}
}
/* Transform back */
smf_fft_data( wf, fdata, data, 1, 0, status );
/* Insert the copy of original real-space WCS into the smfHead since
smf_fft_data does not currently calculate it for inverse
transforms. */
if( data->hdr ) {
/* Annul current wcs if it exists */
if( data->hdr->wcs ) {
data->hdr->wcs = astAnnul( data->hdr->wcs );
}
data->hdr->wcs = wcs;
}
/* If we have a VARIANCE component we also need to smooth it. This
is slightly complicated because we have to do the equivalent of a
real-space convolution between the variance map and the
element-wise square of the real-space filter. So we first stuff
the supplied filter into a smfData (frequency space), take its
inverse to real space and square it. We then transform back to
frequency space, and run it through smf_filter2d_execute to apply
it to the VARIANCE map (which is also stuffed into its own
smfData and then copied into the correct location of the supplied
smfData when finished. */
if( (data->pntr[1]) && (*status==SAI__OK) ) {
dim_t ndata;
double *ptr=NULL;
smfData *realfilter=NULL; /* Real space smfData container for var filter */
smfData *vardata=NULL; /* smfData container for variance only */
smfFilter *vfilt=NULL; /* The var filter */
/* Copy the filter into the smfData container and transform into the
time domain. */
ptr = varfilt->pntr[0];
memcpy(ptr, filt->real, nfdata*sizeof(*ptr));
if( filt->imag) {
memcpy(ptr+nfdata, filt->imag, nfdata*sizeof(*ptr));
} else {
memset(ptr+nfdata, 0, nfdata*sizeof(*ptr));
}
realfilter = smf_fft_data( wf, varfilt, NULL, 1, 0, status );
smf_close_file( wf, &varfilt, status );
/* Square each element of the real-space filter and then transform
back to the frequency domain and stuff into a smfFilter
(vfilt). We just point the real and imaginary parts of the
smfFilter to the respective regions of the smfData to save
memory/time, but we need to be careful when freeing at the
end. */
if( *status == SAI__OK ) {
ptr = realfilter->pntr[0];
smf_get_dims( realfilter, NULL, NULL, NULL, NULL, &ndata, NULL, NULL,
status );
if( *status == SAI__OK ) {
double norm = 1. / (double) ndata;
for(i=0; i<ndata; i++) {
/* Note that we need an additional normalization of N samples */
ptr[i] *= ptr[i] * norm;
}
}
}
varfilt = smf_fft_data( wf, realfilter, NULL, 0, 0, status );
if( *status == SAI__OK ) {
ptr = varfilt->pntr[0];
vfilt = smf_create_smfFilter( data, status );
vfilt->real = ptr;
if( filt->isComplex ) {
/* Only worry about imaginary part if the original filter was
complex. */
vfilt->isComplex = 1;
vfilt->imag = ptr + nfdata;
}
}
/* Now stuff the variance array into a smfData and filter it. */
vardata = smf_deepcopy_smfData( wf, data, 0, SMF__NOCREATE_VARIANCE |
SMF__NOCREATE_QUALITY |
SMF__NOCREATE_FILE |
SMF__NOCREATE_DA, 0, 0, status );
if( *status == SAI__OK ) {
ptr = vardata->pntr[0];
memcpy( ptr, data->pntr[1], ndata*sizeof(*ptr) );
smf_filter2d_execute( wf, vardata, vfilt, 0, status );
}
/* Finally, copy the filtered variance into our output filtered smfData */
if( *status == SAI__OK ) {
ptr = data->pntr[1];
memcpy( ptr, vardata->pntr[0], ndata*sizeof(*ptr) );
}
/* Clean up */
if( realfilter ) smf_close_file( wf, &realfilter, status );
if( vardata ) smf_close_file( wf, &vardata, status );
if( vfilt ) {
vfilt->real = NULL;
vfilt->imag = NULL;
vfilt = smf_free_smfFilter( vfilt, status );
}
}
/* Return the filter to its original state if required */
if( complement == -1 ) smf_filter_complement( filt, status );
/* Clean up */
if( varfilt ) smf_close_file( wf, &varfilt, status );
if( fdata ) smf_close_file( wf, &fdata, status );
}
void smf_calcmodel_noi( ThrWorkForce *wf, smfDIMMData *dat, int chunk,
AstKeyMap *keymap, smfArray **allmodel, int flags,
int *status) {
/* Local Variables */
dim_t bolostep; /* Number of bolos per thread */
dim_t boxsize; /* No. of time slices in each noise box */
smfData *box = NULL; /* SmfData holding one box of input data */
size_t bstride; /* bolometer stride */
int calcfirst=0; /* Were bolo noises already measured? */
int dclimcorr; /* Min number of correlated steps */
int dcmaxsteps; /* Maximum allowed number of dc jumps */
dim_t dcfitbox; /* Width of box for DC step detection */
double dcthresh; /* Threshold for DC step detection */
dim_t dcsmooth; /* Width of median filter in DC step detection*/
double *din; /* Pointer to next input value */
double *dout; /* Pointer to next output value */
int fillgaps; /* If set perform gap filling */
dim_t i; /* Loop counter */
dim_t ibolo; /* Bolometer index */
int ibox; /* Index of current noise box */
dim_t itime; /* Time slice index */
dim_t idx=0; /* Index within subgroup */
JCMTState *instate=NULL; /* Pointer to input JCMTState */
int iw; /* Thread index */
dim_t j; /* Loop counter */
AstKeyMap *kmap=NULL; /* Local keymap */
size_t mbstride; /* model bolometer stride */
dim_t mntslice; /* Number of model time slices */
size_t mtstride; /* model time slice stride */
smfArray *model=NULL; /* Pointer to model at chunk */
double *model_data=NULL; /* Pointer to DATA component of model */
dim_t nbolo; /* Number of bolometers */
int nbox = 0; /* Number of noise boxes */
size_t nchisq; /* Number of data points in chisq calc */
dim_t nelbox; /* Number of data points in a noise box */
dim_t ndata; /* Total number of data points */
size_t nflag; /* Number of new flags */
int nleft; /* Number of samples not in a noise box */
dim_t ntslice; /* Number of time slices */
int nw; /* Number of worker threads */
size_t pend; /* Last non-PAD sample */
size_t pstart; /* First non-PAD sample */
smf_qual_t *qin; /* Pointer to next input quality value */
smf_qual_t *qout; /* Pointer to next output quality value */
smfArray *qua=NULL; /* Pointer to RES at chunk */
smf_qual_t *qua_data=NULL; /* Pointer to RES at chunk */
smfArray *res=NULL; /* Pointer to RES at chunk */
double *res_data=NULL; /* Pointer to DATA component of res */
dim_t spikebox=0; /* Box size for spike detection */
double spikethresh=0; /* Threshold for spike detection */
size_t tend; /* Last input sample to copy */
size_t tstart; /* First input sample to copy */
size_t tstride; /* time slice stride */
double *var=NULL; /* Sample variance */
size_t xbstride; /* Box bolometer stride */
int zeropad; /* Pad with zeros? */
/* Main routine */
if (*status != SAI__OK) return;
/* Obtain pointer to sub-keymap containing NOI parameters */
astMapGet0A( keymap, "NOI", &kmap );
/* Assert bolo-ordered data */
smf_model_dataOrder( dat, allmodel, chunk, SMF__RES|SMF__QUA, 0, status );
/* Obtain pointers to relevant smfArrays for this chunk */
res = dat->res[chunk];
qua = dat->qua[chunk];
model = allmodel[chunk];
/* Obtain parameters for NOI */
/* Data-cleaning parameters */
smf_get_cleanpar( kmap, res->sdata[0], NULL, &dcfitbox, &dcmaxsteps, &dcthresh,
&dcsmooth, &dclimcorr, NULL, &fillgaps, &zeropad, NULL,
NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
&spikethresh, &spikebox, NULL, NULL, NULL, NULL, NULL, NULL,
NULL, NULL, NULL, NULL, status );
/* Did we already calculate the noise on each detector? */
astMapGet0I( kmap, "CALCFIRST", &calcfirst );
/* Initialize chisquared */
dat->chisquared[chunk] = 0;
nchisq = 0;
/* Loop over index in subgrp (subarray) */
for( idx=0; idx<res->ndat; idx++ ) {
/* Get pointers to DATA components */
res_data = (res->sdata[idx]->pntr)[0];
model_data = (model->sdata[idx]->pntr)[0];
qua_data = (qua->sdata[idx]->pntr)[0];
if( (res_data == NULL) || (model_data == NULL) || (qua_data == NULL) ) {
*status = SAI__ERROR;
errRep( "", FUNC_NAME ": Null data in inputs", status);
} else {
/* Get the raw data dimensions */
smf_get_dims( res->sdata[idx], NULL, NULL, &nbolo, &ntslice, &ndata,
&bstride, &tstride, status );
/* NOI model dimensions */
smf_get_dims( model->sdata[idx], NULL, NULL, NULL, &mntslice, NULL,
&mbstride, &mtstride, status );
/* Only estimate the white noise level once at the beginning - the
reason for this is to make measurements of the convergence
easier. We either do it prior to the start of iterations (in which
case the relative weights will be influeced by low-frequency noise,
this is initialized in smf_model_create), or else we calculate
the noise after the first iteration. */
if( (flags & SMF__DIMM_FIRSTITER) && (!calcfirst) ) {
/* There are two forms for the NOI model: one constant noise value
for each bolometer, or "ntslice" noise values for each bolometer.
Handle the first case now. */
if( mntslice == 1 ) {
var = astMalloc( nbolo*sizeof(*var) );
if (var) {
/* Measure the noise from power spectra */
smf_bolonoise( wf, res->sdata[idx], 0, 0.5, SMF__F_WHITELO,
SMF__F_WHITEHI, 0, zeropad ? SMF__MAXAPLEN : SMF__BADSZT,
var, NULL, NULL, status );
for( i=0; i<nbolo; i++ ) if( !(qua_data[i*bstride]&SMF__Q_BADB) ) {
/* Loop over time and store the variance for each sample */
for( j=0; j<mntslice; j++ ) {
model_data[i*mbstride+(j%mntslice)*mtstride] = var[i];
}
}
var = astFree( var );
}
/* If the NOI model is of the second form, the noise is estimated
in boxes of samples lasting "NOI.BOX_SIZE" seconds, and then the
noise level in the box is assigned to all samples in the box. */
} else if( mntslice == ntslice ) {
/* If not already done, get NOI.BOX_SIZE and convert from seconds to
samples. */
if( idx == 0 ) {
boxsize = 0;
smf_get_nsamp( kmap, "BOX_SIZE", res->sdata[0], &boxsize, status );
msgOutf( "", FUNC_NAME ": Calculating a NOI variance for each "
"box of %d samples.", status, (int) boxsize );
/* Find the indices of the first and last non-PAD sample. */
smf_get_goodrange( qua_data, ntslice, tstride, SMF__Q_PAD,
&pstart, &pend, status );
/* How many whole boxes fit into this range? */
nbox = ( pend - pstart + 1 ) / boxsize;
if( nbox == 0 ) nbox = 1;
/* How many samples would be left over at the end if we used this
many boxes? */
nleft = ( pend - pstart + 1 ) - nbox*boxsize;
/* Increase "boxsize" to reduce this number as far as possible.
Any samples that are left over after this increase of boxsize
will not be used when calculating the noise levels in each
bolometer. */
boxsize += nleft/nbox;
/* Create a smfData to hold one box-worth of input data. We
do not need to copy jcmtstate information. */
if( res->sdata[idx]->hdr ) {
instate = res->sdata[idx]->hdr->allState;
res->sdata[idx]->hdr->allState = NULL;
}
box = smf_deepcopy_smfData( res->sdata[idx], 0,
SMF__NOCREATE_DATA |
SMF__NOCREATE_VARIANCE |
SMF__NOCREATE_QUALITY,
0, 0, status );
if( instate ) res->sdata[idx]->hdr->allState = instate;
/* Set the length of the time axis to the box size plus padding,
and create empty data and quality arrays for it. */
if( *status == SAI__OK ) {
box->dims[ box->isTordered?2:0 ] = boxsize + pstart + (ntslice - pend - 1);
smf_get_dims( box, NULL, NULL, NULL, NULL, &nelbox,
&xbstride, NULL, status );
box->pntr[0] = astMalloc( sizeof( double )*nelbox );
box->qual = astMalloc( sizeof( smf_qual_t )*nelbox );
/* For every bolometer, flag the start and end of the quality
array as padding, and store zeros in the data array. */
for( ibolo = 0; ibolo < nbolo; ibolo++ ) {
dout = ((double *) box->pntr[0]) + xbstride*ibolo;
qout = box->qual + xbstride*ibolo;
for( itime = 0; itime < pstart; itime++ ) {
*(qout++) = SMF__Q_PAD;
*(dout++) = 0.0;
}
dout = ((double *) box->pntr[0]) + xbstride*ibolo + pstart + boxsize;;
qout = box->qual + xbstride*ibolo + pstart + boxsize;
for( itime = pend + 1; itime < ntslice; itime++ ) {
*(qout++) = SMF__Q_PAD;
*(dout++) = 0.0;
}
}
}
}
/* Work space to hold the variance for each bolometer in a box */
var = astMalloc( nbolo*sizeof(*var) );
if( *status == SAI__OK ) {
/* Index of the first time slice within the input smfData
that is included in the first box. */
tstart = pstart;
/* Loop round each noise box */
for( ibox = 0; ibox < nbox; ibox++ ) {
/* Copy the data and quality values for this box from the
input smfData into "box", leaving room for padding at
both ends of box. Note, data is bolo-ordered so we
can assume that "tstride" is 1. */
din = ((double *)(res->sdata[idx]->pntr[0])) + tstart;
dout = ((double *)(box->pntr[0])) + pstart;
qin = qua_data + tstart;
qout = box->qual + pstart;
for( ibolo = 0; ibolo < nbolo; ibolo++ ) {
memcpy( dout, din, boxsize*sizeof( *din ) );
memcpy( qout, qin, boxsize*sizeof( *qin ) );
din += bstride;
dout += xbstride;
qin += bstride;
qout += xbstride;
}
/* Measure the noise from power spectra in the box. */
smf_bolonoise( wf, box, 0, 0.5, SMF__F_WHITELO, SMF__F_WHITEHI,
0, zeropad ? SMF__MAXAPLEN : SMF__BADSZT, var,
NULL, NULL, status );
/* Loop over time and store the variance for each sample in
the NOI model. On the last box, pick up any left over time
slices. */
if( ibox < nbox - 1 ) {
tend = tstart + boxsize - 1;
} else {
tend = pend;
}
for( ibolo = 0; ibolo < nbolo; ibolo++ ) {
if( !( qua_data[ ibolo*bstride ] & SMF__Q_BADB ) ) {
dout = model_data + ibolo*bstride + tstart;
for( itime = tstart; itime <= tend; itime++ ) {
*(dout++) = var[ ibolo ];
}
}
}
/* Update the index of the first time slice within the input
smfData that is included in the next box. */
tstart += boxsize;
}
var = astFree( var );
}
/* Report an error if the number of samples for each bolometer in
the NOI model is not 1 or "ntslice". */
} else if( *status == SAI__OK ) {
*status = SAI__ERROR;
errRepf( "", FUNC_NAME ": NOI model has %d samples - should be "
"%d or 1.", status, (int) mntslice, (int) ntslice);
}
}
if( kmap ) {
/* Flag spikes in the residual after first iteration */
if( spikethresh && !(flags&SMF__DIMM_FIRSTITER) ) {
/* Now re-flag */
smf_flag_spikes( wf, res->sdata[idx], SMF__Q_MOD,
spikethresh, spikebox, &nflag, status );
msgOutiff(MSG__VERB," ", " flagged %zu new %lf-sig spikes",
status, nflag, spikethresh );
}
if( dcthresh && dcfitbox ) {
smf_fix_steps( wf, res->sdata[idx], dcthresh, dcsmooth,
dcfitbox, dcmaxsteps, dclimcorr, 1, &nflag, NULL,
NULL, status );
msgOutiff(MSG__VERB, ""," detected %zu bolos with DC steps\n",
status, nflag);
}
}
/* Now calculate contribution to chi^2. This bit takes along time
if there is a lot of data so share the work out amongst the available
worker threads. How many threads do we get to play with */
nw = wf ? wf->nworker : 1;
/* Find how many bolometers to process in each worker thread. */
bolostep = nbolo/nw;
if( bolostep == 0 ) bolostep = 1;
/* Allocate job data for threads, and store the range of bolos to be
processed by each one. Ensure that the last thread picks up any
left-over bolos. */
SmfCalcModelNoiData *job_data = astCalloc( nw, sizeof(*job_data) );
if( *status == SAI__OK ) {
SmfCalcModelNoiData *pdata;
for( iw = 0; iw < nw; iw++ ) {
pdata = job_data + iw;
pdata->b1 = iw*bolostep;
if( iw < nw - 1 ) {
pdata->b2 = pdata->b1 + bolostep - 1;
} else {
pdata->b2 = nbolo - 1 ;
}
/* Store other values common to all jobs. */
pdata->ntslice = ntslice;
pdata->mntslice = mntslice;
pdata->qua_data = qua_data;
pdata->model_data = model_data;
pdata->res_data = res_data;
pdata->bstride = bstride;
pdata->tstride = tstride;
pdata->mbstride = mbstride;
pdata->mtstride = mtstride;
/* Submit the job to the workforce. */
thrAddJob( wf, 0, pdata, smf1_calcmodel_noi, 0, NULL, status );
}
/* Wait for all jobs to complete. */
thrWait( wf, status );
/* Accumulate the results from all the worker threads. */
for( iw = 0; iw < nw; iw++ ) {
pdata = job_data + iw;
dat->chisquared[chunk] += pdata->chisquared;
nchisq += pdata->nchisq;
}
/* Free the job data. */
job_data = astFree( job_data );
}
}
}
/* Free resources */
if( box ) {
box->pntr[0] = astFree( box->pntr[0] );
box->qual = astFree( box->qual );
smf_close_file( &box, status );
}
/* Normalize chisquared for this chunk */
if( (*status == SAI__OK) && (nchisq >0) ) {
dat->chisquared[chunk] /= (double) nchisq;
}
/* Clean Up */
if( kmap ) kmap = astAnnul( kmap );
}
void smf_calc_smoothedwvm ( ThrWorkForce *wf, const smfArray * alldata,
const smfData * adata, AstKeyMap* extpars, double **wvmtau,
size_t *nelems, size_t *ngoodvals, int * status ) {
size_t i;
size_t nrelated = 0; /* Number of entries in smfArray */
size_t nframes = 0; /* Number of timeslices */
size_t ngood = 0; /* Number of elements with good tau */
double *taudata = NULL; /* Local version of WVM tau */
const smfArray * thesedata = NULL; /* Collection of smfDatas to analyse */
smfArray * tmpthesedata = NULL; /* Local version of adata in a smfArray */
if (*status != SAI__OK) return;
if (alldata && adata) {
*status = SAI__ERROR;
errRep("", "smf_calc_smoothedwvm can not be given non-NULL alldata and non-NULL adata arguments"
" (possible programming error)", status );
return;
}
if (!alldata && !adata) {
*status = SAI__ERROR;
errRep("", "smf_calc_smoothedwvm: One of alldata or adata must be non-NULL",
status);
return;
}
if (!wvmtau) {
*status = SAI__ERROR;
errRep("", "Must supply a non-NULL pointer for wvmtau argument"
" (possible programming error)", status );
return;
}
/* if we have a single smfData put it in a smfArray */
if (alldata) {
if (alldata->ndat == 0 ) {
*status = SAI__ERROR;
errRep("", "No smfDatas present in supplied smfArray for WVM smoothing"
" (possible programming error)", status );
return;
}
thesedata = alldata;
} else {
tmpthesedata = smf_create_smfArray( status );
if (tmpthesedata) {
tmpthesedata->owndata = 0; /*not owned by the smfArray */
/* we know that the smfData here will not be touched in this
function so we do the BAD thing of casting const to non-const */
smf_addto_smfArray( tmpthesedata, (smfData *)adata, status );
}
thesedata = tmpthesedata;
}
/* Check that we have headers and that the smfData are the same length */
nrelated = thesedata->ndat;
for (i = 0; i < nrelated; i++ ) {
smfData * data = (thesedata->sdata)[i];
smfHead * hdr = data->hdr;
dim_t thisframes = 0;
if ( !hdr) {
*status = SAI__ERROR;
errRepf( "", "smfData %zu has no header. Aborting WVM smoothing",
status, i );
return;
}
smf_get_dims( data, NULL, NULL, NULL, &thisframes, NULL, NULL, NULL, status );
if (!nframes) nframes = thisframes;
if (thisframes != nframes) {
*status = SAI__ERROR;
errRepf( "", "smfData %zu has different length. Aborting WVM smoothing",
status, i );
return;
}
}
/* We will need the earliest and last airmass value in order
to calculate a zenith tau */
/* As a first step, just fill the time series with calculated WVM
tau values even though we know there are about 240 fewer tau
readings in reality. This initial approach will make it easier to
use the smoothed data directly rather than having to interpolate
from the 1.2 second data back into the 200 Hz data. */
taudata = astCalloc( nframes, sizeof(*taudata) );
if (*status == SAI__OK) {
double amprev = VAL__BADD;
double steptime;
size_t maxgap;
struct timeval tv1;
struct timeval tv2;
smfCalcWvmJobData *job_data = NULL;
int nworker;
/* We need to know the steptime so we can define the max good gap
in seconds and convert it to steps*/
steptime = (thesedata->sdata)[0]->hdr->steptime;
maxgap = (size_t)( 5.0 / steptime ); /* 5 seconds is just larger than 2 WVM readings */
/* Assume all files have the same airmass information */
smf_find_airmass_interval( (thesedata->sdata)[0]->hdr, &rev, NULL, NULL, NULL, status );
smf_timerinit( &tv1, &tv2, status );
/* 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) {
dim_t tstep;
int iworker;
smfCalcWvmJobData *pdata = NULL;
/* Get the number of time slices to process in each thread. */
if( nworker > (int) nframes ) {
tstep = 1;
} else {
tstep = nframes/nworker;
}
/* to return the same values for one thread and multiple threads
we need to break the threads on wvm sample boundaries wherever
possible. We make an initial estimate of the number of WVM measurements
by assuming one every two seconds. */
{
smfData * curdata = NULL;
size_t nwvm = 0;
double prevtime = VAL__BADD;
double curtime;
size_t *boundaries = astGrow(NULL, nframes*(size_t)(steptime/2.0), sizeof(*boundaries));
for (i=0; i<nframes; i++) {
if (!curdata) {
SELECT_DATA( thesedata, curdata, VAL__BADD, wvm_time, i );
}
if (curdata) smf_tslice_ast( curdata, i, 0, NO_FTS, status );
if ( !curdata || curdata->hdr->state->wvm_time == VAL__BADD ) {
/* Try the other datas */
SELECT_DATA( thesedata, curdata, VAL__BADD, wvm_time, i );
}
if (*status != SAI__OK) break;
if (!curdata) {
curtime = VAL__BADD;
} else {
curtime = curdata->hdr->state->wvm_time;
}
if (curtime != prevtime || nwvm == 0 ) {
/* Store the index in the boundaries array */
nwvm++;
boundaries = astGrow(boundaries, nwvm, sizeof(*boundaries));
if (!boundaries) { /* this is serious */
if (*status == SAI__OK) *status = SAI__ERROR;
errRep("", "Error allocating temporary memory for WVM calculation\n",
status );
break;
}
boundaries[nwvm-1] = i;
prevtime = curtime;
}
}
/* No point using too many threads */
if (*status == SAI__OK) {
if (nworker >= (int)nwvm) {
nworker = nwvm;
/* Allocate a measurement per thread */
for( iworker = 0; iworker < nworker; iworker++ ) {
pdata = job_data + iworker;
pdata->t1 = boundaries[iworker];
if (iworker+1 < nworker) pdata->t2 = boundaries[iworker+1]-1;
}
/* Ensure that the last thread picks up any left-over time slices */
pdata->t2 = nframes - 1;
} else {
/* Allocate the workers to slices of approximate size tstep */
size_t prevend = 0; /* End of previous slice */
size_t prevbnd = 0; /* Index into previous boundaries[] array selection */
for( iworker = 0; iworker < nworker; iworker++ ) {
size_t belowidx = prevend+1;
size_t aboveidx = nframes;
size_t lbnd;
size_t ubnd;
size_t j;
size_t guess;
pdata = job_data + iworker;
if (iworker == 0) { /* always start at the beginning */
pdata->t1 = 0;
} else { /* Start one after the previous block */
pdata->t1 = prevend + 1;
}
/* Now we have to find the end of this slice */
guess = (iworker*tstep) + tstep - 1;
if (guess <= pdata->t1) guess = pdata->t1 + tstep;
/* find nearest boundaries */
for (j=prevbnd; j<nwvm; j++) {
if ( boundaries[j] > guess ) {
aboveidx = boundaries[j];
ubnd = j;
if (j>0) {
belowidx = boundaries[j-1];
lbnd = j -1 ;
} else {
lbnd = 0;
}
break;
}
}
/* Choose the closest, making sure that we are not choosing t1 */
if ( (guess - belowidx < aboveidx - guess) && belowidx > pdata->t1 ) {
pdata->t2 = belowidx - 1;
prevbnd = lbnd;
} else {
pdata->t2 = aboveidx - 1;
prevbnd = ubnd;
}
prevend = pdata->t2;
if (prevend == nframes - 1 && iworker < nworker-1 ) {
/* we have run out of slices so just use fewer workers */
nworker = iworker + 1;
break;
}
}
/* Ensure that the last thread picks up any left-over time slices */
pdata->t2 = nframes - 1;
}
/* Tidy up */
boundaries = astFree( boundaries );
}
}
/* Store all the other info needed by the worker threads, and submit the
jobs to fix the steps in each bolo, and then wait for them to complete. */
for( iworker = 0; iworker < nworker; iworker++ ) {
smfArray *thrdata = NULL;
pdata = job_data + iworker;
pdata->nframes = nframes;
pdata->airmass = amprev; /* really need to get it from the start of each chunk */
pdata->taudata = taudata;
pdata->maxgap = maxgap;
/* Need to copy the smfDatas and create a new smfArray for each
thread */
thrdata = smf_create_smfArray( status );
for (i=0;i<nrelated;i++) {
smfData *tmpdata = NULL;
tmpdata = smf_deepcopy_smfData( wf, (thesedata->sdata)[i], 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( tmpdata, 0, status );
smf_addto_smfArray( thrdata, tmpdata, status );
}
pdata->thesedata = thrdata;
/* Need to do a deep copy of ast data and unlock them */
pdata->extpars = astCopy(extpars);
astUnlock( pdata->extpars, 1 );
/* Pass the job to the workforce for execution. */
thrAddJob( wf, THR__REPORT_JOB, pdata, smf__calc_wvm_job, 0, NULL,
status );
}
/* Wait for the workforce to complete all jobs. */
thrWait( wf, status );
/* Now free the resources we allocated during job creation
and calculate the number of good values */
for( iworker = 0; iworker < nworker; iworker++ ) {
smfArray * thrdata;
pdata = job_data + iworker;
astLock( pdata->extpars, 0 );
pdata->extpars = astAnnul( pdata->extpars );
thrdata = pdata->thesedata;
for (i=0;i<thrdata->ndat;i++) {
smf_lock_data( (thrdata->sdata)[i], 1, status );
}
smf_close_related( wf, &thrdata, status );
ngood += pdata->ngood;
}
}
job_data = astFree( job_data );
msgOutiff( MSG__NORM, "", FUNC_NAME ": %f s to calculate unsmoothed WVM tau values",
status, smf_timerupdate(&tv1,&tv2,status) );
}
if (*status == SAI__OK && extpars) {
/* Read extpars to see if we need to smooth */
double smoothtime = VAL__BADD;
if (astMapGet0D( extpars, "SMOOTHWVM", &smoothtime ) ) {
if (smoothtime != VAL__BADD && smoothtime > 0.0) {
smfData * data = (thesedata->sdata)[0];
double steptime = data->hdr->steptime;
dim_t boxcar = (dim_t)( smoothtime / steptime );
msgOutiff( MSG__VERB, "",
"Smoothing WVM data with %f s tophat function",
status, smoothtime );
smf_tophat1D( taudata, nframes, boxcar, NULL, 0, 0.0, status );
/* The tophat smoothing puts a bad value at the start and end of
the time series so we replace that with the adjacent value since
the step time is much smaller than WVM readout time. If more than
one value is bad we do not try to find the good value. */
taudata[0] = taudata[1];
taudata[nframes-1] = taudata[nframes-2];
}
}
}
/* Use this to get the raw WVM output for debugging */
/*
if (*status == SAI__OK) {
smfData *data = (thesedata->sdata)[0];
smfHead *hdr = data->hdr;
printf("# IDX TAU RTS_NUM RTS_END WVM_TIME\n");
for (i=0; i<nframes;i++) {
JCMTState * state;
state = &(hdr->allState)[i];
printf("%zu %.*g %d %.*g %.*g\n", i, DBL_DIG, taudata[i], state->rts_num,
DBL_DIG, state->rts_end, DBL_DIG, state->wvm_time);
}
} */
/* Free resources */
if (tmpthesedata) smf_close_related( wf, &tmpthesedata, status );
if (*status != SAI__OK) {
if (taudata) taudata = astFree( taudata );
*nelems = 0;
*ngoodvals = 0;
} else {
*wvmtau = taudata;
*nelems = nframes;
*ngoodvals = ngood;
}
}
void smf_find_science(const Grp * ingrp, Grp **outgrp, int reverttodark,
Grp **darkgrp, Grp **flatgrp, int reducedark,
int calcflat, smf_dtype darktype, smfArray ** darks,
smfArray **fflats, AstKeyMap ** heateffmap,
double * meanstep, int * status ) {
smfSortInfo *alldarks; /* array of sort structs for darks */
smfSortInfo *allfflats; /* array of fast flat info */
Grp * dgrp = NULL; /* Internal dark group */
double duration_darks = 0.0; /* total duration of all darks */
double duration_sci = 0.0; /* Duration of all science observations */
size_t dkcount = 0; /* Dark counter */
size_t ffcount = 0; /* Fast flat counter */
Grp * fgrp = NULL; /* Fast flat group */
size_t i; /* loop counter */
smfData *infile = NULL; /* input file */
size_t insize; /* number of input files */
size_t nsteps_dark = 0; /* Total number of steps for darks */
size_t nsteps_sci = 0; /* Total number of steps for science */
AstKeyMap * heatermap = NULL; /* Heater efficiency map */
AstKeyMap * obsmap = NULL; /* Info from all observations */
AstKeyMap * objmap = NULL; /* All the object names used */
AstKeyMap * scimap = NULL; /* All non-flat obs indexed by unique key */
Grp *ogrp = NULL; /* local copy of output group */
size_t sccount = 0; /* Number of accepted science files */
struct timeval tv1; /* Timer */
struct timeval tv2; /* Timer */
if (meanstep) *meanstep = VAL__BADD;
if (outgrp) *outgrp = NULL;
if (darkgrp) *darkgrp = NULL;
if (darks) *darks = NULL;
if (fflats) *fflats = NULL;
if (heateffmap) *heateffmap = NULL;
if (*status != SAI__OK) return;
/* Sanity check to make sure we return some information */
if ( outgrp == NULL && darkgrp == NULL && darks == NULL && fflats == NULL) {
*status = SAI__ERROR;
errRep( " ", FUNC_NAME ": Must have some non-NULL arguments"
" (possible programming error)", status);
return;
}
/* Start a timer to see how long this takes */
smf_timerinit( &tv1, &tv2, status );
/* Create new group for output files */
ogrp = smf_grp_new( ingrp, "Science", status );
/* and a new group for darks */
dgrp = smf_grp_new( ingrp, "DarkFiles", status );
/* and for fast flats */
fgrp = smf_grp_new( ingrp, "FastFlats", status );
/* and also create a keymap for the observation description */
obsmap = astKeyMap( "KeyError=1" );
/* and an object map */
objmap = astKeyMap( "KeyError=1" );
/* This keymap contains the sequence counters for each related
subarray/obsidss/heater/shutter combination and is used to decide
if a bad flat is relevant */
scimap = astKeyMap( "KeyError=1,KeyCase=0" );
/* This keymap is used to contain relevant heater efficiency data */
heatermap = astKeyMap( "KeyError=1,KeyCase=0" );
/* Work out how many input files we have and allocate sufficient sorting
space */
insize = grpGrpsz( ingrp, status );
alldarks = astCalloc( insize, sizeof(*alldarks) );
allfflats = astCalloc( insize, sizeof(*allfflats) );
/* check each file in turn */
for (i = 1; i <= insize; i++) {
int seqcount = 0;
char keystr[100]; /* Key for scimap entry */
/* open the file but just to get the header */
smf_open_file( ingrp, i, "READ", SMF__NOCREATE_DATA, &infile, status );
if (*status != SAI__OK) break;
/* Fill in the keymap with observation details */
smf_obsmap_fill( infile, obsmap, objmap, status );
/* Find the heater efficiency map if required */
if (*status == SAI__OK && heateffmap) {
char arrayidstr[32];
smf_fits_getS( infile->hdr, "ARRAYID", arrayidstr, sizeof(arrayidstr),
status );
if (!astMapHasKey( heatermap, arrayidstr ) ) {
smfData * heateff = NULL;
dim_t nbolos = 0;
smf_flat_params( infile, "RESIST", NULL, NULL, NULL, NULL, NULL,
NULL, NULL, NULL, NULL, NULL, &heateff, status );
smf_get_dims( heateff, NULL, NULL, &nbolos, NULL, NULL, NULL, NULL,
status );
if (heateff) astMapPut0P( heatermap, arrayidstr, heateff, NULL );
}
}
/* Get the sequence counter for the file. We do not worry about
duplicate sequence counters (at the moment) */
smf_find_seqcount( infile->hdr, &seqcount, status );
/* The key identifying this subarray/obsidss/heater/shutter combo */
smf__calc_flatobskey( infile->hdr, keystr, sizeof(keystr), status );
if (smf_isdark( infile, status )) {
/* Store the sorting information */
dkcount = smf__addto_sortinfo( infile, alldarks, i, dkcount, "Dark", status );
smf__addto_durations( infile, &duration_darks, &nsteps_dark, status );
astMapPutElemI( scimap, keystr, -1, seqcount );
} else {
/* compare sequence type with observation type and drop it (for now)
if they differ */
if ( infile->hdr->obstype == infile->hdr->seqtype ) {
/* Sanity check the header for corruption. Compare RTS_NUM with SEQSTART
and SEQEND. The first RTS_NUM must either be SEQSTART or else between
SEQSTART and SEQEND (if someone has giving us a section) */
int seqstart = 0;
int seqend = 0;
int firstnum = 0;
JCMTState *tmpState = NULL;
smf_getfitsi( infile->hdr, "SEQSTART", &seqstart, status );
smf_getfitsi( infile->hdr, "SEQEND", &seqend, status );
tmpState = infile->hdr->allState;
if( tmpState ) {
firstnum = (tmpState[0]).rts_num;
smf_smfFile_msg( infile->file, "F", 1, "<unknown file>");
if ( firstnum >= seqstart && firstnum <= seqend ) {
/* store the file in the output group */
ndgCpsup( ingrp, i, ogrp, status );
msgOutif(MSG__DEBUG, " ", "Non-dark file: ^F",status);
smf__addto_durations( infile, &duration_sci, &nsteps_sci, status );
astMapPutElemI( scimap, keystr, -1, seqcount );
sccount++;
} else {
msgOutif( MSG__QUIET, "",
"File ^F has a corrupt FITS header. Ignoring it.",
status );
}
} else {
smf_smfFile_msg( infile->file, "F", 1, "<unknown file>");
/* store the file in the output group */
ndgCpsup( ingrp, i, ogrp, status );
msgOutif( MSG__DEBUG, " ",
"File ^F lacks JCMTState: assuming it is non-dark",status);
smf__addto_durations( infile, &duration_sci, &nsteps_sci, status );
astMapPutElemI( scimap, keystr, -1, seqcount );
sccount++;
}
} else if (infile->hdr->seqtype == SMF__TYP_FASTFLAT ) {
ffcount = smf__addto_sortinfo( infile, allfflats, i, ffcount, "Fast flat", status );
} else {
smf_smfFile_msg( infile->file, "F", 1, "<unknown file>");
msgOutif(MSG__DEBUG, " ", "Sequence type mismatch with observation type: ^F",status);
}
}
/* close the file */
smf_close_file( &infile, status );
}
/* Store output group in return variable or else free it */
if (outgrp) {
*outgrp = ogrp;
} else {
grpDelet( &ogrp, status );
}
/* process flatfields if necessary */
if (ffcount > 0 && fflats ) {
smfArray * array = NULL;
/* sort flats into order */
qsort( allfflats, ffcount, sizeof(*allfflats), smf_sort_bydouble);
if (fflats) array = smf_create_smfArray( status );
/* now open the flats and store them if requested */
if (*status == SAI__OK && array && ffcount) {
size_t start_ffcount = ffcount;
AstKeyMap * flatmap = NULL;
if (calcflat) {
/* Use AgeUp so that we get the keys out in the sorted order
that allfflats used */
flatmap = astKeyMap( "KeyCase=0,KeyError=1,SortBy=AgeDown" );
}
/* Read each flatfield. Calculate a responsivity image and a flatfield
solution. Store these in a keymap along with related information
which is itself stored in a keymap indexed by a string made of
OBSIDSS, reference heater value, shutter and subarray.
*/
for (i = 0; i < start_ffcount; i++ ) {
size_t ori_index = (allfflats[i]).index;
smfData * outfile = NULL;
char keystr[100];
AstKeyMap * infomap = astKeyMap( "KeyError=1" );
int oplen = 0;
char thisfile[MSG__SZMSG];
int seqcount = 0;
/* read filename from group */
infile = NULL;
smf_open_file( ingrp, ori_index, "READ", 0, &infile, status );
if ( *status != SAI__OK ) {
/* This should not happen because we have already opened
the file. If it does happen we abort with error. */
if (infile) smf_close_file( &infile, status );
break;
}
/* Calculate the key for this observation */
smf__calc_flatobskey( infile->hdr, keystr, sizeof(keystr), status );
/* Get the file name for error messages */
smf_smfFile_msg( infile->file, "F", 1, "<unknown file>" );
msgLoad( "", "^F", thisfile, sizeof(thisfile), &oplen, status );
/* And the sequence counter to link against science observations */
smf_find_seqcount( infile->hdr, &seqcount, status );
/* Prefill infomap */
astMapPut0C( infomap, "FILENAME", thisfile, "");
astMapPut0I( infomap, "SEQCOUNT", seqcount, "");
/* Collapse it */
if (*status == SAI__OK) {
smf_flat_fastflat( infile, &outfile, status );
if (*status == SMF__BADFLAT) {
errFlush( status );
if (calcflat) {
/* Need to generate an outfile like smf_flat_fastflat
and one heater setting will force smf_flat_calcflat to fail */
smf_flat_malloc( 1, infile, NULL, &outfile, status );
} else {
if (outfile) smf_close_file( &outfile, status );
if (infile) smf_close_file( &infile, status );
infomap = astAnnul( infomap );
ffcount--;
continue;
}
}
}
if (outfile && *status == SAI__OK) {
smf_close_file( &infile, status );
infile = outfile;
if (calcflat) {
size_t ngood = 0;
smfData * curresp = NULL;
int utdate;
if (*status == SAI__OK) {
ngood = smf_flat_calcflat( MSG__VERB, NULL, "RESIST",
"FLATMETH", "FLATORDER", NULL, "RESPMASK",
"FLATSNR", NULL, infile, &curresp, status );
if (*status != SAI__OK) {
/* if we failed to calculate a flatfield we continue but force the
flatfield to be completely bad. This will force the science data associated
with the flatfield to be correctly blanked. We do not annul though
if we have a SUBPAR error telling us that we have failed to define
our parameters properly. */
if (*status != SUBPAR__NOPAR) errAnnul(status);
/* parameters of flatfield */
ngood = 0;
/* Generate a blank flatfield and blank responsivity image */
smf_flat_badflat( infile, &curresp, status );
}
/* Retrieve the UT date so we can decide whether to compare
flatfields */
smf_getfitsi( infile->hdr, "UTDATE", &utdate, status );
/* Store the responsivity data for later on and the processed
flatfield until we have vetted it */
astMapPut0P( infomap, "CALCFLAT", infile, "" );
astMapPut0P( infomap, "RESP", curresp, "" );
astMapPut0I( infomap, "UTDATE", utdate, "" );
astMapPut0I( infomap, "ISGOOD", 1, "" );
astMapPut0I( infomap, "NGOOD", ngood, "" );
astMapPut0I( infomap, "GRPINDEX", ori_index, "" );
astMapPut0I( infomap, "SMFTYP", infile->hdr->obstype, "" );
astMapPutElemA( flatmap, keystr, -1, infomap );
}
} else { /* if (calcflat) */
/* Store the collapsed flatfield - the processed flat is not stored here yet */
smf_addto_smfArray( array, infile, status );
/* Copy the group info */
ndgCpsup( ingrp, ori_index, fgrp, status );
}
} /* if (outfile) */
/* Annul the keymap (will be fine if it is has been stored in another keymap) */
infomap = astAnnul( infomap );
} /* End loop over flatfields */
/* Now we have to loop over the related flatfields to disable
bolometers that are not good and also decide whether we
need to set status to bad. */
if (*status == SAI__OK && calcflat ) {
size_t nkeys = astMapSize( flatmap );
for (i = 0; i < nkeys; i++ ) {
const char *key = astMapKey( flatmap, i );
int nf = 0;
AstKeyMap ** kmaps = NULL;
int nelem = astMapLength( flatmap, key );
kmaps = astMalloc( sizeof(*kmaps) * nelem );
astMapGet1A( flatmap, key, nelem, &nelem, kmaps );
for ( nf = 0; nf < nelem && *status == SAI__OK; nf++ ) {
AstKeyMap * infomap = kmaps[nf];
int isgood = 0;
astMapGet0I( infomap, "ISGOOD", &isgood );
if (isgood) {
/* The flatfield worked */
size_t ngood = 0;
int itemp;
int utdate = 0;
int ratioFlats = 0;
/* Get the UT date - we do not compare flatfields after
the time we enabled heater tracking at each sequence. */
astMapGet0I( infomap, "UTDATE", &utdate );
/* Get the number of good bolometers at this point */
astMapGet0I( infomap, "NGOOD", &itemp );
ngood = itemp;
/* Decide if we want to do the ratio test. We default to
not doing it between 20110901 and 20120827 which is
the period when we did mini-heater tracks before each
flat. ! indicates that we choose based on date. */
if (*status == SAI__OK) {
parGet0l( "FLATUSENEXT", &ratioFlats, status );
if ( *status == PAR__NULL ) {
errAnnul( status );
if (utdate >= 20110901 || utdate <= 20120827 ) {
ratioFlats = 0;
} else {
ratioFlats = 1;
}
}
}
/* Can we compare with the next flatfield? */
if (ngood < SMF__MINSTATSAMP || !ratioFlats ) {
/* no point doing all the ratio checking for this */
} else if ( nelem - nf >= 2 ) {
AstKeyMap * nextmap = kmaps[nf+1];
const char *nextfname = NULL;
const char *fname = NULL;
smfData * curresp = NULL;
smfData * nextresp = NULL;
smfData * curflat = NULL;
void *tmpvar = NULL;
size_t bol = 0;
smfData * ratio = NULL;
double *in1 = NULL;
double *in2 = NULL;
double mean = VAL__BADD;
size_t nbolo;
double *out = NULL;
double sigma = VAL__BADD;
float clips[] = { 5.0, 5.0 }; /* 5.0 sigma iterative clip */
size_t ngoodz = 0;
astMapGet0C( nextmap, "FILENAME", &nextfname );
astMapGet0C( infomap, "FILENAME", &fname );
/* Retrieve the responsivity images from the keymap */
astMapGet0P( infomap, "RESP", &tmpvar );
curresp = tmpvar;
astMapGet0P( nextmap, "RESP", &tmpvar );
nextresp = tmpvar;
astMapGet0P( infomap, "CALCFLAT", &tmpvar );
curflat = tmpvar;
nbolo = (curresp->dims)[0] * (curresp->dims)[1];
/* get some memory for the ratio if we have not already.
We could get some memory once assuming each flat has the
same number of bolometers... */
ratio = smf_deepcopy_smfData( curresp, 0, 0, 0, 0, status );
if( *status == SAI__OK ) {
/* divide: smf_divide_smfData ? */
in1 = (curresp->pntr)[0];
in2 = (nextresp->pntr)[0];
out = (ratio->pntr)[0];
for (bol=0; bol<nbolo;bol++) {
if ( in1[bol] != VAL__BADD && in1[bol] != 0.0 &&
in2[bol] != VAL__BADD && in2[bol] != 0.0 ) {
out[bol] = in1[bol] / in2[bol];
} else {
out[bol] = VAL__BADD;
}
}
}
/* find some statistics */
smf_clipped_stats1D( out, 2, clips, 1, nbolo, NULL, 0, 0, &mean,
&sigma, NULL, 0, &ngoodz, status );
if (*status == SMF__INSMP) {
errAnnul(status);
msgOutiff( MSG__QUIET, "",
"Flatfield ramp ratio of %s with %s had too few bolometers (%zu < %d).",
status, fname, nextfname, ngoodz, SMF__MINSTATSAMP );
ngood = ngoodz; /* Must be lower or equal to original ngood */
} else if (*status == SAI__OK && mean != VAL__BADD && sigma != VAL__BADD && curflat->da) {
/* Now flag the flatfield as bad for bolometers that have changed
more than n%. We expect the variation to be 1+/-a small bit */
const double pmrange = 0.10;
double thrlo = 1.0 - pmrange;
double thrhi = 1.0 + pmrange;
size_t nmasked = 0;
double *flatcal = curflat->da->flatcal;
msgOutiff( MSG__DEBUG, "", "Flatfield fast ramp ratio mean = %g +/- %g (%zu bolometers)",
status, mean, sigma, ngood);
/* we can just set the first slice of the flatcal to bad. That should
be enough to disable the entire bolometer. We have just read these
data so they should be in ICD order. */
for (bol=0; bol<nbolo;bol++) {
if ( out[bol] != VAL__BADD &&
(out[bol] < thrlo || out[bol] > thrhi ) ) {
flatcal[bol] = VAL__BADD;
nmasked++;
} else if ( in1[bol] != VAL__BADD && in2[bol] == VAL__BADD ) {
/* A bolometer is bad next time but good now so we must set it bad now */
flatcal[bol] = VAL__BADD;
nmasked++;
}
}
if ( nmasked > 0 ) {
msgOutiff( MSG__NORM, "", "Masked %zu bolometers in %s from unstable flatfield",
status, nmasked, fname );
/* update ngood to take into account the masking */
ngood -= nmasked;
}
}
smf_close_file( &ratio, status );
} /* End of flatfield responsivity comparison */
/* if we only have a few bolometers left we now consider this
a bad flat unless it is actually an engineering measurement
where expect some configurations to give zero bolometers */
if (ngood < SMF__MINSTATSAMP) {
const char *fname = NULL;
void * tmpvar = NULL;
int smftyp = 0;
smfData * curflat = NULL;
astMapGet0I( infomap, "SMFTYP", &smftyp );
astMapGet0C( infomap, "FILENAME", &fname );
if (smftyp != SMF__TYP_NEP) {
msgOutiff( MSG__QUIET, "",
"Flatfield %s has %zu good bolometer%s.%s",
status, fname, ngood, (ngood == 1 ? "" : "s"),
( ngood == 0 ? "" : " Keeping none.") );
isgood = 0;
/* Make sure that everything is blanked. */
if (ngood > 0) {
astMapGet0P( infomap, "CALCFLAT", &tmpvar );
curflat = tmpvar;
if (curflat && curflat->da) {
size_t bol;
size_t nbolo = (curflat->dims)[0] * (curflat->dims)[1];
double *flatcal = curflat->da->flatcal;
for (bol=0; bol<nbolo; bol++) {
/* Just need to set the first element to bad */
flatcal[bol] = VAL__BADD;
}
}
}
} else {
msgOutiff( MSG__NORM, "",
"Flatfield ramp file %s has %zu good bolometer%s. Eng mode.",
status, fname, ngood, (ngood == 1 ? "" : "s") );
}
}
/* We do not need the responsivity image again */
{
void *tmpvar = NULL;
smfData * resp = NULL;
astMapGet0P( infomap, "RESP", &tmpvar );
resp = tmpvar;
if (resp) smf_close_file( &resp, status );
astMapRemove( infomap, "RESP" );
}
} /* End of isgood comparison */
/* We are storing flats even if they failed. Let the downstream
software worry about it */
{
int ori_index;
smfData * flatfile = NULL;
void *tmpvar = NULL;
/* Store in the output group */
astMapGet0I( infomap, "GRPINDEX", &ori_index );
ndgCpsup( ingrp, ori_index, fgrp, status );
/* And store in the smfArray */
astMapGet0P( infomap, "CALCFLAT", &tmpvar );
astMapRemove( infomap, "CALCFLAT" );
flatfile = tmpvar;
smf_addto_smfArray( array, flatfile, status );
}
/* Free the object as we go */
kmaps[nf] = astAnnul( kmaps[nf] );
} /* End of loop over this obsidss/subarray/heater */
kmaps = astFree( kmaps );
}
}
if (array->ndat) {
if (fflats) *fflats = array;
} else {
smf_close_related(&array, status );
if (fflats) *fflats = NULL;
}
}
}
/* no need to do any more if neither darks nor darkgrp are defined or we might
be wanting to revert to darks. */
if (dkcount > 0 && (darks || darkgrp || reverttodark ) ) {
smfArray * array = NULL;
/* sort darks into order */
qsort( alldarks, dkcount, sizeof(*alldarks), smf_sort_bydouble);
if (darks) array = smf_create_smfArray( status );
/* now open the darks and store them if requested */
if (*status == SAI__OK) {
for (i = 0; i < dkcount; i++ ) {
size_t ori_index = (alldarks[i]).index;
/* Store the entry in the output group */
ndgCpsup( ingrp, ori_index, dgrp, status );
if (darks) {
/* read the value from the new group */
smf_open_file( dgrp, i+1, "READ", 0, &infile, status );
/* do we have to process these darks? */
if (reducedark) {
smfData *outfile = NULL;
smf_reduce_dark( infile, darktype, &outfile, status );
if (outfile) {
smf_close_file( &infile, status );
infile = outfile;
}
}
smf_addto_smfArray( array, infile, status );
}
}
if (darks) *darks = array;
}
}
/* free memory */
alldarks = astFree( alldarks );
allfflats = astFree( allfflats );
if( reverttodark && outgrp && (grpGrpsz(*outgrp,status)==0) &&
(grpGrpsz(dgrp,status)>0) ) {
/* If outgrp requested but no science observations were found, and
dark observations were found, return darks in outgrp and set
flatgrp and darkgrp to NULL. This is to handle cases where we
want to process data taken in the dark like normal science
data. To activate this behaviour set reverttodark */
msgOutiff( MSG__NORM, "", "Treating the dark%s as science data",
status, ( dkcount > 1 ? "s" : "" ) );
*outgrp = dgrp;
if( darkgrp ){
*darkgrp = NULL;
}
if( flatgrp ) {
*flatgrp = NULL;
}
grpDelet( &ogrp, status);
grpDelet( &fgrp, status);
if (meanstep && nsteps_dark > 0) *meanstep = duration_darks / nsteps_dark;
/* Have to clear the darks smfArray as well */
if (darks) smf_close_related( darks, status );
} else {
/* Store the output groups in the return variable or free it */
if (darkgrp) {
*darkgrp = dgrp;
} else {
grpDelet( &dgrp, status);
}
if (flatgrp) {
*flatgrp = fgrp;
} else {
grpDelet( &fgrp, status);
}
if (meanstep && nsteps_sci > 0) *meanstep = duration_sci / nsteps_sci;
}
msgSeti( "ND", sccount );
msgSeti( "DK", dkcount );
msgSeti( "FF", ffcount );
msgSeti( "TOT", insize );
if ( insize == 1 ) {
if (dkcount == 1) {
msgOutif( MSG__VERB, " ", "Single input file was a dark",
status);
} else if (ffcount == 1) {
msgOutif( MSG__VERB, " ", "Single input file was a fast flatfield",
status);
} else if (sccount == 1) {
msgOutif( MSG__VERB, " ", "Single input file was accepted (observation type same as sequence type)",
status);
} else {
msgOutif( MSG__VERB, " ", "Single input file was not accepted.",
status);
}
} else {
if (dkcount == 1) {
msgSetc( "DKTXT", "was a dark");
} else {
msgSetc( "DKTXT", "were darks");
}
if (ffcount == 1) {
msgSetc( "FFTXT", "was a fast flat");
} else {
msgSetc( "FFTXT", "were fast flats");
}
if (sccount == 1) {
msgSetc( "NDTXT", "was science");
} else {
msgSetc( "NDTXT", "were science");
}
/* This might be a useful message */
msgOutif( MSG__NORM, " ", "Out of ^TOT input files, ^DK ^DKTXT, ^FF ^FFTXT "
"and ^ND ^NDTXT", status );
}
if (meanstep && *meanstep != VAL__BADD) {
msgOutiff( MSG__VERB, "", "Mean step time for input files = %g sec",
status, *meanstep );
}
/* Store the heater efficiency map */
if (*status != SAI__OK) heatermap = smf_free_effmap( heatermap, status );
if (heateffmap) *heateffmap = heatermap;
/* Now report the details of the observation */
smf_obsmap_report( MSG__NORM, obsmap, objmap, status );
obsmap = astAnnul( obsmap );
objmap = astAnnul( objmap );
scimap = astAnnul( scimap );
msgOutiff( SMF__TIMER_MSG, "",
"Took %.3f s to find science observations",
status, smf_timerupdate( &tv1, &tv2, status ) );
return;
}
void
smf_flat_params( const smfData * refdata, const char resistpar[],
const char methpar[], const char orderpar[], const char snrminpar[],
double * refohms, double **resistance, int * outrows,
int * outcols, smf_flatmeth *flatmeth,
int * order, double * snrmin, smfData ** heateff,
int * status ) {
dim_t datarows = 0; /* Number of rows in refdata */
dim_t datacols = 0; /* Number of columns in refdata */
size_t j = 0; /* Counter, index */
char method[SC2STORE_FLATLEN]; /* flatfield method string */
size_t nbols; /* Number of bolometers */
double refohmsval = 0.0; /* Internal version of refohms */
AstKeyMap * resmap = NULL; /* Resistor map */
AstKeyMap * subarrays = NULL; /* Subarray lookup table */
char thissub[32]; /* This sub-instrument string */
if (resistance) *resistance = NULL;
if (*status != SAI__OK) return;
if (!refdata) {
*status = SAI__ERROR;
errRep( "", "Must provide reference data file to calculate flatfield parameters"
" (possible programming error)", status );
return;
}
/* Based on refdata we now need to calculate the default reference
resistance and retrieve the correct heater efficiency file for each array.
We need the unique subarray string so that we can set up a look up keymap.
There is no code in SMURF to return all the known subarrays but
we need to know all the options in order to use kpg1Config. */
subarrays = astKeyMap( " " );
astMapPut0I( subarrays, "CG450MK2_M0907D0501", 0, NULL );
astMapPut0I( subarrays, "CG850MK2_M0904D0503", 0, NULL );
astMapPut0I( subarrays, "SG850_M0906D1005", 0, NULL );
astMapPut0I( subarrays, "SG850_M1002D1006", 0, NULL );
astMapPut0I( subarrays, "SG850_M1005D1007", 0, NULL );
astMapPut0I( subarrays, "SG850_M1003D1004", 0, NULL );
astMapPut0I( subarrays, "SG450_M1004D1000", 0, NULL );
astMapPut0I( subarrays, "SG450_M1007D1002", 0, NULL );
astMapPut0I( subarrays, "SG450_M1006D1003", 0, NULL );
astMapPut0I( subarrays, "SG450_M1009D1008", 0, NULL );
/* and indicate which subarray we are interested in (uppercased) */
smf_fits_getS( refdata->hdr, "ARRAYID", thissub, sizeof(thissub), status );
{ /* need to uppercase */
size_t l = strlen(thissub);
for (j=0;j<l;j++) {
thissub[j] = toupper(thissub[j]);
}
}
astMapPut0I( subarrays, thissub, 1, NULL );
/* Read the config file */
resmap = kpg1Config( resistpar, "$SMURF_DIR/smurf_calcflat.def",
subarrays, 1, status );
subarrays = astAnnul( subarrays );
if (*status != SAI__OK) goto CLEANUP;
/* Read the reference resistance */
astMapGet0D( resmap, "REFRES", &refohmsval );
if (refohms && *status == SAI__OK) {
*refohms = refohmsval;
msgOutiff(MSG__VERB, "",
"Read reference resistance for subarray %s of %g ohms\n",
status, thissub, *refohms );
}
/* We no longer want to read per-bolometer resistor values from the
config file. To retain backwards compatibility with the current
implementation of smf_flat_standardpow we simply fill the
per-bol resistance array with the reference resistance which
effectively disables smf_flat_standardpow */
smf_get_dims( refdata, &datarows, &datacols, NULL, NULL, NULL, NULL, NULL, status );
nbols = datacols * datarows;
if (*status == SAI__OK && resistance ) {
*resistance = astMalloc( nbols*sizeof(**resistance) );
for (j = 0; j < (size_t)nbols; j++) {
(*resistance)[j] = refohmsval;
}
}
/* Get the heater efficiency file */
if (heateff && astMapHasKey( resmap, "HEATEFF" ) ) {
const char * heateffstr = NULL;
if (astMapGet0C( resmap, "HEATEFF", &heateffstr )) {
Grp * heateffgrp = NULL;
smfData * heatefftmp = NULL;
heateffgrp = grpNew( "heateff", status );
grpPut1( heateffgrp, heateffstr, 0, status );
smf_open_file( NULL, heateffgrp, 1, "READ", SMF__NOTTSERIES|SMF__NOFIX_METADATA, &heatefftmp, status );
/* Divorce the smfData from the underlying file. This file stays open for the entire
duration of the data processing and can some times lead to issues when we attempt
to close it an hour after we opened it (it's usually on an NFS disk) */
if (*status == SAI__OK) {
*heateff = smf_deepcopy_smfData( NULL, heatefftmp, 0,
SMF__NOCREATE_FILE | SMF__NOCREATE_FTS |
SMF__NOCREATE_DA,
0, 0, status );
smf_close_file(NULL, &heatefftmp, status);
}
/* Check the dimensions */
if (*status == SAI__OK) {
dim_t heatrows = 0;
dim_t heatcols = 0;
smf_get_dims( *heateff, &heatrows, &heatcols, NULL, NULL, NULL, NULL, NULL, status );
if (*status == SAI__OK) {
if ( datarows != heatrows || datacols != heatcols ) {
*status = SAI__ERROR;
errRepf( "", "Dimensions of heater efficiency file %s are (%zu, %zu)"
" but flatfield has dimensions (%zu, %zu)",
status, heateffstr, (size_t)heatrows, (size_t)heatcols,
(size_t)datarows, (size_t)datacols);
}
}
if (*status == SAI__OK) {
smf_dtype_check_fatal( *heateff, NULL, SMF__DOUBLE, status );
if (*status == SMF__BDTYP) {
errRepf("", "Heater efficiency data in %s should be double precision",
status, heateffstr);
}
}
if (*status == SAI__OK) {
char heateffarrid[32];
smf_fits_getS( refdata->hdr, "ARRAYID", heateffarrid, sizeof(heateffarrid), status );
if (*status != SAI__OK) errAnnul( status );
if (strcasecmp( thissub, heateffarrid ) != 0 ) {
if (*status == SAI__OK) {
*status = SAI__ERROR;
errRepf("", "Subarray associated with heater efficiency image (%s)"
" does not match that of the data to be flatfielded (%s)",
status, heateffarrid, thissub );
}
}
}
}
if (heateffgrp) grpDelet( &heateffgrp, status );
}
}
if (methpar && flatmeth) {
/* See if we want to use TABLE or POLYNOMIAL mode */
parChoic( methpar, "POLYNOMIAL", "POLYNOMIAL, TABLE", 1,
method, sizeof(method), status );
*flatmeth = smf_flat_methcode( method, status );
if (*flatmeth == SMF__FLATMETH_POLY) {
/* need an order for the polynomial */
if (order && orderpar) {
parGdr0i( orderpar, 1, 1, 3, 1, order, status );
/* and if the order is 1 then we can ask for the snr min */
if (snrminpar && *order == 1) {
parGet0d( snrminpar, snrmin, status );
}
}
} else {
/* need an snr min for table mode responsivities */
if (snrminpar) parGet0d( snrminpar, snrmin, status );
}
}
if (outrows) *outrows = datarows;
if (outcols) *outcols = datacols;
CLEANUP:
resmap = astAnnul( resmap );
if (*status != SAI__OK) {
if (resistance && *resistance) *resistance = astFree( *resistance );
if (heateff && *heateff) smf_close_file( NULL, heateff, status );
}
return;
}
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 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 {
smfData *smf_fft_avpspec( const smfData *pspec, smf_qual_t *quality,
size_t qstride, smf_qual_t mask, double *weights,
int *status ) {
dim_t fdims[2]; /* Lengths of frequency-space axes */
size_t i; /* Loop counter */
double *idptr=NULL; /* Pointer to input data */
double mean; /* Mean value at time slice */
dim_t nbolo=0; /* Number of detectors */
size_t ngood; /* Number of good samples */
size_t ndata; /* Total number of data points */
dim_t ntslice=0; /* Number of time slices */
dim_t nf=0; /* Number of frequencies in FFT */
double *odptr=NULL; /* Pointer to output data */
double *ovptr=NULL; /* Pointer to output variance */
dim_t rdims[2]; /* Lengths of real-space axes */
smfData *retdata=NULL; /* Returned power spectrum */
double sigma; /* RMS value at time slice */
if (*status != SAI__OK) return NULL;
/* Check for NULL pointer */
if( pspec == NULL ) {
*status = SAI__ERROR;
errRep( "", FUNC_NAME ": smfData pointer is NULL", status );
return NULL;
}
/* Check that we have frequency-domain input */
if( !smf_isfft( pspec, rdims, &nbolo, fdims, NULL, NULL, status ) ) {
*status = SAI__ERROR;
errRep( "", FUNC_NAME ": Input data are not FFT!", status );
return NULL;
}
ntslice = rdims[0];
nf = fdims[0];
/* Check that we don't have a 1-d input power spectrum */
if( pspec->ndims != 4 ) {
*status = SAI__ERROR;
errRep( "", FUNC_NAME ": Input data are not 4-dimensional!", status );
return NULL;
}
idptr = pspec->pntr[0];
if( !idptr ) {
*status = SAI__ERROR;
errRep( "", FUNC_NAME ": Null input data", status );
return NULL;
}
/* Assume qstride = bolo stride of main array if not specified */
if( !qstride ) {
qstride = nf;
}
/* Create a new smfData, copying over everything except for the bolo
data itself */
retdata = smf_deepcopy_smfData( pspec, 0, SMF__NOCREATE_DATA |
SMF__NOCREATE_VARIANCE |
SMF__NOCREATE_QUALITY |
SMF__NOCREATE_FILE |
SMF__NOCREATE_DA |
SMF__NOCREATE_FTS, 0, 0, status );
if( *status == SAI__OK ) {
/* Allocate space for the averaged power spectrum */
retdata->ndims = 4;
retdata->dims[0] = nf;
retdata->dims[1] = 1;
retdata->dims[2] = 1;
retdata->dims[3] = 2;
retdata->dtype = SMF__DOUBLE;
ndata=1;
for( i=0; i<retdata->ndims; i++ ) {
ndata *= retdata->dims[i];
}
/* Allocate space for DATA and VARIANCE components */
retdata->pntr[0] = astCalloc( ndata, smf_dtype_sz(retdata->dtype,status) );
retdata->pntr[1] = astCalloc( ndata, smf_dtype_sz(retdata->dtype,status) );
/* Pointers to output data */
odptr = retdata->pntr[0];
ovptr = retdata->pntr[1];
/* Call the returned data tordered even though it is irrelevant */
retdata->isTordered=0;
/* Since we assumed we're in power/polar form just need to calculate
average and scatter of the amplitude coefficients. The phase
coefficients are left at their initialized values of 0. */
for( i=0; i<nf; i++ ) {
/* The bolometer stride is nf */
smf_weightstats1D( idptr+i, nf, nbolo, quality, qstride, mask,
weights, 1, &mean, &sigma, &ngood, status );
if( *status == SMF__INSMP ) {
/* If not enough samples just annul and set bad value */
errAnnul( status );
odptr[i] = VAL__BADD;
ovptr[i] = VAL__BADD;
} else {
odptr[i] = mean;
ovptr[i] = sigma*sigma;
}
}
}
return retdata;
}
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();
}
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 );
}