void smf_rebincube_ast( ThrWorkForce *wf, smfData *data, int first, int last,
int *ptime, dim_t nchan, dim_t ndet, dim_t nslice,
dim_t nel, dim_t nxy, dim_t nout, dim_t dim[3],
AstMapping *ssmap, AstSkyFrame *abskyfrm,
AstMapping *oskymap, Grp *detgrp, int moving,
int usewgt, int spread, const double params[],
int genvar, double tfac, double fcon,
float *data_array, float *var_array,
double *wgt_array, float *texp_array,
float *teff_array, int *good_tsys, int *nused,
int *status ){
/* Local Variables */
AstCmpMap *detmap = NULL; /* Mapping from 1D det. index to 2D i/p "grid" coords */
AstMapping *dtotmap = NULL; /* 1D det index->o/p GRID Mapping */
AstMapping *fullmap = NULL; /* WCS->GRID LutMap from input WCS FrameSet */
AstMapping *lutmap = NULL; /* Mapping that identifies detectors to be used */
AstMapping *splut = NULL; /* Spatial LutMap */
AstMapping *sslut = NULL; /* Spectral LutMap */
AstMapping *totmap = NULL; /* WCS->GRID Mapping from input WCS FrameSet */
AstPermMap *pmap; /* Mapping to rearrange output axes */
const char *name = NULL; /* Pointer to current detector name */
const double *tsys = NULL; /* Pointer to Tsys value for first detector */
dim_t iv; /* Vector index into output 3D array */
double *detlut = NULL; /* Work space for detector mask */
double blk_bot[ 2*MAXTHREADS + 1 ]; /* First o/p channel no. in each block */
double con; /* Constant value */
double dtemp; /* Temporary value */
double tcon; /* Variance factor for whole time slice */
float *detwork = NULL; /* Work array for detector values */
float *tdata = NULL; /* Pointer to start of input time slice data */
float *varwork = NULL; /* Work array holding variances for 1 slice/channel */
float *vp = NULL; /* Pointer to next "varwork" element */
float invar; /* Input variance */
float rtsys; /* Tsys value */
float teff; /* Effective integration time */
float texp; /* Total time ( = ton + toff ) */
int *nexttime; /* Pointer to next time slice index to use */
int ast_flags; /* Basic flags to use with astRebinSeq */
int blk_size; /* Number of channels processed by a single thread */
int found; /* Was current detector name found in detgrp? */
int iblock; /* Index of current spectral block */
dim_t ichan; /* Index of current channel */
dim_t idet; /* detector index */
int ignore; /* Ignore this time slice? */
int inperm[ 3 ]; /* Input axis permutation array */
dim_t itime; /* Index of current time slice */
int junk; /* Unused parameter */
int lbnd_in[ 2 ]; /* Lower input bounds on receptor axis */
int ldim[ 3 ]; /* Output array lower GRID bounds */
int maxthreads; /* Max no. of threads to use when re-binning */
int nblock; /* Number of spectral blocks */
int nthreads; /* Number of threads to use when re-binning */
int outperm[ 3 ]; /* Output axis permutation array */
int timeslice_size; /* Number of elements in a time slice */
int ubnd_in[ 2 ]; /* Upper input bounds on receptor axis */
int uddim[ 1 ]; /* Detector array upper GRID bounds */
int udim[ 3 ]; /* Output array upper GRID bounds */
smfHead *hdr = NULL; /* Pointer to data header for this time slice */
/* Check the inherited status. */
if( *status != SAI__OK ) return;
/* Store a pointer to the input NDFs smfHead structure. */
hdr = data->hdr;
/* Fill an array with the lower grid index bounds of the output. */
ldim[ 0 ] = 1;
ldim[ 1 ] = 1;
ldim[ 2 ] = 1;
/* Integer upper grid index bounds of the output. */
udim[ 0 ] = dim[ 0 ];
udim[ 1 ] = dim[ 1 ];
udim[ 2 ] = dim[ 2 ];
/* Integer upper bounds of detector array. */
uddim[ 0 ] = ndet;
/* Store the size of an input time slice. */
timeslice_size = nel/nslice;
/* Create a LutMap that holds the output spectral axis GRID value at
the centre of each input spectral axis pixel. LutMaps are faster to
evaluate, and so astRebinSeq will go faster. We can use LutMaps without
loosing accuracy since astRebinSeq only ever transforms the GRID
values at input pixel centres (i.e. integer GRID values), and so the
LutMap will always return a tabulated value rather than an
interpolated value. */
atlTolut( (AstMapping *) ssmap, 1.0, (double) nchan, 1.0, "LutInterp=1",
&sslut, status );
/* If this is the first pass through this file, initialise the arrays. */
if( first ) smf_rebincube_init( 0, nxy, nout, genvar, data_array, var_array,
wgt_array, texp_array, teff_array, &junk, status );
/* Initialisation the flags for astRebinSeq (we do not include flag
AST__REBININIT because the arrays have been initialised). */
ast_flags = AST__USEBAD;
if( usewgt ) ast_flags = ast_flags | AST__VARWGT;
if( genvar == 1 ) {
ast_flags = ast_flags | AST__GENVAR;
} else if( genvar == 2 ) {
ast_flags = ast_flags | AST__USEVAR;
}
/* If required, allocate a work array to hold all the input variances for a
single time slice. */
if( usewgt || genvar == 2 ) varwork = astMalloc( timeslice_size * sizeof( float ) );
/* Allocate a work array to hold the exposure time for each detector. */
detwork = astMalloc( ndet * sizeof( float ) );
/* If we are dealing with more than 1 detector, create a LutMap that holds
the input GRID index of every detector to be included in the output, and
AST__BAD for every detector that is not to be included in the output cube.
First allocate the work space for the LUT. */
if( ndet > 1 ) {
detlut = astMalloc( ndet*sizeof( double ) );
/* Initialise a string to point to the name of the first detector for which
data is available */
name = hdr->detname;
/* Loop round all detectors for which data is available. */
for( idet = 0; idet < ndet; idet++ ) {
/* Store the input GRID coord of this detector. GRID coords start at 1,
not 0. */
detlut[ idet ] = idet + 1.0;
/* If a group of detectors to be used was supplied, search the group for
the name of the current detector. If not found, set the GRID coord bad.
This will cause astRebinSeq to ignore data from the detector. */
if( detgrp ) {
found = grpIndex( name, detgrp, 1, status );
if( !found ) detlut[ idet ] = AST__BAD;
}
/* Move on to the next available detector name. */
name += strlen( name ) + 1;
}
/* Create the LutMap. */
lutmap = (AstMapping *) astLutMap( ndet, detlut, 1.0, 1.0,
"LutInterp=1" );
/* If we only have 1 detector, use a UnitMap instead of a LutMap (lutMaps
must have 2 or more table entries). */
} else {
lutmap = (AstMapping *) astUnitMap( 1, " " );
}
/* Combine the above LutMap with a 1-input, 2-output PermMap that copies its
input to create its first output, and assigns a constant value of 1.0 to
its second output. We need to do this because smf_tslice returns a 2D
GRID system (even though the second GRID axis is not actually used). */
inperm[ 0 ] = 1;
outperm[ 0 ] = 1;
outperm[ 1 ] = -1;
con = 1.0;
detmap = astCmpMap( lutmap, astPermMap( 1, inperm, 2, outperm, &con, " " ),
1, " " );
/* Store the bounds of a single time slice grid. */
lbnd_in[ 0 ] = 1;
ubnd_in[ 0 ] = nchan;
lbnd_in[ 1 ] = 1;
ubnd_in[ 1 ] = ndet;
/* Create a PermMap that can be used to re-order the output axes so that
channel number is axis 3. */
outperm[ 0 ] = 2;
outperm[ 1 ] = 3;
outperm[ 2 ] = 1;
inperm[ 0 ] = 3;
inperm[ 1 ] = 1;
inperm[ 2 ] = 2;
pmap = astPermMap( 3, inperm, 3, outperm, NULL, " " );
/* If we are using multiple threads to rebin spectral blocks in parallel,
calculate the number of channels that are processed by each thread,
and the number of threads to use. The whole output spectrum is divided
up into blocks. The number of blocks is two times the number of
threads, and each thread rebins two adjacent blocks. Alternate blocks
are re-binned simultanously. First, the odd numbered blocks are re-binned
(one by each thread). When all odd numbered blocks have been re-binned,
the even numbered blocks are re-binned. We ensure that the number of
threads used results in a block size that is larger than the spreading
width produced by the requested spreading scheme. This means that no
pair of simultanously executing threads will ever try to write to the
same channel of the output spectrum. */
maxthreads = wf ? wf->nworker : 1;
if( maxthreads > MAXTHREADS ) maxthreads = MAXTHREADS;
if( maxthreads > 1 ) {
/* Find the largest number of threads into which each output spectrum can
be split. The limit is imposes by the requirement that each block is
larger than the pixel spreading produced by the requested spreading
scheme. */
nthreads = ( ( dim[ 2 ] + 1 )/2 )/smf_spreadwidth( spread, params,
status );
/* If the spectral range is less than twice the spreading width, we
cannot use multiple threads. */
if( nthreads > 1 ) {
/* Restrict the number of threads to be no more than the number of workers
available in the work force. */
if( nthreads > maxthreads ) nthreads = maxthreads;
/* Find the number of output channels in each spectral block. */
blk_size = ( dim[ 2 ] - 1 )/( 2*nthreads ) + 1;
/* Set up the first output channel number within each block. */
nblock = 2*nthreads;
for( iblock = 0; iblock < nblock; iblock++ ) {
blk_bot[ iblock ] = (double) ( iblock*blk_size + 1 );
}
/* Add in the first channel number beyond the last block. */
blk_bot[ nblock ] = blk_bot[ nblock - 1 ] + blk_size;
/* If the output spectrum is too short to guarantee that there are any
independent blocks of output channels, we process the whole spectrum
in a single thread. */
} else {
nthreads = 1;
nblock = 1;
blk_bot[ 0 ] = 1.0;
blk_bot[ 1 ] = (double) ( dim[ 2 ] + 1 );
}
/* If multiple threads are not available, we process the whole spectrum
in a single thread. */
} else {
nthreads = 1;
nblock = 1;
blk_bot[ 0 ] = 1.0;
blk_bot[ 1 ] = (double) ( dim[ 2 ] + 1 );
}
/* Convert the block boundaries from output channel numbers into input
channel numbers. */
astTran1( ssmap, nblock + 1, blk_bot, 0, blk_bot );
/* Ensure they are in increasing order, and are not outside the bounds of
the input array. */
if( blk_bot[ 0 ] > blk_bot[ 1 ] ) {
for( iblock = 0; iblock < ( nblock + 1 )/2; iblock++ ) {
dtemp = blk_bot[ nblock - iblock ];
blk_bot[ nblock - iblock ] = blk_bot[ iblock ];
blk_bot[ iblock ] = dtemp;
}
}
for( iblock = 0; iblock <= nblock; iblock++ ) {
if( blk_bot[ iblock ] < 1 ) {
blk_bot[ iblock ] = 1.0;
} else if( blk_bot[ iblock ] > nchan ) {
blk_bot[ iblock ] = nchan;
}
}
/* Initialise a pointer to the next time slice index to be used. */
nexttime = ptime;
/* Initialise the progress meter. */
smf_reportprogress( nslice, status );
/* Loop round all time slices in the input NDF. */
for( itime = 0; itime < nslice && *status == SAI__OK; itime++ ) {
/* If this time slice is not being pasted into the output cube, pass on. */
if( nexttime ){
if( *nexttime != (int) itime ) continue;
nexttime++;
}
/* Store a pointer to the first input data value in this time slice. */
tdata = ( (float *) (data->pntr)[ 0 ] ) + itime*timeslice_size;
/* Begin an AST context. Having this context within the time slice loop
helps keep the number of AST objects in use to a minimum. */
astBegin;
/* Get a Mapping from the spatial GRID axes in the input the spatial
GRID axes in the output for the current time slice. Note this has
to be done first since it stores details of the current time slice
in the "smfHead" structure inside "data", and this is needed by
subsequent functions. */
totmap = smf_rebin_totmap( data, itime, abskyfrm, oskymap, moving,
status );
if( !totmap ) break;
/* Get the effective exposure time, the total exposure time, and the
Tsys->Variance onversion factor for this time slice. Also get a
pointer to the start of the Tsys array. */
tsys = smf_rebincube_tcon( hdr, itime, fcon, &texp, &teff, &tcon,
status );
/* So "totmap" is a 2-input, 2-output Mapping that transforms the input
spatial GRID coords into output spatial GRID coords. In order to speed
up astRebinSeq we represent this by a pair of parallel LutMaps. To do
this (using atlTolut) we need a Mapping which only has 1 input, so we
preceed "totmap" with "detmap" (which also has the effect of exluding
data from unrequired detectors). We then combine this Mapping in
parallel with the spectral LutMap to get a 2-input (channel number,
detector index) and 3-output (output grid coords) Mapping. We finally
add a PermMap to re-arrange the output axes so that channel number is
axis 3 in the output. */
dtotmap = (AstMapping *) astCmpMap( detmap, totmap, 1, " " );
if( ndet > 1 ) {
atlTolut( dtotmap, 1.0, (double) ndet, 1.0, "LutInterp=1", &splut,
status );
} else {
splut = astClone( dtotmap );
}
fullmap = astSimplify( astCmpMap( astCmpMap( sslut, splut, 0, " " ),
pmap, 1, " " ) );
/* If required calculate the variance associated with each value in the
current time slice. based on the input Tsys values. If they are
needed, but not available, ignored the time slice. */
ignore = 0;
if( varwork ) {
ignore = 1;
vp = varwork;
for( idet = 0; idet < ndet; idet++ ) {
invar = VAL__BADR;
rtsys = tsys ? (float) tsys[ idet ] : VAL__BADR;
if( rtsys <= 0.0 ) rtsys = VAL__BADR;
if( rtsys != VAL__BADR ) {
*good_tsys = 1;
if( tcon != VAL__BADD ) {
invar = tcon*rtsys*rtsys;
ignore = 0;
}
}
for( ichan = 0; ichan < nchan; ichan++ ) *(vp++) = invar;
}
}
/* Unless we are ignoring this time slice, paste it into the 3D output
cube. The smf_rebincube_seqf function is a wrapper for astRebinSeqF
that splits the total job up between "nthreads" threads running in
parallel. */
if( !ignore ) {
smf_rebincube_seqf( wf, nthreads, blk_bot, fullmap, 0.0, 2, lbnd_in,
ubnd_in, tdata, varwork, spread, params,
ast_flags, 0.0, 50, VAL__BADR, 3, ldim, udim,
lbnd_in, ubnd_in, data_array, var_array,
wgt_array, nused, status );
/* Now we update the total exposure time array. Scale the exposure time
of this time slice in order to reduce its influence on the output
expsoure times if it does not have much spectral overlap with the
output cube. then fill the 1D work array with this constant value and
paste it into the 2D texp_array using the spatial mapping. Note we
want the simple sum of the exposure times, with no normalisation. SO
we use the AST__NONORM flag which means we do not need to supply a
weights array. */
if( texp != VAL__BADR ) {
texp *= tfac;
for( iv = 0; iv < ndet; iv++ ) detwork[ iv ] = texp;
astRebinSeqF( splut, 0.0, 1, ldim, uddim, detwork, NULL,
spread, params, AST__NONORM, 0.0, 50,
VAL__BADR, 2, ldim, udim, ldim, uddim, texp_array,
NULL, NULL, NULL );
}
/* Now do the same with the effective exposure time. */
if( teff != VAL__BADR ) {
teff *= tfac;
for( iv = 0; iv < ndet; iv++ ) detwork[ iv ] = teff;
astRebinSeqF( splut, 0.0, 1, ldim, uddim, detwork, NULL,
spread, params, AST__NONORM, 0.0, 50, VAL__BADR, 2,
ldim, udim, ldim, uddim, teff_array, NULL, NULL,
NULL );
}
}
/* Update the progress meter. */
smf_reportprogress( 0, status );
/* End the AST context. */
astEnd;
}
/* If this is the final pass through this function, normalise the returned
data and variance values. */
if( last ) {
/* Create a dummy mapping that can be used with astRebinSeq (it is not
actually used for anything since we are not adding any more data into the
output arrays). */
fullmap = (AstMapping *) astPermMap( 2, NULL, 3, NULL, NULL, " " );
/* Normalise the data values. We do not normalise the exposure time arrays. */
astRebinSeqF( fullmap, 0.0, 2, lbnd_in,
ubnd_in, NULL, NULL, spread, params,
AST__REBINEND | ast_flags, 0.0, 50, VAL__BADR, 3,
ldim, udim, lbnd_in, ubnd_in, data_array, var_array,
wgt_array, nused );
fullmap = astAnnul(fullmap);
}
/* Free resources. */
detlut = astFree( detlut );
detwork = astFree( detwork );
varwork = astFree( varwork );
}
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, 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 ) astSet( oskyframe, "SkyRefIs=Origin" );
/* 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, 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;
}
void smf_resampcube_nn( smfData *data, dim_t nchan,
dim_t ndet, dim_t nslice, dim_t nxy,
dim_t dim[3], AstMapping *ssmap,
AstSkyFrame *abskyfrm, AstMapping *iskymap,
Grp *detgrp, int moving, float *in_data,
float *out_data, int *overlap, int *status ){
/* Local Variables */
AstMapping *totmap = NULL; /* WCS->GRID Mapping from template WCS FrameSet */
const char *name = NULL; /* Pointer to current detector name */
dim_t timeslice_size; /* No of detector values in one time slice */
double *detxtemplt = NULL; /* Work space for template X grid coords */
double *detxskycube = NULL; /* Work space for sky cube X grid coords */
double *detytemplt = NULL; /* Work space for template Y grid coords */
double *detyskycube = NULL; /* Work space for sky cube Y grid coords */
float *ddata = NULL; /* Pointer to start of output detector data */
float *tdata = NULL; /* Pointer to start of sky cube time slice data */
int *spectab = NULL; /* Template->sky cube channel number conversion table */
int found; /* Was current detector name found in detgrp? */
dim_t gxsky; /* Sky cube X grid index */
dim_t gysky; /* Sky cube Y grid index */
dim_t idet; /* Detector index */
dim_t itime; /* Index of current time slice */
int iv0; /* Offset for pixel in 1st sky cube spectral channel */
smfHead *hdr = NULL; /* Pointer to data header for this time slice */
/* Initialise */
*overlap = 0;
/* Check the inherited status. */
if( *status != SAI__OK ) return;
/* Store a pointer to the template NDFs smfHead structure. */
hdr = data->hdr;
/* Store the number of pixels in one time slice */
timeslice_size = ndet*nchan;
/* Use the supplied mapping to get the zero-based sky cube channel number
corresponding to each template channel number. */
smf_rebincube_spectab( nchan, dim[ 2 ], ssmap, &spectab, status );
if( !spectab ) goto L999;
/* Allocate work arrays to hold the template and sky cube grid coords for each
detector. */
detxtemplt = astMalloc( ndet*sizeof( double ) );
detytemplt = astMalloc( ndet*sizeof( double ) );
detxskycube = astMalloc( ndet*sizeof( double ) );
detyskycube = astMalloc( ndet*sizeof( double ) );
/* Initialise a string to point to the name of the first detector for which
data is to be created. */
name = hdr->detname;
/* Fill the arrays with the grid coords of each detector. */
for( idet = 0; idet < ndet; idet++ ) {
detxtemplt[ idet ] = (double) idet + 1.0;
detytemplt[ idet ] = 1.0;
/* If a group of detectors to be used was supplied, search the group for
the name of the current detector. If not found, set the GRID coord
bad. */
if( detgrp ) {
found = grpIndex( name, detgrp, 1, status );
if( !found ) {
detxtemplt[ idet ] = AST__BAD;
detytemplt[ idet ] = AST__BAD;
}
}
/* Move on to the next available detector name. */
name += strlen( name ) + 1;
}
/* Loop round all time slices in the template NDF. */
for( itime = 0; itime < nslice && *status == SAI__OK; itime++ ) {
/* Store a pointer to the first output data value in this time slice. */
tdata = in_data ? ( out_data + itime*timeslice_size ) : NULL;
/* Begin an AST context. Having this context within the time slice loop
helps keep the number of AST objects in use to a minimum. */
astBegin;
/* Get a Mapping from the spatial GRID axes in the template to the spatial
GRID axes in the sky cube for the current time slice. Note this has
to be done first since it stores details of the current time slice
in the "smfHead" structure inside "data", and this is needed by
subsequent functions. */
totmap = smf_rebin_totmap( data, itime, abskyfrm, iskymap, moving,
status );
if( !totmap ) {
astEnd;
break;
}
/* Use this Mapping to get the sky cube spatial grid coords for each
template detector. */
astTran2( totmap, ndet, detxtemplt, detytemplt, 1, detxskycube,
detyskycube );
/* Loop round each detector, obtaining its output value from the sky cube. */
for( idet = 0; idet < ndet; idet++ ) {
/* Get a pointer to the start of the output spectrum data. */
ddata = tdata + idet*nchan;
/* Check the detector has a valid position in sky cube grid coords */
if( detxskycube[ idet ] != AST__BAD && detyskycube[ idet ] != AST__BAD ){
/* Find the closest sky cube pixel and check it is within the bounds of the
sky cube. */
gxsky = floor( detxskycube[ idet ] + 0.5 );
gysky = floor( detyskycube[ idet ] + 0.5 );
if( gxsky >= 1 && gxsky <= dim[ 0 ] &&
gysky >= 1 && gysky <= dim[ 1 ] ) {
/* Get the offset of the sky cube array element that corresponds to this
pixel in the first spectral channel. */
iv0 = ( gysky - 1 )*dim[ 0 ] + ( gxsky - 1 );
/* Copy the sky cube spectrum into the output time series cube. */
*overlap = 1;
if( in_data ) {
smf_resampcube_copy( nchan, spectab, iv0, nxy,
ddata, in_data, status );
} else {
break;
}
}
}
}
/* End the AST context. */
astEnd;
/* If no input data was supplied, and we have found at least one input
spectrum that overlaps the sky cube, we can finish early. */
if( !in_data && *overlap ) break;
}
/* Free non-static resources. */
L999:;
spectab = astFree( spectab );
detxtemplt = astFree( detxtemplt );
detytemplt = astFree( detytemplt );
detxskycube = astFree( detxskycube );
detyskycube = astFree( detyskycube );
}
void smf_rebincube_nn( ThrWorkForce *wf, smfData *data, int first, int last,
int *ptime, dim_t nchan, dim_t ndet, dim_t nslice,
dim_t nxy, dim_t nout, dim_t dim[3],
int badmask, int is2d, AstMapping *ssmap,
AstSkyFrame *abskyfrm, AstMapping *oskymap,
Grp *detgrp, int moving, int usewgt, int genvar,
double tfac, double fcon, float *data_array,
float *var_array, double *wgt_array,
float *texp_array, float *teff_array, int *nused,
int *nreject, int *naccept, int *good_tsys,
int *status ){
/* Local Variables */
AstMapping *totmap = NULL; /* WCS->GRID Mapping from input WCS FrameSet */
const char *name = NULL; /* Pointer to current detector name */
const double *tsys = NULL; /* Pointer to Tsys value for first detector */
dim_t gxout; /* Output X grid index */
dim_t gyout; /* Output Y grid index */
dim_t ichan; /* Input channel index */
dim_t idet; /* detector index */
dim_t itime; /* Index of current time slice */
dim_t nchanout; /* No of spectral channels in the output */
dim_t timeslice_size; /* No of detector values in one time slice */
double *detxin = NULL; /* Work space for input X grid coords */
double *detxout = NULL; /* Work space for output X grid coords */
double *detyin = NULL; /* Work space for input Y grid coords */
double *detyout = NULL; /* Work space for output Y grid coords */
double invar; /* Input variance */
double tcon; /* Variance factor for whole time slice */
double wgt; /* Weight for input value */
float *ddata = NULL; /* Pointer to start of input detector data */
float *tdata = NULL; /* Pointer to start of input time slice data */
float *work = NULL; /* Pointer to start of work array */
float rtsys; /* Tsys value */
float teff; /* Effective integration time */
float texp; /* Total time ( = ton + toff ) */
int *nexttime; /* Pointer to next time slice index to use */
int *specpop = NULL; /* Input channels per output channel */
int *spectab = NULL; /* I/p->o/p channel number conversion table */
int first_ts; /* Is this the first time slice? */
int found; /* Was current detector name found in detgrp? */
int ignore; /* Ignore this time slice? */
int init_detector_data; /* Should detector_data be initialised? */
int iv0; /* Offset for pixel in 1st o/p spectral channel */
int jdet; /* Detector index */
int naccept_old; /* Previous number of accepted spectra */
int ochan; /* Output channel index */
int use_threads; /* Use multiple threads? */
smfHead *hdr = NULL; /* Pointer to data header for this time slice */
static smfRebincubeNNArgs1 *common_data = NULL; /* Holds data common to all detectors */
static smfRebincubeNNArgs2 *detector_data = NULL; /* Holds data for each detector */
static int *pop_array = NULL;/* I/p spectra pasted into each output spectrum */
static dim_t ndet_max = 0; /* Max number of detectors */
/* Check the inherited status. */
if( *status != SAI__OK ) return;
/* Store a pointer to the input NDFs smfHead structure. */
hdr = data->hdr;
/* Store the number of pixels in one time slice */
timeslice_size = ndet*nchan;
/* Use this mapping to get the zero-based output channel number corresponding
to each input channel number. */
smf_rebincube_spectab( nchan, dim[ 2 ], ssmap, &spectab, status );
if( !spectab ) goto L999;
/* The 2D weighting scheme assumes that each output channel receives
contributions from one and only one input channel in each input file.
Create an array with an element for each output channel, holding the
number of input channels that contribute to the output channel. */
nchanout = dim[ 2 ];
if( is2d ) {
specpop = astMalloc( nchanout*sizeof( int ) );
memset( specpop, 0, nchanout*sizeof( int ) );
for( ichan = 0; ichan < nchan; ichan++ ) {
ochan = spectab[ ichan ];
if( ochan != -1 ) specpop[ ochan ]++;
}
}
/* If this is the first pass through this file, initialise the arrays. */
if( first ){
smf_rebincube_init( is2d, nxy, nout, genvar, data_array, var_array,
wgt_array, texp_array, teff_array, nused, status );
/* Allocate an extra work array and initialise it to zero. This holds the
total number of input spectra pasted into each output spectrum. It is
not needed by the AST-based function and so has not been put into
smf_rebincube_init. */
if( is2d ) {
pop_array = astMalloc( nxy*sizeof( int ) );
memset( pop_array, 0, nxy*sizeof( int ) );
}
}
/* Allocate work arrays to hold the input and output grid coords for each
detector. */
detxin = astMalloc( ndet*sizeof( double ) );
detyin = astMalloc( ndet*sizeof( double ) );
detxout = astMalloc( ndet*sizeof( double ) );
detyout = astMalloc( ndet*sizeof( double ) );
/* Initialise a string to point to the name of the first detector for which
data is available */
name = hdr->detname;
/* Fill the input arrays with the grid coords of each detector. */
for( idet = 0; idet < ndet; idet++ ) {
detxin[ idet ] = (double) idet + 1.0;
detyin[ idet ] = 1.0;
/* If a group of detectors to be used was supplied, search the group for
the name of the current detector. If not found, set the GRID coord
bad. */
if( detgrp ) {
found = grpIndex( name, detgrp, 1, status );
if( !found ) {
detxin[ idet ] = AST__BAD;
detyin[ idet ] = AST__BAD;
}
}
/* Move on to the next available detector name. */
name += strlen( name ) + 1;
}
/* Initialise a pointer to the ntex time slice index to be used. */
nexttime = ptime;
/* Count the number of time slices to be processed. */
if( ptime ) {
itime = 0;
while( ptime[ itime ] != VAL__MAXI ) itime++;
if( data->file ) {
msgOutiff( MSG__DEBUG, " ", "smf_rebincube_nn: Selecting %d time "
"slices from data file '%s'.", status, (int) itime,
data->file->name );
}
} else {
itime = nslice;
if( data->file ) {
msgOutiff( MSG__DEBUG, " ", "smf_rebincube_nn: Using all %d time "
"slices from data file '%s'.", status, (int) itime,
data->file->name );
}
}
/* Initialise the progress meter. */
smf_reportprogress( itime, status );
/* Loop round all time slices in the input NDF. */
use_threads = 0;
first_ts = 1;
for( itime = 0; itime < nslice && *status == SAI__OK; itime++ ) {
/* If this time slice is not being pasted into the output cube, pass on. */
if( nexttime ){
if( *nexttime != (int) itime ) continue;
nexttime++;
}
/* Store a pointer to the first input data value in this time slice. */
tdata = ( (float *) (data->pntr)[ 0 ] ) + itime*timeslice_size;
/* Begin an AST context. Having this context within the time slice loop
helps keep the number of AST objects in use to a minimum. */
astBegin;
/* Get a Mapping from the spatial GRID axes in the input the spatial
GRID axes in the output for the current time slice. Note this has
to be done first since it stores details of the current time slice
in the "smfHead" structure inside "data", and this is needed by
subsequent functions. */
totmap = smf_rebin_totmap( data, itime, abskyfrm, oskymap, moving,
status );
if( !totmap ) {
if( data->file ) {
msgOutiff( MSG__DEBUG, " ", "smf_rebincube_nn: Cannot get "
"Mapping for slice %d from data file '%s'.", status,
(int) itime, data->file->name );
}
astEnd;
break;
}
/* Get the effective exposure time, the total exposure time, and the
Tsys->Variance onversion factor for this time slice. Also get a
pointer to the start of the Tsys array. */
tsys = smf_rebincube_tcon( hdr, itime, fcon, &texp, &teff, &tcon,
status );
/* Use this Mapping to get the output spatial grid coords for each input
detector. */
astTran2( totmap, ndet, detxin, detyin, 1, detxout, detyout );
/* If this is the first time slice from the current input file to be pasted
into the output, see if any of the spectra will end up being pasted on
top of each other in the output. If not we can use a separate thread to
paste each spectrum. Otherwise, we cannot use multiple threads since they
may end up trying to write to the same output pixel at the same time. */
if( first_ts ) {
first_ts = 0;
use_threads = wf ? 1 : 0;
for( idet = 0; idet < ndet - 1 && use_threads; idet++ ) {
if( detxout[ idet ] != AST__BAD && detyout[ idet ] != AST__BAD ){
gxout = floor( detxout[ idet ] + 0.5 );
gyout = floor( detyout[ idet ] + 0.5 );
if( gxout >= 1 && gxout <= dim[ 0 ] &&
gyout >= 1 && gyout <= dim[ 1 ] ) {
for( jdet = idet + 1; idet < ndet; idet++ ) {
if( detxout[ jdet ] != AST__BAD &&
detyout[ jdet ] != AST__BAD ){
if( floor( detxout[ jdet ] + 0.5 ) == gxout &&
floor( detyout[ jdet ] + 0.5 ) == gyout ) {
use_threads = 0;
break;
}
}
}
}
}
}
/* If we will be using mutiple threads, do some preparation. */
if( use_threads ) {
if( data->file ) {
msgOutiff( MSG__DEBUG, " ", "smf_rebincube_nn: Using multiple "
"threads to process data file '%s'.", status,
data->file->name );
}
/* Ensure we have a structure holding information which is common to all
detectors and time slices. */
common_data = astGrow( common_data, sizeof( smfRebincubeNNArgs1 ), 1 );
if( astOK ) {
common_data->badmask = badmask;
common_data->nchan = nchan;
common_data->nchanout = nchanout;
common_data->spectab = spectab;
common_data->specpop = specpop;
common_data->nxy = nxy;
common_data->genvar = genvar;
common_data->data_array = data_array;
common_data->var_array = var_array;
common_data->wgt_array = wgt_array;
common_data->pop_array = pop_array;
common_data->nout = nout;
common_data->is2d = is2d;
}
/* Ensure we have a structure for each detector to hold the detector-specific
data, plus a pointer to the common data. */
init_detector_data = ( detector_data == NULL );
if( init_detector_data ) ndet_max = 0;
detector_data = astGrow( detector_data, sizeof( smfRebincubeNNArgs2 ),
ndet ) ;
/* Initialise pointers stored within any new elements added to the
"detector_data" array. */
if( ndet > ndet_max && astOK ) {
for( idet = ndet_max; idet < ndet; idet++ ) {
detector_data[ idet ].common = NULL;
detector_data[ idet ].work = NULL;
detector_data[ idet ].ddata = NULL;
}
ndet_max = ndet;
}
/* Allocate work space for each detector and store the common data
pointer. */
if( astOK ) {
for( idet = 0; idet < ndet; idet++ ) {
detector_data[ idet ].common = common_data;
detector_data[ idet ].work = astGrow( detector_data[ idet ].work,
sizeof( float ), nchanout );
}
}
/* If we are using a single threads, do some alternative preparation. */
} else {
if( data->file ) {
msgOutiff( MSG__DEBUG, " ", "smf_rebincube_nn: Using a single "
"thread to process data file '%s'.", status,
data->file->name );
}
/* We need an extra work array for 2D weighting that can hold a single
output spectrum. This is used as a staging post for each input
spectrum prior to pasting it into the output cube. */
work = astMalloc( nchanout*sizeof( float ) );
}
}
/* Loop round each detector, pasting its spectral values into the output
cube. */
for( idet = 0; idet < ndet; idet++ ) {
/* If multi-threaded, initialise a bad value for the detector's weight
to indicate that it is not being used. */
if( use_threads ) detector_data[ idet ].wgt = VAL__BADD;
/* See if any good tsys values are present. */
rtsys = tsys ? (float) tsys[ idet ] : VAL__BADR;
if( rtsys <= 0.0 ) rtsys = VAL__BADR;
if( rtsys != VAL__BADR ) *good_tsys = 1;
/* Check the detector has a valid position in output grid coords */
if( detxout[ idet ] != AST__BAD && detyout[ idet ] != AST__BAD ){
/* Find the closest output pixel and check it is within the bounds of the
output cube. */
gxout = floor( detxout[ idet ] + 0.5 );
gyout = floor( detyout[ idet ] + 0.5 );
if( gxout >= 1 && gxout <= dim[ 0 ] &&
gyout >= 1 && gyout <= dim[ 1 ] ) {
/* Get the offset of the output array element that corresponds to this
pixel in the first spectral channel. */
iv0 = ( gyout - 1 )*dim[ 0 ] + ( gxout - 1 );
/* If required calculate the variance associated with this detector, based on
the input Tsys values. */
invar = VAL__BADR;
if( usewgt || genvar == 2 ) {
if( rtsys != VAL__BADR ) {
if( tcon != VAL__BADD ) invar = tcon*rtsys*rtsys;
}
}
/* Calculate the weight for this detector. If we need the input variance,
either to weight the input or to calculate output variances, but the
input variance is not available, then ignore this detector. */
ignore = 0;
if( usewgt ) {
if( invar > 0.0 && invar != VAL__BADR ) {
wgt = 1.0/invar;
} else {
ignore = 1;
}
} else if( genvar == 2 ) {
ignore = ( invar <= 0.0 || invar == VAL__BADR );
wgt = 1.0;
} else {
wgt = 1.0;
}
/* If we are not ignoring this input spectrum, get a pointer to the start
of the input spectrum data and paste it into the output cube using
either the 2D or 3D algorithm. */
if( !ignore ) {
ddata = tdata + idet*nchan;
/* First deal with cases where we are using a single thread (the current
thread). */
if( !use_threads ) {
naccept_old = *naccept;
if( is2d ) {
smf_rebincube_paste2d( badmask, nchan, nchanout, spectab,
specpop, iv0, nxy, wgt, genvar,
invar, ddata, data_array,
var_array, wgt_array, pop_array,
nused, nreject, naccept, work,
status );
} else {
smf_rebincube_paste3d( nchan, nout, spectab, iv0, nxy,
wgt, genvar, invar, ddata,
data_array, var_array,
wgt_array, nused, status );
(*naccept)++;
}
/* Now we update the total and effective exposure time arrays for the
output spectrum that receives this input spectrum. Scale the exposure
times of this time slice in order to reduce its influence on the
output expsoure times if it does not have much spectral overlap with
the output cube. Only update the exposure time arrays if the spectrum
was used (as shown by an increase in the number of accepted spectra). */
if( texp != VAL__BADR && *naccept > naccept_old ) {
texp_array[ iv0 ] += texp*tfac;
teff_array[ iv0 ] += teff*tfac;
}
/* Now deal with cases where we are using several threads. */
} else {
/* Set up the detector specific data. */
detector_data[ idet ].iv0 = iv0;
detector_data[ idet ].wgt = wgt;
detector_data[ idet ].invar = invar;
detector_data[ idet ].ddata = ddata;
detector_data[ idet ].nused = 0;
detector_data[ idet ].nreject = 0;
detector_data[ idet ].naccept = 0;
/* Add a job to the workforce's job list. This job calls smf_rebincube_paste2d
or smf_rebincube_paste3d to paste the detector input spectrum into the
output cube. */
thrAddJob( wf, 0, detector_data + idet,
smf_rebincube_paste_thread, 0, NULL, status );
}
} else if( data->file ) {
msgOutiff( MSG__DEBUG, " ", "smf_rebincube_nn: Detector %d "
"is being ignored when processing data file '%s'.",
status, idet, data->file->name );
}
} else if( data->file ) {
msgOutiff( MSG__DEBUG, " ", "smf_rebincube_nn: Detector %d "
"fell outside the output cube when processing "
"data file '%s'.", status, idet, data->file->name );
}
} else if( data->file ) {
msgOutiff( MSG__DEBUG, " ", "smf_rebincube_nn: Detector %d has "
"an unknown position in the output cube when processing "
"data file '%s'.", status, idet, data->file->name );
}
}
/* If using multiple threads, wait until all spectra for this time slice
have been pasted into the output cube. Then transfer the output values
from the detector data structures to the returned variables. */
if( use_threads ) {
thrWait( wf, status );
for( idet = 0; idet < ndet; idet++ ) {
if( detector_data[ idet ].wgt != VAL__BADD ) {
(*nused) += detector_data[ idet ].nused;
(*nreject) += detector_data[ idet ].nreject;
(*naccept) += detector_data[ idet ].naccept;
if( texp != VAL__BADR && detector_data[ idet ].naccept > 0 ) {
texp_array[ detector_data[ idet ].iv0 ] += texp*tfac;
teff_array[ detector_data[ idet ].iv0 ] += teff*tfac;
}
}
}
}
/* Update the progress meter. */
smf_reportprogress( 0, status );
/* End the AST context. */
astEnd;
}
/* If this is the final pass through this function, normalise the returned
data and variance values, and release any static resources allocated
within this function. */
if( last ) {
if( is2d ) {
smf_rebincube_norm2d( nout, nxy, genvar, data_array,
var_array, wgt_array, pop_array, status );
} else {
smf_rebincube_norm3d( nout, genvar, *nused, data_array,
var_array, wgt_array, status );
}
pop_array = astFree( pop_array );
if( use_threads ) {
common_data = astFree( common_data );
for( idet = 0; idet < ndet_max; idet++ ) {
detector_data[ idet ].work = astFree( detector_data[ idet ].work );
}
detector_data = astFree( detector_data );
}
}
/* Free non-static resources. */
L999:;
work = astFree( work );
spectab = astFree( spectab );
specpop = astFree( specpop );
detxin = astFree( detxin );
detyin = astFree( detyin );
detxout = astFree( detxout );
detyout = astFree( detyout );
}
void smf_coords_lut( smfData *data, int tstep, dim_t itime_lo,
dim_t itime_hi, AstSkyFrame *abskyfrm,
AstMapping *oskymap, int moving, int olbnd[ 2 ],
int oubnd[ 2 ], fts2Port fts_port, int *lut,
double *angle,
double *lon, double *lat, int *status ) {
/* Local Variables */
AstCmpMap *bsmap = NULL; /* Tracking -> output grid Mapping */
AstFrame *trfrm = NULL; /* Tracking Frame */
AstFrameSet *fs = NULL; /* Tracking -> output sky FrameSet */
AstMapping *fullmap = NULL; /* Full Mapping from bolo GRID to output map GRID */
AstMapping *offmap = NULL; /* Mapping from absolute to offset sky coords */
AstMapping *tr2skyabs = NULL;/* Tracking -> output sky Mapping */
AstSkyFrame *offsky = NULL; /* Offset sky frame */
JCMTState *state; /* Pointer to telescope info for time slice */
dim_t ibolo; /* Vector index of bolometer */
dim_t idimx; /* Bolometers per row */
dim_t idimy; /* Bolometers per column */
dim_t ilut; /* Index of LUT element */
dim_t itime0; /* Time slice index at next full calculation */
dim_t itime; /* Time slice index */
dim_t nbolo; /* Total number of bolometers */
double *outmapcoord; /* Array holding output map GRID coords */
double *px; /* Pointer to next output map X GRID coord */
double *py; /* Pointer to next output map Y GRID coord */
double *pgx; /* Pointer to next X output grid coords */
double *pgy; /* Pointer to next Y output grid coords */
double *wgx = NULL; /* Work space to hold X output grid coords */
double *wgy = NULL; /* Work space to hold Y output grid coords */
double bsx0; /* Boresight output map GRID X at previous full calc */
double bsx; /* Boresight output map GRID X at current time slice */
double bsxlast; /* Boresight output map GRID X at previous time slice*/
double bsy0; /* Boresight output map GRID Y at previous full calc */
double bsy; /* Boresight output map GRID Y at current time slice */
double bsylast; /* Boresight output map GRID Y at previous time slice*/
double dx; /* Offset in GRID X from previous full calc */
double dxlast; /* Offset in GRID X from previous time slice */
double dy; /* Offset in GRID Y from previous full calc */
double dylast; /* Offset in GRID Y from previous time slice */
double shift[ 2 ]; /* Shift from PIXEL to GRID in output map */
double x; /* Output GRID X at current bolo in current row */
double xin[ 2 ]; /* Input X values */
double xout[ 2 ]; /* Output X values */
double y; /* Output GRID Y at current bolo in current row */
double yin[ 2 ]; /* Input Y values */
double yout[ 2 ]; /* Output Y values */
int lbnd_in[ 2 ]; /* Lower bounds of input array */
int np; /* Number of positions to transform */
int odimx; /* Output map X dimension in pixels */
int odimy; /* Output map Y dimension in pixels */
int ox; /* Output X GRID index (-1) containing current bolo */
int oy; /* Output Y GRID index (-1) containing current bolo */
int ubnd_in[ 2 ]; /* Upper bounds of input array */
/* Check the inherited status. */
if( *status != SAI__OK ) return;
/* Begin an AST context. */
astBegin;
/* Get the dimensions of the output map. */
odimx = oubnd[ 0 ] - olbnd[ 0 ] + 1;
odimy = oubnd[ 1 ] - olbnd[ 1 ] + 1;
/* Get the dimensions of the bolometer array. */
idimx = (data->dims)[ 0 ];
idimy = (data->dims)[ 1 ];
/* Store integer bounds within the input bolometer GRID system. */
lbnd_in[ 0 ] = 1;
lbnd_in[ 1 ] = 1;
ubnd_in[ 0 ] = idimx;
ubnd_in[ 1 ] = idimy;
/* Determine the number of bolometers. */
nbolo = idimx*idimy;
/* Initialise the index of the next LUT element to write. */
ilut = 0;
/* Ensure tstep is at least one. */
if( tstep < 1 ) tstep = 1;
/* Get the time slice index at which to do the next full calculation. */
itime0 = itime_lo;
/* We only need the following AST objects if we will be approximating
some caclulations. */
if( tstep > 1 ) {
/* We need to find the first good TCS index in order to get the
tracking system (Which for SCUBA-2 won't be changing in the sequence) */
itime0 = VAL__BADI;
for (itime = itime_lo; itime <= itime_hi; itime++) {
JCMTState * slice = &((data->hdr->allState)[itime]);
if (!(slice->jos_drcontrol >= 0 && slice->jos_drcontrol & DRCNTRL__POSITION)) {
itime0 = itime;
break;
}
}
if ((int)itime0 != VAL__BADI) {
/* We need a Frame describing absolute tracking system coords. Take a
copy of the supplied skyframe (to inherit obslat, obslon, epoch,
etc), and then set its system to the tracking system. */
trfrm = astCopy( abskyfrm );
astSetC( trfrm, "System",
sc2ast_convert_system( (data->hdr->allState)[itime0].tcs_tr_sys,
status ) );
/* Get the Mapping from the tracking system to the output (absolute, since
abskyfrm is absolute) sky system. */
fs = astConvert( trfrm, abskyfrm, " " );
if( !fs && *status == SAI__OK ) {
*status = SAI__ERROR;
errRep( " ", "smf_coords_lut: Failed to convert from "
"tracking system to output WCS system.", status );
}
tr2skyabs = astSimplify( astGetMapping( fs, AST__BASE, AST__CURRENT ) );
/* For moving targets, we also need a Frame describing offset sky
coordinates in the output map, in which the reference point is the
current telescope base position. This will involve changing the
SkyRef attribute of the Frame for every time slice, so take a
copy of the supplied SkyFrame to avoid changing it. */
if( moving ) {
offsky = astCopy( abskyfrm );
astSet( offsky, "SkyRefIs=Origin" );
}
/* Create the Mapping from offsets within the output map sky coordinate
system output to map GRID coords to output map GRID coords. This uses a
ShiftMap to convert from output PIXEL coords (produced by "oskymap") to
output GRID coords. Note, if the target is moving, "oskymap" maps from
sky *offsets* to output map PIXEL coords. */
shift[ 0 ] = 1.5 - olbnd[ 0 ];
shift[ 1 ] = 1.5 - olbnd[ 1 ];
bsmap = astCmpMap( oskymap, astShiftMap( 2, shift, " " ), 1, " " );
} else {
/* We did not find any good TCS data so force us into tstep==1
case and end up with VAL__BADI for every element. */
tstep = 1;
itime0 = itime_lo;
msgOutiff(MSG__VERB, "", "All time slices from %zu -- %zu had bad TCS data.",
status, (size_t)itime_lo, (size_t)itime_hi );
}
}
/* Allocate memory to hold the (x,y) output map grid coords at each bolo
for a single time slice. */
outmapcoord = astMalloc( sizeof( *outmapcoord )*2*nbolo );
/* Initialise boresight position for the benefit of the tstep == 1 case. */
bsx = bsy = 0.0;
bsx0 = bsy0 = AST__BAD;
bsxlast = bsylast = AST__BAD;
/* If lon and lat arrays are to be returned, allocate memory to hold the grid
coords of every bolometer for a single sample. */
if( lon && lat ) {
wgx = astMalloc( nbolo*sizeof( *wgx ) );
wgy = astMalloc( nbolo*sizeof( *wgy ) );
}
/* Loop round each time slice. */
state = data->hdr->allState + itime_lo;
for( itime = itime_lo; itime <= itime_hi && *status == SAI__OK;
itime++,state++ ) {
/* No need to get the boresight position if we are doing full
calculations at every time slice. If this time slice has bad
TCS data then the problem will be caught in smf_rebin_totmap. */
if( tstep > 1 ) {
/* Transform the current boresight and base (if moving) positions from
tracking coords to absolute output map sky coords. */
xin[ 0 ] = state->tcs_tr_ac1;
yin[ 0 ] = state->tcs_tr_ac2;
if( moving ) {
xin[ 1 ] = state->tcs_tr_bc1;
yin[ 1 ] = state->tcs_tr_bc2;
np = 2;
} else {
np = 1;
}
astTran2( tr2skyabs, np, xin, yin, 1, xout, yout );
/* If the target is moving, find the offsets within the output map sky
coordinate system, from base to boresight at the current time slice.
These offsets become the new "boresight" position (in xin/yin). Guard
against assigning bad values to the ref pos, which can cause AST to
report errors. */
if( moving && xout[ 1 ] != AST__BAD && yout[ 1 ] != AST__BAD ) {
/* Set the current telescope base position as the reference point in
"offsky". Then get the Mapping from absolute to offset sky coords. */
astSetD( offsky, "SkyRef(1)", xout[ 1 ] );
astSetD( offsky, "SkyRef(2)", yout[ 1 ] );
offmap = astSkyOffsetMap( offsky );
/* Use this Mapping to convert the current boresight position from
absolute sky coords to offsets from the current base position. */
astTran2( offmap, 1, xout, yout, 1, xin, yin );
/* Annul the Mapping to avoid keep the number of AST objects to a minimum. */
offmap = astAnnul( offmap );
/* If the target is stationary, we can just use the absolute boresight
position as it is. */
} else {
xin[ 0 ] = xout[ 0 ];
yin[ 0 ] = yout[ 0 ];
}
/* Transform the above boresight position from output map sky coords to output
map GRID coords. */
astTran2( bsmap, 1, xin, yin, 1, &bsx, &bsy );
}
/* If we have reached the next full calculation... */
if( itime == itime0 ) {
/* Calculate the full bolometer to map-pixel transformation for the current
time slice */
fullmap = smf_rebin_totmap( data, itime, abskyfrm, oskymap, moving,
fts_port, status );
/* If succesful, use it to transform every bolometer position from bolo
GRID coords to output map GRID coords. */
if( fullmap ) {
itime0 += tstep;
astTranGrid( fullmap, 2, lbnd_in, ubnd_in, 0.1, 1000000, 1,
2, nbolo, outmapcoord );
fullmap = astAnnul( fullmap );
/* Record the boresight grid coords at this time slice. */
bsx0 = bsx;
bsy0 = bsy;
/* If we cannot determine a full Mapping for this time slice, move the
node to the next time slice (otherwise we would loose all the data to
the next node), and set the boresight position bad to indicate we
have no mapping for this time slice. */
} else {
itime0++;
bsx0 = AST__BAD;
bsy0 = AST__BAD;
}
}
/* Get the offset from the boresight position at the previous full
calculation and the current boresight position, in output map GRID
coords. */
dx = ( bsx != AST__BAD && bsx0 != AST__BAD ) ? bsx - bsx0 : AST__BAD;
dy = ( bsy != AST__BAD && bsy0 != AST__BAD ) ? bsy - bsy0 : AST__BAD;
/* Work out the scan direction based on the GRID offsets between this and
the previous time slice. Angles are calculated using atan2, with values
ranging from -pi to +pi. */
if( angle ) {
double theta = AST__BAD;
dxlast = ( bsx != AST__BAD && bsxlast != AST__BAD ) ?
bsx - bsxlast : AST__BAD;
dylast = ( bsy != AST__BAD && bsylast != AST__BAD ) ?
bsy - bsylast : AST__BAD;
if( dxlast != AST__BAD && dylast != AST__BAD &&
!( !dxlast && !dylast ) ) {
theta = atan2( dylast, dxlast );
}
angle[itime-itime_lo] = theta;
bsxlast = bsx;
bsylast = bsy;
}
/* Initialise pointers to the place to store the final grid coords for
each bolometer. */
pgx = wgx;
pgy = wgy;
/* Loop round all bolometers. */
px = outmapcoord;
py = outmapcoord + nbolo;
for( ibolo = 0; ibolo < nbolo; ibolo++ ){
/* If good, get the x and y output map GRID coords for this bolometer. */
if( dx != AST__BAD && dy != AST__BAD ) {
x = *(px++) + dx;
y = *(py++) + dy;
/* If required, store them so that we can convert them into lon/lat
values later. */
if( pgx && pgy ) {
*(pgx++) = x;
*(pgy++) = y;
}
/* Find the grid indices (minus one) of the output map pixel containing the
mapped bolo grid coords. One is subtracted in order to simplify the
subsequent calculation of the vector index. */
ox = (int) ( x - 0.5 );
oy = (int) ( y - 0.5 );
/* Check it is within the output map */
if( ox >= 0 && ox < odimx && oy >= 0 && oy < odimy ) {
/* Find the 1-dimensional vector index into the output array for this
pixel and store in the next element of the returned LUT. */
lut[ ilut++ ] = ox + oy*odimx;
/* Store a bad value for points that are off the edge of the output map. */
} else {
lut[ ilut++ ] = VAL__BADI;
}
/* If good, store a bad index in the LUT and move on to the next pixel. */
} else {
lut[ ilut++ ] = VAL__BADI;
px++;
py++;
if( pgx && pgy ) {
*(pgx++) = AST__BAD;
*(pgy++) = AST__BAD;
}
}
}
/* If required transform the grid coords into (lon,lat) coords and store in
the relevant elements of the supplied "lon" and "lat" arrays. */
if( wgx && wgy ) {
astTran2( oskymap, nbolo, wgx, wgy, 0, lon + itime*nbolo,
lat + itime*nbolo );
/* Convert from rads to degs. */
pgx = lon + itime*nbolo;
pgy = lat + itime*nbolo;
for( ibolo = 0; ibolo < nbolo; ibolo++ ) {
if( *pgx != AST__BAD && *pgy != AST__BAD ) {
*(pgx++) *= AST__DR2D;
*(pgy++) *= AST__DR2D;
} else {
pgx++;
pgy++;
}
}
}
}
/* To obtain a reasonable value for the first entry of angle, we simply
duplicate the second value. */
if( angle && (itime_hi > itime_lo) ) {
angle[0] = angle[1];
}
/* Free remaining work space. */
outmapcoord = astFree( outmapcoord );
wgx = astFree( wgx );
wgy = astFree( wgy );
/* Export the WCS pointer in the data header since it will be annulled at
a higher level. Note the FrameSet pointer may be null if the last
full calculation was for a slice with bad telescope data. */
if( data->hdr->wcs ) astExport( data->hdr->wcs );
/* End the AST context. */
astEnd;
}
void smf_calc_iqu( ThrWorkForce *wf, smfData *data, int block_start,
int block_end, int ipolcrd, int qplace, int uplace,
int iplace, NdgProvenance *oprov, AstFitsChan *fc,
int pasign, double paoff, double angrot, int submean,
int harmonic, int *status ){
/* Local Variables: */
AstCmpMap *cm1;
AstCmpMap *cm2;
AstFrameSet *wcs; /* WCS FrameSet for output NDFs */
AstMapping *fpmap1;
AstMapping *fpmap2;
AstMapping *oskymap;
AstMapping *totmap;
AstSkyFrame *oskyfrm;
AstWinMap *wm; /* Mapping to reverse the X GRID axis */
const JCMTState *state; /* JCMTState info for current time slice */
const char *usesys; /* Used system string */
dim_t itime; /* Time slice index */
dim_t nbolo; /* No. of bolometers */
dim_t ncol; /* No. of columns of bolometers */
dim_t nrow; /* No. of rows of bolometers */
dim_t ntime; /* Time slices to check */
dim_t ntslice; /* Number of time-slices in data */
double *ipi; /* Pointer to output I array */
double *ipiv; /* Pointer to output I variance array */
double *ipq; /* Pointer to output Q array */
double *ipqv; /* Pointer to output Q variance array */
double *ipu; /* Pointer to output U array */
double *ipuv; /* Pointer to output U variance array */
double *mean;
double ang_data[2];
double fox[2];
double foy[2];
double fpr0;
double fprinc;
double fx[2];
double fy[2];
double ina[ 2 ]; /* Bolometer coords at bottom left */
double inb[ 2 ]; /* Bolometer coords at top right */
double outa[ 2 ]; /* NDF GRID coords at bottom left */
double outb[ 2 ]; /* NDF GRID coords at top right */
int bstep; /* Bolometer step between threads */
int el; /* Number of mapped array elements */
int gotvar; /* Were any output variances created? */
int indfi; /* Identifier for NDF holding I values */
int indfq; /* Identifier for NDF holding Q values */
int indfu; /* Identifier for NDF holding Q values */
int iworker; /* Index of a worker thread */
int lbnd[ 2 ]; /* Lower pixel bounds of output NDF */
int moving;
int nworker; /* No. of worker threads */
int old; /* Data has old-style POL_ANG values? */
int tstep; /* Time slice step between threads */
int ubnd[ 2 ]; /* Upper pixel bounds of output NDF */
size_t bstride; /* Stride between adjacent bolometer values */
size_t tstride; /* Stride between adjacent time slice values */
smfCalcIQUJobData *job_data = NULL; /* Pointer to all job data */
smfCalcIQUJobData *pdata = NULL;/* Pointer to next job data */
smfHead *hdr; /* Pointer to data header this time slice */
/* Check the inherited status. */
if( *status != SAI__OK ) return;
/* Convenience pointers. */
hdr = data->hdr;
/* Obtain number of time slices - will also check for 3d-ness. Also get
the dimensions of the bolometer array and the strides between adjacent
bolometer values. */
smf_get_dims( data, &nrow, &ncol, &nbolo, &ntslice, NULL, &bstride,
&tstride, status );
/* Report an error if the block of time slices extends of either end. */
if( block_start < 0 || block_end >= (int) ntslice ) {
if( *status == SAI__OK ) {
*status = SAI__ERROR;
msgSeti( "S", block_start );
msgSeti( "E", block_end );
msgSeti( "N", ntslice );
errRep( " ", "smf_calc_iqu: invalid block of time slices - ^S to "
"^E (^N time slices are available).", status );
}
}
/* Create the output NDFs. Each one is a 2D array with dimensions
equal to the bolometer array. */
lbnd[ 0 ] = 1;
lbnd[ 1 ] = 1;
ubnd[ 0 ] = ncol;
ubnd[ 1 ] = nrow;
ndfNew( "_DOUBLE", 2, lbnd, ubnd, &qplace, &indfq, status );
ndfNew( "_DOUBLE", 2, lbnd, ubnd, &uplace, &indfu, status );
if( iplace != NDF__NOPL ) {
ndfNew( "_DOUBLE", 2, lbnd, ubnd, &iplace, &indfi, status );
} else {
indfi = NDF__NOID;
}
/* Store any supplied provenance in all NDFs. */
if( oprov ) {
ndgWriteProv( oprov, indfq, 1, status );
ndgWriteProv( oprov, indfu, 1, status );
if( indfi != NDF__NOID ) ndgWriteProv( oprov, indfi, 1, status );
}
/* Store any supplied FITS headers in all NDFs.*/
if( fc && astGetI( fc, "NCard" ) > 0 ) {
kpgPtfts( indfq, fc, status );
kpgPtfts( indfu, fc, status );
if( indfi != NDF__NOID ) kpgPtfts( indfi, fc, status );
}
/* Store the WCS frameSet in all NDFs. First get the FrameSet for the
central time slice in the block, and set its current Frame to the
tracking frame. */
smf_tslice_ast( data, ( block_start + block_end )/2, 1, NO_FTS, status);
usesys = sc2ast_convert_system( (data->hdr->allState)[0].tcs_tr_sys,
status );
astSetC( hdr->wcs, "System", usesys );
/* Get the Mapping from focal plane coords to bolometer grid coords. This
is the same for all time slices. sc2ast ensures that frame 3 is FPLANE. */
fpmap1 = astGetMapping( hdr->wcs, 3, AST__BASE );
/* Take a copy and then reverse the X axis of the GRID Frame by remaping the
base Frame using a WinMap. This produces a pixel grid such as you would
see by looking up at the sky from underneath the array, rather than looking
down at the ground from above the array. */
wcs = astCopy( hdr->wcs );
ina[ 0 ] = 1.0;
inb[ 0 ] = ncol;
ina[ 1 ] = 1.0;
inb[ 1 ] = nrow;
outa[ 0 ] = ncol;
outb[ 0 ] = 1.0;
outa[ 1 ] = 1.0;
outb[ 1 ] = nrow;
wm = astWinMap( 2, ina, inb, outa, outb, " " );
astRemapFrame( wcs, AST__BASE, wm );
wm = astAnnul( wm );
/* Get the Mapping from output grid coords to focal plane coords. */
fpmap2 = astGetMapping( wcs, AST__BASE, 3 );
/* If the target is moving (assumed to be the case if the tracking
system is AZEL or GAPPT), make the FrameSet current Frame represent
offsets from the reference position (i.e. the moving target), and
indicate that the offset coord system should be used for alignment. */
if( !strcmp( usesys, "AZEL" ) || !strcmp( usesys, "GAPPT" ) ){
astSet( wcs, "SkyRefIs=Origin,AlignOffset=1" );
moving = 1;
} else {
moving = 0;
}
/* Store the FrameSet in the output NDFs. */
ndfPtwcs( wcs, indfq, status );
ndfPtwcs( wcs, indfu, status );
if( indfi != NDF__NOID ) ndfPtwcs( wcs, indfi, status );
/* Map the Data array in each NDF. */
ndfMap( indfq, "Data", "_DOUBLE", "WRITE", (void **) &ipq, &el, status );
ndfMap( indfu, "Data", "_DOUBLE", "WRITE", (void **) &ipu, &el, status );
if( indfi != NDF__NOID ) {
ndfMap( indfi, "Data", "_DOUBLE", "WRITE", (void **) &ipi, &el, status );
} else {
ipi = NULL;
}
/* Map the Variance array in each NDF. */
ndfMap( indfq, "Variance", "_DOUBLE", "WRITE", (void **) &ipqv, &el, status );
ndfMap( indfu, "Variance", "_DOUBLE", "WRITE", (void **) &ipuv, &el, status );
if( indfi != NDF__NOID ) {
ndfMap( indfi, "Variance", "_DOUBLE", "WRITE", (void **) &ipiv, &el, status );
} else {
ipiv = NULL;
}
/* If required, allocate memory to hold the mean bolometer value at each
time slice. */
mean = submean ? astMalloc( ntslice*sizeof( *mean ) ) : NULL;
/* Create structures used to pass information to the worker threads. */
nworker = wf ? wf->nworker : 1;
job_data = astMalloc( nworker*sizeof( *job_data ) );
/* Check the above pointers can be used safely. */
if( *status == SAI__OK ) {
/* 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. */
old = 0;
state = hdr->allState;
ntime = ( ntslice > 1000 ) ? 1000 : ntslice;
for( itime = 0; itime < ntime; itime++,state++ ) {
if( state->pol_ang > 20 ) {
old = 1;
msgOutif( MSG__VERB, ""," POL2 data contains POL_ANG values "
"in encoder units - converting to radians.", status );
break;
}
}
/* If required, find the mean bolometer value at each time slice. */
if( submean ) {
/* Determine which time-slices are to be processed by which threads. */
tstep = ntslice/nworker;
if( tstep < 1 ) tstep = 1;
for( iworker = 0; iworker < nworker; iworker++ ) {
pdata = job_data + iworker;
pdata->block_start = iworker*tstep;
if( iworker < nworker - 1 ) {
pdata->block_end = pdata->block_start + tstep - 1;
} else {
pdata->block_end = ntslice - 1;
}
}
/* Store all the other info needed by the worker threads, and submit the
jobs to calculate the Q and U values in each bolo, and then wait for
them to complete. */
for( iworker = 0; iworker < nworker; iworker++ ) {
pdata = job_data + iworker;
pdata->bstride = bstride;
pdata->dat = data->pntr[0];
pdata->nbolo = nbolo;
pdata->qua = smf_select_qualpntr( data, NULL, status );;
pdata->tstride = tstride;
pdata->mean = mean;
pdata->action = 1;
/* Pass the job to the workforce for execution. */
thrAddJob( wf, THR__REPORT_JOB, pdata, smf1_calc_iqu_job, 0, NULL,
status );
}
/* Wait for the workforce to complete all jobs. */
thrWait( wf, status );
}
/* Get the Frame representing absolute sky coords in the output NDF,
and the Mapping from sky to grid in the output NDF. */
oskyfrm = astCopy( astGetFrame( wcs, AST__CURRENT ) );
astSet( oskyfrm, "SkyRefIs=Ignored" );
oskymap = astGetMapping( wcs, AST__CURRENT, AST__BASE );
wcs = astAnnul( wcs );
/* Find the first and last time slices, calculate the angle between the
focal pane Y axis at the time slice, and the focal plane Y axis in
the output NDF. For intervening time-slices, the angle is found by
linear interpolation between the extreme time slices. */
for( el = 0; el < 2; el++ ) {
/* Get the mapping from GRID coords in the input time slice to GRID
coords in the output. */
totmap = smf_rebin_totmap( data, el?ntslice-1:0, oskyfrm, oskymap,
moving, NO_FTS, status );
/* Modify it to be the Mapping from focal plane coords in the input time
slice to focal plane coords in the output. */
cm1 = astCmpMap( fpmap1, totmap, 1, " " );
cm2 = astCmpMap( cm1, fpmap2, 1, " " );
/* Use this Mapping to convert two points on the focal plane Y axis from
the input to the output. */
fx[0] = 0.0;
fy[0] = 0.0;
fx[1] = 0.0;
fy[1] = 4.0;
astTran2( cm2, 2, fx, fy, 1, fox, foy );
/* The angle from the focal plane Y axis in the output to the focal plane
Y axis in the input time slice, measured positive in sense of rotation
from Fy to Fx. */
ang_data[ el ] = atan2( fox[1]-fox[0], foy[1]-foy[0] );
/* Free resources for this time slice. */
totmap = astAnnul( totmap );
cm1 = astAnnul( cm1 );
cm2 = astAnnul( cm2 );
}
/* Annul objects. */
oskymap = astAnnul( oskymap );
oskyfrm = astAnnul( oskyfrm );
fpmap1 = astAnnul( fpmap1 );
fpmap2 = astAnnul( fpmap2 );
/* Get the constants of the linear relationship between focal plane
rotation and time slice index "fpr = fpr0 + itime*fprinc". */
fpr0 = ang_data[ 0 ];
fprinc = ( ang_data[ 1 ] - fpr0 )/( ntslice - 1 );
/* 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;
/* Store all the other info needed by the worker threads, and submit the
jobs to calculate the Q and U values in each bolo, and then wait for
them to complete. */
for( iworker = 0; iworker < nworker; iworker++ ) {
pdata = job_data + iworker;
pdata->bstride = bstride;
pdata->dat = data->pntr[0];;
pdata->nbolo = nbolo;
pdata->qua = smf_select_qualpntr( data, NULL, status );;
pdata->tstride = tstride;
pdata->allstates = hdr->allState;
pdata->ipq = ipq;
pdata->ipu = ipu;
pdata->ipi = ipi;
pdata->ipqv = ipqv;
pdata->ipuv = ipuv;
pdata->ipiv = ipiv;
pdata->ipolcrd = ipolcrd;
pdata->block_start = block_start;
pdata->block_end = block_end;
pdata->old = old;
pdata->ncol = ncol;
pdata->pasign = pasign ? +1: -1;
pdata->paoff = paoff;
pdata->angrot = angrot;
pdata->fpr0 = fpr0;
pdata->fprinc = fprinc;
pdata->angfac = harmonic/4.0;
pdata->action = 0;
pdata->mean = mean;
/* Pass the job to the workforce for execution. */
thrAddJob( wf, THR__REPORT_JOB, pdata, smf1_calc_iqu_job, 0, NULL,
status );
}
/* Wait for the workforce to complete all jobs. */
thrWait( wf, status );
/* See if any thread produced non-bad variance values. */
gotvar = 0;
for( iworker = 0; iworker < nworker; iworker++ ) {
pdata = job_data + iworker;
if( pdata->gotvar ) gotvar = 1;
}
/* If no variances were created, erase the Variance component and tell
the user. */
ndfUnmap( indfq, "*", status );
ndfUnmap( indfu, "*", status );
if( ipi ) ndfUnmap( indfi, "*", status );
if( !gotvar ) {
ndfReset( indfq, "Variance", status );
ndfReset( indfu, "Variance", status );
if( ipi ) ndfReset( indfi, "Variance", status );
msgOut( "", "Warning: Insufficient input data to produce variances",
status );
}
}
/* Add POLANAL Frames to the WCS FrameSet in each output NDF. This Frame
is used by POLPACK to determine the reference direction of the Stokes
vectors (focal plane Y in this case, i.e. zero-based axis 1 ). */
smf_polext( indfq, 0, 0.0, "FPLANE", 1, status );
smf_polext( indfu, 0, 0.0, "FPLANE", 1, status );
if( ipi ) smf_polext( indfi, 0, 0.0, "FPLANE", 1, status );
/* Free the two output NDFs. */
ndfAnnul( &indfq, status );
ndfAnnul( &indfu, status );
if( ipi ) ndfAnnul( &indfi, status );
/* Free other resources. */
job_data = astFree( job_data );
mean = astFree( mean );
}
