void smf_write_flagmap( ThrWorkForce *wf, smf_qual_t mask, smfArray *lut, smfArray *qua,
smfDIMMData *dat, const Grp *flagrootgrp,
size_t contchunk, const int *lbnd_out,
const int *ubnd_out, AstFrameSet *outfset,
int *status ) {
AstFrameSet *tfset; /* Temporary FrameSet pointer */
Grp *mgrp=NULL; /* Temporary group for map names */
char *pname=NULL; /* Poiner to name */
char name[GRP__SZNAM+1]; /* Buffer for storing names */
char tempstr[20]; /* Temporary string */
char tmpname[GRP__SZNAM+1]; /* temp name buffer */
dim_t nbolo; /* Number of bolometers */
dim_t ntslice; /* Number of time slices */
double shift[ 1 ]; /* Shift from GRID to bit number */
int *flagmap=NULL; /* pointer to flagmap data */
int *lut_data=NULL; /* Pointer to DATA component of lut */
int ibit; /* Quality bit number */
int lbnd3d[3]; /* Lower bounds for 3D output */
int npix; /* Number of pixels per plane */
int target; /* Target value for incrementing pixel count */
int ubnd3d[3]; /* Upper bounds for 3D output */
size_t bstride; /* Bolometer stride */
size_t i; /* loop counter */
size_t idx=0; /* index within subgroup */
size_t ii; /* array offset index */
size_t j; /* loop counter */
size_t tstride; /* Time stride */
smfData *mapdata=NULL; /* smfData for new map */
smf_qual_t *qua_data=NULL; /* Pointer to DATA component of qua */
if( *status != SAI__OK ) return;
if( !lut || !qua || !dat || !flagrootgrp || !lbnd_out || !ubnd_out ||
!outfset ) {
*status = SAI__ERROR;
errRep( "", FUNC_NAME ": NULL inputs supplied", status );
return;
}
/* Create a name for the flagmap, taking into account the chunk
number. Only required if we are using a single output
container. */
pname = tmpname;
grpGet( flagrootgrp, 1, 1, &pname, sizeof(tmpname), status );
one_strlcpy( name, tmpname, sizeof(name), status );
one_strlcat( name, ".", sizeof(name), status );
sprintf(tempstr, "CH%02zd", contchunk);
one_strlcat( name, tempstr, sizeof(name), status );
mgrp = grpNew( "flagmap", status );
grpPut1( mgrp, name, 0, status );
msgOutf( "", "*** Writing flagmap %s", status, name );
/* If a non-zero mask value wassupplied, the flagmap is 2-dimensional
and each pixel value counts the number of samples flagged by any of
the qualities included in the mask. */
if( mask ) {
smf_open_newfile( wf, mgrp, 1, SMF__INTEGER, 2, lbnd_out, ubnd_out, 0, &mapdata,
status);
flagmap = mapdata->pntr[0];
/* Loop over subgroup index (subarray) */
for( idx=0; (idx<qua->ndat)&&(*status==SAI__OK); idx++ ) {
smf_get_dims( qua->sdata[idx], NULL, NULL, &nbolo, &ntslice,
NULL, &bstride, &tstride, status );
qua_data = (qua->sdata[idx]->pntr)[0];
lut_data = (lut->sdata[idx]->pntr)[0];
/* Loop over bolometer and time slice and create map */
for( i=0; i<nbolo; i++ ) {
/* Skip bolometers only if SMF__Q_BADB is set both in the
data and the mask */
if( !(qua_data[i*bstride] & mask & SMF__Q_BADB) ) {
for( j=0; j<ntslice; j++ ) {
ii = i*bstride + j*tstride;
if( (qua_data[ii] & mask) && (lut_data[ii] != VAL__BADI) ) {
flagmap[lut_data[ii]]++;
}
}
}
}
}
/* Write WCS */
smf_set_moving( (AstFrame *) outfset, NULL, status );
ndfPtwcs( outfset, mapdata->file->ndfid, status );
/* If the mask is zero, the flagmap is 3-dimensional and contains a
plane for each quality bit, plus an additional plane (plane 1)
containing the number of unflagged samples in each pixel. */
} else {
lbnd3d[ 0 ] = lbnd_out[ 0 ];
lbnd3d[ 1 ] = lbnd_out[ 1 ];
lbnd3d[ 2 ] = -1;
ubnd3d[ 0 ] = ubnd_out[ 0 ];
ubnd3d[ 1 ] = ubnd_out[ 1 ];
ubnd3d[ 2 ] = SMF__NQBITS_TSERIES - 1;
smf_open_newfile( wf, mgrp, 1, SMF__INTEGER, 3, lbnd3d, ubnd3d, 0,
&mapdata, status);
flagmap = mapdata->pntr[0];
/* No. of pixels in one plane */
npix = ( ubnd3d[ 1 ] - lbnd3d[ 1 ] + 1 )*( ubnd3d[ 0 ] - lbnd3d[ 0 ] + 1 );
/* Loop over each quality bit (-1 == "no flags"). */
for( ibit = -1; ibit < SMF__NQBITS_TSERIES; ibit++ ) {
/* The test of each sample is performed by checking if the
sample's quality value ANDed with "mask" is equal to "target".
This is requires since ibit==-1 (i.e. "count all samples that
have no flags set") requires a different logic to the other
ibit values. */
if( ibit == -1 ) {
mask = SMF__Q_GOOD;
target = 0;
} else {
mask = BIT_TO_VAL(ibit);
target = mask;
}
/* Loop over subgroup index (subarray) */
for( idx=0; (idx<qua->ndat)&&(*status==SAI__OK); idx++ ) {
smf_get_dims( qua->sdata[idx], NULL, NULL, &nbolo, &ntslice,
NULL, &bstride, &tstride, status );
qua_data = (qua->sdata[idx]->pntr)[0];
lut_data = (lut->sdata[idx]->pntr)[0];
/* Loop over bolometer and time slice and create map */
for( i=0; i<nbolo; i++ ) {
/* Skip bolometers only if SMF__Q_BADB is set both in the
data and the mask */
for( j=0; j<ntslice; j++ ) {
ii = i*bstride + j*tstride;
if( ( (qua_data[ii] & mask) == target ) &&
(lut_data[ii] != VAL__BADI) ) {
flagmap[lut_data[ii]]++;
}
}
}
}
/* Move the pointer on to th enext plane. */
flagmap += npix;
/* Next quality bit. */
}
/* Take a copy of the supplied FrameSet so we do not modify it. */
tfset = astCopy( outfset );
/* Set atributes for moving target if necessary. */
smf_set_moving( (AstFrame *) tfset, NULL, status );
/* Modify the WCS FrameSet so that the base and current Frames are
3-dimensional. The current Frame is expanded by adding in a simple
1D Frame representing quality bit, and the base Frame is expanded
by adding in a 3rd GRID axis. Other Frames are left unchanged.
The quality bit Frame and the new GRID axis are connected using
a ShiftMap that gives the right zero-based bit numbers (which
also correspond to PIXEL indices). */
shift[ 0 ] = -2.0;
atlAddWcsAxis( tfset, (AstMapping *) astShiftMap( 1, shift, " " ),
astFrame( 1, "Label(1)=Quality bit,Domain=QUALITY" ),
NULL, NULL, status );
/* Store the FrameSet in the 3D NDF. */
ndfPtwcs( tfset, mapdata->file->ndfid, status );
tfset = astAnnul( tfset );
}
/* Clean up */
if( mgrp ) grpDelet( &mgrp, status );
smf_close_file( wf, &mapdata, status );
}
void smf_open_ndfname( const HDSLoc *loc, const char accmode[],
const char extname[], const char state[], const char dattype[],
const int ndims, const int lbnd[], const int ubnd[],
const char datalabel[], const char dataunits[],
const AstFrameSet* wcs,
smfData **ndfdata,
int *status) {
/* Local variables */
void *datarr[] = { NULL, NULL }; /* Pointers for data */
int dims[NDF__MXDIM]; /* Extent of each dimension */
smf_dtype dtype; /* Data type */
int flags = 0; /* Flags for creating smfDA, smfFile and
smfHead components in the output smfData */
int i;
int ndat; /* Number of elements mapped in the requested NDF */
char ndfaccmode[NDF__SZMMD+1];/* Access mode to use to open the file */
int ndimsmapped; /* Number of dimensions in mapped NDF */
int ndfid; /* NDF identifier */
AstFrameSet *ndfwcs = NULL; /* Copy of input FrameSet to write to NDF */
smfFile *newfile = NULL; /* New smfFile with details of requested NDF */
int place; /* Placeholder for NDF */
int updating = 0; /* True if the extension is being updated */
/* Initialize the output smfData to NULL pointer */
*ndfdata = NULL;
if ( *status != SAI__OK ) return;
/* Check to see if the HDS Locator is null and retrieve the NDF id */
if ( loc == NULL ) {
errRep( FUNC_NAME, "Given HDS locator is NULL", status );
return;
}
/* Start be assuming the requested access mode can be used for mapping
and file opening */
one_strlcpy( ndfaccmode, accmode, sizeof(ndfaccmode), status );
/* Note: write access clears the contents of the NDF */
if ( strncmp( accmode, "WRITE", 5 ) == 0 ) {
msgOutif(MSG__DEBUG," ", "Opening NDF with WRITE access: this will clear the current contents if the NDF exists.", status);
updating = 1;
/* We can have WRITE/ZERO or WRITE/BAD so we need to force WRITE
into the NDF open access mode */
one_strlcpy( ndfaccmode, "WRITE", sizeof(ndfaccmode), status );
} else if ( strncmp( accmode, "UPDATE", 6) == 0) {
updating = 1;
}
ndfOpen( loc, extname, ndfaccmode, state, &ndfid, &place, status );
if ( *status != SAI__OK ) {
errRep( FUNC_NAME,
"Call to ndfOpen failed: unable to obtain an NDF identifier",
status );
return;
}
/* No placeholder => NDF exists */
if ( place != NDF__NOPL ) {
/* Define properties of NDF */
ndfNew( dattype, ndims, lbnd, ubnd, &place, &ndfid, status );
if ( *status != SAI__OK ) {
errRep( FUNC_NAME, "Unable to create a new NDF", status );
return;
}
}
/* Convert the data type string to SMURF dtype */
dtype = smf_dtype_fromstring( dattype, status );
/* First step is to create an empty smfData with no extra components */
flags |= SMF__NOCREATE_DA;
flags |= SMF__NOCREATE_FTS;
flags |= SMF__NOCREATE_HEAD;
flags |= SMF__NOCREATE_FILE;
*ndfdata = smf_create_smfData( flags, status);
/* Set the requested data type */
(*ndfdata)->dtype = dtype;
/* OK, now map the data array */
ndfMap( ndfid, "DATA", dattype, accmode, &datarr[0], &ndat, status );
if ( *status != SAI__OK ) {
errRep( FUNC_NAME, "Unable to map data array: invalid NDF identifier?", status );
}
/* Retrieve dimensions of mapped array */
ndfDim( ndfid, NDF__MXDIM, dims, &ndimsmapped, status );
if ( *status != SAI__OK ) {
errRep( FUNC_NAME, "Problem identifying dimensions of requested NDF", status );
}
/* Consistency check */
if ( ndimsmapped != ndims ) {
if ( *status == SAI__OK ) {
*status = SAI__ERROR;
errRep( FUNC_NAME, "Number of dimensions in new NDF not equal to number of dimensions specified", status );
}
}
if (*status == SAI__OK) {
for (i=0; i<ndims; i++) {
((*ndfdata)->dims)[i] = dims[i];
((*ndfdata)->lbnd)[i] = lbnd[i];
}
}
/* Allow for label, units and WCS to be written */
if (updating) {
if (datalabel) ndfCput( datalabel, ndfid, "Label", status );
if (dataunits) ndfCput( dataunits, ndfid, "Unit", status );
if (wcs) {
/* Take a copy of the input WCS and modify if necessary that
before writing to the NDF */
ndfwcs = astCopy( wcs );
smf_set_moving( (AstFrame *) ndfwcs, NULL, status );
ndfPtwcs( ndfwcs, ndfid, status );
if (ndfwcs) ndfwcs = astAnnul( ndfwcs );
}
}
/* Create the smfFile */
newfile = smf_construct_smfFile( newfile, ndfid, 0, 0, NULL, status );
if ( *status != SAI__OK ) {
errRep( FUNC_NAME, "Unable to construct new smfFile", status );
}
/* And populate the new smfData */
*ndfdata = smf_construct_smfData( *ndfdata, newfile, NULL, NULL, NULL, dtype,
datarr, NULL, SMF__QFAM_NULL, NULL, 0, 1,
(*ndfdata)->dims, (*ndfdata)->lbnd, ndims,
0, 0, NULL, NULL, status );
}
void smf_write_itermap( ThrWorkForce *wf, const double *map, const double *mapvar,
const smf_qual_t *mapqua, dim_t msize,
const Grp *iterrootgrp, size_t contchunk, int iter,
const int *lbnd_out, const int *ubnd_out,
AstFrameSet *outfset, const smfHead *hdr,
const smfArray *qua, int *status ) {
int flags; /* Flags indicating required NDF components */
Grp *mgrp=NULL; /* Temporary group to hold map name */
smfData *imapdata=NULL; /* smfData for this iteration map */
char name[GRP__SZNAM+1]; /* Buffer for storing name */
char *pname=NULL; /* Poiner to name */
char tmpname[GRP__SZNAM+1]; /* temp name buffer */
char tempstr[20];
if( *status != SAI__OK ) return;
if( !map || !mapvar || !iterrootgrp || !lbnd_out || !ubnd_out || !outfset ) {
*status = SAI__ERROR;
errRep( "", FUNC_NAME ": NULL inputs supplied", status );
return;
}
if( hdr && !qua ) {
*status = SAI__ERROR;
errRep( "", FUNC_NAME ": hdr supplied but qua is NULL", status );
return;
}
/* Create a name for this iteration map, take into
account the chunk number. Only required if we are
using a single output container. */
pname = tmpname;
grpGet( iterrootgrp, 1, 1, &pname, sizeof(tmpname), status );
one_strlcpy( name, tmpname, sizeof(name), status );
one_strlcat( name, ".", sizeof(name), status );
/* Continuous chunk number */
sprintf(tempstr, "CH%02zd", contchunk);
one_strlcat( name, tempstr, sizeof(name), status );
/* Iteration number */
sprintf( tempstr, "I%03i", iter+1 );
one_strlcat( name, tempstr, sizeof(name), status );
mgrp = grpNew( "itermap", status );
grpPut1( mgrp, name, 0, status );
msgOutf( "", "*** Writing map from this iteration to %s", status,
name );
flags = SMF__MAP_VAR;
if( mapqua ) flags |= SMF__MAP_QUAL;
smf_open_newfile ( wf, mgrp, 1, SMF__DOUBLE, 2, lbnd_out,
ubnd_out, flags, &imapdata, status);
/* Copy over the signal and variance maps */
if( *status == SAI__OK ) {
memcpy( imapdata->pntr[0], map, msize*sizeof(*map) );
memcpy( imapdata->pntr[1], mapvar, msize*sizeof(*mapvar) );
if( mapqua ) memcpy( imapdata->qual, mapqua, msize*sizeof(*mapqua) );
}
/* Write out a FITS header */
if( (*status == SAI__OK) && hdr && hdr->allState ) {
AstFitsChan *fitschan=NULL;
JCMTState *allState = hdr->allState;
char *obsidss=NULL;
char obsidssbuf[SZFITSTR];
double iter_nboloeff;
size_t nmap;
size_t ngood_tslices;
dim_t ntslice; /* Number of time slices */
fitschan = astFitsChan ( NULL, NULL, " " );
obsidss = smf_getobsidss( hdr->fitshdr,
NULL, 0, obsidssbuf,
sizeof(obsidssbuf), status );
if( obsidss ) {
atlPtfts( fitschan, "OBSIDSS", obsidss,
"Unique observation subsys identifier", status );
}
atlPtfti( fitschan, "SEQSTART", allState[0].rts_num,
"RTS index number of first frame", status );
ntslice = hdr->nframes;
atlPtfti( fitschan, "SEQEND", allState[ntslice-1].rts_num,
"RTS index number of last frame", status );
/* calculate the effective number of bolometers for this
iteration */
smf_qualstats_model( wf, SMF__QFAM_TSERIES, 1, qua, NULL, NULL, &nmap,
NULL, NULL, &ngood_tslices, NULL, NULL, status );
iter_nboloeff = (double)nmap / (double)ngood_tslices;
atlPtftd( fitschan, "NBOLOEFF", iter_nboloeff,
"Effective bolometer count", status );
kpgPtfts( imapdata->file->ndfid, fitschan, status );
if( fitschan ) fitschan = astAnnul( fitschan );
}
/* Write WCS (protecting the pointer dereference) */
smf_set_moving(outfset,NULL,status);
if (*status == SAI__OK && imapdata) {
ndfPtwcs( outfset, imapdata->file->ndfid, status );
}
/* Clean up */
if( mgrp ) grpDelet( &mgrp, status );
smf_close_file( wf, &imapdata, status );
}
void smf_write_bolomap( ThrWorkForce *wf, smfArray *res, smfArray *lut,
smfArray *qua, smfDIMMData *dat, dim_t msize,
const Grp *bolrootgrp, int varmapmethod,
const int *lbnd_out, const int *ubnd_out,
AstFrameSet *outfset, int *status ) {
int addtomap=0; /* Set if adding to existing map */
size_t bstride; /* Bolometer stride */
double *curmap=NULL; /* Pointer to current map being rebinned */
double *curvar=NULL; /* Pointer to variance associate with curmap */
dim_t dsize; /* Size of data arrays in containers */
size_t idx=0; /* index within subgroup */
size_t k; /* loop counter */
int *lut_data=NULL; /* Pointer to DATA component of lut */
char name[GRP__SZNAM+1]; /* Buffer for storing names */
dim_t nbolo; /* Number of bolometers */
size_t nbolomaps = 0; /* Number of bolomaps written */
char *pname=NULL; /* Poiner to name */
smf_qual_t *qua_data=NULL; /* Pointer to DATA component of qua */
double *res_data=NULL; /* Pointer to DATA component of res */
if( *status != SAI__OK ) return;
if( !res || !lut || !qua || !dat || !bolrootgrp ||
!lbnd_out || !ubnd_out || !outfset ) {
*status = SAI__ERROR;
errRep( "", FUNC_NAME ": NULL inputs supplied", status );
return;
}
/* Loop over subgroup index (subarray) */
for( idx=0; idx<res->ndat; idx++ ) {
smf_qual_t *bolomask = NULL;
double *bmapweight = NULL;
double *bmapweightsq = NULL;
int *bhitsmap = NULL;
/* Pointers to everything we need */
res_data = res->sdata[idx]->pntr[0];
lut_data = lut->sdata[idx]->pntr[0];
qua_data = qua->sdata[idx]->pntr[0];
smf_get_dims( res->sdata[idx], NULL, NULL, &nbolo, NULL,
&dsize, &bstride, NULL, status );
/* Make a copy of the quality at first time slice as a good
bolo mask, and then set quality to SMF__Q_BADB. Later we
will unset BADB for one bolo at a time to make individual
maps. */
bolomask = astMalloc( nbolo*sizeof(*bolomask) );
bmapweight = astMalloc( msize*sizeof(*bmapweight) );
bmapweightsq = astMalloc( msize*sizeof(*bmapweightsq) );
bhitsmap = astMalloc( msize*sizeof(*bhitsmap) );
if( *status == SAI__OK ) {
for( k=0; k<nbolo; k++ ) {
bolomask[k] = qua_data[k*bstride];
qua_data[k*bstride] = SMF__Q_BADB;
}
/* Identify good bolos in the copied mask and produce a map */
for( k=0; (k<nbolo)&&(*status==SAI__OK); k++ ) {
if( !(bolomask[k]&SMF__Q_BADB) ) {
Grp *mgrp=NULL; /* Temporary group to hold map names */
smfData *mapdata=NULL;/* smfData for new map */
char tmpname[GRP__SZNAM+1]; /* temp name buffer */
char thisbol[20]; /* name particular to this bolometer */
size_t col, row;
char subarray[10];
nbolomaps++;
/* Set the quality back to good for this single bolometer */
qua_data[k*bstride] = bolomask[k];
/* Create a name for the new map, take into account the
chunk number and subarray. Only required if we are using a single
output container. */
pname = tmpname;
grpGet( bolrootgrp, 1, 1, &pname, sizeof(tmpname), status );
one_strlcpy( name, tmpname, sizeof(name), status );
one_strlcat( name, ".", sizeof(name), status );
/* Subarray, column and row. HDS does not care about case but we
convert to upper case anyhow. */
smf_find_subarray( res->sdata[idx]->hdr, subarray, sizeof(subarray),
NULL, status );
if (*status == SAI__OK) {
size_t len = strlen(subarray);
size_t n = 0;
for (n=0; n<len; n++) {
subarray[n] = toupper(subarray[n]);
}
}
col = (k % res->sdata[idx]->dims[1])+1;
row = (k / res->sdata[idx]->dims[1])+1;
sprintf( thisbol, "%3sC%02zuR%02zu",
subarray,
col, /* x-coord */
row ); /* y-coord */
one_strlcat( name, thisbol, sizeof(name), status );
mgrp = grpNew( "bolomap", status );
grpPut1( mgrp, name, 0, status );
msgOutf( "", "*** Writing single bolo map %s", status,
name );
/* Try to open an existing extention first. Create a new map
array, and then later we'll add it to the existing
one. If it isn't there, create it. */
smf_open_file( mgrp, 1, "UPDATE", 0, &mapdata, status );
if( *status == SAI__OK ) {
/* Allocate memory for the new rebinned data */
curmap = astCalloc( msize, sizeof(*curmap) );
curvar = astCalloc( msize, sizeof(*curvar) );
addtomap = 1;
} else if( *status == DAT__NAMIN ) {
/* Create a new extension */
errAnnul( status );
smf_open_newfile ( mgrp, 1, SMF__DOUBLE, 2, lbnd_out,
ubnd_out, SMF__MAP_VAR, &mapdata, status);
/* Rebin directly into the newly mapped space */
if( *status == SAI__OK ) {
curmap = mapdata->pntr[0];
curvar = mapdata->pntr[1];
addtomap = 0;
}
}
/* Rebin the data for this single bolometer. Don't care
about variance weighting because all samples from
same detector are about the same. */
smf_rebinmap1( wf, res->sdata[idx],
dat->noi ? dat->noi[0]->sdata[idx] : NULL,
lut_data, 0, 0, 0, NULL, 0,
SMF__Q_GOOD, varmapmethod,
AST__REBININIT | AST__REBINEND,
curmap, bmapweight, bmapweightsq, bhitsmap,
curvar, msize, NULL, status );
/* If required, add this new map to the existing one */
if( addtomap ) {
size_t i;
double *oldmap=NULL;
double *oldvar=NULL;
double weight;
if( *status == SAI__OK ) {
oldmap = mapdata->pntr[0];
oldvar = mapdata->pntr[1];
for( i=0; i<msize; i++ ) {
if( oldmap[i]==VAL__BADD ) {
/* No data in this pixel in the old map, just copy */
oldmap[i] = curmap[i];
oldvar[i] = curvar[i];
} else if( curmap[i]!=VAL__BADD &&
oldvar[i]!=VAL__BADD && oldvar[i]!=0 &&
curvar[i]!=VAL__BADD && curvar[i]!=0 ) {
/* Both old and new values available */
weight = 1/oldvar[i] + 1/curvar[i];
oldmap[i] = (oldmap[i]/oldvar[i] + curmap[i]/curvar[i]) /
weight;
oldvar[i] = 1/weight;
}
}
}
/* Free up temporary arrays */
curmap = astFree( curmap );
curvar = astFree( curvar );
}
/* Write out COLNUM and ROWNUM to FITS header */
if( *status == SAI__OK ) {
AstFitsChan *fitschan=NULL;
fitschan = astFitsChan ( NULL, NULL, " " );
atlPtfti( fitschan, "COLNUM", col, "bolometer column", status);
atlPtfti( fitschan, "ROWNUM", row, "bolometer row", status );
atlPtfts( fitschan, "SUBARRAY", subarray, "Subarray identifier",
status );
kpgPtfts( mapdata->file->ndfid, fitschan, status );
if( fitschan ) fitschan = astAnnul( fitschan );
/* Set the bolo to bad quality again */
qua_data[k*bstride] = SMF__Q_BADB;
/* Write WCS */
smf_set_moving(outfset,NULL,status);
ndfPtwcs( outfset, mapdata->file->ndfid, status );
}
/* Clean up */
if( mgrp ) grpDelet( &mgrp, status );
if( mapdata ) smf_close_file( &mapdata, status );
}
}
/* Set quality back to its original state */
for( k=0; k<nbolo; k++ ) {
qua_data[k*bstride] = bolomask[k];
}
}
/* Free up memory */
bolomask = astFree( bolomask );
bmapweight = astFree( bmapweight );
bmapweightsq = astFree( bmapweightsq );
bhitsmap = astFree( bhitsmap );
}
msgOutf( "", "*** Wrote %zu bolo maps", status, nbolomaps );
}
void smf_write_shortmap( ThrWorkForce *wf, int shortmap, smfArray *res,
smfArray *lut, smfArray *qua, smfDIMMData *dat,
dim_t msize, const Grp *shortrootgrp, size_t contchunk,
int varmapmethod, const int *lbnd_out,
const int *ubnd_out, AstFrameSet *outfset,
int *status ) {
dim_t dsize; /* Size of data arrays in containers */
size_t i; /* loop counter */
size_t idx=0; /* index within subgroup */
size_t istart; /* First useful timeslice */
size_t iend; /* Last useful timeslice */
int *lut_data=NULL; /* Pointer to DATA component of lut */
char name[GRP__SZNAM+1]; /* Buffer for storing names */
size_t nshort=0; /* Number of short maps */
dim_t ntslice; /* Number of time slices */
char *pname=NULL; /* Poiner to name */
smf_qual_t *qua_data=NULL; /* Pointer to DATA component of qua */
double *res_data=NULL; /* Pointer to DATA component of res */
size_t sc; /* Short map counter */
double *shortmapweight=NULL; /* buffer for shotmap weights */
double *shortmapweightsq=NULL;/* buffer for shotmap weights squared */
int *shorthitsmap=NULL; /* buffer for shotmap hits */
size_t shortstart; /* first time slice of short map */
size_t shortend; /* last time slice of short map */
size_t tstride; /* Time stride */
if( *status != SAI__OK ) return;
if( !res || !lut || !qua || !dat || !shortrootgrp ||
!lbnd_out || !ubnd_out || !outfset || !shortmap ) {
*status = SAI__ERROR;
errRep( "", FUNC_NAME ": NULL inputs supplied", status );
return;
}
if( !res || !res->sdata || !res->sdata[idx] || !res->sdata[idx]->hdr ||
!res->sdata[idx]->hdr->allState ) {
*status = SAI__ERROR;
errRep( "", FUNC_NAME ": RES does not contain JCMTState", status );
return;
}
/* Allocate space for the arrays */
shortmapweight = astMalloc( msize*sizeof(*shortmapweight) );
shortmapweightsq = astMalloc( msize*sizeof(*shortmapweightsq) );
shorthitsmap = astMalloc( msize*sizeof(*shorthitsmap) );
/* Use first subarray to figure out time dimension. Get the
useful start and end points of the time series, and then
determine "nshort" -- the number of complete blocks of
shortmap time slices in the useful range. */
smf_get_dims( qua->sdata[0], NULL, NULL, NULL, &ntslice,
NULL, NULL, &tstride, status );
qua_data = (qua->sdata[0]->pntr)[0];
smf_get_goodrange( qua_data, ntslice, tstride, SMF__Q_BOUND,
&istart, &iend, status );
shortstart = istart;
if( *status == SAI__OK ) {
if( shortmap == -1 ) {
nshort = res->sdata[idx]->hdr->allState[iend].tcs_index -
res->sdata[idx]->hdr->allState[istart].tcs_index + 1;
msgOutf( "", FUNC_NAME
": writing %zu short maps, once each time TCS_INDEX increments",
status, nshort );
} else {
nshort = (iend-istart+1)/shortmap;
if( nshort ) {
msgOutf( "", FUNC_NAME
": writing %zu short maps of length %i time slices.",
status, nshort, shortmap );
} else {
/* Generate warning message if requested short maps are too long*/
msgOutf( "", FUNC_NAME
": Warning! short maps of lengths %i requested, but "
"data only %zu time slices.", status, shortmap,
iend-istart+1 );
}
}
}
/* Loop over short maps */
for( sc=0; (sc<nshort)&&(*status==SAI__OK); sc++ ) {
Grp *mgrp=NULL; /* Temporary group for map names */
smfData *mapdata=NULL; /* smfData for new map */
char tempstr[20]; /* Temporary string */
char tmpname[GRP__SZNAM+1]; /* temp name buffer */
char thisshort[20]; /* name particular to this shortmap */
/* Create a name for the new map, take into account the
chunk number. Only required if we are using a single
output container. */
pname = tmpname;
grpGet( shortrootgrp, 1, 1, &pname, sizeof(tmpname), status );
one_strlcpy( name, tmpname, sizeof(name), status );
one_strlcat( name, ".", sizeof(name), status );
/* Continuous chunk number */
sprintf(tempstr, "CH%02zd", contchunk);
one_strlcat( name, tempstr, sizeof(name), status );
/* Shortmap number */
sprintf( thisshort, "SH%06zu", sc );
one_strlcat( name, thisshort, sizeof(name), status );
mgrp = grpNew( "shortmap", status );
grpPut1( mgrp, name, 0, status );
msgOutf( "", "*** Writing short map (%zu / %zu) %s", status,
sc+1, nshort, name );
smf_open_newfile ( wf, mgrp, 1, SMF__DOUBLE, 2, lbnd_out,
ubnd_out, SMF__MAP_VAR, &mapdata,
status);
/* Time slice indices for start and end of short map -- common to
all subarrays */
if( shortmap > 0) {
/* Evenly-spaced shortmaps in time */
shortstart = istart+sc*shortmap;
shortend = istart+(sc+1)*shortmap-1;
} else {
/* One map each time TCS_INDEX increments -- just uses header
for the first subarray */
for(i=shortstart+1; (i<=iend) &&
(res->sdata[0]->hdr->allState[i].tcs_index ==
res->sdata[0]->hdr->allState[shortstart].tcs_index);
i++ );
shortend = i-1;
}
/* Bad status if we have invalid shortmap ranges. This might
happen if there is ever a jump in TCS_INDEX for the shortmap=-1
case since the total number of shortmaps is calculated simply
as the difference between the first and final TCS indices. */
if( !nshort || (iend<istart) || (iend>=ntslice) ) {
*status = SAI__ERROR;
errRepf( "", FUNC_NAME ": invalid shortmap range (%zu--%zu, ntslice=%zu)"
"encountered", status, istart, iend, ntslice );
break;
}
/* Loop over subgroup index (subarray) */
for( idx=0; (idx<res->ndat)&&(*status==SAI__OK); idx++ ) {
int rebinflag = 0;
/* Pointers to everything we need */
res_data = (res->sdata[idx]->pntr)[0];
lut_data = (lut->sdata[idx]->pntr)[0];
qua_data = (qua->sdata[idx]->pntr)[0];
smf_get_dims( res->sdata[idx], NULL, NULL, NULL, &ntslice,
&dsize, NULL, &tstride, status );
/* Rebin the data for this range of tslices. */
if( idx == 0 ) {
rebinflag |= AST__REBININIT;
}
if( idx == (res->ndat-1) ) {
rebinflag |= AST__REBINEND;
}
smf_rebinmap1( NULL, res->sdata[idx],
dat->noi ? dat->noi[0]->sdata[idx] : NULL,
lut_data, shortstart, shortend, 1, NULL, 0,
SMF__Q_GOOD, varmapmethod,
rebinflag,
mapdata->pntr[0],
shortmapweight, shortmapweightsq, shorthitsmap,
mapdata->pntr[1], msize, NULL, status );
/* Write out FITS header */
if( (*status == SAI__OK) && res->sdata[idx]->hdr &&
res->sdata[idx]->hdr->allState ) {
AstFitsChan *fitschan=NULL;
JCMTState *allState = res->sdata[idx]->hdr->allState;
size_t midpnt = (shortstart + shortend) / 2;
fitschan = astFitsChan ( NULL, NULL, " " );
atlPtfti( fitschan, "SEQSTART", allState[shortstart].rts_num,
"RTS index number of first frame", status );
atlPtfti( fitschan, "SEQEND", allState[shortend].rts_num,
"RTS index number of last frame", status);
atlPtftd( fitschan, "MJD-AVG", allState[midpnt].rts_end,
"Average MJD of this map", status );
atlPtfts( fitschan, "TIMESYS", "TAI", "Time system for MJD-AVG",
status );
atlPtfti( fitschan, "TCSINDST", allState[shortstart].tcs_index,
"TCS index of first frame", status );
atlPtfti( fitschan, "TCSINDEN", allState[shortend].tcs_index,
"TCS index of last frame", status );
kpgPtfts( mapdata->file->ndfid, fitschan, status );
if( fitschan ) fitschan = astAnnul( fitschan );
}
}
/* Update shortstart in case we are counting steps in TCS_INDEX */
shortstart = shortend+1;
/* Write WCS */
smf_set_moving( (AstFrame *) outfset, NULL, status );
ndfPtwcs( outfset, mapdata->file->ndfid, status );
/* Clean up */
if( mgrp ) grpDelet( &mgrp, status );
smf_close_file( wf, &mapdata, status );
}
/* Free up memory */
shortmapweight = astFree( shortmapweight );
shortmapweightsq = astFree( shortmapweightsq );
shorthitsmap = astFree( shorthitsmap );
}
void smf_get_projpar( AstSkyFrame *skyframe, const double skyref[2],
int moving, int autogrid, int nallpos,
const double * allpos, float telres, double map_pa,
double par[7], int * issparse,int *usedefs, int *status ) {
/* Local Variables */
char reflat[ 41 ]; /* Reference latitude string */
char reflon[ 41 ]; /* Reference longitude string */
char usesys[ 41 ]; /* Output skyframe system */
const char *deflat; /* Default for REFLAT */
const char *deflon; /* Default for REFLON */
const double fbpixsize = 6.0; /* Fallback pixel size if we have no other information */
double autorot; /* Autogrid default for CROTA parameter */
double defsize[ 2 ]; /* Default pixel sizes in arc-seconds */
double pixsize[ 2 ]; /* Pixel sizes in arc-seconds */
double refpix[ 2 ]; /* New REFPIX values */
double rdiam; /* Diameter of bounding circle, in rads */
int coin; /* Are all points effectively co-incident? */
int i;
int nval; /* Number of values supplied */
int refine_crpix; /* Should the pixel ref position be updated? */
int sparse = 0; /* Local definition of sparseness */
int udefs = 0; /* Flag for defaults used or not */
/* Check inherited status. */
if( *status != SAI__OK ) return;
/* If the number of supplied positions is 0 or null pointer,
disable autogrid */
if( nallpos == 0 || !allpos ) autogrid = 0;
/* Get the output system */
one_strlcpy( usesys, astGetC( skyframe, "SYSTEM"), sizeof(usesys),
status );
/* Ensure the reference position in the returned SkyFrame is set to the
first telescope base pointing position. */
astSetD( skyframe, "SkyRef(1)", skyref[ 0 ] );
astSetD( skyframe, "SkyRef(2)", skyref[ 1 ] );
/* If the target is moving, ensure the returned SkyFrame represents
offsets from the first telescope base pointing position rather than
absolute coords. */
if( moving ) smf_set_moving( (AstFrame *) skyframe, NULL, status );
/* Set a flag indicating if all the points are co-incident. */
coin = 0;
/* Set the sky axis values at the tangent point. If the target is moving,
the tangent point is at (0,0) (i.e. it is at the origin of the offset
coordinate system). If the target is not moving, the tangent point is
at the position held in "skyref". */
if( par ) {
if( moving ){
par[ 2 ] = 0.0;
par[ 3 ] = 0.0;
} else {
par[ 2 ] = skyref[ 0 ];
par[ 3 ] = skyref[ 1 ];
}
/* If required, calculate the optimal projection parameters. If the target
is moving, these refer to the offset coordinate system centred on the
first time slice base pointing position, with north defined by the
requested output coordinate system. The values found here are used as
dynamic defaults for the environment parameter */
if( autogrid ) {
kpg1Opgrd( nallpos, allpos, strcmp( usesys, "AZEL" ), par, &rdiam,
status );
/* See if all the points are effectively co-incident (i.e. within an Airy
disk). If so, we use default grid parameters that result in a grid of
1x1 spatial pixels. The grid pixel sizes (par[4] and par[5]) are made
larger than the area covered by the points in order to avoid points
spanning two pixels. */
if( rdiam < telres || nallpos < 3 ) {
if( rdiam < 0.1*AST__DD2R/3600.0 ) rdiam = 0.1*AST__DD2R/3600.0;
par[ 0 ] = 0.0;
par[ 1 ] = 0.0;
par[ 4 ] = -rdiam*4;
par[ 5 ] = -par[ 4 ];
par[ 6 ] = 0.0;
coin = 1;
/* If the sky positions are not co-incident, and the automatic grid
determination failed, we cannot use a grid, so warn the user. */
} else if( par[ 0 ] == AST__BAD ) {
msgOutif( MSG__NORM, " ", " Automatic grid determination "
"failed: the detector samples do not form a "
"regular grid.", status );
}
}
/* If autogrid values were not found, use the following fixed default
values. Do not override extenal defaults for pixel size. */
if( !autogrid || ( autogrid && par[ 0 ] == AST__BAD ) ) {
par[ 0 ] = 0.0;
par[ 1 ] = 0.0;
if (par[4] == AST__BAD || par[5] == AST__BAD ) {
par[ 4 ] = (fbpixsize/3600.0)*AST__DD2R;
par[ 5 ] = (fbpixsize/3600.0)*AST__DD2R;
}
par[ 6 ] = map_pa;
}
/* Ensure the default pixel sizes have the correct signs. */
if( par[ 4 ] != AST__BAD ) {
if( !strcmp( usesys, "AZEL" ) ) {
par[ 4 ] = fabs( par[ 4 ] );
} else {
par[ 4 ] = -fabs( par[ 4 ] );
}
par[ 5 ] = fabs( par[ 5 ] );
}
/* See if the output cube is to include a spatial projection, or a sparse
list of spectra. Disabled if the sparse pointer is NULL. */
if (issparse) {
parDef0l( "SPARSE", ( par[ 0 ] == AST__BAD ), status );
parGet0l( "SPARSE", &sparse, status );
}
/* If we are producing an output cube with the XY plane being a spatial
projection, then get the parameters describing the projection, using the
defaults calculated above. */
if( !sparse && *status == SAI__OK ) {
const int ndigits = 8; /* Number of digits for deflat/deflon precision */
/* If the target is moving, display the tracking centre coordinates for
the first time slice. */
if( moving ) {
astClear( skyframe, "SkyRefIs" );
msgBlank( status );
msgSetc( "S1", astGetC( skyframe, "Symbol(1)" ) );
msgSetc( "S2", astGetC( skyframe, "Symbol(2)" ) );
msgOutif( MSG__NORM, " ", " Output sky coordinates are "
"(^S1,^S2) offsets from the (moving)", status );
msgSetc( "S1", astGetC( skyframe, "Symbol(1)" ) );
msgSetc( "S2", astGetC( skyframe, "Symbol(2)" ) );
msgSetc( "SREF", astGetC( skyframe, "SkyRef" ) );
msgOutif( MSG__NORM, " ", " telescope base position, which "
"started at (^S1,^S2) = (^SREF).", status );
astSet( skyframe, "SkyRefIs=Origin" );
}
/* Set up a flag indicating that the default values calculated by autogrid
are being used. */
udefs = 1;
/* Ensure we have usable CRPIX1/2 values */
if( par[ 0 ] == AST__BAD ) par[ 0 ] = 1.0;
if( par[ 1 ] == AST__BAD ) par[ 1 ] = 1.0;
/* Get the crpix1/2 (in the interim GRID frame) to use. Note if the user
specifies any values. These parameters have vpath=default (which is null)
and ppath=dynamic. */
refine_crpix = 0;
parDef0d( "REFPIX1", par[ 0 ], status );
parDef0d( "REFPIX2", par[ 1 ], status );
if( *status == SAI__OK ) {
parGet0d( "REFPIX1", refpix + 0, status );
parGet0d( "REFPIX2", refpix + 1, status );
if( *status == PAR__NULL ) {
errAnnul( status );
refine_crpix = 1;
} else {
par[ 0 ] = refpix[ 0 ];
par[ 1 ] = refpix[ 1 ];
}
}
/* Get the sky coords reference position strings. Use the returned SkyFrame
to format and unformat them. */
if( par[ 2 ] != AST__BAD ) {
int curdigits;
curdigits = astGetI( skyframe, "digits(1)" );
astSetI( skyframe, "digits(1)", ndigits );
deflon = astFormat( skyframe, 1, par[ 2 ] );
astSetI( skyframe, "digits(1)", curdigits );
parDef0c( "REFLON", deflon, status );
} else {
deflon = NULL;
}
if( par[ 3 ] != AST__BAD ) {
int curdigits;
curdigits = astGetI( skyframe, "digits(2)" );
astSetI( skyframe, "digits(2)", ndigits );
deflat = astFormat( skyframe, 2, par[ 3 ] );
astSetI( skyframe, "digits(2)", curdigits );
parDef0c( "REFLAT", deflat, status );
} else {
deflat = NULL;
}
parGet0c( "REFLON", reflon, 40, status );
parGet0c( "REFLAT", reflat, 40, status );
if( *status == SAI__OK ) {
if( ( deflat && strcmp( deflat, reflat ) ) ||
( deflon && strcmp( deflon, reflon ) ) ) udefs = 0;
if( astUnformat( skyframe, 1, reflon, par + 2 ) == 0 && *status == SAI__OK ) {
msgSetc( "REFLON", reflon );
errRep( "", "Bad value supplied for REFLON: '^REFLON'", status );
}
if( astUnformat( skyframe, 2, reflat, par + 3 ) == 0 && *status == SAI__OK ) {
msgSetc( "REFLAT", reflat );
errRep( "", "Bad value supplied for REFLAT: '^REFLAT'", status );
}
/* Ensure the reference position in the returned SkyFrame is set to the
supplied position (which defaults to the first telescope base pointing
position). */
if( !moving ){
astSetD( skyframe, "SkyRef(1)", par[ 2 ] );
astSetD( skyframe, "SkyRef(2)", par[ 3 ] );
}
}
/* Get the user defined spatial pixel size in arcsec (the calibration for
the spectral axis is fixed by the first input data file - see
smf_cubebounds.c). First convert the autogrid values form rads to arcsec
and establish them as the dynamic default for "PIXSIZE". */
nval = 0;
if( par[ 4 ] != AST__BAD || par[ 5 ] != AST__BAD ) {
for ( i = 4; i <= 5; i++ ) {
if ( par[ i ] != AST__BAD ) {
defsize[ nval ] = 0.1*NINT( fabs( par[ i ] )*AST__DR2D*36000.0 );
nval++;
}
}
/* set the dynamic default, handling case where both dimensions
have same default. */
if (nval == 1) {
defsize[1] = defsize[0];
} else if (nval == 2 && defsize[0] == defsize[1]) {
nval = 1;
}
parDef1d( "PIXSIZE", nval, defsize, status );
} else {
/* pick a default in case something odd happens and we have
no other values*/
defsize[ 0 ] = fbpixsize;
defsize[ 1 ] = defsize[ 0 ];
nval = 2;
}
if (*status == SAI__OK) {
pixsize[0] = AST__BAD;
pixsize[1] = AST__BAD;
parGet1d( "PIXSIZE", 2, pixsize, &nval, status );
if (*status == PAR__NULL) {
/* Null just defaults to what we had before */
errAnnul( status );
pixsize[0] = defsize[0];
pixsize[1] = defsize[1];
nval = 2;
}
}
/* If OK, duplicate the first value if only one value was supplied. */
if( *status == SAI__OK ) {
if( nval < 2 ) pixsize[ 1 ] = pixsize[ 0 ];
if( defsize[ 0 ] != pixsize[ 0 ] ||
defsize[ 1 ] != pixsize[ 1 ] ) udefs = 0;
/* Check the values are OK. */
if( pixsize[ 0 ] <= 0 || pixsize[ 1 ] <= 0 ) {
msgSetd( "P1", pixsize[ 0 ] );
msgSetd( "P2", pixsize[ 1 ] );
*status = SAI__ERROR;
errRep( FUNC_NAME, "Invalid pixel sizes (^P1,^P2).", status);
}
/* Convert to rads, and set the correct signs. */
if( par[ 4 ] == AST__BAD || par[ 4 ] < 0.0 ) {
par[ 4 ] = -pixsize[ 0 ]*AST__DD2R/3600.0;
} else {
par[ 4 ] = pixsize[ 0 ]*AST__DD2R/3600.0;
}
if( par[ 5 ] == AST__BAD || par[ 5 ] < 0.0 ) {
par[ 5 ] = -pixsize[ 1 ]*AST__DD2R/3600.0;
} else {
par[ 5 ] = pixsize[ 1 ]*AST__DD2R/3600.0;
}
}
/* Convert the autogrid CROTA value from rads to degs and set as the
dynamic default for parameter CROTA (the position angle of the output
Y axis, in degrees). The get the CROTA value and convert to rads. */
if( par[ 6 ] != AST__BAD ) {
autorot = par[ 6 ]*AST__DR2D;
parDef0d( "CROTA", autorot, status );
} else {
parDef0d( "CROTA", map_pa*AST__DR2D, status );
autorot = AST__BAD;
}
parGet0d( "CROTA", par + 6, status );
if( par[ 6 ] != autorot ) udefs = 0;
par[ 6 ] *= AST__DD2R;
/* If any parameter were given explicit values which differ from the
autogrid default values, then we need to re-calculate the optimal CRPIX1/2
values. We also do this if all the points are effectively co-incident. */
if( ( coin || !udefs ) && autogrid && refine_crpix ) {
par[ 0 ] = AST__BAD;
par[ 1 ] = AST__BAD;
kpg1Opgrd( nallpos, allpos, strcmp( usesys, "AZEL" ), par,
&rdiam, status );
}
/* Display the projection parameters being used. */
smf_display_projpars( skyframe, par, status );
/* Write out the reference grid coords to output parameter PIXREF. */
parPut1d( "PIXREF", 2, par, status );
/* If no grid was found, indicate that no spatial projection will be used. */
} else {
msgBlank( status );
msgOutif( MSG__NORM, " ", " The output will be a sparse array "
"containing a list of spectra.", status );
}
/* If we have a pre-defined spatial projection, indicate that the output
array need not be sparse. */
} else {
sparse = 0;
}
/* Return usedefs if requested */
if( usedefs ) {
*usedefs = udefs;
}
/* Set sparse if requested */
if( issparse ) *issparse = sparse;
}
void smf_mapbounds( int fast, Grp *igrp, int size, const char *system,
AstFrameSet *spacerefwcs, int alignsys, int *lbnd_out,
int *ubnd_out, AstFrameSet **outframeset, int *moving,
smfBox ** boxes, fts2Port fts_port, AstKeyMap *config,
int *status ) {
/* Local Variables */
AstSkyFrame *abskyframe = NULL; /* Output Absolute SkyFrame */
int actval; /* Number of parameter values supplied */
AstMapping *bolo2map = NULL; /* Combined mapping bolo->map
coordinates, WCS->GRID Mapping from
input WCS FrameSet */
smfBox *box = NULL; /* smfBox for current file */
smfData *data = NULL; /* pointer to SCUBA2 data struct */
double dlbnd[ 2 ]; /* Floating point lower bounds for output map */
drcntrl_bits drcntrl_mask = 0;/* Mask to use for DRCONTROL on this instrument */
double dubnd[ 2 ]; /* Floating point upper bounds for output map */
AstMapping *fast_map = NULL; /* Mapping from tracking to absolute map coords */
smfFile *file = NULL; /* SCUBA2 data file information */
int first; /* Is this the first good subscan ? */
AstFitsChan *fitschan = NULL;/* Fits channels to construct WCS header */
AstFrameSet *fs = NULL; /* A general purpose FrameSet pointer */
smfHead *hdr = NULL; /* Pointer to data header this time slice */
int i; /* Loop counter */
dim_t j; /* Loop counter */
AstSkyFrame *junksky = NULL; /* Unused SkyFrame argument */
dim_t k; /* Loop counter */
int lbnd0[ 2 ]; /* Defaults for LBND parameter */
double map_pa=0; /* Map PA in output coord system (rads) */
dim_t maxloop; /* Number of times to go round the time slice loop */
dim_t nbadt = 0; /* Number of bad time slices */
dim_t ngoodt = 0; /* Number of good time slices */
double par[7]; /* Projection parameters */
double shift[ 2 ]; /* Shifts from PIXEL to GRID coords */
AstMapping *oskymap = NULL; /* Mapping celestial->map coordinates,
Sky <> PIXEL mapping in output
FrameSet */
AstSkyFrame *oskyframe = NULL;/* Output SkyFrame */
char *refsys = NULL; /* Sky system from supplied reference FrameSet */
dim_t textreme[4]; /* Time index corresponding to minmax TCS posn */
AstFrame *skyin = NULL; /* Sky Frame in input FrameSet */
double skyref[ 2 ]; /* Values for output SkyFrame SkyRef attribute */
struct timeval tv1; /* Timer */
struct timeval tv2; /* Timer */
AstMapping *tmap; /* Temporary Mapping */
int trim; /* Trim borders of bad pixels from o/p image? */
int ubnd0[ 2 ]; /* Defaults for UBND parameter */
double x_array_corners[4]; /* X-Indices for corner bolos in array */
double x_map[4]; /* Projected X-coordinates of corner bolos */
double y_array_corners[4]; /* Y-Indices for corner pixels in array */
double y_map[4]; /* Projected X-coordinates of corner bolos */
/* Main routine */
if (*status != SAI__OK) return;
/* Start a timer to see how long this takes */
smf_timerinit( &tv1, &tv2, status );
/* Initialize pointer to output FrameSet and moving-source flag */
*outframeset = NULL;
*moving = 0;
/* initialize double precision output bounds and the proj pars */
for( i = 0; i < 7; i++ ) par[ i ] = AST__BAD;
dlbnd[ 0 ] = VAL__MAXD;
dlbnd[ 1 ] = VAL__MAXD;
dubnd[ 0 ] = VAL__MIND;
dubnd[ 1 ] = VAL__MIND;
/* If we have a supplied reference WCS we can use that directly
without having to calculate it from the data. Replace the requested
system with the system from the reference FrameSet (take a copy of the
string since astGetC may re-use its buffer). */
if (spacerefwcs) {
oskyframe = astGetFrame( spacerefwcs, AST__CURRENT );
int nc = 0;
refsys = astAppendString( NULL, &nc, astGetC( oskyframe, "System" ) );
system = refsys;
}
/* Create array of returned smfBox structures and store a pointer
to the next one to be initialised. */
*boxes = astMalloc( sizeof( smfBox ) * size );
box = *boxes;
astBegin;
/* Loop over all files in the Grp */
first = 1;
for( i=1; i<=size; i++, box++ ) {
/* Initialise the spatial bounds of section of the the output cube that is
contributed to by the current ionput file. */
box->lbnd[ 0 ] = VAL__MAXD;
box->lbnd[ 1 ] = VAL__MAXD;
box->ubnd[ 0 ] = VAL__MIND;
box->ubnd[ 1 ] = VAL__MIND;
/* Read data from the ith input file in the group */
smf_open_file( NULL, igrp, i, "READ", SMF__NOCREATE_DATA, &data, status );
if (*status != SAI__OK) {
msgSeti( "I", i );
errRep( "smf_mapbounds", "Could not open data file no ^I.", status );
break;
} else {
if( *status == SAI__OK ) {
if( data->file == NULL ) {
*status = SAI__ERROR;
errRep( FUNC_NAME, "No smfFile associated with smfData.",
status );
break;
} else if( data->hdr == NULL ) {
*status = SAI__ERROR;
errRep( FUNC_NAME, "No smfHead associated with smfData.",
status );
break;
} else if( data->hdr->fitshdr == NULL ) {
*status = SAI__ERROR;
errRep( FUNC_NAME, "No FITS header associated with smfHead.",
status );
break;
}
}
}
/* convenience pointers */
file = data->file;
hdr = data->hdr;
/* report name of the input file */
smf_smfFile_msg( file, "FILE", 1, "<unknown>" );
msgSeti("I", i);
msgSeti("N", size);
msgOutif(MSG__VERB, " ",
"SMF_MAPBOUNDS: Processing ^I/^N ^FILE",
status);
/* Check that there are 3 pixel axes. */
if( data->ndims != 3 ) {
smf_smfFile_msg( file, "FILE", 1, "<unknown>" );
msgSeti( "NDIMS", data->ndims );
*status = SAI__ERROR;
errRep( FUNC_NAME, "^FILE has ^NDIMS pixel axes, should be 3.",
status );
break;
}
/* Check that the data dimensions are 3 (for time ordered data) */
if( *status == SAI__OK ) {
/* If OK Decide which detectors (GRID coord) to use for
checking bounds, depending on the instrument in use. */
switch( hdr->instrument ) {
case INST__SCUBA2:
drcntrl_mask = DRCNTRL__POSITION;
/* 4 corner bolometers of the subarray */
x_array_corners[0] = 1;
x_array_corners[1] = 1;
x_array_corners[2] = (data->dims)[0];
x_array_corners[3] = (data->dims)[0];
y_array_corners[0] = 1;
y_array_corners[1] = (data->dims)[1];
y_array_corners[2] = 1;
y_array_corners[3] = (data->dims)[1];
break;
case INST__AZTEC:
/* Rough guess for extreme bolometers around the edge */
x_array_corners[0] = 22;
x_array_corners[1] = 65;
x_array_corners[2] = 73;
x_array_corners[3] = 98;
y_array_corners[0] = 1; /* Always 1 for AzTEC */
y_array_corners[1] = 1;
y_array_corners[2] = 1;
y_array_corners[3] = 1;
break;
case INST__ACSIS:
smf_find_acsis_corners( data, x_array_corners, y_array_corners,
status);
break;
default:
*status = SAI__ERROR;
errRep(FUNC_NAME, "Don't know how to calculate mapbounds for data created with this instrument", status);
}
}
if( *status == SAI__OK) {
size_t goodidx = SMF__BADSZT;
/* Need to build up a frameset based on good telescope position.
We can not assume that we the first step will be a good TCS position
so we look for one. If we can not find anything we skip to the
next file. */
maxloop = (data->dims)[2];
for (j=0; j<maxloop; j++) {
JCMTState state = (hdr->allState)[j];
if (state.jos_drcontrol >= 0 && state.jos_drcontrol & drcntrl_mask ) {
/* bad TCS - so try again */
} else {
/* Good tcs */
goodidx = j;
break;
}
}
if (goodidx == SMF__BADSZT) {
smf_smfFile_msg( data->file, "FILE", 1, "<unknown>");
msgOutif( MSG__QUIET, "", "No good telescope positions found in file ^FILE. Ignoring",
status );
smf_close_file( NULL, &data, status );
continue;
}
/* If we are dealing with the first good file, create the output
SkyFrame. */
if( first ) {
first = 0;
/* Create output SkyFrame if it has not come from a reference */
if ( oskyframe == NULL ) {
/* smf_tslice_ast only needs to get called once to set up framesets */
if( hdr->wcs == NULL ) {
smf_tslice_ast( data, goodidx, 1, fts_port, status);
}
/* Retrieve input SkyFrame */
skyin = astGetFrame( hdr->wcs, AST__CURRENT );
smf_calc_skyframe( skyin, system, hdr, alignsys, &oskyframe, skyref,
moving, status );
/* Get the orientation of the map vertical within the output celestial
coordinate system. This is derived form the MAP_PA FITS header, which
gives the orientation of the map vertical within the tracking system. */
map_pa = smf_calc_mappa( hdr, system, skyin, status );
/* Provide a sensible default for the pixel size based on wavelength */
par[4] = smf_calc_telres( hdr->fitshdr, status );
par[4] *= AST__DD2R/3600.0;
par[5] = par[4];
/* Calculate the projection parameters. We do not enable autogrid determination
for SCUBA-2 so we do not need to obtain all the data before calculating
projection parameters. */
smf_get_projpar( oskyframe, skyref, *moving, 0, 0, NULL, 0,
map_pa, par, NULL, NULL, status );
if (skyin) skyin = astAnnul( skyin );
/* If the output skyframe has been supplied, we still need to
determine whether the source is moving or not, and set the
reference position. */
} else {
/* smf_tslice_ast only needs to get called once to set up framesets */
if( hdr->wcs == NULL ) {
smf_tslice_ast( data, goodidx, 1, fts_port, status);
}
/* Retrieve input SkyFrame */
skyin = astGetFrame( hdr->wcs, AST__CURRENT );
smf_calc_skyframe( skyin, system, hdr, alignsys, &junksky, skyref,
moving, status );
/* Store the sky reference position. If the target is moving,
ensure the returned SkyFrame represents offsets from the
reference position rather than absolute coords. */
astSetD( oskyframe, "SkyRef(1)", skyref[ 0 ] );
astSetD( oskyframe, "SkyRef(2)", skyref[ 1 ] );
if( *moving ) smf_set_moving( (AstFrame *) oskyframe, NULL,
status );
/* Ensure the Epoch attribute in the map is set to the date of
the first data in the map, rather than the date in supplied
reference WCS. */
astSetD( oskyframe, "Epoch", astGetD( junksky, "Epoch" ) );
}
if ( *outframeset == NULL && oskyframe != NULL && (*status == SAI__OK)){
/* Now created a spatial Mapping. Use the supplied reference frameset
if supplied */
if (spacerefwcs) {
oskymap = astGetMapping( spacerefwcs, AST__BASE, AST__CURRENT );
} else {
/* Now populate a FitsChan with FITS-WCS headers describing
the required tan plane projection. The longitude and
latitude axis types are set to either (RA,Dec) or (AZ,EL)
to get the correct handedness. */
fitschan = astFitsChan ( NULL, NULL, " " );
smf_makefitschan( astGetC( oskyframe, "System"), &(par[0]),
&(par[2]), &(par[4]), par[6], fitschan, status );
astClear( fitschan, "Card" );
fs = astRead( fitschan );
/* Extract the output PIXEL->SKY Mapping. */
oskymap = astGetMapping( fs, AST__BASE, AST__CURRENT );
/* Tidy up */
fs = astAnnul( fs );
}
/* Create the output FrameSet */
*outframeset = astFrameSet( astFrame(2, "Domain=GRID"), " " );
/* Now add the SkyFrame to it */
astAddFrame( *outframeset, AST__BASE, oskymap, oskyframe );
/* Now add a POLANAL Frame if required (i.e. if the input time
series are POL-2 Q/U values). */
smf_addpolanal( *outframeset, hdr, config, status );
/* Invert the oskymap mapping */
astInvert( oskymap );
} /* End WCS FrameSet construction */
}
/* Get a copy of the output SkyFrame and ensure it represents
absolute coords rather than offset coords. */
abskyframe = astCopy( oskyframe );
astClear( abskyframe, "SkyRefIs" );
astClear( abskyframe, "AlignOffset" );
maxloop = (data->dims)[2];
if (fast) {
/* For scan map we scan through looking for largest telescope moves.
For dream/stare we just look at the start and end time slices to
account for sky rotation. */
if (hdr->obsmode != SMF__OBS_SCAN) {
textreme[0] = 0;
textreme[1] = (data->dims)[2] - 1;
maxloop = 2;
} else {
const char *tracksys;
double *ac1list, *ac2list, *bc1list, *bc2list, *p1, *p2, *p3, *p4;
double flbnd[4], fubnd[4];
JCMTState state;
/* If the output and tracking systems are different, get a
Mapping between them. */
tracksys = sc2ast_convert_system( (hdr->allState)[goodidx].tcs_tr_sys,
status );
if( strcmp( system, tracksys ) ) {
AstSkyFrame *tempsf = astCopy( abskyframe );
astSetC( tempsf, "System", tracksys );
AstFrameSet *tempfs = astConvert( tempsf, abskyframe, "" );
tmap = astGetMapping( tempfs, AST__BASE, AST__CURRENT );
fast_map = astSimplify( tmap );
tmap = astAnnul( tmap );
tempsf = astAnnul( tempsf );
tempfs = astAnnul( tempfs );
} else {
fast_map = NULL;
}
/* Copy all ac1/2 positions into two array, and transform them
from tracking to absolute output sky coords. */
ac1list = astMalloc( maxloop*sizeof( *ac1list ) );
ac2list = astMalloc( maxloop*sizeof( *ac2list ) );
if( *status == SAI__OK ) {
p1 = ac1list;
p2 = ac2list;
for( j = 0; j < maxloop; j++ ) {
state = (hdr->allState)[ j ];
*(p1++) = state.tcs_tr_ac1;
*(p2++) = state.tcs_tr_ac2;
}
if( fast_map ) astTran2( fast_map, maxloop, ac1list, ac2list, 1,
ac1list, ac2list );
}
/* If the target is moving, we need to adjust these ac1/2 values
to represent offsets from the base position. */
if( *moving ) {
/* Copy all bc1/2 positions into two arrays. */
bc1list = astMalloc( maxloop*sizeof( *bc1list ) );
bc2list = astMalloc( maxloop*sizeof( *bc2list ) );
if( *status == SAI__OK ) {
p1 = bc1list;
p2 = bc2list;
for( j = 0; j < maxloop; j++ ) {
state = (hdr->allState)[ j ];
*(p1++) = state.tcs_tr_bc1;
*(p2++) = state.tcs_tr_bc2;
}
/* Transform them from tracking to absolute output sky coords. */
if( fast_map ) astTran2( fast_map, maxloop, bc1list, bc2list,
1, bc1list, bc2list );
/* Replace each ac1/2 position with the offsets from the
corresponding base position. */
p1 = bc1list;
p2 = bc2list;
p3 = ac1list;
p4 = ac2list;
for( j = 0; j < maxloop; j++ ) {
smf_offsets( *(p1++), *(p2++), p3++, p4++, status );
}
}
/* We no longer need the base positions. */
bc1list = astFree( bc1list );
bc2list = astFree( bc2list );
}
/* Transform the ac1/2 position from output sky coords to
output pixel coords. */
astTran2( oskymap, maxloop, ac1list, ac2list, 1, ac1list, ac2list );
/* Find the bounding box containing these pixel coords and the
time slices at which the boresight touches each edge of this
box. */
flbnd[ 0 ] = VAL__MAXD;
flbnd[ 1 ] = VAL__MAXD;
fubnd[ 0 ] = VAL__MIND;
fubnd[ 1 ] = VAL__MIND;
for( j = 0; j < 4; j++ ) textreme[ j ] = (dim_t) VAL__BADI;
if( *status == SAI__OK ) {
p1 = ac1list;
p2 = ac2list;
for( j = 0; j < maxloop; j++,p1++,p2++ ) {
if( *p1 != VAL__BADD && *p2 != VAL__BADD ){
if ( *p1 < flbnd[0] ) { flbnd[0] = *p1; textreme[0] = j; }
if ( *p2 < flbnd[1] ) { flbnd[1] = *p2; textreme[1] = j; }
if ( *p1 > fubnd[0] ) { fubnd[0] = *p1; textreme[2] = j; }
if ( *p2 > fubnd[1] ) { fubnd[1] = *p2; textreme[3] = j; }
}
}
}
maxloop = 4;
msgSetd("X1", textreme[0]);
msgSetd("X2", textreme[1]);
msgSetd("X3", textreme[2]);
msgSetd("X4", textreme[3]);
msgOutif( MSG__DEBUG, " ",
"Extrema time slices are ^X1, ^X2, ^X3 and ^X4",
status);
ac1list = astFree( ac1list );
ac2list = astFree( ac2list );
}
}
/* Get the astrometry for all the relevant time slices in this data file */
for( j=0; j<maxloop; j++ ) {
dim_t ts; /* Actual time slice to use */
/* if we are doing the fast loop, we need to read the time slice
index from textreme. Else we just use the index */
if (fast) {
/* get the index but make sure it is good */
ts = textreme[j];
if (ts == (dim_t)VAL__BADI) continue;
} else {
ts = j;
}
/* Calculate the bolo to map-pixel transformation for this tslice */
bolo2map = smf_rebin_totmap( data, ts, abskyframe, oskymap,
*moving, fts_port, status );
if ( *status == SAI__OK ) {
/* skip if we did not get a mapping this time round */
if (!bolo2map) continue;
/* Check corner pixels in the array for their projected extent
on the sky to set the pixel bounds */
astTran2( bolo2map, 4, x_array_corners, y_array_corners, 1,
x_map, y_map );
/* Update min/max for this time slice */
for( k=0; k<4; k++ ) {
if( x_map[k] != AST__BAD && y_map[k] != AST__BAD ) {
if( x_map[k] < dlbnd[0] ) dlbnd[0] = x_map[k];
if( y_map[k] < dlbnd[1] ) dlbnd[1] = y_map[k];
if( x_map[k] > dubnd[0] ) dubnd[0] = x_map[k];
if( y_map[k] > dubnd[1] ) dubnd[1] = y_map[k];
if( x_map[k] < box->lbnd[0] ) box->lbnd[0] = x_map[k];
if( y_map[k] < box->lbnd[1] ) box->lbnd[1] = y_map[k];
if( x_map[k] > box->ubnd[0] ) box->ubnd[0] = x_map[k];
if( y_map[k] > box->ubnd[1] ) box->ubnd[1] = y_map[k];
} else if( *status == SAI__OK ) {
*status = SAI__ERROR;
errRep( FUNC_NAME, "Extreme positions are bad.", status );
break;
}
}
}
/* Explicitly annul these mappings each time slice for reduced
memory usage */
if (bolo2map) bolo2map = astAnnul( bolo2map );
if (fs) fs = astAnnul( fs );
/* Break out of loop over time slices if bad status */
if (*status != SAI__OK) goto CLEANUP;
}
/* Annul any remaining Ast objects before moving on to the next file */
if (fs) fs = astAnnul( fs );
if (bolo2map) bolo2map = astAnnul( bolo2map );
}
/* Close the data file */
smf_close_file( NULL, &data, status);
/* Break out of loop over data files if bad status */
if (*status != SAI__OK) goto CLEANUP;
}
/* make sure we got values - should not be possible with good status */
if (dlbnd[0] == VAL__MAXD || dlbnd[1] == VAL__MAXD) {
if (*status == SAI__OK) {
*status = SAI__ERROR;
errRep( " ", "Unable to find any valid map bounds", status );
}
}
if (nbadt > 0) {
msgOutf( "", " Processed %zu time slices to calculate bounds,"
" of which %zu had bad telescope data and were skipped",
status, (size_t)(ngoodt+nbadt), (size_t)nbadt );
}
/* If spatial reference wcs was supplied, store par values that result in
no change to the pixel origin. */
if( spacerefwcs ){
par[ 0 ] = 0.5;
par[ 1 ] = 0.5;
}
/* Need to re-align with the interim GRID coordinates */
lbnd_out[0] = ceil( dlbnd[0] - par[0] + 0.5 );
ubnd_out[0] = ceil( dubnd[0] - par[0] + 0.5 );
lbnd_out[1] = ceil( dlbnd[1] - par[1] + 0.5 );
ubnd_out[1] = ceil( dubnd[1] - par[1] + 0.5 );
/* Do the same with the individual input file bounding boxes */
box = *boxes;
for (i = 1; i <= size; i++, box++) {
box->lbnd[0] = ceil( box->lbnd[0] - par[0] + 0.5);
box->ubnd[0] = ceil( box->ubnd[0] - par[0] + 0.5);
box->lbnd[1] = ceil( box->lbnd[1] - par[1] + 0.5);
box->ubnd[1] = ceil( box->ubnd[1] - par[1] + 0.5);
}
/* Apply a ShiftMap to the output FrameSet to re-align the GRID
coordinates */
shift[0] = 2.0 - par[0] - lbnd_out[0];
shift[1] = 2.0 - par[1] - lbnd_out[1];
astRemapFrame( *outframeset, AST__BASE, astShiftMap( 2, shift, " " ) );
/* Set the dynamic defaults for lbnd/ubnd */
lbnd0[ 0 ] = lbnd_out[ 0 ];
lbnd0[ 1 ] = lbnd_out[ 1 ];
parDef1i( "LBND", 2, lbnd0, status );
ubnd0[ 0 ] = ubnd_out[ 0 ];
ubnd0[ 1 ] = ubnd_out[ 1 ];
parDef1i( "UBND", 2, ubnd0, status );
parGet1i( "LBND", 2, lbnd_out, &actval, status );
if( actval == 1 ) lbnd_out[ 1 ] = lbnd_out[ 0 ];
parGet1i( "UBND", 2, ubnd_out, &actval, status );
if( actval == 1 ) ubnd_out[ 1 ] = ubnd_out[ 0 ];
/* Ensure the bounds are the right way round. */
if( lbnd_out[ 0 ] > ubnd_out[ 0 ] ) {
int itmp = lbnd_out[ 0 ];
lbnd_out[ 0 ] = ubnd_out[ 0 ];
ubnd_out[ 0 ] = itmp;
}
if( lbnd_out[ 1 ] > ubnd_out[ 1 ] ) {
int itmp = lbnd_out[ 1 ];
lbnd_out[ 1 ] = ubnd_out[ 1 ];
ubnd_out[ 1 ] = itmp;
}
/* If borders of bad pixels are being trimmed from the output image,
then do not allow the user-specified bounds to extend outside the
default bounding box (since we know that the default bounding box
encloses all available data). */
parGet0l( "TRIM", &trim, status );
if( trim ) {
if( lbnd_out[ 0 ] < lbnd0[ 0 ] ) lbnd_out[ 0 ] = lbnd0[ 0 ];
if( lbnd_out[ 1 ] < lbnd0[ 1 ] ) lbnd_out[ 1 ] = lbnd0[ 1 ];
if( ubnd_out[ 0 ] > ubnd0[ 0 ] ) ubnd_out[ 0 ] = ubnd0[ 0 ];
if( ubnd_out[ 1 ] > ubnd0[ 1 ] ) ubnd_out[ 1 ] = ubnd0[ 1 ];
}
/* Modify the returned FrameSet to take account of the new pixel origin. */
shift[ 0 ] = lbnd0[ 0 ] - lbnd_out[ 0 ];
shift[ 1 ] = lbnd0[ 1 ] - lbnd_out[ 1 ];
if( shift[ 0 ] != 0.0 || shift[ 1 ] != 0.0 ) {
astRemapFrame( *outframeset, AST__BASE, astShiftMap( 2, shift, " " ) );
}
/* Report the pixel bounds of the cube. */
if( *status == SAI__OK ) {
msgOutif( MSG__NORM, " ", " ", status );
msgSeti( "XL", lbnd_out[ 0 ] );
msgSeti( "YL", lbnd_out[ 1 ] );
msgSeti( "XU", ubnd_out[ 0 ] );
msgSeti( "YU", ubnd_out[ 1 ] );
msgOutif( MSG__NORM, " ", " Output map pixel bounds: ( ^XL:^XU, ^YL:^YU )",
status );
if( ( ubnd_out[ 0 ] - lbnd_out[ 0 ] + 1 ) > MAX_DIM ||
( ubnd_out[ 1 ] - lbnd_out[ 1 ] + 1 ) > MAX_DIM ) {
*status = SAI__ERROR;
errRep( "", FUNC_NAME ": The map is too big. Check your list of input "
"data files does not include widely separated observations.",
status );
}
}
/* If no error has occurred, export the returned FrameSet pointer from the
current AST context so that it will not be annulled when the AST
context is ended. Otherwise, ensure a null pointer is returned. */
if( *status == SAI__OK ) {
astExport( *outframeset );
} else {
*outframeset = astAnnul( *outframeset );
}
msgOutiff( SMF__TIMER_MSG, "",
"Took %.3f s to calculate map bounds",
status, smf_timerupdate( &tv1, &tv2, status ) );
/* Clean Up */
CLEANUP:
if (*status != SAI__OK) {
errRep(FUNC_NAME, "Unable to determine map bounds", status);
}
if (oskymap) oskymap = astAnnul( oskymap );
if (bolo2map) bolo2map = astAnnul( bolo2map );
if (fitschan) fitschan = astAnnul( fitschan );
if( data != NULL )
smf_close_file( NULL, &data, status );
refsys = astFree( refsys );
astEnd;
}
