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;
}
int main( int argc, char **argv ){
/* Local variables: */
AstBox *pixbox;
AstFitsChan *fchan;
AstFrame *pixfrm;
AstFrame *wcsfrm;
AstFrameSet *frameset;
AstKeyMap *warnings;
AstMapping *pix2wcs;
AstObject *object;
AstRegion *wcsbox;
AstStcsChan *schan;
FILE *fd;
char key[ 15 ];
char keyword[ 9 ];
const char *message;
double p1[ MAX_AXES ];
double p2[ MAX_AXES ];
int axis;
int iwarn;
int naxis;
int status;
/* Initialised the returned system status to indicate success. */
status = 0;
/* Check a file was specified on the command line, and attempt to open it
for read access. */
if( argc < 2 ) {
printf( "Usage: stcschan-demo2 <header-file>\n" );
status = 1;
} else {
fd = fopen( argv[ 1 ], "r" );
if( !fd ) {
printf("Failed to open input file '%s'.\n", argv[ 1 ] );
status = 1;
}
}
/* If a disk file was opened successfully... */
if( !status ) {
/* Start an AST object context. This means we do not need to annull
each AST Object individually. Instead, all Objects created within
this context will be annulled automatically by the corresponding
invocation of astEnd. */
astBegin;
/* Create a FitsChan. This is the object that converts external FITS
headers into corresponding AST Objects. Tell it to use the "source"
function for obtaining lines of text from the disk file. */
fchan = astFitsChan( source, NULL, " " );
/* Associate the descriptor for the input disk file with the StcsChan.
This makes it available to the "source" function. Since this
application is single threaded, we could instead have made "fd" a
global variable, but the ChannelData facility is used here to illustrate
how to pass data to a source or sink function safely in a multi-threaded
application. */
astPutChannelData( fchan, fd );
/* Attempt to read the FITS heades and convert them into an AST FrameSet. */
object = astRead( fchan );
/* The astRead function is a generic function and so returns a generic
AstObject pointer. Check an Object was created successfully. */
if( !object ) {
printf( "Failed to read an AST Object from file '%s'.\n",
argv[ 1 ] );
status = 1;
/* Now check that the object read is actually an AST FrameSet, rather than
some other class of AST Object. */
} else if( !astIsAFrameSet( object ) ) {
printf( "Expected a FrameSet but read a %s from file '%s'.\n",
astGetC( object, "Class" ), argv[ 1 ] );
status = 1;
/* We now know we have a FrameSet so it is safe to use the pointer
returned by astRead as a FrameSet pointer. Do the cast now to avoid
repeated casting in future. */
} else {
frameset = (AstFrameSet *) object;
/* Get a pointer to the Frame that describes the attributes of the FITS
world coordinate system. This is the current Frame in the FrameSet
read from the FITS headers. */
wcsfrm = astGetFrame( frameset, AST__CURRENT );
/* Get a pointer to the Frame that describes the attributes of the FITS
pixel coordinate system. This is the base Frame in the FrameSet
read from the FITS headers. */
pixfrm = astGetFrame( frameset, AST__BASE );
/* Get the Mapping that transforms pixel positions into WCS positions.
The is the Mapping from base to current Frame in the FrameSet read
from the FITS headers. */
pix2wcs = astGetMapping( frameset, AST__BASE, AST__CURRENT );
/* Get the number of axes in ther pixel Frame. */
naxis = astGetI( pixfrm, "Naxes" );
/* For each pixel axis, form the name of the corresponding NAXISi
keyword. */
for( axis = 0; axis < naxis; axis++ ) {
sprintf( keyword, "NAXIS%d", axis + 1 );
/* Store the pixel coordinate on the current axis at the lower left corner
of the first pixel. */
p1[ axis ] = 0.5;
/* Get the NAXISi value for the current axis from the FITS header, and
store it in array "p2". Report an error if NAXISi is not found. */
if( !astGetFitsF( fchan, keyword, p2 + axis ) ){
printf("Keyword '%s' not found in header\n", keyword );
status = 1;
break;
/* If it is found, modify "p2" so that it holds the pixel coordinate on
the current axis at the upper right corner of the last pixel. */
} else {
p2[ axis ] += 0.5;
}
}
}
/* If all has gone well, create an AST Region (a Box) describing the
rectangular region of pixel coordinates covered by the pixel array. */
if( !status ) {
pixbox = astBox( pixfrm, 1, p1, p2, NULL, " " );
/* Map this box into the FITS world coordinate system. The Mapping is
specified by "pix2wcs", and the attributes of the resulting axes is
described by "wcsfrm". */
wcsbox = astMapRegion( pixbox, pix2wcs, wcsfrm );
/* Create an StcsChan. This is the object that converts (either way)
between external STC-S descriptions and their corresponding AST Objects.
Tell it to use the "source" function for obtaining lines of text from
the disk file. Also tell it to store all warnings generated by the
conversion for later use. Other attributes of the StcsChan class retain
their default values. */
schan = astStcsChan( NULL, NULL, "ReportLevel=3" );
/* Attempt to write out the Region describing the pixel array (in WCS)
as an STC-S description. Report an error if this fails. */
if( ! astWrite( schan, wcsbox ) && astOK ) {
printf( "Failed to convert the Region into an STC-S "
"description.\n" );
}
}
/* We asked the StcsChan to record any warnings that were generated
whilst converting the AST Region into a corresponding STC-S description.
We now see if any such warnings were generated by the earlier call to
astWrite. */
warnings = astWarnings( schan );
/* If any warnings were generated, and if no other error has occurred so
far, display the warnings. */
if( warnings && !status && astOK ) {
printf( "\nThe following warnings were issued:\n" );
/* The warnings are stored in an AST KeyMap (a sort of hashmap). Each
warning message is associated with a key of the form "Warning_1",
"Warning_2", etc. Loop round successive keys, obtaining a value for
each key from the warnings KeyMap, and displaying it. */
iwarn = 1;
while( astOK ) {
sprintf( key, "Warning_%d", iwarn++ );
if( astMapGet0C( warnings, key, &message ) ) {
printf( "\n- %s\n", message );
} else {
break;
}
}
}
/* End the AST Object context. All Objects created since the
corresponding invocation of astbegin will be annulled automatically. */
astEnd;
/* Close the disk file. */
(void) fclose( fd );
}
/* If an error occurred in the AST library, set the retiurns system
status non-zero. */
if( !astOK ) status = 1;
return status;
}
/* Main entry */
void smf_jsadicer( int indf, const char *base, int trim, smf_inst_t instrument,
smf_jsaproj_t proj, size_t *ntile, Grp *grp, int *status ){
/* Local Variables: */
AstBox *box;
AstFitsChan *fc;
AstFrame *specfrm = NULL;
AstFrame *tile_frm = NULL;
AstFrameSet *iwcs;
AstFrameSet *tfs = NULL;
AstFrameSet *tile_wcs;
AstMapping *ndf_map = NULL;
AstMapping *p2pmap = NULL;
AstMapping *specmap = NULL;
AstMapping *tile_map = NULL;
AstRegion *region;
Grp *grpt = NULL;
char *path;
char dtype[ NDF__SZFTP + 1 ];
char jsatile_comment[45];
char type[ NDF__SZTYP + 1 ];
const char *dom = NULL;
const char *keyword;
const char *latsys = NULL;
const char *lonsys = NULL;
double *pd;
double dlbnd[3];
double dubnd[3];
double gcen[3];
double lbnd_in[3];
double lbnd_out[3];
double ubnd_in[3];
double ubnd_out[3];
float *pf;
int *created_tiles = NULL;
int *tiles;
int axlat;
int axlon;
int axspec;
int bbox[ 6 ];
int i;
int ifrm;
int igrid;
int indfo;
int indfs;
int indfx;
int inperm[3];
int ipixel;
int ishpx;
int isxph;
int itile;
int ix;
int iy;
int iz;
int junk;
int latax = -1;
int lbnd[3];
int lbnd_tile[ 3 ];
int lbndx[ NDF__MXDIM ];
int lonax = -1;
int nbase;
int ndim;
int ndimx;
int nfrm;
int nsig;
int ntiles;
int olbnd[ 3 ];
int oubnd[ 3 ];
int outperm[ 3 ];
int place;
int qual;
int tile_index;
int tile_lbnd[2];
int tile_ubnd[2];
int ubnd[3];
int ubnd_tile[ 3 ];
int ubndx[ NDF__MXDIM ];
int var;
size_t iext;
size_t size;
smfJSATiling tiling;
unsigned char *ipq = NULL;
void *ipd = NULL;
void *ipv = NULL;
/* Initialise */
*ntile = 0;
/* Check inherited status */
if( *status != SAI__OK ) return;
/* Begin an AST context. */
astBegin;
/* Begin an NDF context. */
ndfBegin();
/* Note the used length of the supplied base string. If it ends with
".sdf", reduce it by 4. */
nbase = astChrLen( base );
if( !strcmp( base + nbase - 4, ".sdf" ) ) nbase -= 4;
/* Allocate a buffer large enough to hold the full path for an output NDF. */
path = astMalloc( nbase + 25 );
/* Get the WCS from the NDF. */
kpg1Gtwcs( indf, &iwcs, status );
/* Note if the NDF projection is HPX or XPH. */
ishpx = astChrMatch( astGetC( iwcs, "Projection" ), "HEALPix" );
isxph = astChrMatch( astGetC( iwcs, "Projection" ), "polar HEALPix" );
/* Report an error if the NDFs projection is neither of these. */
if( !ishpx && !isxph && *status == SAI__OK ) {
ndfMsg( "N", indf );
*status = SAI__ERROR;
errRep( "", "The input NDF (^N) does not appear to be gridded "
"on the JSA all-sky pixel grid.", status );
}
/* Get the bounds of the NDF in pixel indices and the the corresponding
double precision GRID bounds (reduce the size of the grid by a small
amount to avoid problems with tiles that are on the edge of the valid sky
regions - astMapRegion can report an error for such tiles). Also store
the GRID coords of the centre. Also count the number of significant
pixel axes. */
ndfBound( indf, 3, lbnd, ubnd, &ndim, status );
nsig = 0;
for( i = 0; i < ndim; i++ ) {
dlbnd[ i ] = 0.5 + 0.1;
dubnd[ i ] = ubnd[ i ] - lbnd[ i ] + 1.5 - 0.1;
gcen[ i ] = 0.5*( dlbnd[ i ] + dubnd[ i ] );
if( ubnd[ i ] > lbnd[ i ] ) nsig++;
}
/* Find the one-based indices of the RA, Dec and spectral axes in the
current Frame of the NDF. */
axlon = 0;
if( astGetI( iwcs, "IsLonAxis(1)" ) ) {
axlon = 1;
lonsys = astGetC( iwcs, "System(1)" );
} else if( astGetI( iwcs, "IsLonAxis(2)" ) ) {
axlon = 2;
lonsys = astGetC( iwcs, "System(2)" );
} else if( ndim == 3 && astGetI( iwcs, "IsLonAxis(3)" ) ) {
axlon = 3;
lonsys = astGetC( iwcs, "System(3)" );
} else if( *status == SAI__OK ) {
*status = SAI__ERROR;
errRep( "", "smf_jsadicer: Cannot find the longitude axis in the "
"input NDF.", status );
}
axlat = 0;
if( astGetI( iwcs, "IsLatAxis(1)" ) ) {
axlat = 1;
latsys = astGetC( iwcs, "System(1)" );
} else if( astGetI( iwcs, "IsLatAxis(2)" ) ) {
axlat = 2;
latsys = astGetC( iwcs, "System(2)" );
} else if( ndim == 3 && astGetI( iwcs, "IsLatAxis(3)" ) ) {
axlat = 3;
latsys = astGetC( iwcs, "System(3)" );
} else if( *status == SAI__OK ) {
*status = SAI__ERROR;
errRep( "", "smf_jsadicer: Cannot find the latitude axis in the "
"input NDF.", status );
}
axspec = 6 - axlon - axlat;
/* Report an error if the spatial axes are not ICRS RA and Dec. */
if( ( lonsys && strcmp( lonsys, "ICRS" ) ) ||
( latsys && strcmp( latsys, "ICRS" ) ) ) {
if( *status == SAI__OK ) {
*status = SAI__ERROR;
ndfMsg( "N", indf );
errRep( "", "smf_jsadicer: The spatial axes in '^N' are not "
"ICRS RA and Dec.", status );
}
}
/* Create a Box describing the region covered by the NDF pixel grid in
GRID coords. */
box = astBox( astGetFrame( iwcs, AST__BASE ), 1, dlbnd, dubnd,
AST__NULL, " " );
/* Map this Box into the current WCS Frame of the NDF. */
region = astMapRegion( box, iwcs, iwcs );
/* If no instrument was specified, we will determine the instrument from
the contexts of the FITS extension. Copy the NDF FITS extension to a
FitsChan. Annul the error if the NDF no FITS extension. */
if( instrument == SMF__INST_NONE && *status == SAI__OK ) {
kpgGtfts( indf, &fc, status );
if( *status == KPG__NOFTS ) {
errAnnul( status );
fc = NULL;
}
} else {
fc = NULL;
}
/* Get the parameters of the required tiling scheme. */
smf_jsainstrument( NULL, fc, instrument, &tiling, status );
/* Get a list of the JSA tiles touched by the supplied NDF. */
tiles = smf_jsatiles_region( region, &tiling, &ntiles, status );
if( ntiles == 0 && *status == SAI__OK ) {
*status = SAI__ERROR;
errRep( "", "smf_jsadicer: No JSA tiles found touching supplied NDF "
"(programming error).", status );
}
/* Does the input NDF have a Variance component? */
ndfState( indf, "Variance", &var, status );
/* Does the input NDF have a Quality component? */
ndfState( indf, "Quality", &qual, status );
/* Decide on the data type to use: _REAL or _DOUBLE. */
ndfMtype( "_REAL,_DOUBLE", indf, indf, "Data", type, sizeof(type), dtype,
sizeof(dtype), status );
/* Tell the user what is happening. */
msgBlank( status );
msgOutf( "", "Dicing %s into JSA tiles:", status,
( nsig == 2 ) ? "map" : "cube" );
/* Loop round all tiles that overlap the supplied NDF. */
for( itile = 0; itile < ntiles && *status == SAI__OK; itile++ ) {
tile_index = tiles[ itile ];
/* Get the spatial pixel bounds of the current tile within the requested
JSA all-sky projection. Also get the (2D) WCS FrameSet for the tile. */
smf_jsatile( tile_index, &tiling, 0, proj, NULL, &tile_wcs, NULL,
tile_lbnd, tile_ubnd, status );
/* Extract the tile pixel->WCS mapping and WCS Frame. We know the indices
of the required Frames because they are hard-wired in smf_jsatile. */
tile_map = astGetMapping( tile_wcs, 3, 2 );
tile_frm = astGetFrame( tile_wcs, 2 );
/* Find the indices of the grid and pixel frames in the input NDF. */
ipixel = -1;
igrid = astGetI( iwcs, "Base" );
nfrm = astGetI( iwcs, "NFrame" );
for( ifrm = 0; ifrm < nfrm; ifrm++ ) {
dom = astGetC( astGetFrame( iwcs, ifrm + 1 ), "Domain" );
if( astChrMatch( dom, "PIXEL" ) ) ipixel = ifrm + 1;
}
/* If required, extract the pixel->spectral mapping and spectral frame in
the input NDF, and add it in parallel with the above tile mapping. */
if( ndim == 3 ) {
astSetI( iwcs, "Base", ipixel );
tfs = atlFrameSetSplit( iwcs, "DSBSPECTRUM SPECTRUM", NULL,
NULL, status );
astSetI( iwcs, "Base", igrid );
if( tfs ) {
specmap = astGetMapping( tfs, AST__BASE, AST__CURRENT );
specfrm = astGetFrame( tfs, AST__CURRENT );
} else if( *status == SAI__OK ) {
*status = SAI__ERROR;
ndfMsg( "N", indf );
errRep( "", "smf_jsadicer: Cannot find the spectral axis "
"in '^N'.", status );
}
tile_map = (AstMapping *) astCmpMap( tile_map, specmap, 0, " " );
tile_frm = (AstFrame *) astCmpFrame( tile_frm, specfrm, " " );
}
/* Ensure the Epoch is inherited form the input NDF. */
astSetD( tile_frm, "Epoch", astGetD( iwcs, "Epoch" ) );
/* Currently tile axis 1 is RA, axis 2 is Dec and axis 3 (if present) is
spectral. Append a PermMap that re-orders these tile WCS axes to match
those of the NDF. */
outperm[ axlon - 1 ] = 1;
outperm[ axlat - 1 ] = 2;
outperm[ axspec - 1 ] = 3;
inperm[ 0 ] = axlon;
inperm[ 1 ] = axlat;
inperm[ 2 ] = axspec;
tile_map = (AstMapping *) astCmpMap( tile_map, astPermMap( ndim, inperm,
ndim, outperm,
NULL, " " ),
1, " " );
tile_map = astSimplify( tile_map );
/* Also re-order the WCS axes in the tile frame. */
astPermAxes( tile_frm, outperm );
/* We want the zero-based indicies of the input pixel axes corresponding
to ra, dec and spectral. So find the indicies of the pixel axes in the
supplied NDF that are most closely aligned with each WCS axis. */
atlPairAxes( iwcs, NULL, gcen, NULL, inperm, status );
if( inperm[ 0 ] == axlon ) {
lonax = 0;
} else if( inperm[ 1 ] == axlon ) {
lonax = 1;
} else {
lonax = 2;
}
if( inperm[ 0 ] == axlat ) {
latax = 0;
} else if( inperm[ 1 ] == axlat ) {
latax = 1;
} else {
latax = 2;
}
/* To get the mapping from pixel coords in the input NDF to pixel coords
in the output NDF, we invert the above mapping so that it goes from WCS
to pixel, and append it to the end of the NDF pixel->WCS mapping. */
ndf_map = astGetMapping( iwcs, ipixel, AST__CURRENT );
astInvert( tile_map );
p2pmap = (AstMapping *) astCmpMap( ndf_map, tile_map, 1, " " );
p2pmap = astSimplify( p2pmap );
astInvert( tile_map );
/* Show the bounds of the tile within the input NDF. */
msgOutiff( MSG__DEBUG, "", " tile %d has bounds (%d:%d,%d:%d) "
"within the output NDF.", status, tile_index,
tile_lbnd[ 0 ], tile_ubnd[ 0 ], tile_lbnd[ 1 ],
tile_ubnd[ 1 ] );
/* Next job is to find the pixel bounds of the output NDF to create
which will hold data for the current tile. First map the pixel bounds
of the whole tile from output to input. */
lbnd_in[ 0 ] = tile_lbnd[ 0 ] - 0.5;
lbnd_in[ 1 ] = tile_lbnd[ 1 ] - 0.5;
lbnd_in[ 2 ] = lbnd[ 2 ] - 0.5;
ubnd_in[ 0 ] = tile_ubnd[ 0 ] - 0.5;
ubnd_in[ 1 ] = tile_ubnd[ 1 ] - 0.5;
ubnd_in[ 2 ] = ubnd[ 2 ] - 0.5;
astMapBox( p2pmap, lbnd_in, ubnd_in, 0, 1, lbnd_out + 0,
ubnd_out + 0, NULL, NULL );
astMapBox( p2pmap, lbnd_in, ubnd_in, 0, 2, lbnd_out + 1,
ubnd_out + 1, NULL, NULL );
if( ndim == 3 ) astMapBox( p2pmap, lbnd_in, ubnd_in, 0, 3,
lbnd_out + 2, ubnd_out + 2, NULL,
NULL );
lbnd_tile[ 0 ] = floor( lbnd_out[ 0 ] ) + 1;
lbnd_tile[ 1 ] = floor( lbnd_out[ 1 ] ) + 1;
lbnd_tile[ 2 ] = floor( lbnd_out[ 2 ] ) + 1;
ubnd_tile[ 0 ] = floor( ubnd_out[ 0 ] ) + 1;
ubnd_tile[ 1 ] = floor( ubnd_out[ 1 ] ) + 1;
ubnd_tile[ 2 ] = floor( ubnd_out[ 2 ] ) + 1;
/* Show the bounds of the tile within the input NDF. */
msgOutiff( MSG__DEBUG, "", " tile %d has bounds (%d:%d,%d:%d) "
"within the input NDF.", status, tile_index,
lbnd_tile[ 0 ], ubnd_tile[ 0 ], lbnd_tile[ 1 ],
ubnd_tile[ 1 ] );
/* If required, trim the bounds to the extent of the input NDF. */
if( trim ) {
if( lbnd_tile[ 0 ] < lbnd[ 0 ] ) lbnd_tile[ 0 ] = lbnd[ 0 ];
if( lbnd_tile[ 1 ] < lbnd[ 1 ] ) lbnd_tile[ 1 ] = lbnd[ 1 ];
if( lbnd_tile[ 2 ] < lbnd[ 2 ] ) lbnd_tile[ 2 ] = lbnd[ 2 ];
if( ubnd_tile[ 0 ] > ubnd[ 0 ] ) ubnd_tile[ 0 ] = ubnd[ 0 ];
if( ubnd_tile[ 1 ] > ubnd[ 1 ] ) ubnd_tile[ 1 ] = ubnd[ 1 ];
if( ubnd_tile[ 2 ] > ubnd[ 2 ] ) ubnd_tile[ 2 ] = ubnd[ 2 ];
}
/* Check there is some overlap. */
if( lbnd_tile[ 0 ] <= ubnd_tile[ 0 ] &&
lbnd_tile[ 1 ] <= ubnd_tile[ 1 ] &&
lbnd_tile[ 2 ] <= ubnd_tile[ 2 ] ){
/* Now need to check if this section of the input NDF contains any good
values. We also find the bounding box of the good values (within the
input pixel coordinate system). So first obtain and map the required
section of the input NDF. */
ndfSect( indf, ndim, lbnd_tile, ubnd_tile, &indfs, status );
ndfMap( indfs, "Data", type, "Read", &ipd, &junk, status );
if( var ) ndfMap( indfs, "Variance", type, "Read", &ipv, &junk, status );
if( qual ) ndfMap( indfs, "Quality", "_UBYTE", "Read", (void **) &ipq,
&junk, status );
/* Initialise the pixel bounds (within the input NDF) of the box holding
good data values for the current tile. */
bbox[ 0 ] = INT_MAX;
bbox[ 1 ] = INT_MAX;
bbox[ 2 ] = INT_MAX;
bbox[ 3 ] = -INT_MAX;
bbox[ 4 ] = -INT_MAX;
bbox[ 5 ] = -INT_MAX;
/* Loop round all pixels in the section. */
if( *status == SAI__OK ) {
if( !strcmp( type, "_REAL" ) ) {
pf = (float *) ipd;
for( iz = lbnd_tile[ 2 ]; iz <= ubnd_tile[ 2 ]; iz++ ) {
for( iy = lbnd_tile[ 1 ]; iy <= ubnd_tile[ 1 ]; iy++ ) {
for( ix = lbnd_tile[ 0 ]; ix <= ubnd_tile[ 0 ]; ix++ ) {
if( *(pf++) != VAL__BADR ) {
if( ix < bbox[ 0 ] ) bbox[ 0 ] = ix;
if( iy < bbox[ 1 ] ) bbox[ 1 ] = iy;
if( iz < bbox[ 2 ] ) bbox[ 2 ] = iz;
if( ix > bbox[ 3 ] ) bbox[ 3 ] = ix;
if( iy > bbox[ 4 ] ) bbox[ 4 ] = iy;
if( iz > bbox[ 5 ] ) bbox[ 5 ] = iz;
}
}
}
}
} else {
pd = (double *) ipd;
for( iz = lbnd_tile[ 2 ]; iz <= ubnd_tile[ 2 ]; iz++ ) {
for( iy = lbnd_tile[ 1 ]; iy <= ubnd_tile[ 1 ]; iy++ ) {
for( ix = lbnd_tile[ 0 ]; ix <= ubnd_tile[ 0 ]; ix++ ) {
if( *(pd++) != VAL__BADD ) {
if( ix < bbox[ 0 ] ) bbox[ 0 ] = ix;
if( iy < bbox[ 1 ] ) bbox[ 1 ] = iy;
if( iz < bbox[ 2 ] ) bbox[ 2 ] = iz;
if( ix > bbox[ 3 ] ) bbox[ 3 ] = ix;
if( iy > bbox[ 4 ] ) bbox[ 4 ] = iy;
if( iz > bbox[ 5 ] ) bbox[ 5 ] = iz;
}
}
}
}
}
/* Skip empty tiles. */
if( bbox[ 0 ] != INT_MAX ) {
msgOutf( "", " tile %d", status, tile_index );
/* If required, trim the bounds to the edges of the bounding box. */
if( trim >= 2 ) {
olbnd[ 0 ] = bbox[ 0 ];
olbnd[ 1 ] = bbox[ 1 ];
olbnd[ 2 ] = bbox[ 2 ];
oubnd[ 0 ] = bbox[ 3 ];
oubnd[ 1 ] = bbox[ 4 ];
oubnd[ 2 ] = bbox[ 5 ];
} else {
olbnd[ 0 ] = lbnd_tile[ 0 ];
olbnd[ 1 ] = lbnd_tile[ 1 ];
olbnd[ 2 ] = lbnd_tile[ 2 ];
oubnd[ 0 ] = ubnd_tile[ 0 ];
oubnd[ 1 ] = ubnd_tile[ 1 ];
oubnd[ 2 ] = ubnd_tile[ 2 ];
}
/* Modify these pixel bounds so that they refer to the output NDF. */
lbnd_in[ 0 ] = olbnd[ 0 ] - 0.5;
lbnd_in[ 1 ] = olbnd[ 1 ] - 0.5;
lbnd_in[ 2 ] = olbnd[ 2 ] - 0.5;
ubnd_in[ 0 ] = oubnd[ 0 ] - 0.5;
ubnd_in[ 1 ] = oubnd[ 1 ] - 0.5;
ubnd_in[ 2 ] = oubnd[ 2 ] - 0.5;
astMapBox( p2pmap, lbnd_in, ubnd_in, 1, 1, lbnd_out + 0,
ubnd_out + 0, NULL, NULL );
astMapBox( p2pmap, lbnd_in, ubnd_in, 1, 2, lbnd_out + 1,
ubnd_out + 1, NULL, NULL );
if( ndim == 3 ) astMapBox( p2pmap, lbnd_in, ubnd_in, 1, 3,
lbnd_out + 2, ubnd_out + 2, NULL,
NULL );
olbnd[ 0 ] = floor( lbnd_out[ 0 ] ) + 1;
olbnd[ 1 ] = floor( lbnd_out[ 1 ] ) + 1;
olbnd[ 2 ] = floor( lbnd_out[ 2 ] ) + 1;
oubnd[ 0 ] = floor( ubnd_out[ 0 ] ) + 1;
oubnd[ 1 ] = floor( ubnd_out[ 1 ] ) + 1;
oubnd[ 2 ] = floor( ubnd_out[ 2 ] ) + 1;
/* Get the full path to the output NDF for the current tile, and create an
NDF placeholder for it. */
sprintf( path, "%.*s_%d", nbase, base, tile_index );
ndfPlace( NULL, path, &place, status );
/* Create a new output NDF by copying the meta-data from the input NDF
section. */
ndfScopy( indfs, "Units", &place, &indfo, status );
/* Set the pixel bounds of the output NDF to the values found above and copy
the input data for the current tile into it. */
smf1_jsadicer( indfo, olbnd, oubnd, tile_map, tile_frm, p2pmap,
ipd, ipv, ipq, status );
/* Add the name of this output NDF to the group holding the names of the
output NDFs that have actually been created. */
if( grp ) grpPut1( grp, path, 0, status );
/* Add a TILENUM header to the output FITS extension. */
kpgGtfts( indfo, &fc, status );
if( *status == KPG__NOFTS ) {
errAnnul( status );
fc = astFitsChan( NULL, NULL, " " );
/* If the last card is "END", remove it. */
} else {
astSetI( fc, "Card", astGetI( fc, "NCARD" ) );
keyword = astGetC( fc, "CardName" );
if( keyword && !strcmp( keyword, "END" ) ) astDelFits( fc );
}
one_snprintf(jsatile_comment, 45, "JSA all-sky tile index (Nside=%i)",
status, tiling.ntpf);
atlPtfti( fc, "TILENUM", tile_index, jsatile_comment, status );
kpgPtfts( indfo, fc, status );
fc = astAnnul( fc );
/* Now store an STC-S polygon that describes the shortest boundary
enclosing the good data in the output NDF, and store it as an NDF extension. */
kpgPutOutline( indfo, 0.5, 1, status );
/* We now reshape any extension NDFs contained within the output NDF to
have the same spatial bounds as the main NDF (but only for extension
NDFs that originally have the same spatial bounds as the supplied NDF).
Get a group containing paths to all extension NDFs in the output NDF. */
ndgMoreg( indfo, &grpt, &size, status );
/* Loop round each output extension NDF. */
for( iext = 1; iext <= size && *status == SAI__OK; iext++ ) {
ndgNdfas( grpt, iext, "Update", &indfx, status );
/* Get its bounds. */
ndfBound( indfx, NDF__MXDIM, lbndx, ubndx, &ndimx, status );
/* See if this extension NDF has the same bounds on the spatial axes as
the supplied NDF. */
if( ndimx > 1 && lbndx[ lonax ] == lbnd[ lonax ] &&
lbndx[ latax ] == lbnd[ latax ] &&
ubndx[ lonax ] == ubnd[ lonax ] &&
ubndx[ latax ] == ubnd[ latax ] ) {
/* If so, change the bounds of the output extension NDF so that they are
the same as the main NDF on the spatial axes, and map the original
contents of the NDF onto the new pixel grid. */
smf1_jsadicer( indfx, olbnd, oubnd, tile_map, tile_frm, p2pmap,
NULL, NULL, NULL, status );
}
/* Annul the extension NDF identifier. */
ndfAnnul( &indfx, status );
}
/* Free resources associated with the current tile. */
grpDelet( &grpt, status );
ndfAnnul( &indfo, status );
/* Issue warnings about empty tiles. */
} else {
msgOutiff( MSG__VERB, "", " tile %d is empty and so will not be "
"created", status, tile_index );
}
}
/* Free the section of the input NDF. */
ndfAnnul( &indfs, status );
/* Append the index of this tile in the list of tiles to be created. */
created_tiles = astGrow( created_tiles, ++(*ntile),
sizeof( *created_tiles ) );
if( *status == SAI__OK ) created_tiles[ *ntile - 1 ] = tile_index;
} else {
msgOutiff( MSG__DEBUG, "", " Tile %d does not overlap the input "
"NDF after trimming.", status, tile_index );
}
}
msgBlank( status );
/* Write the indicies of the created tiles out to a parameter. */
if( *ntile ) parPut1i( "JSATILELIST", *ntile, created_tiles, status );
/* Free resources. */
created_tiles = astFree( created_tiles );
tiles = astFree( tiles );
path = astFree( path );
/* End the NDF context. */
ndfEnd( status );
/* End the AST context. */
astEnd;
}
void smf_calc_mapcoord( ThrWorkForce *wf, AstKeyMap *config, smfData *data,
AstFrameSet *outfset, int moving, int *lbnd_out,
int *ubnd_out, fts2Port fts_port, int flags,
int *status ) {
/* Local Variables */
AstSkyFrame *abskyfrm = NULL;/* Output SkyFrame (always absolute) */
AstMapping *bolo2map=NULL; /* Combined mapping bolo->map coordinates */
int bndndf=NDF__NOID; /* NDF identifier for map bounds */
void *data_pntr[1]; /* Array of pointers to mapped arrays in ndf */
int *data_index; /* Mapped DATA_ARRAY part of NDF */
int docalc=1; /* If set calculate the LUT */
int doextension=0; /* Try to write LUT to MAPCOORD extension */
smfFile *file=NULL; /* smfFile pointer */
AstObject *fstemp = NULL; /* AstObject version of outfset */
int ii; /* loop counter */
int indf_lat = NDF__NOID; /* Identifier for NDF to receive lat values */
int indf_lon = NDF__NOID; /* Identifier for NDF to receive lon values */
smfCalcMapcoordData *job_data=NULL; /* Array of job */
int lbnd[1]; /* Pixel bounds for 1d pointing array */
int lbnd_old[2]; /* Pixel bounds for existing LUT */
int lbnd_temp[1]; /* Bounds for bounds NDF component */
int lutndf=NDF__NOID; /* NDF identifier for coordinates */
AstMapping *map2sky_old=NULL;/* Existing mapping map->celestial coord. */
HDSLoc *mapcoordloc=NULL; /* HDS locator to the MAPCOORD extension */
int nw; /* Number of worker threads */
AstFrameSet *oldfset=NULL; /* Pointer to existing WCS info */
AstSkyFrame *oskyfrm = NULL; /* SkyFrame from the output WCS Frameset */
smfCalcMapcoordData *pdata=NULL; /* Pointer to job data */
double *lat_ptr = NULL; /* Pointer to array to receive lat values */
double *lon_ptr = NULL; /* Pointer to array to receive lon values */
int ubnd[1]; /* Pixel bounds for 1d pointing array */
int ubnd_old[2]; /* Pixel bounds for existing LUT */
int ubnd_temp[1]; /* Bounds for bounds NDF component */
int *lut = NULL; /* The lookup table */
dim_t nbolo=0; /* Number of bolometers */
dim_t ntslice=0; /* Number of time slices */
int nmap; /* Number of mapped elements */
AstMapping *sky2map=NULL; /* Mapping celestial->map coordinates */
size_t step; /* step size for dividing up work */
AstCmpMap *testcmpmap=NULL; /* Combined forward/inverse mapping */
AstMapping *testsimpmap=NULL;/* Simplified testcmpmap */
double *theta = NULL; /* Scan direction at each time slice */
int tstep; /* Time slices between full Mapping calculations */
int exportlonlat; /* Dump longitude and latitude values? */
/* Main routine */
if (*status != SAI__OK) return;
/* How many threads do we get to play with */
nw = wf ? wf->nworker : 1;
/* Initialize bounds to avoid compiler warnings */
lbnd_old[0] = 0;
lbnd_old[1] = 0;
ubnd_old[0] = 0;
ubnd_old[1] = 0;
/* Check for pre-existing LUT and de-allocate it. This will only waste
time if the MAPCOORD extension is found to be valid and it has
to be re-loaded from disk. */
smf_close_mapcoord( data, status );
/* Assert ICD data order */
smf_dataOrder( data, 1, status );
/* Get the data dimensions */
smf_get_dims( data, NULL, NULL, &nbolo, &ntslice, NULL, NULL, NULL, status );
/* If SMF__NOCREATE_FILE is not set, and file associated with an NDF,
map a new MAPCOORD extension (or verify an existing one) */
if( !(flags & SMF__NOCREATE_FILE) && data->file ) {
doextension = 1;
} else {
doextension = 0;
docalc = 1;
}
/* Create / check for existing MAPCOORD extension */
if( doextension ) {
file = data->file;
/* Check type of file before proceeding */
if( file->isSc2store ) {
*status = SAI__ERROR;
errRep(FUNC_NAME,
"File was opened by sc2store library (raw data?)",
status);
}
if( !file->isTstream ) {
*status = SAI__ERROR;
errRep(FUNC_NAME, "File does not contain time stream data",status);
}
/* Get HDS locator to the MAPCOORD extension */
mapcoordloc = smf_get_xloc( data, "MAPCOORD", "MAP_PROJECTION", "UPDATE",
0, 0, status );
/* Obtain NDF identifier/placeholder for LUT in MAPCOORD extension*/
lbnd[0] = 0;
ubnd[0] = nbolo*ntslice-1;
lutndf = smf_get_ndfid( mapcoordloc, "LUT", "UPDATE", "UNKNOWN",
"_INTEGER", 1, lbnd, ubnd, status );
if( *status == SAI__OK ) {
/* store the NDF identifier */
file->mapcoordid = lutndf;
/* Create sky to output grid mapping using the base coordinates to
get the coordinates of the tangent point if it hasn't been done
yet. */
sky2map = astGetMapping( outfset, AST__CURRENT, AST__BASE );
}
/* Before mapping the LUT, first check for existing WCS information
and LBND/UBND for the output map. If they are already correct don't
bother re-calculating the LUT! */
if( *status == SAI__OK ) {
/* Try reading in the WCS information */
kpg1Wread( mapcoordloc, "WCS", &fstemp, status );
oldfset = (AstFrameSet*)fstemp;
if( *status == SAI__OK ) {
/* Check that the old and new mappings are the same by
checking that combining one with the inverse of the other
reduces to a UnitMap. */
map2sky_old = astGetMapping( oldfset, AST__BASE, AST__CURRENT );
testcmpmap = astCmpMap( map2sky_old, sky2map, 1, " " );
testsimpmap = astSimplify( testcmpmap );
if( astIsAUnitMap( testsimpmap ) ) {
/* The mappings are the same, now just check the pixel
bounds in the output map */
lbnd_temp[0] = 1;
ubnd_temp[0] = 2;
bndndf = smf_get_ndfid( mapcoordloc, "LBND", "READ", "UNKNOWN",
"_INTEGER", 1, lbnd_temp, ubnd_temp,
status );
if( *status == SAI__OK ) {
ndfMap( bndndf, "DATA", "_INTEGER", "READ", data_pntr, &nmap,
status );
data_index = data_pntr[0];
if( *status == SAI__OK ) {
lbnd_old[0] = data_index[0];
lbnd_old[1] = data_index[1];
}
ndfAnnul( &bndndf, status );
}
bndndf = smf_get_ndfid( mapcoordloc, "UBND", "READ", "UNKNOWN",
"_INTEGER", 1, lbnd_temp, ubnd_temp,
status );
if( *status == SAI__OK ) {
ndfMap( bndndf, "DATA", "_INTEGER", "READ", data_pntr, &nmap,
status );
data_index = data_pntr[0];
if( *status == SAI__OK ) {
ubnd_old[0] = data_index[0];
ubnd_old[1] = data_index[1];
}
ndfAnnul( &bndndf, status );
}
if( *status == SAI__OK ) {
/* If we get this far finally do the bounds check! */
if( (lbnd_old[0] == lbnd_out[0]) &&
(lbnd_old[1] == lbnd_out[1]) &&
(ubnd_old[0] == ubnd_out[0]) &&
(ubnd_old[1] == ubnd_out[1]) ) {
docalc = 0; /* We don't have to re-calculate the LUT */
msgOutif(MSG__VERB," ",FUNC_NAME ": Existing LUT OK",
status);
}
}
}
/* Bad status / AST errors at this point due to problems with
MAPCOORD. Annul and continue calculating new MAPCOORD extension. */
astClearStatus;
errAnnul(status);
} else {
/* Bad status due to non-existence of MAPCOORD. Annul and continue */
errAnnul(status);
}
}
}
/* If we need to calculate the LUT do it here */
if( docalc && (*status == SAI__OK) ) {
msgOutif(MSG__VERB," ", FUNC_NAME ": Calculate new LUT",
status);
/* Get the increment in time slices between full Mapping calculations.
The Mapping for intermediate time slices will be approximated. */
dim_t dimval;
smf_get_nsamp( config, "TSTEP", data, &dimval, status );
tstep = dimval;
/* Get space for the LUT */
if( doextension ) {
/* Map the LUT array */
ndfMap( lutndf, "DATA", "_INTEGER", "WRITE", data_pntr, &nmap,
status );
data_index = data_pntr[0];
if( *status == SAI__OK ) {
lut = data_index;
} else {
errRep( FUNC_NAME, "Unable to map LUT in MAPCOORD extension",
status);
}
} else {
/* alloc the LUT and THETA arrays */
lut = astMalloc( (nbolo*ntslice)*sizeof(*(data->lut)) );
theta = astMalloc( ntslice*sizeof(*(data->theta)) );
}
/* Retrieve the sky2map mapping from the output frameset (actually
map2sky) */
oskyfrm = astGetFrame( outfset, AST__CURRENT );
sky2map = astGetMapping( outfset, AST__BASE, AST__CURRENT );
/* If the longitude and latitude is being dumped, create new NDFs to
hold them, and map them. */
if( config ) {
astMapGet0I( config, "EXPORTLONLAT", &exportlonlat );
if( exportlonlat ) {
lon_ptr = smf1_calc_mapcoord1( data, nbolo, ntslice, oskyfrm,
&indf_lon, 1, status );
lat_ptr = smf1_calc_mapcoord1( data, nbolo, ntslice, oskyfrm,
&indf_lat, 2, status );
}
}
/* Invert the mapping to get Output SKY to output map coordinates */
astInvert( sky2map );
/* Create a SkyFrame in absolute coordinates */
abskyfrm = astCopy( oskyfrm );
astClear( abskyfrm, "SkyRefIs" );
astClear( abskyfrm, "SkyRef(1)" );
astClear( abskyfrm, "SkyRef(2)" );
if( *status == SAI__OK ) {
/* --- Begin parellelized portion ------------------------------------ */
/* Start a new job context. Each call to thrWait within this
context will wait until all jobs created within the context have
completed. Jobs created in higher contexts are ignored by thrWait. */
thrBeginJobContext( wf, status );
/* Allocate job data for threads */
job_data = astCalloc( nw, sizeof(*job_data) );
if( *status == SAI__OK ) {
/* Set up job data, and start calculating pointing for blocks of
time slices in different threads */
if( nw > (int) ntslice ) {
step = 1;
} else {
step = ntslice/nw;
}
for( ii=0; (*status==SAI__OK)&&(ii<nw); ii++ ) {
pdata = job_data + ii;
/* Blocks of time slices */
pdata->t1 = ii*step;
pdata->t2 = (ii+1)*step-1;
/* Ensure that the last thread picks up any left-over tslices */
if( (ii==(nw-1)) && (pdata->t1<(ntslice-1)) ) {
pdata->t2=ntslice-1;
}
pdata->ijob = -1;
pdata->lut = lut;
pdata->theta = theta;
pdata->lbnd_out = lbnd_out;
pdata->moving = moving;
pdata->ubnd_out = ubnd_out;
pdata->tstep = tstep;
pdata->lat_ptr = lat_ptr;
pdata->lon_ptr = lon_ptr;
pdata->fts_port = fts_port;
/* Make deep copies of AST objects and unlock them so that each
thread can then lock them for their own exclusive use */
pdata->abskyfrm = astCopy( abskyfrm );
astUnlock( pdata->abskyfrm, 1 );
pdata->sky2map = astCopy( sky2map );
astUnlock( pdata->sky2map, 1 );
/* Similarly, make a copy of the smfData, including only the header
information which each thread will need in order to make calls to
smf_rebin_totmap */
pdata->data = smf_deepcopy_smfData( data, 0, SMF__NOCREATE_FILE |
SMF__NOCREATE_DA |
SMF__NOCREATE_FTS |
SMF__NOCREATE_DATA |
SMF__NOCREATE_VARIANCE |
SMF__NOCREATE_QUALITY, 0, 0,
status );
smf_lock_data( pdata->data, 0, status );
}
for( ii=0; ii<nw; ii++ ) {
/* Submit the job */
pdata = job_data + ii;
pdata->ijob = thrAddJob( wf, THR__REPORT_JOB, pdata,
smfCalcMapcoordPar, 0, NULL, status );
}
/* Wait until all of the jobs submitted within the current job
context have completed */
thrWait( wf, status );
}
/* End the current job context. */
thrEndJobContext( wf, status );
/* --- End parellelized portion -------------------------------------- */
/* Set the lut pointer in data to the buffer */
data->lut = lut;
data->theta = theta;
/* Write the WCS for the projection to the extension */
if( doextension ) {
kpg1Wwrt( (AstObject*)outfset, "WCS", mapcoordloc, status );
/* Write the pixel bounds for the map to the extension */
lbnd_temp[0] = 1; /* Don't get confused! Bounds for NDF that will */
ubnd_temp[0] = 2; /* contain the bounds for the output 2d map! */
bndndf = smf_get_ndfid( mapcoordloc, "LBND", "UPDATE", "UNKNOWN",
"_INTEGER", 1, lbnd_temp, ubnd_temp, status );
ndfMap( bndndf, "DATA", "_INTEGER", "WRITE", data_pntr, &nmap,
status );
data_index = data_pntr[0];
if( *status == SAI__OK ) {
data_index[0] = lbnd_out[0];
data_index[1] = lbnd_out[1];
} else {
errRep( FUNC_NAME, "Unable to map LBND in MAPCOORD extension",
status);
}
ndfAnnul( &bndndf, status );
bndndf = smf_get_ndfid( mapcoordloc, "UBND", "UPDATE", "UNKNOWN",
"_INTEGER", 1, lbnd_temp, ubnd_temp, status );
ndfMap( bndndf, "DATA", "_INTEGER", "WRITE", data_pntr, &nmap,
status );
data_index = data_pntr[0];
if( *status == SAI__OK ) {
data_index[0] = ubnd_out[0];
data_index[1] = ubnd_out[1];
} else {
errRep( FUNC_NAME, "Unable to map UBND in MAPCOORD extension",
status);
}
ndfAnnul( &bndndf, status );
}
}
}
/* Clean Up */
if( testsimpmap ) testsimpmap = astAnnul( testsimpmap );
if( testcmpmap ) testcmpmap = astAnnul( testcmpmap );
if( map2sky_old ) map2sky_old = astAnnul( map2sky_old );
if( oldfset ) oldfset = astAnnul( oldfset );
if (sky2map) sky2map = astAnnul( sky2map );
if (bolo2map) bolo2map = astAnnul( bolo2map );
if( abskyfrm ) abskyfrm = astAnnul( abskyfrm );
if( oskyfrm ) oskyfrm = astAnnul( oskyfrm );
if( mapcoordloc ) datAnnul( &mapcoordloc, status );
if( indf_lat != NDF__NOID ) ndfAnnul( &indf_lat, status );
if( indf_lon != NDF__NOID ) ndfAnnul( &indf_lon, status );
/* If we get this far, docalc=0, and status is OK, there must be
a good LUT in there already. Map it so that it is accessible to
the caller; "UPDATE" so that the caller can modify it if desired. */
if( (*status == SAI__OK) && (docalc == 0) ) {
smf_open_mapcoord( data, "UPDATE", status );
}
/* Clean up job data */
if( job_data ) {
for( ii=0; (*status==SAI__OK)&&(ii<nw); ii++ ) {
pdata = job_data + ii;
if( pdata->data ) {
smf_lock_data( pdata->data, 1, status );
smf_close_file( &(pdata->data), status );
}
astLock( pdata->abskyfrm, 0 );
pdata->abskyfrm = astAnnul( pdata->abskyfrm );
astLock( pdata->sky2map, 0 );
pdata->sky2map = astAnnul( pdata->sky2map );
}
job_data = astFree( job_data );
}
}
void smurf_unmakecube( int *status ) {
/* Local Variables */
AstFrame *tfrm = NULL; /* Current Frame from input WCS */
AstFrameSet *wcsin = NULL; /* WCS Frameset for input cube */
AstMapping *tmap = NULL; /* Base->current Mapping from input WCS */
AstSkyFrame *iskyfrm = NULL; /* SkyFrame from the input WCS Frameset */
Grp *detgrp = NULL; /* Group of detector names */
Grp *igrp1 = NULL; /* Group of input sky cube files */
Grp *igrp2 = NULL; /* Group of input template files */
Grp *ogrp = NULL; /* Group containing output file */
NdgProvenance *oprov = NULL;/* Provenance for the output NDF */
SkyCube *sky_cubes = NULL; /* Pointer to array of sky cube descriptions */
SkyCube *skycube = NULL; /* Pointer to next sky cube description */
char pabuf[ 10 ]; /* Text buffer for parameter value */
double params[ 4 ]; /* astResample parameters */
int axes[ 2 ]; /* Indices of selected axes */
int blank; /* Was a blank line just output? */
int flag; /* Was the group expression flagged? */
int ifile; /* Input file index */
int interp = 0; /* Pixel interpolation method */
int iskycube; /* Index of current sky cube */
int nel; /* Number of elements in 3D array */
int nparam = 0; /* No. of parameters required for interpolation scheme */
int ondf; /* Output time series NDF identifier */
int outax[ 2 ]; /* Indices of corresponding output axes */
int overlap; /* Does time series overlap sky cube? */
int sdim[3]; /* Array of significant pixel axes */
int usedetpos; /* Should the detpos array be used? */
size_t ndet; /* Number of detectors supplied for "DETECTORS" */
size_t nskycube; /* Number of supplied sky cubes */
size_t outsize; /* Number of files in output group */
size_t size; /* Number of files in input group */
smfData *data = NULL; /* Pointer to data struct */
void *in_data = NULL; /* Pointer to the input cube data array */
void *out_data = NULL; /* Pointer to the output cube data array */
#if defined(FPTRAP)
feenableexcept(FE_DIVBYZERO|FE_INVALID|FE_OVERFLOW);
#endif
/* Check inherited status */
if( *status != SAI__OK ) return;
/* We have not yet displayed a blank line on stdout. */
blank = 0;
/* Begin an AST context */
astBegin;
/* Begin an NDF context. */
ndfBegin();
/* Get a group holding the input sky cubes. */
kpg1Rgndf( "IN", 0, 1, "", &igrp1, &nskycube, status );
/* Create an array of structures to hold information about each input sky
cube. */
sky_cubes = astMalloc( sizeof( SkyCube )*(size_t) nskycube );
/* Store a description of each sky cube. */
if( sky_cubes ) {
for( iskycube = 0; iskycube < nskycube; iskycube++ ) {
skycube = sky_cubes + iskycube;
/* Get an NDF identifier for the next sky cube. */
ndgNdfas( igrp1, iskycube + 1, "READ", &(skycube->indf), status );
/* Get the WCS FrameSet from the sky cube, together with its pixel index
bounds. */
kpg1Asget( skycube->indf, 3, 0, 1, 1, sdim, skycube->slbnd,
skycube->subnd, &wcsin, status );
/* Get the base->current Mapping from the input WCS FrameSet, and split it
into two Mappings; one (iskymap) that maps the first 2 GRID axes into
celestial sky coordinates, and one (ispecmap) that maps the third GRID
axis into a spectral coordinate. Also extract the SpecFrame and
SkyFrame from the current Frame. */
tmap = astGetMapping( wcsin, AST__BASE, AST__CURRENT );
tfrm = astGetFrame( wcsin, AST__CURRENT );
axes[ 0 ] = 1;
axes[ 1 ] = 2;
astMapSplit( tmap, 2, axes, outax, &(skycube->iskymap) );
iskyfrm = astPickAxes( tfrm, 2, outax, NULL );
axes[ 0 ] = 3;
astMapSplit( tmap, 1, axes, outax, &(skycube->ispecmap) );
skycube->ispecfrm = astPickAxes( tfrm, 1, outax, NULL );
/* Create a copy of "iskyfrm" representing absolute coords rather than
offsets. We assume the target is moving if the cube represents offsets. */
skycube->abskyfrm = astCopy( iskyfrm );
astClear( skycube->abskyfrm, "SkyRefIs" );
skycube->moving = ( *status == SAI__OK &&
!strcmp( astGetC( iskyfrm, "SkyRefIs" ),
"Origin" ) ) ? 1 : 0;
/* Invert the Mappings (for the convenience of smf_resamplecube), so
that they go from current Frame to grid axis. */
astInvert( skycube->ispecmap );
astInvert( skycube->iskymap );
/* For efficiency, annul manually the unneeded AST objects created in
this loop. */
wcsin = astAnnul( wcsin );
tmap = astAnnul( tmap );
tfrm = astAnnul( tfrm );
iskyfrm = astAnnul( iskyfrm );
}
}
/* See if the detector positions are to be read from the RECEPPOS array
in the template NDFs. Otherwise, they are calculated on the basis of
the FPLANEX/Y arrays. */
parGet0l( "USEDETPOS", &usedetpos, status );
/* Get the detectors to use. If a null value is supplied, annull the
error. Otherwise, make the group case insensitive. */
detgrp = NULL;
if( *status == SAI__OK ) {
kpg1Gtgrp( "DETECTORS", &detgrp, &ndet, status );
if( *status == PAR__NULL ) {
errAnnul( status );
if (detgrp) {
grpDelet( &detgrp, status );
}
} else {
grpSetcs( detgrp, 0, status );
}
}
/* Get the pixel interpolation scheme to use. */
parChoic( "INTERP", "NEAREST", "NEAREST,LINEAR,SINC,"
"SINCSINC,SINCCOS,SINCGAUSS,SOMB,SOMBCOS",
1, pabuf, 10, status );
if( !strcmp( pabuf, "NEAREST" ) ) {
interp = AST__NEAREST;
nparam = 0;
} else if( !strcmp( pabuf, "LINEAR" ) ) {
interp = AST__LINEAR;
nparam = 0;
} else if( !strcmp( pabuf, "SINC" ) ) {
interp = AST__SINC;
nparam = 1;
} else if( !strcmp( pabuf, "SINCSINC" ) ) {
interp = AST__SINCSINC;
nparam = 2;
} else if( !strcmp( pabuf, "SINCCOS" ) ) {
interp = AST__SINCCOS;
nparam = 2;
} else if( !strcmp( pabuf, "SINCGAUSS" ) ) {
interp = AST__SINCGAUSS;
nparam = 2;
} else if( !strcmp( pabuf, "SOMB" ) ) {
interp = AST__SOMB;
nparam = 1;
} else if( !strcmp( pabuf, "SOMBCOS" ) ) {
interp = AST__SOMBCOS;
nparam = 2;
} else if( *status == SAI__OK ) {
nparam = 0;
*status = SAI__ERROR;
msgSetc( "V", pabuf );
errRep( "", "Support not available for INTERP = ^V (programming "
"error)", status );
}
/* Get an additional parameter vector if required. */
if( nparam > 0 ) parExacd( "PARAMS", nparam, params, status );
/* Get a group of reference time series files to use as templates for
the output time series files.*/
ndgAssoc( "REF", 1, &igrp2, &size, &flag, status );
/* Create a group holding the names of the corresponding output NDFs. */
ndgCreat ( "OUT", igrp2, &ogrp, &outsize, &flag, status );
if( outsize != size && *status == SAI__OK ) {
*status = SAI__ERROR;
msgSeti( "O", outsize );
msgSeti( "I", size );
errRep( "", "Numbers of input reference cubes (^I) and output "
"cubes (^O) differ.", status );
}
/* Loop round all the template time series files. */
for( ifile = 1; ifile <= size && *status == SAI__OK; ifile++ ) {
/* Start a new NDF context. */
ndfBegin();
/* Obtain information about the current template NDF, but do not map the
arrays. */
smf_open_file( igrp2, ifile, "READ", SMF__NOCREATE_DATA, &data, status );
/* Issue a suitable message and abort if anything went wrong. */
if( *status != SAI__OK ) {
errRep( FUNC_NAME, "Could not open input template file.", status );
break;
} else {
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;
}
}
/* Report the name of the input template. */
smf_smfFile_msg( data->file, "FILE", 1, "<unknown>" );
msgSeti( "THISFILE", ifile );
msgSeti( "NUMFILES", size );
msgOutif( MSG__NORM, " ", "Simulating ^THISFILE/^NUMFILES ^FILE",
status );
/* Create the output NDF by propagation from the input template NDF.
Everything is copied except for the array components and any PROVENANCE
extension. */
ndgNdfpr( data->file->ndfid, "TITLE,LABEL,UNITS,AXIS,WCS,HISTORY,"
"NOEXTENSION(PROVENANCE)", ogrp, ifile, &ondf, status );
/* Ensure the output NDF has a history component. */
ndfHcre( ondf, status );
/* Get a pointer to the mapped output data array. Set all values bad. */
ndfMap( ondf, "DATA", "_REAL", "WRITE/BAD", &out_data, &nel, status );
/* If the detector positions are to calculated on the basis of FPLANEX/Y
rather than detpos, then free the detpos array in the templates smfHead
structure. This will cause smf_tslice_ast to use the fplanex/y values. */
if( !usedetpos && data->hdr->detpos ) {
astFree( (double *) data->hdr->detpos );
data->hdr->detpos = NULL;
}
/* Get a pointer to a structure holding provenance information for the
output time series. */
oprov = ndgReadProv( ondf, "SMURF:UNMAKECUBE", status );
/* Record details of the template in the provenance structure for the
output time series. */
ndgPutProv( oprov, data->file->ndfid, NULL, 0, status );
/* Loop round all input sky cubes. */
for( iskycube = 0; iskycube < nskycube; iskycube++ ) {
skycube = sky_cubes + iskycube;
/* Record details of the input cube in the provenance extension of the
output time series. */
ndgPutProv( oprov, skycube->indf, NULL, 0, status );
/* See if the current time series overlaps the current sky cube. */
smf_resampcube( data, skycube->abskyfrm,
skycube->iskymap, skycube->ispecfrm,
skycube->ispecmap, detgrp, skycube->moving,
skycube->slbnd, skycube->subnd, interp,
params, NULL, NULL, &overlap, status );
/* If not, pass on to the next sky cube. */
if( overlap ) {
/* Report the name of the sky cube. */
ndfMsg( "NDF", skycube->indf );
msgOutif( MSG__NORM, " ", " Re-sampling ^NDF", status );
/* Map the data array in the current sky cube. */
ndfMap( skycube->indf, "DATA", "_REAL", "READ", &in_data, &nel,
status );
/* Resample the cube data into the output time series. */
smf_resampcube( data, skycube->abskyfrm,
skycube->iskymap, skycube->ispecfrm,
skycube->ispecmap, detgrp, skycube->moving,
skycube->slbnd, skycube->subnd, interp,
params, in_data, out_data, &overlap, status );
/* Unmap the data array. */
ndfUnmap( skycube->indf, "DATA", status );
}
}
/* Write the provenance structure to the output NDF, and then free it. */
ndgWriteProv( oprov, ondf, 1, status );
oprov =ndgFreeProv( oprov, status );
/* Close the input time series file. */
if( data != NULL ) {
smf_close_file( &data, status );
data = NULL;
}
/* End the NDF context. */
ndfEnd( status );
}
/* Close any input data file that is still open due to an early exit from
the above loop. */
if( data != NULL ) {
smf_close_file( &data, status );
data = NULL;
}
/* Free remaining resources. */
if( detgrp != NULL) grpDelet( &detgrp, status);
if( igrp1 != NULL) grpDelet( &igrp1, status);
if( igrp2 != NULL) grpDelet( &igrp2, status);
if( ogrp != NULL) grpDelet( &ogrp, status);
sky_cubes = astFree( sky_cubes );
/* End the NDF context. */
ndfEnd( status );
/* End the tile's AST context. */
astEnd;
/* Issue a status indication.*/
if( *status == SAI__OK ) {
msgOutif(MSG__VERB," ",TASK_NAME " succeeded, time series written.", status);
} else {
msgOutif(MSG__VERB," ",TASK_NAME " failed.", status);
}
}
void smf_mapbounds_approx( Grp *igrp, size_t index, char *system,
int *lbnd_out, int *ubnd_out, AstFrameSet **outframeset,
int *moving, int *status ) {
/* Local variables */
smfData *data = NULL; /* pointer to SCUBA2 data struct */
int dxpix; /* Map X offset in pixels */
int dypix; /* Map Y offset in pixels */
smfFile *file = NULL; /* SCUBA2 data file information */
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 */
double hghtbox; /* Map height in arcsec */
int hghtpix; /* RA-Dec map height in pixels */
int i; /* loop counter */
dim_t k; /* Loop counter */
double maphght = 0.0; /* Map height in radians */
double mappa = 0.0; /* Map position angle in radians */
double mapwdth = 0.0; /* Map width in radians */
double mapx; /* Map X offset in radians */
double mapy; /* Map Y offset in radians */
double par[7]; /* Projection parameters */
double pixsize = 0.0; /* Requested pixel size */
double shift[ 2 ]; /* Shifts from PIXEL to GRID coords */
AstMapping *sky2map = NULL; /* Mapping celestial->map coordinates */
AstSkyFrame *skyframe = NULL;/* Output SkyFrame */
AstFrame *skyin = NULL; /* Sky Frame in input FrameSet */
double skyref[ 2 ]; /* Values for output SkyFrame SkyRef attribute */
AstFrameSet *swcsin = NULL; /* FrameSet describing input WCS */
int temp; /* Temporary variable */
double wdthbox; /* Map width in arcsec */
int wdthpix; /* RA-Dec map width in pixels */
double x_array_corners[4]; /* X-Indices for corner bolos in array */
double y_array_corners[4]; /* Y-Indices for corner pixels in array */
/* Main routine */
if (*status != SAI__OK) return;
/* Begin an AST context to ensure that all AST objects are annuled
before returning to caller */
astBegin;
/* Initialize output frameset pointer to NULL */
*outframeset = NULL;
for( i = 0; i < 7; i++ ) par[ i ] = AST__BAD;
/* Read data from the given input file in the group - note index
should be 1 as we use the first file in the Grp to define the map
bounds */
smf_open_file( igrp, index, "READ", SMF__NOCREATE_DATA, &data, status );
/* Simply abort if it is not a scan */
if (*status == SAI__OK && data->hdr->obsmode != SMF__OBS_SCAN) {
*status = SAI__ERROR;
errRep(" ", "Can not call smf_mapbounds_approx with non-scan observation"
" (possible programming error)", status);
goto CLEANUP;
}
/* Retrieve file name for use feedback */
file = data->file;
smf_smfFile_msg( file, "FILE", 1, "<unknown>" );
if( *status == SAI__OK ) {
msgOutif(MSG__VERB, " ",
"SMF_MAPBOUNDS_APPROX: Processing ^FILE",
status);
} else {
errRep( "smf_mapbounds_approx", "Couldn't open input file, ^FILE", status );
}
/* Check that the data dimensions are 3 (for time ordered data) */
if( *status == SAI__OK ) {
if( data->ndims != 3 ) {
smf_smfFile_msg( file, "FILE", 1, "<unknown>" );
msgSeti("THEDIMS", data->ndims);
*status = SAI__ERROR;
errRep("smf_mapbounds_approx",
"^FILE data has ^THEDIMS dimensions, should be 3.",
status);
}
}
/* Construct the WCS for the first time slice in this file */
smf_tslice_ast( data, 1, 1, NO_FTS, status);
/* Retrieve header for later constructing output WCS */
if( *status == SAI__OK) {
hdr = data->hdr;
swcsin = hdr->wcs;
/* Calculate default pixel size */
pixsize = smf_calc_telres( hdr->fitshdr, status );
/* Get the user defined pixel size - we trust that smf_get_projpar will
also read PIXSIZE and get the same answer. We pre-fill par[] to allow
PIXSIZE=! to accept the dynamic default in both places.*/
parGdr0d( "PIXSIZE", pixsize, 0, 60, 1, &pixsize, status );
par[4] = pixsize*AST__DD2R/3600.0;
par[5] = par[4];
/* Retrieve input SkyFrame */
skyin = astGetFrame( swcsin, AST__CURRENT );
/* Retrieve map height and width from header - will be undef for
non-scan so set up defaults first. */
mapwdth = 0.0;
maphght = 0.0;
smf_getfitsd( hdr, "MAP_WDTH", &mapwdth, status );
smf_getfitsd( hdr, "MAP_HGHT", &maphght, status );
/* Make an approximation if map height and width are not set -
note that this should ONLY apply for non-scan mode data */
if ( !mapwdth || !maphght ) {
if (*status == SAI__OK) {
*status = SAI__ERROR;
errRep(" ", "MAP_WDTH and MAP_HGHT must be > 0", status);
goto CLEANUP;
}
}
mapx = 0.0; /* Used if the FITS keyword values are undefed */
mapy = 0.0;
smf_getfitsd( hdr, "MAP_X", &mapx, status );
smf_getfitsd( hdr, "MAP_Y", &mapy, status );
/* Convert map Position Angle to radians */
mappa = 0.0;
smf_fits_getD( hdr, "MAP_PA", &mappa, status );
mappa *= AST__DD2R;
/* Calculate size of output map in pixels */
/* Note: this works for the simulator... */
wdthbox = mapwdth*fabs(cos(mappa)) + maphght*fabs(sin(mappa));
hghtbox = maphght*fabs(cos(mappa)) + mapwdth*fabs(sin(mappa));
wdthpix = (int) ( wdthbox / pixsize);
hghtpix = (int) ( wdthbox / pixsize);
dxpix = (int) (mapx / pixsize);
dypix = (int) (mapy / pixsize);
/* Get the offsets for each corner of the array */
temp = (wdthpix - 1) / 2;
x_array_corners[0] = dxpix - temp;
x_array_corners[1] = dxpix - temp;
x_array_corners[2] = dxpix + temp;
x_array_corners[3] = dxpix + temp;
temp = (hghtpix - 1) / 2;
y_array_corners[0] = dypix - temp;
y_array_corners[1] = dypix + temp;
y_array_corners[2] = dypix - temp;
y_array_corners[3] = dypix + temp;
lbnd_out[0] = x_array_corners[0];
ubnd_out[0] = x_array_corners[0];
lbnd_out[1] = y_array_corners[0];
ubnd_out[1] = y_array_corners[0];
/* Update min/max */
for( k=0; k<4; k++ ) {
if( x_array_corners[k] < lbnd_out[0] ) lbnd_out[0] = x_array_corners[k];
if( y_array_corners[k] < lbnd_out[1] ) lbnd_out[1] = y_array_corners[k];
if( x_array_corners[k] > ubnd_out[0] ) ubnd_out[0] = x_array_corners[k];
if( y_array_corners[k] > ubnd_out[1] ) ubnd_out[1] = y_array_corners[k];
}
} else {
goto CLEANUP;
}
/* Now create the output FrameSet. */
smf_calc_skyframe( skyin, system, hdr, 0, &skyframe, 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. */
mappa = smf_calc_mappa( hdr, system, skyin, status );
/* 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( skyframe, skyref, *moving, 0, 0, NULL, 0,
mappa, par, NULL, NULL, status );
/* 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( skyframe, "System"), &(par[0]),
&(par[2]), &(par[4]), par[6], fitschan, status );
astClear( fitschan, "Card" );
fs = astRead( fitschan );
/* Extract the output PIXEL->SKY Mapping - note this is will be
inverted later to create the sk2map mapping */
sky2map = astGetMapping( fs, AST__BASE, AST__CURRENT );
/* Create the output FrameSet */
*outframeset = astFrameSet( astFrame(2, "Domain=GRID"), " " );
/* Now add the SkyFrame to it */
astAddFrame( *outframeset, AST__BASE, sky2map, skyframe );
/* Apply a ShiftMap to the output FrameSet to re-align the GRID
coordinates */
shift[0] = -lbnd_out[0];
shift[1] = -lbnd_out[1];
astRemapFrame( *outframeset, AST__BASE, astShiftMap( 2, shift, " " ) );
astExport( *outframeset );
/* 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 );
}
/* Change the pixel bounds to be consistent with the new CRPIX */
ubnd_out[0] -= lbnd_out[0]-1;
lbnd_out[0] = 1;
ubnd_out[1] -= lbnd_out[1]-1;
lbnd_out[1] = 1;
/* Clean Up */
CLEANUP:
if (*status != SAI__OK) {
errRep(FUNC_NAME, "Unable to determine map bounds", status);
}
if( data != NULL )
smf_close_file( &data, status);
astEnd;
}
/* Returns an array holding the angle (rad.s) from north to focal plane Y,
measured positive in the sense of rotation from focal plane Y to focal
plane X, for every bolometer sample in a smfData. The values are bolo
ordered so that "bstride" is 1 and "tstsride" is nbolo. The returned
array should be freed using astFre when no longer needed. */
static double *smf1_calcang( smfData *data, int *status ){
/* Local Variables: */
AstFrameSet *fpfset;
AstFrameSet *wcs;
AstMapping *g2s;
AstMapping *s2f;
const char *usesys;
dim_t ibolo;
dim_t itime;
dim_t nbolo;
dim_t ncol;
dim_t ntslice;
double *fx2;
double *fx;
double *fy2;
double *fy;
double *gx;
double *gy;
double *pr;
double *result;
double *sx;
double *sy;
int subsysnum;
/* Check the inherited status. */
if( *status != SAI__OK ) return NULL;
/* Get the number of bolometers and time slices, together with the strides
between adjacent bolometers and adjacent time slices. */
smf_get_dims( data, NULL, &ncol, &nbolo, &ntslice, NULL, NULL, NULL,
status );
/* Allocate the returned array. */
result = astMalloc( nbolo*ntslice*sizeof( *result ) );
/* Allocate arrays to hold the grid coords for every bolometer. */
gx = astMalloc( nbolo*sizeof( *gx ) );
gy = astMalloc( nbolo*sizeof( *gy ) );
/* Allocate arrays to hold the sky coords for every bolometer. */
sx = astMalloc( nbolo*sizeof( *sx ) );
sy = astMalloc( nbolo*sizeof( *sy ) );
/* Allocate arrays to hold the focal plane coords for every bolometer. */
fx = astMalloc( nbolo*sizeof( *fx ) );
fy = astMalloc( nbolo*sizeof( *fy ) );
/* Allocate arrays to hold the focal plane coords of a point slightly to
the north of every bolometer. */
fx2 = astMalloc( nbolo*sizeof( *fx2 ) );
fy2 = astMalloc( nbolo*sizeof( *fy2 ) );
/* Get the AST code equivalent to the tracking system. */
usesys = sc2ast_convert_system( (data->hdr->allState)[0].tcs_tr_sys, status );
if( *status == SAI__OK ) {
/* Initialise the arrays holding the grid coords for every bolometer. */
for( ibolo = 0; ibolo < nbolo; ibolo++ ) {
gx[ ibolo ] = ibolo % ncol + 1;
gy[ ibolo ] = ibolo / ncol + 1;
}
/* Get the GRID->focal plane FrameSet (the same for every time slice). */
smf_find_subarray( data->hdr, NULL, 0, &subsysnum, status );
sc2ast_createwcs( subsysnum, NULL, data->hdr->instap, data->hdr->telpos,
NO_FTS, &fpfset, status);
/* Use this to transform the bolometrer GRID coords to focal plane. */
astTran2( fpfset, nbolo, gx, gy, 1, fx, fy );
/* Loop over all time slices. */
pr = result;
for( itime = 0; itime < ntslice; itime++ ) {
/* Get the WCS FrameSet for the time slice, and set its current Frame to the tracking
frame. */
smf_tslice_ast( data, itime, 1, NO_FTS, status );
wcs = data->hdr->wcs;
if( wcs ) {
astSetC( wcs, "System", usesys );
/* Get the mapping from GRID to SKY. */
astBegin;
g2s = astSimplify( astGetMapping( wcs, AST__BASE, AST__CURRENT ));
/* Get the mapping from SKY to focal plane (x,y) (the index of the FPLANE
Frame is fixed at 3 by file sc2ast.c). */
s2f = astSimplify( astGetMapping( wcs, AST__CURRENT, 3 ) );
/* Transform the grid coords of all bolometers to SKY coordinates using the FrameSet. */
astTran2( g2s, nbolo, gx, gy, 1, sx, sy );
/* Increment the sky positions slightly to the north. */
for( ibolo = 0; ibolo < nbolo; ibolo++ ) sy[ ibolo ] += 1.0E-6;
/* Transform these modified sky coordinates to focal plane. */
astTran2( s2f, nbolo, sx, sy, 1, fx2, fy2 );
astEnd;
/* Loop round all bolometers. */
for( ibolo = 0; ibolo < nbolo; ibolo++ ) {
/* Get the angle from north to focal plane Y, measured positive in the
sense of rotation from focal plane Y to focal plane X. */
if( fx[ibolo] != VAL__BADD && fy[ibolo] != VAL__BADD &&
fx2[ibolo] != VAL__BADD && fy2[ibolo] != VAL__BADD ) {
*(pr++) = atan2( fx[ibolo] - fx2[ibolo], fy2[ibolo] - fy[ibolo] );
} else {
*(pr++) = VAL__BADD;
}
}
} else {
for( ibolo = 0; ibolo < nbolo; ibolo++ ) *(pr++) = VAL__BADD;
}
}
}
/* Free resources. */
fx = astFree( fx );
fy = astFree( fy );
fx2 = astFree( fx2 );
fy2 = astFree( fy2 );
sx = astFree( sx );
sy = astFree( sy );
gx = astFree( gx );
gy = astFree( gy );
/* Return the array of angle values. */
return result;
}
void clumpinfo( int *status ) {
/*
*+
* Name:
* CLUMPINFO
* Purpose:
* Obtain information about one or more previously identified clumps.
* Language:
* C
* Type of Module:
* ADAM A-task
* Description:
* This application returns various items of information about a
* single clump, or a collection of clumps, previously identified
* using FINDCLUMPS or EXTRACTCLUMPS.
* Usage:
* clumpinfo ndf clumps quiet
* ADAM Parameters:
* CLUMPS = LITERAL (Read)
* Specifies the indices of the clumps to be included in the
* returned information. It can take any of the following values:
*
* - "ALL" or "*" -- All clumps.
*
* - "xx,yy,zz" -- A list of clump indices.
*
* - "xx:yy" -- Clump indices between xx and yy inclusively. When
* xx is omitted the range begins from one; when yy is omitted the
* range ends with the final clump index.
*
* - Any reasonable combination of above values separated by
* commas.
* FLBND( ) = _DOUBLE (Write)
* The lower bounds of the bounding box enclosing the selected
* clumps in the current WCS Frame of the input NDF. Celestial axis
* values are always in units of radians, but spectral axis units
* will be in the spectral units used by the current WCS Frame.
* FUBND( ) = _DOUBLE (Write)
* The upper bounds of the bounding box enclosing the selected
* clumps. See parameter FLBND for more details.
* LBOUND( ) = _INTEGER (Write)
* The lower pixel bounds of bounding box enclosing the selected
* clumps.
* NCLUMPS = _INTEGER (Write)
* The total number of clumps descrriptions stored within the supplied
* NDF.
* NDF = NDF (Read)
* The NDF defining the previously identified clumps. This
* should contain a CUPID extension describing all the identified
* clumps, in the format produced by FINDCLUMPS or EXTRACTCLUMPS.
* QUIET = _LOGICAL (Read)
* If TRUE, then no information is written out to the screen,
* although the output parameters are still assigned values. [FALSE]
* UBOUND( ) = _INTEGER (Write)
* The upper pixel bounds of bounding box enclosing the selected
* clumps.
* Notes:
* - It is hoped to extend the range of information reported by this
* application as new requirements arise.
* Synopsis:
* void clumpinfo( int *status );
* Copyright:
* Copyright (C) 2007 Particle Physics & Astronomy Research Council.
* All Rights Reserved.
* Licence:
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License as
* published by the Free Software Foundation; either version 2 of
* the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be
* useful, but WITHOUT ANY WARRANTY; without even the implied
* warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
* PURPOSE. See the GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street,Fifth Floor, Boston, MA
* 02110-1301, USA
* Authors:
* DSB: David S. Berry
* {enter_new_authors_here}
* History:
* 22-MAR-2007 (DSB):
* Original version.
* {enter_further_changes_here}
* Bugs:
* {note_any_bugs_here}
*-
*/
/* Local Variables: */
AstFrame *cfrm; /* Pointer to current WCS Frame */
AstMapping *cmap; /* Pointer to PIXEL->current Frame Mapping */
CupidClumpInfo info; /* Structure holding returned information */
Grp *grp = NULL; /* GRP group holding input NDF name */
HDSLoc *aloc = NULL; /* Locator for CLUMPS array in CUPID extension */
HDSLoc *cloc = NULL; /* Locator for a single CLUMP structure */
HDSLoc *xloc = NULL; /* Locator for CUPID extension */
char *p; /* Pointer into tmpstr string */
char tmpstr[ 100 ]; /* Buffer for temporary strings */
const char *dom; /* Pointer to axis Domain name */
double flbnd[ NDF__MXDIM ]; /* Lower bounds of WCS bounding box */
double fubnd[ NDF__MXDIM ]; /* Upper bounds of WCS bounding box */
double plbnd[ NDF__MXDIM ]; /* Lower bounds of PIXEL bounding box */
double pubnd[ NDF__MXDIM ]; /* Upper bounds of PIXEL bounding box */
int *clump_flags = NULL; /* Flags indicating if each clump is to be used */
int *clump_indices = NULL;/* List of indices of clumps to be used */
int i; /* Loop count */
int iclump; /* One-based clump index */
int indf; /* NDF identifier for input NDF */
int ipix; /* Index of PIXEL Frame */
size_t nclumps; /* No. of clump descriptions within the supplied NDF */
int nuse; /* Number of clumps to be used */
int primary; /* Value for locator primary flag */
int quiet; /* Supress screen output? */
size_t size; /* Number of values in group "*grp" */
int there; /* Does the enquired object exist? */
/* Abort if an error has already occurred. */
if( *status != SAI__OK ) return;
/* Begin an AST context */
astBegin;
/* Start an NDF context */
ndfBegin();
/* Obtain the input NDF and get a locator for the array of clump
descriptions within it.
----------------------------------------------------------------- */
/* Get an identifier for the input NDF. We use NDG (via kpg1_Rgndf)
instead of calling ndfAssoc directly since NDF/HDS has problems with
file names containing spaces, which NDG does not have. */
kpg1Rgndf( "NDF", 1, 1, "", &grp, &size, status );
ndgNdfas( grp, 1, "READ", &indf, status );
grpDelet( &grp, status );
/* Check the NDF has a suitable CUPID extension containing an array of
clump cut-outs. Get an HDS locator for the array. */
ndfXstat( indf, "CUPID", &there, status );
if( !there ) {
if( *status == SAI__OK ) {
*status = SAI__ERROR;
ndfMsg( "NDF", indf );
errRep( "", "The NDF \"^NDF\" does not contain a CUPID extension "
"such as created by FINDCLUMPS or EXTRACTCLUMPS.", status );
}
} else {
ndfXloc( indf, "CUPID", "READ", &xloc, status );
datThere( xloc, "CLUMPS", &there, status );
if( !there ) {
if( *status == SAI__OK ) {
*status = SAI__ERROR;
ndfMsg( "NDF", indf );
errRep( "", "The CUPID extension within NDF \"^NDF\" does not "
"contain an array of clumps such as created by "
"FINDCLUMPS or EXTRACTCLUMPS.", status );
}
} else {
datFind( xloc, "CLUMPS", &aloc, status );
primary = 1;
datPrmry( 1, &aloc, &primary, status );
}
datAnnul( &xloc, status );
}
/* Abort if we have no clumps array locator, or if an error occurred. */
if( !aloc || *status != SAI__OK ) goto L999;
/* Calculate the required clump information, and store it in the "info"
structure.
----------------------------------------------------------------- */
/* Indicate that the structure holding the returned information has not
yet been initialised. */
info.init = 0;
/* Get the WCS FrameSet from the input NDF, and store a pointer to it in
the "info" structure. */
kpg1Gtwcs( indf, &(info.iwcs), status );
/* Get the number of clumps defined within the input NDF. */
datSize( aloc, &nclumps, status );
/* Get the list of clump indices to iclude in the returned information. */
clump_flags = astMalloc( sizeof( int )*nclumps );
clump_indices = astMalloc( sizeof( int )*nclumps );
kpg1Gilst( 1, (int) nclumps, (int) nclumps, "CLUMPS", clump_flags, clump_indices,
&nuse, status );
/* Loop round all clumps that are to be used. */
for( i = 0; i < nuse && *status == SAI__OK; i++ ) {
iclump = clump_indices[ i ];
/* Get a locator for this clump. */
datCell( aloc, 1, &iclump, &cloc, status );
/* Update the returned information to include this clump. */
cupidClumpInfo1( cloc, &info, status );
/* Annul the clump structure locator. */
datAnnul( &cloc, status );
}
/* Write out the information to the screen and to appropriate output
parameters.
----------------------------------------------------------------- */
/* See if screen output is required. */
parGet0l( "QUIET", &quiet, status );
if( !quiet ) msgBlank( status );
/* The number of clumps defined within the input NDF... */
parPut0i( "NCLUMPS", (int) nclumps, status );
if( ! quiet ) {
msgSeti( "NCLUMPS", (int) nclumps );
msgOut( "", " Total no. of clumps: ^NCLUMPS", status );
}
/* Pixel index bounding box... */
parPut1i( "LBOUND", info.npix, info.lbnd, status );
parPut1i( "UBOUND", info.npix, info.ubnd, status );
if( !quiet ) {
p = tmpstr + sprintf( tmpstr, "( " );
for( i = 0; i < info.npix; i++) {
p += sprintf( p, "%d:%d", info.lbnd[ i ], info.ubnd[ i ] );
if( i < info.npix - 1 ) p += sprintf( p, ", " );
}
p += sprintf( p, " )" );
msgSetc( "SECTION", tmpstr );
msgOut( "", " Pixel index bounding box: ^SECTION", status );
}
/* WCS bounding box (first convert the pixel index bounding box into WCS
coords)... */
cfrm = astGetFrame( info.iwcs, AST__CURRENT );
kpg1Asffr( info.iwcs, "PIXEL", &ipix, status );
cmap = astGetMapping( info.iwcs, ipix, AST__CURRENT );
for( i = 0; i < info.npix; i++ ) {
plbnd[ i ] = info.lbnd[ i ] - 1.0;
pubnd[ i ] = info.ubnd[ i ];
}
for( i = 0; i < info.nwcs; i++ ) {
astMapBox( cmap, plbnd, pubnd, 1, i + 1, flbnd + i, fubnd + i,
NULL, NULL);
}
astNorm( cfrm, flbnd );
astNorm( cfrm, fubnd );
parPut1d( "FLBND", info.nwcs, flbnd, status );
parPut1d( "FUBND", info.nwcs, fubnd, status );
if( !quiet ) {
msgOut( "", " WCS bounding box:", status );
for( i = 0; i < info.nwcs; i++) {
msgSetc( "L", astFormat( cfrm, i + 1, flbnd[ i ] ) );
msgSetc( "U", astFormat( cfrm, i + 1, fubnd[ i ] ) );
sprintf( tmpstr, "Domain(%d)", i + 1 );
dom = astGetC( cfrm, tmpstr );
if( dom && strcmp( dom, "SKY" ) ) {
sprintf( tmpstr, "Unit(%d)", i + 1 );
msgSetc( "UNT", astGetC( cfrm, tmpstr ) );
} else {
msgSetc( "UNT", "" );
}
sprintf( tmpstr, "Label(%d)", i + 1 );
msgSetc( "LAB", astGetC( cfrm, tmpstr ) );
msgOut( "", " ^LAB: ^L -> ^U ^UNT", status );
}
}
if( !quiet ) msgBlank( status );
/* Tidy up.
-------- */
L999:
;
/* Free resources. */
clump_flags = astFree( clump_flags );
clump_indices = astFree( clump_indices );
if( aloc ) datAnnul( &aloc, status );
/* End the NDF context */
ndfEnd( status );
/* End the AST context */
astEnd;
/* If an error has occurred, issue another error report identifying the
program which has failed (i.e. this one). */
if( *status != SAI__OK ) {
errRep( "CLUMPINFO_ERR", "CLUMPINFO: Failed to obtain information "
"about one or more previously identified clumps.", status );
}
}
void smurf_unmakemap( int *status ) {
/* Local Variables */
AstFrameSet *wcsin = NULL; /* WCS Frameset for input cube */
AstMapping *skymap; /* GRID->SkyFrame Mapping from input WCS */
AstSkyFrame *abskyfrm; /* Input SkyFrame (always absolute) */
AstSkyFrame *skyfrm = NULL;/* SkyFrame from the input WCS Frameset */
Grp *igrp1 = NULL; /* Group of input sky files */
Grp *igrp2 = NULL; /* Group of input template files */
Grp *igrpc = NULL; /* Group of input COM files */
Grp *igrpg = NULL; /* Group of input GAI files */
Grp *igrpq = NULL; /* Group of input Q sky files */
Grp *igrpu = NULL; /* Group of input U sky files */
Grp *ogrp = NULL; /* Group containing output file */
HDSLoc *cloc = NULL; /* HDS locator for component ipdata structure */
HDSLoc *iploc = NULL; /* HDS locator for top level ipdata structure */
ThrWorkForce *wf = NULL; /* Pointer to a pool of worker threads */
char ipdata[ 200 ]; /* Text buffer for IPDATA value */
char pabuf[ 10 ]; /* Text buffer for parameter value */
char subarray[ 5 ]; /* Name of SCUBA-2 subarray (s8a,s8b,etc) */
dim_t iel; /* Index of next element */
dim_t ndata; /* Number of elements in array */
dim_t ntslice; /* Number of time slices in array */
double *ang_data = NULL; /* Pointer to the FP orientation angles */
double *angc_data = NULL; /* Pointer to the instrumental ANGC data */
double *c0_data = NULL; /* Pointer to the instrumental C0 data */
double *gai_data = NULL; /* Pointer to the input GAI map */
double *in_data = NULL; /* Pointer to the input I sky map */
double *inc_data = NULL; /* Pointer to the input COM data */
double *inq_data = NULL; /* Pointer to the input Q sky map */
double *inu_data = NULL; /* Pointer to the input U sky map */
double *outq_data = NULL; /* Pointer to the Q time series data */
double *outu_data = NULL; /* Pointer to the U time series data */
double *p0_data = NULL; /* Pointer to the instrumental P0 data */
double *p1_data = NULL; /* Pointer to the instrumental P1 data */
double *pd; /* Pointer to next element */
double *pq = NULL; /* Pointer to next Q time series value */
double *pu = NULL; /* Pointer to next U time series value */
double *qinst_data = NULL; /* Pointer to the instrumental Q data */
double *uinst_data = NULL; /* Pointer to the instrumental U data */
double amp16; /* Amplitude of 16 Hz signal */
double amp2; /* Amplitude of 2 Hz signal */
double amp4; /* Amplitude of 4 Hz signal */
double angrot; /* Angle from focal plane X axis to fixed analyser */
double paoff; /* WPLATE value corresponding to POL_ANG=0.0 */
double params[ 4 ]; /* astResample parameters */
double phase16; /* Phase of 16 Hz signal */
double phase2; /* Phase of 2 Hz signal */
double phase4; /* Phase of 4 Hz signal */
double sigma; /* Standard deviation of noise to add to output */
int alignsys; /* Align data in the map's system? */
int cdims[ 3 ]; /* Common-mode NDF dimensions */
int dims[ NDF__MXDIM ]; /* NDF dimensions */
int flag; /* Was the group expression flagged? */
int gdims[ 3 ]; /* GAI model NDF dimensions */
int harmonic; /* The requested harmonic */
int ifile; /* Input file index */
int indf; /* Input sky map NDF identifier */
int indfangc; /* IP ANGC values NDF identifier */
int indfc0; /* IP C0 values NDF identifier */
int indfc; /* Input COM NDF identifier */
int indfcs; /* NDF identifier for matching section of COM */
int indfg; /* Input GAI NDF identifier */
int indfin; /* Input template cube NDF identifier */
int indfiq; /* Input instrumental Q NDF */
int indfiu; /* Input instrumental U NDF */
int indfout; /* Output cube NDF identifier */
int indfp0; /* IP P0 values NDF identifier */
int indfp1; /* IP P1 values NDF identifier */
int indfq; /* Input Q map NDF identifier */
int indfu; /* Input U map NDF identifier */
int interp = 0; /* Pixel interpolation method */
int lbndc[ 3 ]; /* Array of lower bounds of COM NDF */
int moving; /* Is the telescope base position changing? */
int ndim; /* Number of pixel axes in NDF */
int ndimc; /* Number of pixel axes in common-mode NDF */
int ndimg; /* Number of pixel axes in GAI NDF */
int nel; /* Number of elements in array */
int nelc; /* Number of elements in COM array */
int nelg; /* Number of elements in GAI array */
int nelqu; /* Number of elements in Q or U array */
int ngood; /* No. of good values in putput cube */
int nparam = 0; /* No. of parameters required for interpolation scheme */
int pasign; /* Indicates sense of POL_ANG value */
int sdim[ 2 ]; /* Array of significant pixel axes */
int slbnd[ 2 ]; /* Array of lower bounds of input map */
int subnd[ 2 ]; /* Array of upper bounds of input map */
int ubndc[ 3 ]; /* Array of upper bounds of COM NDF */
size_t ncom; /* Number of com files */
size_t ngai; /* Number of gai files */
size_t nskymap; /* Number of supplied sky cubes */
size_t outsize; /* Number of files in output group */
size_t size; /* Number of files in input group */
smfData *odata = NULL; /* Pointer to output data struct */
/* Check inherited status */
if( *status != SAI__OK ) return;
/* Begin an AST context */
astBegin;
/* Begin an NDF context. */
ndfBegin();
/* Find the number of cores/processors available and create a pool of
threads of the same size. */
wf = thrGetWorkforce( thrGetNThread( SMF__THREADS, status ), status );
/* Get an identifier for the input NDF. We use NDG (via kpg1Rgndf)
instead of calling ndfAssoc directly since NDF/HDS has problems with
file names containing spaces, which NDG does not have. */
kpg1Rgndf( "IN", 1, 1, "", &igrp1, &nskymap, status );
ndgNdfas( igrp1, 1, "READ", &indf, status );
/* Map the data array in the input sky map. */
ndfMap( indf, "DATA", "_DOUBLE", "READ", (void **) &in_data, &nel,
status );
/* Get the WCS FrameSet from the sky map, together with its pixel index
bounds. */
kpg1Asget( indf, 2, 0, 1, 1, sdim, slbnd, subnd, &wcsin, status );
/* Check the current Frame is a SKY frame. */
skyfrm = astGetFrame( wcsin, AST__CURRENT );
if( !astIsASkyFrame( skyfrm ) && *status == SAI__OK ) {
ndfMsg( "N", indf );
*status = SAI__ERROR;
errRep( " ", " Current Frame in ^N is not a SKY Frame.", status );
}
/* Get a copy of the current frame that represents absolute coords rather
than offsets. We assume the target is moving if the map represents
offsets. */
moving = ( *status == SAI__OK &&
!strcmp( astGetC( skyfrm, "SkyRefIs" ), "Origin" ) ) ? 1 : 0;
abskyfrm = astCopy( skyfrm );
astClear( abskyfrm, "SkyRefIs" );
/* If the ALIGNSYS parameter is TRUE then we align the raw data with the
map in the current system of the map, rather than the default ICRS. */
parGet0l( "ALIGNSYS", &alignsys, status );
if( alignsys ) astSetC( abskyfrm, "AlignSystem", astGetC( abskyfrm,
"System" ) );
/* Get the Mapping from the Sky Frame to grid axis in the iput map. */
skymap = astGetMapping( wcsin, AST__CURRENT, AST__BASE );
/* Get the pixel interpolation scheme to use. */
parChoic( "INTERP", "NEAREST", "NEAREST,LINEAR,SINC,"
"SINCSINC,SINCCOS,SINCGAUSS,SOMB,SOMBCOS",
1, pabuf, 10, status );
if( !strcmp( pabuf, "NEAREST" ) ) {
interp = AST__NEAREST;
nparam = 0;
} else if( !strcmp( pabuf, "LINEAR" ) ) {
interp = AST__LINEAR;
nparam = 0;
} else if( !strcmp( pabuf, "SINC" ) ) {
interp = AST__SINC;
nparam = 1;
} else if( !strcmp( pabuf, "SINCSINC" ) ) {
interp = AST__SINCSINC;
nparam = 2;
} else if( !strcmp( pabuf, "SINCCOS" ) ) {
interp = AST__SINCCOS;
nparam = 2;
} else if( !strcmp( pabuf, "SINCGAUSS" ) ) {
interp = AST__SINCGAUSS;
nparam = 2;
} else if( !strcmp( pabuf, "SOMB" ) ) {
interp = AST__SOMB;
nparam = 1;
} else if( !strcmp( pabuf, "SOMBCOS" ) ) {
interp = AST__SOMBCOS;
nparam = 2;
} else if( *status == SAI__OK ) {
nparam = 0;
*status = SAI__ERROR;
msgSetc( "V", pabuf );
errRep( "", "Support not available for INTERP = ^V (programming "
"error)", status );
}
/* Get an additional parameter vector if required. */
if( nparam > 0 ) parExacd( "PARAMS", nparam, params, status );
/* Get a group of reference time series files to use as templates for
the output time series files.*/
ndgAssoc( "REF", 1, &igrp2, &size, &flag, status );
/* Get output file(s) */
kpg1Wgndf( "OUT", igrp2, size, size, "More output files required...",
&ogrp, &outsize, status );
/* Get he noise level to add to the output data. */
parGet0d( "SIGMA", &sigma, status );
/* Get any Q and U input maps. */
if( *status == SAI__OK ) {
kpg1Rgndf( "QIN", 1, 1, "", &igrpq, &nskymap, status );
ndgNdfas( igrpq, 1, "READ", &indfq, status );
ndfMap( indfq, "DATA", "_DOUBLE", "READ", (void **) &inq_data, &nelqu,
status );
if( nelqu != nel && *status == SAI__OK ) {
ndfMsg( "Q", indfq );
*status = SAI__ERROR;
errRep( "", "Q image '^Q' is not the same size as the I image.",
status );
}
kpg1Rgndf( "UIN", 1, 1, "", &igrpu, &nskymap, status );
ndgNdfas( igrpu, 1, "READ", &indfu, status );
ndfMap( indfu, "DATA", "_DOUBLE", "READ", (void **) &inu_data, &nelqu,
status );
if( nelqu != nel && *status == SAI__OK ) {
ndfMsg( "U", indfu );
*status = SAI__ERROR;
errRep( "", "U image '^U' is not the same size as the I image.",
status );
}
if( *status == PAR__NULL ) {
ndfAnnul( &indfq, status );
ndfAnnul( &indfu, status );
inq_data = NULL;
inu_data = NULL;
errAnnul( status );
} else {
parGet0d( "ANGROT", &angrot, status );
parGet0d( "PAOFF", &paoff, status );
parGet0l( "PASIGN", &pasign, status );
}
}
/* Get any common-mode files. */
if( *status == SAI__OK ) {
kpg1Rgndf( "COM", size, size, "", &igrpc, &ncom, status );
if( *status == PAR__NULL ) {
errAnnul( status );
ncom = 0;
}
}
/* Get any GAI files. */
if( *status == SAI__OK ) {
kpg1Rgndf( "GAI", size, size, "", &igrpg, &ngai, status );
if( *status == PAR__NULL ) {
errAnnul( status );
ngai = 0;
}
}
/* Get any instrumental polarisation files. */
if( *status == SAI__OK ) {
/* First see if the user wants to use the "INSTQ/INSTU" scheme for
specifying instrumental polarisation. */
ndfAssoc( "INSTQ", "Read", &indfiq, status );
ndfAssoc( "INSTU", "Read", &indfiu, status );
if( *status == PAR__NULL ) {
ndfAnnul( &indfiq, status );
ndfAnnul( &indfiu, status );
errAnnul( status );
} else {
msgOut( " ", "Using user-defined IP model", status );
ndfDim( indfiq, 2, dims, &ndim, status );
if( dims[ 0 ] != 32 || dims[ 1 ] != 40 ) {
*status = SAI__ERROR;
ndfMsg( "N", indfiq );
errRep( " ", "Instrumental polarisation file ^N has bad "
"dimensions - should be 32x40.", status );
} else {
ndfMap( indfiq, "DATA", "_DOUBLE", "READ", (void **) &qinst_data,
&nel, status );
}
ndfDim( indfiu, 2, dims, &ndim, status );
if( dims[ 0 ] != 32 || dims[ 1 ] != 40 ) {
*status = SAI__ERROR;
ndfMsg( "N", indfiu );
errRep( " ", "Instrumental polarisation file ^N has bad "
"dimensions - should be 32x40.", status );
} else {
ndfMap( indfiu, "DATA", "_DOUBLE", "READ", (void **) &uinst_data,
&nel, status );
}
}
/* If not, see if the user wants to use the Johnstone/Kennedy instrumental
polarisation model. The IPDATA parameter gives the path to an HDS
container file contining NDFs holding the required IP data for all
subarrays. */
if( !qinst_data ) {
parGet0c( "IPDATA", ipdata, sizeof(ipdata), status );
if( *status == PAR__NULL ) {
errAnnul( status );
} else {
msgOutf( " ", "Using Johnstone/Kennedy IP model in %s",
status, ipdata );
hdsOpen( ipdata, "READ", &iploc, status );
}
}
}
/* Loop round all the template time series files. */
for( ifile = 1; ifile <= (int) size && *status == SAI__OK; ifile++ ) {
/* Start a new NDF context. */
ndfBegin();
/* Create the output NDF by propagating everything from the input, except
for quality and variance. */
ndgNdfas( igrp2, ifile, "READ", &indfin, status );
ndfMsg( "FILE", indfin );
msgSeti( "THISFILE", ifile );
msgSeti( "NUMFILES", size );
msgOutif( MSG__NORM, " ", "Simulating ^THISFILE/^NUMFILES ^FILE",
status );
ndgNdfpr( indfin, "DATA,HISTORY,LABEL,TITLE,WCS,UNITS,EXTENSION(*)",
ogrp, ifile, &indfout, status );
ndfAnnul( &indfin, status );
ndfAnnul( &indfout, status );
/* We now re-open the output NDF and then modify its data values. */
smf_open_file( wf, ogrp, ifile, "UPDATE", 0, &odata, status );
/* Issue a suitable message and abort if anything went wrong. */
if( *status != SAI__OK ) {
errRep( FUNC_NAME, "Could not open input template file.", status );
break;
} else {
if( odata->file == NULL ) {
*status = SAI__ERROR;
errRep( FUNC_NAME, "No smfFile associated with smfData.",
status );
break;
} else if( odata->hdr == NULL ) {
*status = SAI__ERROR;
errRep( FUNC_NAME, "No smfHead associated with smfData.",
status );
break;
}
}
/* Check the reference time series contains double precision values. */
smf_dtype_check_fatal( odata, NULL, SMF__DOUBLE, status );
/* Get the total number of data elements, and the number of time slices. */
smf_get_dims( odata, NULL, NULL, NULL, &ntslice, &ndata, NULL,
NULL, status );
/* Get the subarray name */
smf_fits_getS( odata->hdr, "SUBARRAY", subarray, sizeof(subarray),
status );
/* If we are using the Johnstone/Kennedy IP model, open and map the
relevant parameter NDFs within the IPDATA container file. */
if( iploc ) {
datFind( iploc, subarray, &cloc, status );
ndfFind( cloc, "C0", &indfc0, status );
ndfDim( indfc0, 2, dims, &ndim, status );
if( dims[ 0 ] != 32 || dims[ 1 ] != 40 ) {
*status = SAI__ERROR;
ndfMsg( "N", indfc0 );
errRep( " ", "Instrumental polarisation file ^N has bad "
"dimensions - should be 32x40.", status );
} else {
ndfMap( indfc0, "DATA", "_DOUBLE", "READ", (void **) &c0_data,
&nel, status );
}
ndfFind( cloc, "P0", &indfp0, status );
ndfDim( indfp0, 2, dims, &ndim, status );
if( dims[ 0 ] != 32 || dims[ 1 ] != 40 ) {
*status = SAI__ERROR;
ndfMsg( "N", indfp0 );
errRep( " ", "Instrumental polarisation file ^N has bad "
"dimensions - should be 32x40.", status );
} else {
ndfMap( indfp0, "DATA", "_DOUBLE", "READ", (void **) &p0_data,
&nel, status );
}
ndfFind( cloc, "P1", &indfp1, status );
ndfDim( indfp1, 2, dims, &ndim, status );
if( dims[ 0 ] != 32 || dims[ 1 ] != 40 ) {
*status = SAI__ERROR;
ndfMsg( "N", indfp1 );
errRep( " ", "Instrumental polarisation file ^N has bad "
"dimensions - should be 32x40.", status );
} else {
ndfMap( indfp1, "DATA", "_DOUBLE", "READ", (void **) &p1_data,
&nel, status );
}
ndfFind( cloc, "ANGC", &indfangc, status );
ndfDim( indfangc, 2, dims, &ndim, status );
if( dims[ 0 ] != 32 || dims[ 1 ] != 40 ) {
*status = SAI__ERROR;
ndfMsg( "N", indfangc );
errRep( " ", "Instrumental polarisation file ^N has bad "
"dimensions - should be 32x40.", status );
} else {
ndfMap( indfangc, "DATA", "_DOUBLE", "READ", (void **) &angc_data,
&nel, status );
}
}
/* Open any COM file. */
if( ncom ) {
ndgNdfas( igrpc, ifile, "READ", &indfc, status );
ndfDim( indfc, 3, cdims, &ndimc, status );
/* Check its dimensions. */
if( *status == SAI__OK ) {
if( ndimc == 1 ) {
if( cdims[ 0 ] < (int) ntslice ) {
*status = SAI__ERROR;
ndfMsg( "C", indfc );
ndfMsg( "R", indfin );
msgSeti( "N", cdims[ 0 ] );
msgSeti( "M", ntslice );
errRep( " ", "Supplied COM file (^C) has ^N time-slices, but "
"the reference NDF (^R) has ^M time-slices.", status );
} else {
ndfBound( indfc, 3, lbndc, ubndc, &ndimc, status );
ubndc[ 0 ] = lbndc[ 0 ] + ntslice - 1;
ndfSect( indfc, 1, lbndc, ubndc, &indfcs, status );
}
} else if( ndimc == 3 ) {
if( cdims[ 0 ] != 1 || cdims[ 1 ] != 1 ) {
*status = SAI__ERROR;
ndfMsg( "C", indfc );
errRep( " ", "Supplied 3D COM file (^C) has bad "
"dimensions for axis 1 and/or 2 (should "
"both be 1 pixel long).", status );
} else if( cdims[ 2 ] < (int) ntslice ) {
*status = SAI__ERROR;
ndfMsg( "C", indfc );
ndfMsg( "R", indfin );
msgSeti( "N", cdims[ 2 ] );
msgSeti( "M", ntslice );
errRep( " ", "Supplied COM file (^C) has ^N time-slices, but "
"the reference NDF (^R) has ^M time-slices.", status );
} else {
ndfBound( indfc, 3, lbndc, ubndc, &ndimc, status );
ubndc[ 2 ] = lbndc[ 2 ] + ntslice - 1;
ndfSect( indfc, 3, lbndc, ubndc, &indfcs, status );
}
} else {
*status = SAI__ERROR;
ndfMsg( "C", indfc );
msgSeti( "N", ndimc );
errRep( " ", "Supplied COM file (^C) has ^N dimensions - "
"must be 3.", status );
}
}
ndfMap( indfcs, "DATA", "_DOUBLE", "READ", (void **) &inc_data,
&nelc, status );
} else {
indfcs = NDF__NOID;
inc_data = NULL;
}
/* Open any GAI files. */
if( ngai ) {
ndgNdfas( igrpg, ifile, "READ", &indfg, status );
ndfDim( indfg, 3, gdims, &ndimg, status );
/* Check its dimensions, and map it if OK. */
if( *status == SAI__OK ) {
if( ndimg != 2 ) {
*status = SAI__ERROR;
ndfMsg( "C", indfg );
msgSeti( "N", ndimg );
errRep( " ", "Supplied GAI file (^C) has ^N dimensions - "
"must be 2.", status );
} else if( gdims[ 0 ] != 32 || gdims[ 1 ] != 40 ) {
*status = SAI__ERROR;
ndfMsg( "C", indfg );
errRep( " ", "Supplied GAI file (^C) has has bad "
"dimensions - should be 32x40.", status );
}
}
ndfMap( indfg, "DATA", "_DOUBLE", "READ", (void **) &gai_data,
&nelg, status );
} else {
indfg = NDF__NOID;
gai_data = NULL;
}
/* Fill the output with bad values. */
if( *status == SAI__OK ) {
pd = odata->pntr[ 0 ];
for( iel = 0; iel < ndata; iel++ ) *(pd++) = VAL__BADD;
}
/* Resample the sky map data into the output time series. */
smf_resampmap( wf, odata, abskyfrm, skymap, moving, slbnd, subnd,
interp, params, sigma, in_data, odata->pntr[ 0 ],
NULL, &ngood, status );
/* Add on any COM data. */
smf_addcom( wf, odata, inc_data, status );
/* Issue a wrning if there is no good data in the output cube. */
if( ngood == 0 ) msgOutif( MSG__NORM, " ", " Output contains no "
"good data values.", status );
/* If Q and U maps have been given, allocate room to hold resampled Q and
U values, and fill them with bad values. */
if( inq_data && inu_data ) {
pq = outq_data = astMalloc( ndata*sizeof( *outq_data ) );
pu = outu_data = astMalloc( ndata*sizeof( *outu_data ) );
if( *status == SAI__OK ) {
for( iel = 0; iel < ndata; iel++ ) {
*(pu++) = VAL__BADD;
*(pq++) = VAL__BADD;
}
}
/* Determine the harmonic to use. */
parGet0i( "HARMONIC", &harmonic, status );
/* If producing the normal 8 Hz harmonic, get the amplitude and phase of a
other signals to add onto the 8 Hz signal. */
if( harmonic == 4 ) {
parGet0d( "AMP2", &2, status );
parGet0d( "PHASE2", &phase2, status );
parGet0d( "AMP4", &4, status );
parGet0d( "PHASE4", &phase4, status );
parGet0d( "AMP16", &16, status );
parGet0d( "PHASE16", &phase16, status );
} else {
amp2 = 0.0;
phase2 = 0.0;
amp4 = 0.0;
phase4 = 0.0;
amp16 = 0.0;
phase16 = 0.0;
}
/* Allocate room for an array to hold the angle from the Y pixel axis
in the sky map to the focal plane Y axis, in radians, at each time
slice. Positive rotation is in the same sense as rotation from
focal plane X to focal plane Y. */
ang_data = astMalloc( ntslice*sizeof( *ang_data ) );
/* Resample them both into 3D time series. These Q/U values arw with
respect to the sky image Y axis. */
smf_resampmap( wf, odata, abskyfrm, skymap, moving, slbnd, subnd,
interp, params, sigma, inq_data, outq_data,
ang_data, &ngood, status );
smf_resampmap( wf, odata, abskyfrm, skymap, moving, slbnd, subnd,
interp, params, sigma, inu_data, outu_data,
NULL, &ngood, status );
/* Combine these time series with the main output time series so that the
main output is analysed intensity. */
smf_uncalc_iqu( wf, odata, odata->pntr[ 0 ], outq_data, outu_data,
ang_data, pasign, AST__DD2R*paoff, AST__DD2R*angrot,
amp2, AST__DD2R*phase2, amp4, AST__DD2R*phase4,
amp16, AST__DD2R*phase16, qinst_data, uinst_data,
c0_data, p0_data, p1_data, angc_data, harmonic,
status );
/* Release work space. */
outq_data = astFree( outq_data );
outu_data = astFree( outu_data );
ang_data = astFree( ang_data );
}
/* Factor in any GAI data. */
smf_addgai( wf, odata, gai_data, status );
/* Close the output time series file. */
smf_close_file( wf, &odata, status );
/* Close the IP data container for the current subarray, if it is open. */
if( cloc ) datAnnul( &cloc, status );
/* End the NDF context. */
ndfEnd( status );
}
/* Close any input data file that is still open due to an early exit from
the above loop. */
if( odata != NULL ) {
smf_close_file( wf, &odata, status );
odata = NULL;
}
/* Free remaining resources. */
if( igrp1 != NULL) grpDelet( &igrp1, status);
if( igrp2 != NULL) grpDelet( &igrp2, status);
if( igrpq != NULL) grpDelet( &igrpq, status);
if( igrpu != NULL) grpDelet( &igrpu, status);
if( igrpc != NULL) grpDelet( &igrpc, status);
if( igrpg != NULL) grpDelet( &igrpg, status);
if( ogrp != NULL) grpDelet( &ogrp, status);
if( iploc ) datAnnul( &iploc, status );
/* End the NDF context. */
ndfEnd( status );
/* End the tile's AST context. */
astEnd;
/* Issue a status indication.*/
if( *status == SAI__OK ) {
msgOutif(MSG__VERB," ",TASK_NAME " succeeded, time series written.", status);
} else {
msgOutif(MSG__VERB," ",TASK_NAME " failed.", status);
}
}
void smurf_jsatileinfo( int *status ) {
/* Local Variables */
AstCmpRegion *overlap;
AstFitsChan *fc;
AstFrameSet *fs;
AstObject *obj;
AstRegion *region;
AstRegion *target;
HDSLoc *cloc = NULL;
HDSLoc *xloc = NULL;
char *jcmt_tiles;
char *tilendf = NULL;
char text[ 200 ];
double dec[ 8 ];
double dist;
double dlbnd[ 2 ];
double dubnd[ 2 ];
double gx[ 8 ];
double gy[ 8 ];
double maxdist;
double norm_radec[2];
double point1[ 2 ];
double point2[ 2 ];
double ra[ 8 ];
double ra0;
double dec0;
int *ipntr;
int axes[ 2 ];
int create;
int dirlen;
int el;
int exists;
int flag;
int i;
int indf1;
int indf2;
int indf3;
int itile;
int iv;
int jtile;
int lbnd[ 2 ];
int local_origin;
int nc;
int place;
int tlbnd[ 2 ];
int tubnd[ 2 ];
int ubnd[ 2 ];
smf_jsaproj_t proj;
int xt;
int yt;
smfJSATiling skytiling;
void *pntr;
/* Check inherited status */
if( *status != SAI__OK ) return;
/* Start a new AST context. */
astBegin;
/* Get the instrument to use abnd get the parameters describing the
layout of its JSA tiles. */
smf_jsainstrument( "INSTRUMENT", NULL, SMF__INST_NONE, &skytiling,
status );
/* Return the maximum tile index. */
parPut0i( "MAXTILE", skytiling.ntiles - 1, status );
/* Abort if an error has occurred. */
if( *status != SAI__OK ) goto L999;
/* Decide what sort of projection to use. */
parChoic( "PROJ", "HPX", "HPX,HPX12,XPHN,XPHS", 1, text, sizeof(text),
status );
proj = smf_jsaproj_fromstr( text, 1, status );
/* If required, create an all-sky NDF in which each pixel covers the area
of a single tile, and holds the integer tile index. The NDF has an
initial size of 1x1 pixels, but is expanded later to the required size. */
lbnd[ 0 ] = ubnd[ 0 ] = lbnd[ 1 ] = ubnd[ 1 ] = 1;
ndfCreat( "ALLSKY", "_INTEGER", 2, lbnd, ubnd, &indf3, status );
/* If a null (!) value was supplied for parameter ALLSKY, annull the
error and pass on. */
if( *status == PAR__NULL ) {
errAnnul( status );
/* Otherwise, create a FrameSet describing the whole sky in which each
pixel corresponds to a single tile. */
} else {
smf_jsatile( -1, &skytiling, 0, proj, NULL, &fs, NULL, lbnd, ubnd,
status );
/* Change the bounds of the output NDF. */
ndfSbnd( 2, lbnd, ubnd, indf3, status );
/* Store the FrameSet in the NDF. */
ndfPtwcs( fs, indf3, status );
/* Map the data array. */
ndfMap( indf3, "Data", "_INTEGER", "WRITE/BAD", (void **) &ipntr, &el,
status );
/* Create all-sky map using XPH projection. */
if( *status == SAI__OK ) {
/* Loop round every tile index. */
for( jtile = 0; jtile < skytiling.ntiles; jtile++ ) {
/* Get the zero-based (x,y) indices of the tile within an HPX projection.
This flips the bottom left half-facet up to the top right. */
smf_jsatilei2xy( jtile, &skytiling, &xt, &yt, NULL, status );
/* Convert these HPX indices to the corresponding indices within the
required projection. Note, the lower left facet is split by the above
call to smf_jsatilei2xy tile (i.e. (xt,yt) indices are *not* in the
"raw" mode). For instance, (0,0) is not a valid tile. */
smf_jsatilexyconv( &skytiling, proj, xt, yt, 0, &xt, &yt, status );
/* Get the vector index of the corresponding element of the all-sky NDF. */
if( proj == SMF__JSA_HPX || proj == SMF__JSA_HPX12 ) {
iv = xt + 5*skytiling.ntpf*yt;
} else {
iv = xt + 4*skytiling.ntpf*yt;
}
/* Report an error if this element has already been assigned a tile
index. Otherwise, store the tile index. */
if( ipntr[ iv ] == VAL__BADI ) {
ipntr[ iv ] = jtile;
} else if( *status == SAI__OK ) {
*status = SAI__ERROR;
errRepf( "", "%s projection assigns multiple tiles to "
"pixel (%d,%d).", status, text, xt, yt );
break;
}
}
}
/* Store NDF title. */
sprintf( text, "JSA tile indices for %s data", skytiling.name );
ndfCput( text, indf3, "TITLE", status );
/* Store the instrument as a component in the SMURF extension. */
ndfXnew( indf3, "SMURF", "INSTRUMENT", 0, 0, &xloc, status );
ndfXpt0c( skytiling.name, indf3, "SMURF", "INSTRUMENT", status );
datAnnul( &xloc, status );
/* Close the NDF. */
ndfAnnul( &indf3, status );
}
/* Abort if an error has occurred. */
if( *status != SAI__OK ) goto L999;
/* Get the zero-based index of the required tile. If a null value is
supplied, annull the error and skip to the end. */
parGdr0i( "ITILE", 0, 0, skytiling.ntiles - 1, 0, &itile, status );
if( *status == PAR__NULL ) {
errAnnul( status );
goto L999;
}
/* See if the pixel origin is to be at the centre of the tile. */
parGet0l( "LOCAL", &local_origin, status );
/* Display the tile number. */
msgBlank( status );
msgSeti( "ITILE", itile );
msgSeti( "MAXTILE", skytiling.ntiles - 1);
msgOut( " ", " Tile ^ITILE (from 0 to ^MAXTILE):", status );
/* Get the FITS header, FrameSet and Region defining the tile, and the tile
bounds in pixel indices. */
smf_jsatile( itile, &skytiling, local_origin, proj, &fc, &fs, ®ion,
lbnd, ubnd, status );
/* Write the FITS headers out to a file, annulling the error if the
header is not required. */
if( *status == SAI__OK ) {
atlDumpFits( "HEADER", fc, status );
if( *status == PAR__NULL ) errAnnul( status );
}
/* If required, write the Region out to a text file. */
if( *status == SAI__OK ) {
atlCreat( "REGION", (AstObject *) region, status );
if( *status == PAR__NULL ) errAnnul( status );
}
/* Store the lower and upper pixel bounds of the tile. */
parPut1i( "LBND", 2, lbnd, status );
parPut1i( "UBND", 2, ubnd, status );
/* Display pixel bounds on the screen. */
msgSeti( "XL", lbnd[ 0 ] );
msgSeti( "XU", ubnd[ 0 ] );
msgSeti( "YL", lbnd[ 1 ] );
msgSeti( "YU", ubnd[ 1 ] );
msgOut( " ", " Pixel bounds: (^XL:^XU,^YL:^YU)", status );
/* Get the RA,Dec at the tile centre. */
if( astTest( fs, "SkyRef" ) ) {
ra0 = astGetD( fs, "SkyRef(1)" );
dec0 = astGetD( fs, "SkyRef(2)" );
/* Format the central RA and Dec. and display. Call astNorm on the
coordinates provided that the frame set has the correct number of
axes (which it should as it comes from smf_jsatile). */
norm_radec[0] = ra0;
norm_radec[1] = dec0;
if (astGetI(fs, "Naxes") == 2) astNorm(fs, norm_radec);
msgSetc( "RACEN", astFormat( fs, 1, norm_radec[ 0 ] ));
msgSetc( "DECCEN", astFormat( fs, 2, norm_radec[ 1 ] ));
msgOut( " ", " Centre (ICRS): RA=^RACEN DEC=^DECCEN", status );
/* Transform a collection of points on the edge of the region (corners and
side mid-points) from GRID coords to RA,Dec. */
point1[ 0 ] = 0.5;
point1[ 1 ] = 0.5;
point2[ 0 ] = ubnd[ 0 ] - lbnd[ 0 ] + 1;
point2[ 1 ] = ubnd[ 1 ] - lbnd[ 1 ] + 1;
gx[ 0 ] = point1[ 0 ]; /* Bottom left */
gy[ 0 ] = point1[ 1 ];
gx[ 1 ] = point1[ 0 ]; /* Centre left */
gy[ 1 ] = gy[ 0 ];
gx[ 2 ] = point1[ 0 ]; /* Top left */
gy[ 2 ] = point2[ 1 ];
gx[ 3 ] = gx[ 0 ]; /* Top centre */
gy[ 3 ] = point2[ 1 ];
gx[ 4 ] = point2[ 0 ]; /* Top right */
gy[ 4 ] = point2[ 1 ];
gx[ 5 ] = point2[ 0 ]; /* Centre right */
gy[ 5 ] = gy[ 0 ];
gx[ 6 ] = point2[ 0 ]; /* Bottom right */
gy[ 6 ] = point1[ 1 ];
gx[ 7 ] = gx[ 0 ]; /* Bottom centre */
gy[ 7 ] = point1[ 1 ];
astTran2( fs, 8, gx, gy, 1, ra, dec );
/* Find the arc-distance from the centre to the furthest point from the
centre. */
point1[ 0 ] = ra0;
point1[ 1 ] = dec0;
maxdist = -1.0;
for( i = 1; i < 8; i++ ) {
if( ra[ i ] != AST__BAD && dec[ i ] != AST__BAD ) {
point2[ 0 ] = ra[ i ];
point2[ 1 ] = dec[ i ];
dist = astDistance( fs, point1, point2 );
if( dist > maxdist ) maxdist = dist;
}
}
/* Convert from radius to diameter. */
maxdist *= 2.0;
/* Format this size as a dec value (i.e. arc-distance) and display it. */
if( maxdist > 0.0 ) {
msgSetc( "SIZE", astFormat( fs, 2, maxdist ) );
msgOut( " ", " Size: ^SIZE", status );
} else {
maxdist = AST__BAD;
msgOut( " ", " Size: <unknown>", status );
}
/* If a discontinuity passes through the tile, the centre and size may be
unknown. */
} else {
ra0 = AST__BAD;
dec0 = AST__BAD;
maxdist = AST__BAD;
msgOut( " ", " Centre (ICRS): RA=<unknown> DEC=<unknown>", status );
msgOut( " ", " Size: <unknown>", status );
}
/* Write the tile centre ra and dec in radians to the output parameters. */
parPut0d( "RACEN", norm_radec[ 0 ], status );
parPut0d( "DECCEN", norm_radec[ 1 ], status );
/* Write the size to the output parameter as radians. */
parPut0d( "SIZE", maxdist, status );
/* Get the translation of the environment variable JSA_TILE_DIR. */
jcmt_tiles = getenv( "JSA_TILE_DIR" );
/* Initialise the path to the tile's NDF to hold the root directory.
Use the current working directory if JSA_TILE_DIR is undefined. */
if( jcmt_tiles ) {
nc = 0;
tilendf = astAppendString( tilendf, &nc, jcmt_tiles );
} else {
nc = 512;
jcmt_tiles = astMalloc( nc );
while( !getcwd( jcmt_tiles, nc ) ) {
nc *= 2;
jcmt_tiles = astRealloc( jcmt_tiles, nc );
}
nc = 0;
tilendf = astAppendString( tilendf, &nc, jcmt_tiles );
jcmt_tiles = astFree( jcmt_tiles );
}
/* Complete the path to the tile's NDF. */
tilendf = astAppendString( tilendf, &nc, "/" );
tilendf = astAppendString( tilendf, &nc, skytiling.subdir );
dirlen = nc;
sprintf( text, "/tile_%d.sdf", itile );
tilendf = astAppendString( tilendf, &nc, text );
/* Write it to the output parameter. */
parPut0c( "TILENDF", tilendf, status );
/* See if the NDF exists, and store the flag in the output parameter. */
exists = access( tilendf, F_OK ) ? 0 : 1;
parPut0l( "EXISTS", exists, status );
/* If the NDF does not exist, create it if required. */
parGet0l( "CREATE", &create, status );
if( !exists && create && *status == SAI__OK ) {
/* Write the NDF info to the screen. */
msgSetc( "NDF", tilendf );
msgOutif( MSG__NORM, " ", " NDF: ^NDF (created)", status );
/* Temporarily terminate the NDF path at the end of the subdirectory. */
tilendf[ dirlen ] = 0;
/* Create the required directory (does nothing if the directory
already exists). It is given read/write/search permissions for owner
and group, and read/search permissions for others. */
(void) mkdir( tilendf, S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH );
/* Replace the character temporarily overwritten above. */
tilendf[ dirlen ] = '/';
/* Now create the tile's NDF. */
ndfPlace( NULL, tilendf, &place, status );
ndfNew( skytiling.type, 2, lbnd, ubnd, &place, &indf1, status );
/* Fill its data array with zeros. */
ndfMap( indf1, "Data", skytiling.type, "WRITE/ZERO", &pntr, &el,
status );
/* Store the WCS FrameSet. */
ndfPtwcs( fs, indf1, status );
/* If the instrument jsatiles.have variance, fill the variance array with zeros. */
if( skytiling.var ) {
ndfMap( indf1, "Variance", skytiling.type, "WRITE/ZERO", &pntr,
&el, status );
}
/* Create a SMURF extension. */
ndfXnew( indf1, SMURF__EXTNAME, SMURF__EXTTYPE, 0, NULL, &xloc, status );
/* Store the tile number and instrument name in the extension. */
datNew0I( xloc, "TILE", status );
datFind( xloc, "TILE", &cloc, status );
datPut0I( cloc, itile, status );
datAnnul( &cloc, status );
datNew0C( xloc, "INSTRUMENT", strlen( skytiling.name ), status );
datFind( xloc, "INSTRUMENT", &cloc, status );
datPut0C( cloc, skytiling.name, status );
datAnnul( &cloc, status );
/* Create a weights NDF within the SMURF extension, and fill its data
array with zeros. */
ndfPlace( xloc, "WEIGHTS", &place, status );
ndfNew( skytiling.type, 2, lbnd, ubnd, &place, &indf2, status );
ndfMap( indf2, "Data", skytiling.type, "WRITE/ZERO", &pntr, &el,
status );
ndfPtwcs( fs, indf2, status );
ndfAnnul( &indf2, status );
/* Annul the extension locator and the main NDF identifier. */
datAnnul( &xloc, status );
ndfAnnul( &indf1, status );
/* Write the NDF info to the screen. */
} else {
msgSetc( "NDF", tilendf );
msgSetc( "E", exists ? "exists" : "does not exist" );
msgOut( " ", " NDF: ^NDF (^E)", status );
}
/* Initialise TBND and TLBND to indicate no overlap. */
tlbnd[ 0 ] = 1;
tlbnd[ 1 ] = 1;
tubnd[ 0 ] = 0;
tubnd[ 1 ] = 0;
/* Attempt to to get an AST Region (assumed to be in some 2D sky coordinate
system) using parameter "TARGET". */
if( *status == SAI__OK ) {
kpg1Gtobj( "TARGET", "Region",
(void (*)( void )) F77_EXTERNAL_NAME(ast_isaregion),
&obj, status );
/* Annul the error if none was obtained. */
if( *status == PAR__NULL ) {
errAnnul( status );
/* Otherwise, use the supplied object. */
} else {
target = (AstRegion *) obj;
/* If the target Region is 3-dimensional, remove the third axis, which
is assumed to be a spectral axis. */
if( astGetI( target, "Naxes" ) == 3 ) {
axes[ 0 ] = 1;
axes[ 1 ] = 2;
target = astPickAxes( target, 2, axes, NULL );
}
/* See if there is any overlap between the target and the tile. */
overlap = NULL;
flag = astOverlap( region, target );
if( flag == 0 ) {
msgOut( "", " Cannot convert between the coordinate system of the "
"supplied target and the tile.", status );
} else if( flag == 1 || flag == 6 ) {
msgOut( "", " There is no overlap between the target and the tile.",
status );
} else if( flag == 2 ) {
msgOut( "", " The tile is contained within the target.",
status );
tlbnd[ 0 ] = lbnd[ 0 ];
tlbnd[ 1 ] = lbnd[ 1 ];
tubnd[ 0 ] = ubnd[ 0 ];
tubnd[ 1 ] = ubnd[ 1 ];
} else if( flag == 3 ) {
overlap = astCmpRegion( region, target, AST__AND, " " );
} else if( flag == 4 ) {
overlap = astCmpRegion( region, target, AST__AND, " " );
} else if( flag == 5 ) {
msgOut( "", " The target and tile are identical.",
status );
tlbnd[ 0 ] = lbnd[ 0 ];
tlbnd[ 1 ] = lbnd[ 1 ];
tubnd[ 0 ] = ubnd[ 0 ];
tubnd[ 1 ] = ubnd[ 1 ];
} else if( *status == SAI__OK ) {
*status = SAI__OK;
errRepf( "", "Unexpected value %d returned by astOverlap "
"(programming error).", status, flag );
}
/* If a region containing the intersection of the tile and target was
created above, map it into the grid coordinate system of the tile. */
if( overlap ) {
overlap = astMapRegion( overlap, astGetMapping( fs, AST__CURRENT,
AST__BASE ),
astGetFrame( fs, AST__BASE ) );
/* Get its GRID bounds. */
astGetRegionBounds( overlap, dlbnd, dubnd );
/* Convert to integer. */
tlbnd[ 0 ] = ceil( dlbnd[ 0 ] - 0.5 );
tlbnd[ 1 ] = ceil( dlbnd[ 1 ] - 0.5 );
tubnd[ 0 ] = ceil( dubnd[ 0 ] - 0.5 );
tubnd[ 1 ] = ceil( dubnd[ 1 ] - 0.5 );
/* Convert to PIXEL indices within the tile. */
tlbnd[ 0 ] += lbnd[ 0 ] - 1;
tlbnd[ 1 ] += lbnd[ 1 ] - 1;
tubnd[ 0 ] += lbnd[ 0 ] - 1;
tubnd[ 1 ] += lbnd[ 1 ] - 1;
msgOutf( "", " The target overlaps section (%d:%d,%d:%d).",
status, tlbnd[ 0 ], tubnd[ 0 ], tlbnd[ 1 ], tubnd[ 1 ] );
}
}
}
/* Store the pixel index bounds of the tiles overlap with the target. */
parPut1i( "TLBND", 2, tlbnd, status );
parPut1i( "TUBND", 2, tubnd, status );
/* Arrive here if an error occurs. */
L999:;
/* Free resources. */
tilendf = astFree( tilendf );
/* End the AST context. */
astEnd;
/* Issue a status indication.*/
msgBlank( status );
if( *status == SAI__OK ) {
msgOutif( MSG__VERB, "", "JSATILEINFO succeeded.", status);
} else {
msgOutif( MSG__VERB, "", "JSATILEINFO failed.", status);
}
}
void smf_addpolanal( AstFrameSet *fset, smfHead *hdr, AstKeyMap *config,
int *status ){
/* Local Variables */
AstCmpMap *tmap;
AstFrame *cfrm;
AstFrame *pfrm;
AstFrame *tfrm;
AstFrameSet *tfs;
AstPermMap *pm;
char *polnorth = NULL;
const char *cursys;
const char *trsys;
int aloff;
int icurr;
int inperm[2];
int outperm[2];
int pol2fp;
/* Check inherited status, and also check the supplied angle is not bad. */
if( *status != SAI__OK ) return;
/* Begin an AST object context. */
astBegin;
/* Get the value of the POLNORTH FITS keyword from the supplied header.
The rest only happens if the keyword is found. */
if( astGetFitsS( hdr->fitshdr, "POLNORTH", &polnorth ) ) {
/* Normally, we do not allow maps to be made from Q/U time streams that
use focal plane Y as the reference direction (because of the problems
of sky rotation). Therefore we report an error. However, we do need to
make such maps as part of the process of determining the parameters of
the Instrumental Polarisation (IP) model. So only report the error if
"pol2fp" config parameter is non-zero. */
if( !strcmp( polnorth, "FPLANE" ) ) {
astMapGet0I( config, "POL2FP", &pol2fp );
if( pol2fp ) {
msgBlank( status );
msgOut( "", "WARNING: The input NDFs hold POL-2 Q/U data specified "
"with respect to focal plane Y.",status );
msgOut( "", "Maps should normally be made from POL-2 data specified "
"with respect to celestial north.",status );
msgOut( "", "The output map will not contain a POLANAL Frame and "
"so will be unusable by POLPACK applications.",status );
msgBlank( status );
} else if( *status == SAI__OK ) {
*status = SAI__ERROR;
errRep( "", "The input NDFs hold POL-2 Q/U data specified with "
"respect to focal plane Y.",status );
errRep( "", "Maps can only be made from POL-2 data specified with "
"respect to celestial north.",status );
}
/* If the ref. direction is celestial north, create a suitable Frame and
Mapping and add them into the supplied FrameSet. */
} else {
/* Check the current Frame is a SkyFrame. */
cfrm = astGetFrame( fset, AST__CURRENT );
if( astIsASkyFrame( cfrm ) ) {
/* Create a POLANAL Frame. */
pfrm = astFrame( 2, "Domain=POLANAL" );
astSet( pfrm, "Title=Polarimetry reference frame" );
astSet( pfrm, "Label(1)=Polarimetry reference direction" );
astSet( pfrm, "Label(2)=" );
/* Create a PermMap that ensures that axis 1 of the POLANAL Frame is parallel
to the latitude axis (i.e. north) of the curent Frame (the current Frame axes
may have been swapped). */
outperm[ 0 ] = astGetI( cfrm, "LatAxis" );
outperm[ 1 ] = astGetI( cfrm, "LonAxis" );
inperm[ outperm[ 0 ] - 1 ] = 1;
inperm[ outperm[ 1 ] - 1 ] = 2;
pm = astPermMap( 2, inperm, 2, outperm, NULL, " " );
/* Record the index of the original current Frame. */
icurr = astGetI( fset, "Current" );
/* Determine the system to use. */
if( !strcmp( polnorth, "TRACKING" ) ) {
trsys = sc2ast_convert_system( hdr->state->tcs_tr_sys, status );
} else {
trsys = polnorth;
}
/* If the current Frame in the supplied FrameSet has this system. Then we
use the above PermMap to connect the POLANAL Frame directly to the current
Frame. */
cursys = astGetC( cfrm, "System" );
if( trsys && cursys && !strcmp( cursys, trsys ) ) {
astAddFrame( fset, AST__CURRENT, pm, pfrm );
/* Otherwise we need to get a Mapping from the current Frame to the
required frame. */
} else {
/* Take a copy of the current Frame (in order to pick up epoch, observatory
position, etc), and set its System to the required system. */
tfrm = astCopy( cfrm );
astSetC( tfrm, "System", trsys );
/* Get the Mapping from the original current Frame to this modified copy.
Ensure alignment happens in absolute coords (alignment in offset
coords is always a unit mapping and so no rotation occurs). */
aloff = astGetI( cfrm, "AlignOffset" );
if( aloff ) {
astSetI( cfrm, "AlignOffset", 0 );
astSetI( tfrm, "AlignOffset", 0 );
}
tfs = astConvert( cfrm, tfrm, "SKY" );
if( aloff ) {
astSetI( cfrm, "AlignOffset", 1 );
astSetI( tfrm, "AlignOffset", 1 );
}
if( tfs ) {
/* Use it, in series with with the above PermMap, to connect the POLANAL frame
to the current Frame. */
tmap = astCmpMap( astGetMapping( tfs, AST__BASE,
AST__CURRENT ),
pm, 1, " " );
astAddFrame( fset, AST__CURRENT, astSimplify( tmap ),
pfrm );
/* Report an error if the mapping from current to required system could
not be found. */
} else if( *status == SAI__OK ) {
*status = SAI__ERROR;
errRepf( "", "smf_addpolanal: Could not convert Frame "
"from %s to %s (prgramming error).", status,
cursys, trsys );
}
}
/* Re-instate the original current Frame. */
astSetI( fset, "Current", icurr );
/* Report an error if the current Frame is not a SkyFrame. */
} else if( *status == SAI__OK ) {
*status = SAI__ERROR;
errRep( "", "smf_addpolanal: The current Frame in the "
"supplied FrameSet is not a SkyFrame (prgramming "
"error).", status );
}
}
}
/* End the AST object 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 );
}
void smurf_unmakemap( int *status ) {
/* Local Variables */
AstFrameSet *wcsin = NULL; /* WCS Frameset for input cube */
AstMapping *skymap; /* GRID->SkyFrame Mapping from input WCS */
AstSkyFrame *abskyfrm; /* Input SkyFrame (always absolute) */
AstSkyFrame *skyfrm = NULL;/* SkyFrame from the input WCS Frameset */
Grp *igrp1 = NULL; /* Group of input sky files */
Grp *igrp2 = NULL; /* Group of input template files */
Grp *igrpq = NULL; /* Group of input Q sky files */
Grp *igrpu = NULL; /* Group of input U sky files */
Grp *ogrp = NULL; /* Group containing output file */
ThrWorkForce *wf = NULL; /* Pointer to a pool of worker threads */
char pabuf[ 10 ]; /* Text buffer for parameter value */
dim_t iel; /* Index of next element */
dim_t ndata; /* Number of elements in array */
dim_t ntslice; /* Number of time slices in array */
double *ang_data = NULL; /* Pointer to the FP orientation angles */
double *in_data = NULL; /* Pointer to the input I sky map */
double *inq_data = NULL; /* Pointer to the input Q sky map */
double *inu_data = NULL; /* Pointer to the input U sky map */
double *outq_data = NULL; /* Pointer to the Q time series data */
double *outu_data = NULL; /* Pointer to the U time series data */
double *pd; /* Pointer to next element */
double *pq = NULL; /* Pointer to next Q time series value */
double *pu = NULL; /* Pointer to next U time series value */
double angrot; /* Angle from focal plane X axis to fixed analyser */
double paoff; /* WPLATE value corresponding to POL_ANG=0.0 */
double params[ 4 ]; /* astResample parameters */
double sigma; /* Standard deviation of noise to add to output */
int alignsys; /* Align data in the map's system? */
int flag; /* Was the group expression flagged? */
int harmonic; /* The requested harmonic */
int ifile; /* Input file index */
int indf; /* Input sky map NDF identifier */
int indfin; /* Input template cube NDF identifier */
int indfout; /* Output cube NDF identifier */
int indfq; /* Input Q map NDF identifier */
int indfu; /* Input U map NDF identifier */
int interp = 0; /* Pixel interpolation method */
int moving; /* Is the telescope base position changing? */
int nel; /* Number of elements in array */
int nelqu; /* Number of elements in Q or U array */
int ngood; /* No. of good values in putput cube */
int nparam = 0; /* No. of parameters required for interpolation scheme */
int pasign; /* Indicates sense of POL_ANG value */
int sdim[ 2 ]; /* Array of significant pixel axes */
int slbnd[ 2 ]; /* Array of lower bounds of input map */
int subnd[ 2 ]; /* Array of upper bounds of input map */
size_t nskymap; /* Number of supplied sky cubes */
size_t outsize; /* Number of files in output group */
size_t size; /* Number of files in input group */
smfData *odata = NULL; /* Pointer to output data struct */
/* Check inherited status */
if( *status != SAI__OK ) return;
/* Begin an AST context */
astBegin;
/* Begin an NDF context. */
ndfBegin();
/* Find the number of cores/processors available and create a pool of
threads of the same size. */
wf = thrGetWorkforce( thrGetNThread( SMF__THREADS, status ), status );
/* Get an identifier for the input NDF. We use NDG (via kpg1Rgndf)
instead of calling ndfAssoc directly since NDF/HDS has problems with
file names containing spaces, which NDG does not have. */
kpg1Rgndf( "IN", 1, 1, "", &igrp1, &nskymap, status );
ndgNdfas( igrp1, 1, "READ", &indf, status );
/* Map the data array in the input sky map. */
ndfMap( indf, "DATA", "_DOUBLE", "READ", (void **) &in_data, &nel,
status );
/* Get the WCS FrameSet from the sky map, together with its pixel index
bounds. */
kpg1Asget( indf, 2, 0, 1, 1, sdim, slbnd, subnd, &wcsin, status );
/* Check the current Frame is a SKY frame. */
skyfrm = astGetFrame( wcsin, AST__CURRENT );
if( !astIsASkyFrame( skyfrm ) && *status == SAI__OK ) {
ndfMsg( "N", indf );
*status = SAI__ERROR;
errRep( " ", " Current Frame in ^N is not a SKY Frame.", status );
}
/* Get a copy of the current frame that represents absolute coords rather
than offsets. We assume the target is moving if the map represents
offsets. */
moving = ( *status == SAI__OK &&
!strcmp( astGetC( skyfrm, "SkyRefIs" ), "Origin" ) ) ? 1 : 0;
abskyfrm = astCopy( skyfrm );
astClear( abskyfrm, "SkyRefIs" );
/* If the ALIGNSYS parameter is TRUE then we align the raw data with the
map in the current system of the map, rather than the default ICRS. */
parGet0l( "ALIGNSYS", &alignsys, status );
if( alignsys ) astSetC( abskyfrm, "AlignSystem", astGetC( abskyfrm,
"System" ) );
/* Get the Mapping from the Sky Frame to grid axis in the iput map. */
skymap = astGetMapping( wcsin, AST__CURRENT, AST__BASE );
/* Get the pixel interpolation scheme to use. */
parChoic( "INTERP", "NEAREST", "NEAREST,LINEAR,SINC,"
"SINCSINC,SINCCOS,SINCGAUSS,SOMB,SOMBCOS",
1, pabuf, 10, status );
if( !strcmp( pabuf, "NEAREST" ) ) {
interp = AST__NEAREST;
nparam = 0;
} else if( !strcmp( pabuf, "LINEAR" ) ) {
interp = AST__LINEAR;
nparam = 0;
} else if( !strcmp( pabuf, "SINC" ) ) {
interp = AST__SINC;
nparam = 1;
} else if( !strcmp( pabuf, "SINCSINC" ) ) {
interp = AST__SINCSINC;
nparam = 2;
} else if( !strcmp( pabuf, "SINCCOS" ) ) {
interp = AST__SINCCOS;
nparam = 2;
} else if( !strcmp( pabuf, "SINCGAUSS" ) ) {
interp = AST__SINCGAUSS;
nparam = 2;
} else if( !strcmp( pabuf, "SOMB" ) ) {
interp = AST__SOMB;
nparam = 1;
} else if( !strcmp( pabuf, "SOMBCOS" ) ) {
interp = AST__SOMBCOS;
nparam = 2;
} else if( *status == SAI__OK ) {
nparam = 0;
*status = SAI__ERROR;
msgSetc( "V", pabuf );
errRep( "", "Support not available for INTERP = ^V (programming "
"error)", status );
}
/* Get an additional parameter vector if required. */
if( nparam > 0 ) parExacd( "PARAMS", nparam, params, status );
/* Get a group of reference time series files to use as templates for
the output time series files.*/
ndgAssoc( "REF", 1, &igrp2, &size, &flag, status );
/* Get output file(s) */
kpg1Wgndf( "OUT", igrp2, size, size, "More output files required...",
&ogrp, &outsize, status );
/* Get he noise level to add to the output data. */
parGet0d( "SIGMA", &sigma, status );
/* Get any Q and U input maps. */
if( *status == SAI__OK ) {
kpg1Rgndf( "QIN", 1, 1, "", &igrpq, &nskymap, status );
ndgNdfas( igrpq, 1, "READ", &indfq, status );
ndfMap( indfq, "DATA", "_DOUBLE", "READ", (void **) &inq_data, &nelqu,
status );
if( nelqu != nel && *status == SAI__OK ) {
ndfMsg( "Q", indfq );
*status = SAI__ERROR;
errRep( "", "Q image '^Q' is not the same size as the I image.",
status );
}
kpg1Rgndf( "UIN", 1, 1, "", &igrpu, &nskymap, status );
ndgNdfas( igrpu, 1, "READ", &indfu, status );
ndfMap( indfu, "DATA", "_DOUBLE", "READ", (void **) &inu_data, &nelqu,
status );
if( nelqu != nel && *status == SAI__OK ) {
ndfMsg( "U", indfu );
*status = SAI__ERROR;
errRep( "", "U image '^U' is not the same size as the I image.",
status );
}
if( *status == PAR__NULL ) {
ndfAnnul( &indfq, status );
ndfAnnul( &indfu, status );
inq_data = NULL;
inu_data = NULL;
errAnnul( status );
} else {
parGet0d( "ANGROT", &angrot, status );
parGet0d( "PAOFF", &paoff, status );
parGet0l( "PASIGN", &pasign, status );
}
}
/* Loop round all the template time series files. */
for( ifile = 1; ifile <= (int) size && *status == SAI__OK; ifile++ ) {
/* Start a new NDF context. */
ndfBegin();
/* Create the output NDF by propagating everything from the input, except
for quality and variance. */
ndgNdfas( igrp2, ifile, "READ", &indfin, status );
ndfMsg( "FILE", indfin );
msgSeti( "THISFILE", ifile );
msgSeti( "NUMFILES", size );
msgOutif( MSG__NORM, " ", "Simulating ^THISFILE/^NUMFILES ^FILE",
status );
ndgNdfpr( indfin, "DATA,HISTORY,LABEL,TITLE,WCS,UNITS,EXTENSION(*)",
ogrp, ifile, &indfout, status );
ndfAnnul( &indfin, status );
ndfAnnul( &indfout, status );
/* We now re-open the output NDF and then modify its data values. */
smf_open_file( wf, ogrp, ifile, "UPDATE", 0, &odata, status );
/* Issue a suitable message and abort if anything went wrong. */
if( *status != SAI__OK ) {
errRep( FUNC_NAME, "Could not open input template file.", status );
break;
} else {
if( odata->file == NULL ) {
*status = SAI__ERROR;
errRep( FUNC_NAME, "No smfFile associated with smfData.",
status );
break;
} else if( odata->hdr == NULL ) {
*status = SAI__ERROR;
errRep( FUNC_NAME, "No smfHead associated with smfData.",
status );
break;
}
}
/* Check the reference time series contains double precision values. */
smf_dtype_check_fatal( odata, NULL, SMF__DOUBLE, status );
/* Get the total number of data elements, and the number of time slices. */
smf_get_dims( odata, NULL, NULL, NULL, &ntslice, &ndata, NULL,
NULL, status );
/* Fill the output with bad values. */
if( *status == SAI__OK ) {
pd = odata->pntr[ 0 ];
for( iel = 0; iel < ndata; iel++ ) *(pd++) = VAL__BADD;
}
/* Resample the sky map data into the output time series. */
smf_resampmap( wf, odata, abskyfrm, skymap, moving, slbnd, subnd,
interp, params, sigma, in_data, odata->pntr[ 0 ],
NULL, &ngood, status );
/* Issue a wrning if there is no good data in the output cube. */
if( ngood == 0 ) msgOutif( MSG__NORM, " ", " Output contains no "
"good data values.", status );
/* If Q and U maps have been given, allocate room to hold resampled Q and
U values, and fill them with bad values. */
if( inq_data && inu_data ) {
pq = outq_data = astMalloc( ndata*sizeof( *outq_data ) );
pu = outu_data = astMalloc( ndata*sizeof( *outu_data ) );
if( *status == SAI__OK ) {
for( iel = 0; iel < ndata; iel++ ) {
*(pu++) = VAL__BADD;
*(pq++) = VAL__BADD;
}
}
/* Determine the harmonic to use. */
parGet0i( "HARMONIC", &harmonic, status );
/* Allocate room for an array to hold the anti-clockwise angle from the
focal plane Y axis to the Y pixel axis in the reference map, at each
time slice. */
ang_data = astMalloc( ntslice*sizeof( *ang_data ) );
/* Resample them both into 3D time series. */
smf_resampmap( wf, odata, abskyfrm, skymap, moving, slbnd, subnd,
interp, params, sigma, inq_data, outq_data,
ang_data, &ngood, status );
smf_resampmap( wf, odata, abskyfrm, skymap, moving, slbnd, subnd,
interp, params, sigma, inu_data, outu_data,
NULL, &ngood, status );
/* Combine these time series with the main output time series so that the
main output is analysed intensity. */
smf_uncalc_iqu( wf, odata, odata->pntr[ 0 ], outq_data, outu_data,
ang_data, pasign, AST__DD2R*paoff, AST__DD2R*angrot,
harmonic, status );
/* Release work space. */
outq_data = astFree( outq_data );
outu_data = astFree( outu_data );
ang_data = astFree( ang_data );
}
/* Close the output time series file. */
smf_close_file( wf, &odata, status );
/* End the NDF context. */
ndfEnd( status );
}
/* Close any input data file that is still open due to an early exit from
the above loop. */
if( odata != NULL ) {
smf_close_file( wf, &odata, status );
odata = NULL;
}
/* Free remaining resources. */
if( igrp1 != NULL) grpDelet( &igrp1, status);
if( igrp2 != NULL) grpDelet( &igrp2, status);
if( igrpq != NULL) grpDelet( &igrpq, status);
if( igrpu != NULL) grpDelet( &igrpu, status);
if( ogrp != NULL) grpDelet( &ogrp, status);
/* End the NDF context. */
ndfEnd( status );
/* End the tile's AST context. */
astEnd;
/* Issue a status indication.*/
if( *status == SAI__OK ) {
msgOutif(MSG__VERB," ",TASK_NAME " succeeded, time series written.", status);
} else {
msgOutif(MSG__VERB," ",TASK_NAME " failed.", status);
}
}
unsigned char *smf_get_mask( ThrWorkForce *wf, smf_modeltype mtype,
AstKeyMap *config, smfDIMMData *dat, int flags,
int *status ) {
/* Local Variables: */
AstCircle *circle; /* AST Region used to mask a circular area */
AstKeyMap *akm; /* KeyMap holding AST config values */
AstKeyMap *subkm; /* KeyMap holding model config values */
char refparam[ DAT__SZNAM ];/* Name for reference NDF parameter */
char words[100]; /* Buffer for variable message words */
const char *cval; /* The ZERO_MASK string value */
const char *modname; /* The name of the model being masked */
const char *skyrefis; /* Pointer to SkyRefIs attribute value */
dim_t i; /* Pixel index */
double *pd; /* Pointer to next element of map data */
double *predef; /* Pointer to mask defined by previous run */
double *ptr; /* Pointer to NDF Data array */
double *pv; /* Pointer to next element of map variance */
double centre[ 2 ]; /* Coords of circle centre in radians */
double meanhits; /* Mean hits in the map */
double radius[ 1 ]; /* Radius of circle in radians */
double zero_circle[ 3 ]; /* LON/LAT/Radius of circular mask */
double zero_lowhits; /* Fraction of mean hits at which to threshold */
double zero_snr; /* Higher SNR at which to threshold */
double zero_snrlo; /* Lower SNR at which to threshold */
int *ph; /* Pointer to next hits value */
int have_mask; /* Did a mask already exist on entry? */
int imask; /* Index of next mask type */
int indf1; /* Id. for supplied reference NDF */
int indf2; /* Id. for used section of reference NDF */
int isstatic; /* Are all used masks static? */
int lbnd_grid[ 2 ]; /* Lower bounds of map in GRID coords */
int mask_types[ NTYPE ]; /* Identifier for the types of mask to use */
int munion; /* Use union of supplied masks */
int nel; /* Number of mapped NDF pixels */
int nmask; /* The number of masks to be combined */
int nsource; /* No. of source pixels in final mask */
int skip; /* No. of iters for which AST is not subtracted */
int thresh; /* Absolute threshold on hits */
int ubnd_grid[ 2 ]; /* Upper bounds of map in GRID coords */
int zero_c_n; /* Number of zero circle parameters read */
int zero_mask; /* Use the reference NDF as a mask? */
int zero_niter; /* Only mask for the first "niter" iterations. */
int zero_notlast; /* Don't zero on last iteration? */
size_t ngood; /* Number good samples for stats */
smf_qual_t *pq; /* Pinter to map quality */
unsigned char **mask; /* Address of model's mask pointer */
unsigned char *newmask; /* Individual mask work space */
unsigned char *pm; /* Pointer to next returned mask pixel */
unsigned char *pn; /* Pointer to next new mask pixel */
unsigned char *result; /* Returned mask pointer */
/* Initialise returned values */
result = NULL;
/* Check inherited status. Also check that a map is being created. */
if( *status != SAI__OK || !dat || !dat->map ) return result;
/* Begin an AST context. */
astBegin;
/* Get the sub-keymap containing the configuration parameters for the
requested model. Also get a pointer to the mask array to use (there is
one for each maskable model)*/
if( mtype == SMF__COM ) {
modname = "COM";
mask = &(dat->com_mask);
} else if( mtype == SMF__AST ) {
modname = "AST";
mask = &(dat->ast_mask);
} else if( mtype == SMF__FLT ) {
modname = "FLT";
mask = &(dat->flt_mask);
} else {
modname = NULL;
mask = NULL;
*status = SAI__ERROR;
errRepf( " ", "smf_get_mask: Unsupported model type %d supplied - "
"must be COM, FLT or AST.", status, mtype );
}
subkm = NULL;
astMapGet0A( config, modname, &subkm );
/* Get the "ast.skip" value - when considering "zero_niter" and
"zero_freeze", we only count iterations for which the AST model
is subtracted (i.e. the ones following the initial "ast.skip"
iterations). */
astMapGet0A( config, "AST", &akm );
astMapGet0I( akm, "SKIP", &skip );
akm = astAnnul( akm );
/* Get the number of iterations over which the mask is to be applied. Zero
means all. Return with no mask if this number of iterations has
already been performed. */
zero_niter = 0;
astMapGet0I( subkm, "ZERO_NITER", &zero_niter );
if( zero_niter == 0 || dat->iter < zero_niter + skip ) {
/* Only return a mask if this is not the last iteration, or if ZERO_NOTLAST
is unset. */
zero_notlast = 0;
astMapGet0I( subkm, "ZERO_NOTLAST", &zero_notlast );
if( !( flags & SMF__DIMM_LASTITER ) || !zero_notlast ) {
/* Create a list of the mask types to be combined to get the final mask by
looking for non-default values for the corresponding configuration
parameters in the supplied KeyMap. Static masks (predefined, circles
or external NDFs) may be used on any iteration, but dynamic masks
(lowhits, snr) will only be avialable once the map has been determined
at the end of the first iteration. This means that when masking anything
but the AST model (which is determined after the map), the dynamic masks
cannot be used on the first iteration. Make a note if all masks being
used are static. */
isstatic = 1;
nmask = 0;
zero_lowhits = 0.0;
astMapGet0D( subkm, "ZERO_LOWHITS", &zero_lowhits );
if( zero_lowhits > 0.0 ) {
if( mtype == SMF__AST || !( flags & SMF__DIMM_FIRSTITER ) ) {
mask_types[ nmask++] = LOWHITS;
isstatic = 0;
}
} else if( zero_lowhits < 0.0 && *status == SAI__OK ) {
*status = SAI__ERROR;
errRepf( " ", "Bad value for config parameter %s.ZERO_LOWHITS (%g) - "
"it must not be negative.", status, modname, zero_lowhits );
}
if( astMapGet1D( subkm, "ZERO_CIRCLE", 3, &zero_c_n, zero_circle ) ) {
if( zero_c_n == 1 || zero_c_n == 3 ) {
mask_types[ nmask++] = CIRCLE;
} else if( *status == SAI__OK ) {
*status = SAI__ERROR;
errRepf( " ", "Bad number of values (%d) for config parameter "
"%s.ZERO_CIRCLE - must be 1 or 3.", status, zero_c_n,
modname );
}
}
cval = NULL;
astMapGet0C( subkm, "ZERO_MASK", &cval );
if( cval ) {
if( !astChrMatch( cval, "REF" ) &&
!astChrMatch( cval, "MASK2" ) &&
!astChrMatch( cval, "MASK3" ) ) {
astMapGet0I( subkm, "ZERO_MASK", &zero_mask );
cval = ( zero_mask > 0 ) ? "REF" : NULL;
}
if( cval ) {
strcpy( refparam, cval );
astChrCase( NULL, refparam, 1, 0 );
mask_types[ nmask++] = REFNDF;
}
}
zero_snr = 0.0;
astMapGet0D( subkm, "ZERO_SNR", &zero_snr );
if( zero_snr > 0.0 ) {
if( mtype == SMF__AST || !( flags & SMF__DIMM_FIRSTITER ) ) {
mask_types[ nmask++] = SNR;
isstatic = 0;
}
} else if( zero_snr < 0.0 && *status == SAI__OK ) {
*status = SAI__ERROR;
errRepf( " ", "Bad value for config parameter %s.ZERO_SNR (%g) - "
"it must not be negative.", status, modname, zero_snr );
}
if( astMapHasKey( subkm, "ZERO_MASK_POINTER" ) ) {
astMapGet0P( subkm, "ZERO_MASK_POINTER", (void **) &predef );
if( predef ) mask_types[ nmask++] = PREDEFINED;
}
/* No need to create a mask if no masking was requested or possible. */
if( nmask > 0 ) {
/* Decide if we are using the union or intersection of the masks. */
astMapGet0I( subkm, "ZERO_UNION", &munion );
/* Note if a mask existed on entry. If not, create a mask now, and
initialise it to hold the mask defined by the initial sky map. */
if( *mask == NULL ) {
have_mask = 0;
if( dat->initqual ) {
*mask = astMalloc( dat->msize*sizeof( **mask ) );
if( *mask ) {
pm = *mask;
pq = dat->initqual;
for( i = 0; i < dat->msize; i++ ) {
*(pm++) = ( *(pq++) != 0 );
}
}
} else{
*mask = astCalloc( dat->msize, sizeof( **mask ) );
}
} else {
have_mask = 1;
}
/* If we are combining more than one mask, we need work space to hold
an individual mask independently of the total mask. If we are using
only one mask, then just use the main mask array. */
if( nmask > 1 ) {
newmask = astMalloc( dat->msize*sizeof( *newmask ) );
} else {
newmask = *mask;
}
/* Get the number of iterations after which the mask is to be frozen.
Zero means "never freeze the mask". */
int zero_freeze = 0;
astMapGet0I( subkm, "ZERO_FREEZE", &zero_freeze );
/* Loop round each type of mask to be used. */
for( imask = 0; imask < nmask && *status == SAI__OK; imask++ ){
/* If the mask is now frozen, we just return the existing mask. So leave the
loop. */
if( zero_freeze != 0 && dat->iter > zero_freeze + skip ) {
break;
/* Low hits masking... */
} else if( mask_types[ imask ] == LOWHITS ) {
/* Set hits pixels with 0 hits to VAL__BADI so that stats1 ignores them */
ph = dat->hitsmap;
for( i = 0; i < dat->msize; i++,ph++ ) {
if( *ph == 0 ) *ph = VAL__BADI;
}
/* Find the mean hits in the map */
smf_stats1I( dat->hitsmap, 1, dat->msize, NULL, 0, 0, &meanhits,
NULL, NULL, &ngood, status );
msgOutiff( MSG__DEBUG, " ", "smf_get_mask: mean hits = %lf, ngood "
"= %zd", status, meanhits, ngood );
/* Create the mask */
thresh = meanhits*zero_lowhits;
ph = dat->hitsmap;
pn = newmask;
for( i = 0; i < dat->msize; i++,ph++ ) {
*(pn++) = ( *ph != VAL__BADI && *ph < thresh ) ? 1 : 0;
}
/* Report masking info. */
msgOutiff( MSG__DEBUG, " ", "smf_get_mask: masking %s "
"model at hits = %d.", status, modname, thresh );
/* Circle masking... */
} else if( mask_types[ imask ] == CIRCLE ) {
/* If we had a mask on entry, then there is no need to create a new one
since it will not have changed. But we need to recalculate the circle
mask if are combining it with any non-static masks. */
if( ! have_mask || ! isstatic ) {
/* If only one parameter supplied it is radius, assume reference
LON/LAT from the frameset to get the centre. If the SkyFrame
represents offsets from the reference position (i.e. the source is
moving), assume the circle is to be centred on the origin. */
if( zero_c_n == 1 ) {
zero_circle[ 2 ] = zero_circle[ 0 ];
skyrefis = astGetC( dat->outfset, "SkyRefIs" );
if( skyrefis && !strcmp( skyrefis, "Origin" ) ) {
zero_circle[ 0 ] = 0.0;
zero_circle[ 1 ] = 0.0;
} else {
zero_circle[ 0 ] = astGetD( dat->outfset, "SkyRef(1)" );
zero_circle[ 1 ] = astGetD( dat->outfset, "SkyRef(2)" );
}
zero_circle[ 0 ] *= AST__DR2D;
zero_circle[ 1 ] *= AST__DR2D;
}
/* The supplied bounds are for pixel coordinates... we need bounds for grid
coordinates which have an offset */
lbnd_grid[ 0 ] = 1;
lbnd_grid[ 1 ] = 1;
ubnd_grid[ 0 ] = dat->ubnd_out[ 0 ] - dat->lbnd_out[ 0 ] + 1;
ubnd_grid[ 1 ] = dat->ubnd_out[ 1 ] - dat->lbnd_out[ 1 ] + 1;
/* Coordinates & radius of the circular region converted from degrees
to radians */
centre[ 0 ] = zero_circle[ 0 ]*AST__DD2R;
centre[ 1 ] = zero_circle[ 1 ]*AST__DD2R;
radius[ 0 ] = zero_circle[ 2 ]*AST__DD2R;
/* Create the Circle, defined in the current Frame of the FrameSet (i.e.
the sky frame). */
circle = astCircle( astGetFrame( dat->outfset, AST__CURRENT), 1,
centre, radius, NULL, " " );
/* Fill the mask with zeros. */
memset( newmask, 0, sizeof( *newmask )*dat->msize );
/* Get the mapping from the sky frame (current) to the grid frame (base),
and then set the mask to 1 for all of the values outside this circle */
astMaskUB( circle, astGetMapping( dat->outfset, AST__CURRENT,
AST__BASE ),
0, 2, lbnd_grid, ubnd_grid, newmask, 1 );
/* Report masking info. */
if( zero_niter == 0 ) {
sprintf( words, "on each iteration" );
} else {
sprintf( words, "for %d iterations", zero_niter );
}
msgOutiff( MSG__DEBUG, " ", "smf_get_mask: The %s model will"
" be masked %s using a circle of "
"radius %g arc-secs, centred at %s=%s, %s=%s.",
status, modname, words, radius[0]*AST__DR2D*3600,
astGetC( dat->outfset, "Symbol(1)" ),
astFormat( dat->outfset, 1, centre[ 0 ] ),
astGetC( dat->outfset, "Symbol(2)" ),
astFormat( dat->outfset, 2, centre[ 1 ] ) );
}
/* Reference NDF masking... */
} else if( mask_types[ imask ] == REFNDF ) {
/* If we had a mask on entry, then there is no need to create a new one
since it will not have changed. But we need to recalculate the NDF
mask if are combining it with any non-static masks. */
if( ! have_mask || ! isstatic ) {
/* Begin an NDF context. */
ndfBegin();
/* Get an identifier for the NDF using the associated ADAM parameter. */
ndfAssoc( refparam, "READ", &indf1, status );
/* Get a section from this NDF that matches the bounds of the map. */
ndfSect( indf1, 2, dat->lbnd_out, dat->ubnd_out, &indf2,
status );
/* Map the section. */
ndfMap( indf2, "DATA", "_DOUBLE", "READ", (void **) &ptr,
&nel, status );
/* Check we can use the pointer safely. */
if( *status == SAI__OK ) {
/* Find bad pixels in the NDF and set those pixels to 1 in the mask. */
pn = newmask;
for( i = 0; i < dat->msize; i++ ) {
*(pn++) = ( *(ptr++) == VAL__BADD ) ? 1 : 0;
}
/* Report masking info. */
ndfMsg( "N", indf2 );
msgSetc( "M", modname );
if( zero_niter == 0 ) {
msgOutiff( MSG__DEBUG, " ", "smf_get_mask: The ^M "
"model will be masked on each iteration "
"using the bad pixels in NDF '^N'.",
status );
} else {
msgSeti( "I", zero_niter );
msgOutiff( MSG__DEBUG, " ", "smf_get_mask: The ^M "
"model will be masked for ^I iterations "
"using the bad pixels in NDF '^N'.",
status );
}
}
/* End the NDF context. */
ndfEnd( status );
}
/* SNR masking... */
} else if( mask_types[ imask ] == SNR ) {
/* Get the lower SNR limit. */
zero_snrlo = 0.0;
astMapGet0D( subkm, "ZERO_SNRLO", &zero_snrlo );
if( zero_snrlo <= 0.0 ) {
zero_snrlo = zero_snr;
} else if( zero_snrlo > zero_snr && *status == SAI__OK ) {
*status = SAI__ERROR;
errRepf( " ", "Bad value for config parameter "
"%s.ZERO_SNRLO (%g) - it must not be higher "
"than %s.ZERO_SNR (%g).", status, modname,
zero_snrlo, modname, zero_snr );
}
/* If the higher and lower SNR limits are equal, just do a simple
threshold on the SNR values to get the mask. */
if( zero_snr == zero_snrlo ) {
pd = dat->map;
pv = dat->mapvar;
pn = newmask;
for( i = 0; i < dat->msize; i++,pd++,pv++ ) {
*(pn++) = ( *pd != VAL__BADD && *pv != VAL__BADD &&
*pv >= 0.0 && *pd < zero_snr*sqrt( *pv ) ) ? 1 : 0;
}
/* Report masking info. */
if( !have_mask ) {
if( zero_niter == 0 ) {
sprintf( words, "on each iteration" );
} else {
sprintf( words, "for %d iterations", zero_niter );
}
msgOutiff( MSG__DEBUG, " ", "smf_get_mask: The %s model "
"will be masked %s using an SNR limit of %g.",
status, modname, words, zero_snr );
}
/* If the higher and lower SNR limits are different, create an initial
mask by thresholding at the ZERO_SNR value, and then extend the source
areas within the mask down to an SNR limit of ZERO_SNRLO. */
} else {
smf_snrmask( wf, dat->map, dat->mapvar, dat->mdims,
zero_snr, zero_snrlo, newmask, status );
/* Report masking info. */
if( !have_mask ) {
if( zero_niter == 0 ) {
sprintf( words, "on each iteration" );
} else {
sprintf( words, "for %d iterations", zero_niter );
}
msgOutiff( MSG__DEBUG, " ", "smf_get_mask: The %s model "
"will be masked %s using an SNR limit of %g "
"extended down to %g.", status, modname,
words, zero_snr, zero_snrlo );
}
}
/* Predefined masking... */
} else if( mask_types[ imask ] == PREDEFINED ) {
/* If we had a mask on entry, then there is no need to create a new one
since it will not have changed. But we need to recalculate the
mask if are combining it with any non-static masks. */
if( ! have_mask || ! isstatic ) {
/* Find bad pixels in the predefined array and set those pixels to 1 in
the mask. */
pn = newmask;
for( i = 0; i < dat->msize; i++ ) {
*(pn++) = ( *(predef++) == VAL__BADD ) ? 1 : 0;
}
/* Report masking info. */
if( zero_niter == 0 ) {
sprintf( words, "on each iteration" );
} else {
sprintf( words, "for %d iterations", zero_niter );
}
msgOutiff( MSG__DEBUG, " ", "smf_get_mask: The %s model "
"will be masked %s using a smoothed form of "
"the final mask created with the previous map.",
status, modname, words );
}
}
/* If required, add the new mask into the returned mask. If this is the
first mask, we just copy the new mask to form the returned mask.
Otherwise, we combine it with the existing returned mask. */
if( ! have_mask || ! isstatic ) {
if( nmask > 1 ) {
if( imask == 0 ) {
memcpy( *mask, newmask, dat->msize*sizeof(*newmask));
} else {
pm = *mask;
pn = newmask;
if( munion ) {
for( i = 0; i < dat->msize; i++,pm++ ) {
if( *(pn++) == 0 ) *pm = 0;
}
} else {
for( i = 0; i < dat->msize; i++,pm++ ) {
if( *(pn++) == 1 ) *pm = 1;
}
}
}
}
}
}
/* Free the individual mask work array if it was used. */
if( nmask > 1 ) newmask = astFree( newmask );
/* Check that the mask has some source pixels (i.e. pixels that have non-bad data values -
we do not also check variance values since they are not available until the second
iteration). */
if( *status == SAI__OK ) {
nsource = 0;
pm = *mask;
pd = dat->map;
for( i = 0; i < dat->msize; i++,pd++,pv++,pm++ ) {
if( *pd != VAL__BADD && *pm == 0 ) nsource++;
}
if( nsource < 5 && *status == SAI__OK ) {
*status = SAI__ERROR;
errRepf( "", "The %s mask being used has fewer than 5 "
"source pixels.", status, modname );
if( zero_snr > 0.0 ) {
errRepf( "", "Maybe your zero_snr value (%g) is too high?",
status, zero_snr );
}
}
}
/* Return the mask pointer if all has gone well. */
if( *status == SAI__OK ) result = *mask;
}
}
}
/* End the AST context, annulling all AST Objects created in the context. */
astEnd;
/* Return the pointer to the boolean mask. */
return result;
}
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_rebinsparse( smfData *data, int first, int *ptime, AstFrame *ospecfrm,
AstMapping *ospecmap, AstSkyFrame *oskyframe,
Grp *detgrp, int lbnd_out[ 3 ], int ubnd_out[ 3 ],
int genvar, float *data_array, float *var_array,
int *ispec, float *texp_array, float *teff_array,
double *fcon, int *status ){
/* Local Variables */
AstCmpMap *fmap = NULL; /* Mapping from spectral grid to topo freq Hz */
AstCmpMap *ssmap = NULL; /* I/p GRID-> o/p PIXEL Mapping for spectral axis */
AstFitsChan *fc = NULL; /* Storage for FITS headers */
AstFrame *specframe = NULL; /* Spectral Frame in input FrameSet */
AstFrame *specframe2 = NULL; /* Temporary copy of SpecFrame in input WCS */
AstFrameSet *fs = NULL; /* A general purpose FrameSet pointer */
AstFrameSet *swcsin = NULL; /* FrameSet describing spatial input WCS */
AstMapping *fsmap = NULL; /* Base->Current Mapping extracted from a FrameSet */
AstMapping *specmap = NULL; /* PIXEL -> Spec mapping in input FrameSet */
char *fftwin = NULL; /* Name of FFT windowing function */
const char *name = NULL; /* Pointer to current detector name */
const double *tsys=NULL; /* Pointer to Tsys value for first detector */
dim_t timeslice_size; /* No of detector values in one time slice */
double *spectab = NULL;/* Workspace for spectral output grid positions */
double *xin = NULL; /* Workspace for detector input grid positions */
double *xout = NULL; /* Workspace for detector output pixel positions */
double *yin = NULL; /* Workspace for detector input grid positions */
double *yout = NULL; /* Workspace for detector output pixel positions */
double at; /* Frequency at which to take the gradient */
double dnew; /* Channel width in Hz */
double fcon2; /* Variance factor for whole file */
double k; /* Back-end degradation factor */
double tcon; /* Variance factor for whole time slice */
float *pdata = NULL; /* Pointer to next data sample */
float *qdata = NULL; /* Pointer to next data sample */
float rtsys; /* Tsys value */
float teff; /* Effective integration time, times 4 */
float texp; /* Total time ( = ton + toff ) */
float toff; /* Off time */
float ton; /* On time */
int *nexttime = NULL; /* Pointer to next time slice index to use */
int dim[ 3 ]; /* Output array dimensions */
int found; /* Was current detector name found in detgrp? */
int good; /* Are there any good detector samples? */
int ibasein; /* Index of base Frame in input FrameSet */
int ichan; /* Index of current channel */
int iv; /* Offset to next element */
int iz; /* Output grid index on axis 3 */
int nchan; /* Number of input spectral channels */
int pixax[ 3 ]; /* The output fed by each selected mapping input */
int specax; /* Index of spectral axis in input FrameSet */
size_t irec; /* Index of current input detector */
size_t itime; /* Index of current time slice */
smfHead *hdr = NULL; /* Pointer to data header for this time slice */
/* Check inherited status */
if( *status != SAI__OK ) return;
/* Begin an AST context.*/
astBegin;
/* Store a pointer to the input NDFs smfHead structure. */
hdr = data->hdr;
/* Store the dimensions of the output array. */
dim[ 0 ] = ubnd_out[ 0 ] - lbnd_out[ 0 ] + 1;
dim[ 1 ] = ubnd_out[ 1 ] - lbnd_out[ 1 ] + 1;
dim[ 2 ] = ubnd_out[ 2 ] - lbnd_out[ 2 ] + 1;
/* Store the number of pixels in one time slice */
timeslice_size = (data->dims)[ 0 ]*(data->dims)[ 1 ];
/* We want a description of the spectral WCS axis in the input file. If
the input file has a WCS FrameSet containing a SpecFrame, use it,
otherwise we will obtain it from the FITS header later. NOTE, if we knew
that all the input NDFs would have the same spectral axis calibration,
then the spectral WCS need only be obtained from the first NDF. However,
in the general case, I presume that data files may be combined that use
different spectral axis calibrations, and so these differences need to
be taken into account. */
if( hdr->tswcs ) {
fs = astClone( hdr->tswcs );
/* The first axis should be a SpecFrame. See if this is so. If not annul
the specframe pointer. */
specax = 1;
specframe = astPickAxes( fs, 1, &specax, NULL );
if( !astIsASpecFrame( specframe ) ) specframe = astAnnul( specframe );
}
/* If the above did not yield a SpecFrame, use the FITS-WCS headers in the
FITS extension of the input NDF. Take a copy of the FITS header (so that
the contents of the header are not changed), and then read a FrameSet
out of it. */
if( !specframe ) {
fc = astCopy( hdr->fitshdr );
astClear( fc, "Card" );
fs = astRead( fc );
/* Extract the SpecFrame that describes the spectral axis from the current
Frame of this FrameSet. This is assumed to be the third WCS axis (NB
the different axis number). */
specax = 3;
specframe = astPickAxes( fs, 1, &specax, NULL );
}
/* Split off the 1D Mapping for this single axis from the 3D Mapping for
the whole WCS. This results in "specmap" holding the Mapping from
SpecFrame value to GRID value. */
fsmap = astGetMapping( fs, AST__CURRENT, AST__BASE );
astMapSplit( fsmap, 1, &specax, pixax, &specmap );
/* Invert the Mapping for the spectral axis so that it goes from input GRID
coord to spectral coord. */
astInvert( specmap );
/* Get a Mapping that converts values in the input spectral system to the
corresponding values in the output spectral system. */
fs = astConvert( specframe, ospecfrm, "" );
/* Concatenate these Mappings with the supplied spectral Mapping to get
a Mapping from the input spectral grid axis (pixel axis 1) to the
output spectral grid axis (pixel axis 3). Simplify the Mapping. */
ssmap = astCmpMap( astCmpMap( specmap, astGetMapping( fs, AST__BASE,
AST__CURRENT ),
1, " " ),
ospecmap, 1, " " );
ssmap = astSimplify( ssmap );
/* Create a table with one element for each channel in the input array,
holding the index of the nearest corresponding output channel. */
nchan = (data->dims)[ 0 ];
spectab = astMalloc( sizeof( *spectab )*nchan );
if( spectab ) {
for( ichan = 0; ichan < nchan; ichan++ ) spectab[ ichan ] = ichan + 1;
astTran1( ssmap, nchan, spectab, 1, spectab );
for( ichan = 0; ichan < nchan; ichan++ ) {
if( spectab[ ichan ] != AST__BAD ) {
iz = floor( spectab[ ichan ] + 0.5 );
if( iz >= 1 && iz <= dim[ 2 ] ) {
spectab[ ichan ] = iz;
} else {
spectab[ ichan ] = 0;
}
} else {
spectab[ ichan ] = 0;
}
}
}
/* Allocate work arrays big enough to hold the coords of all the
detectors in the current input file.*/
xin = astMalloc( (data->dims)[ 1 ] * sizeof( *xin ) );
yin = astMalloc( (data->dims)[ 1 ] * sizeof( *yin ) );
xout = astMalloc( (data->dims)[ 1 ] * sizeof( *xout ) );
yout = astMalloc( (data->dims)[ 1 ] * sizeof( *yout ) );
/* Initialise a string to point to the name of the first detector for which
data is available */
name = hdr->detname;
/* Store input coords for the detectors. Axis 1 is the detector index, and
axis 2 is a dummy axis that always has the value 1. */
for( irec = 0; irec < (data->dims)[ 1 ]; irec++ ) {
xin[ irec ] = irec + 1.0;
yin[ irec ] = 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 coords bad. */
if( detgrp ) {
found = grpIndex( name, detgrp, 1, status );
if( !found ) {
xin[ irec ] = AST__BAD;
yin[ irec ] = AST__BAD;
}
}
/* Move on to the next available detector name. */
name += strlen( name ) + 1;
}
/* Find the constant factor associated with the current input file. This
is the squared backend degradation factor, divided by the noise bandwidth.
Get the required FITS headers, checking they were found. */
if( astGetFitsF( hdr->fitshdr, "BEDEGFAC", &k ) &&
astGetFitsS( hdr->fitshdr, "FFT_WIN", &fftwin ) ){
/* Get a Mapping that converts values in the input spectral system to
topocentric frequency in Hz, and concatenate this Mapping with the
Mapping from input GRID coord to the input spectral system. The result
is a Mapping from input GRID coord to topocentric frequency in Hz. */
specframe2 = astCopy( specframe );
astSet( specframe2, "system=freq,stdofrest=topo,unit=Hz" );
fmap = astCmpMap( specmap, astGetMapping( astConvert( specframe,
specframe2,
"" ),
AST__BASE, AST__CURRENT ),
1, " " );
/* Differentiate this Mapping at the mid channel position to get the width
of an input channel in Hz. */
at = 0.5*nchan;
dnew = astRate( fmap, &at, 1, 1 );
/* Modify the channel width to take account of the effect of the FFT windowing
function. Allow undef value because FFT_WIN for old data had a broken value
in hybrid subband modes. */
if( dnew != AST__BAD ) {
dnew = fabs( dnew );
if( !strcmp( fftwin, "truncate" ) ) {
dnew *= 1.0;
} else if( !strcmp( fftwin, "hanning" ) ) {
dnew *= 1.5;
} else if( !strcmp( fftwin, "<undefined>" ) ) {
/* Deal with broken data - make an assumption */
dnew *= 1.0;
} else if( *status == SAI__OK ) {
*status = SAI__ERROR;
msgSetc( "W", fftwin );
errRep( FUNC_NAME, "FITS header FFT_WIN has unknown value "
"'^W' (programming error).", status );
}
/* Form the required constant. */
fcon2 = k*k/dnew;
} else {
fcon2 = VAL__BADD;
}
} else {
fcon2 = VAL__BADD;
}
/* Return the factor needed for calculating Tsys from the variance. */
if( first ) {
*fcon = fcon2;
} else if( fcon2 != *fcon ) {
*fcon = VAL__BADD;
}
/* Initialise a pointer to the next time slice index to be used. */
nexttime = ptime;
/* Loop round all the time slices in the input file. */
for( itime = 0; itime < (data->dims)[ 2 ] && *status == SAI__OK; itime++ ) {
/* If this time slice is not being pasted into the output cube, pass on. */
if( nexttime ){
if( *nexttime != itime ) continue;
nexttime++;
}
/* Store a pointer to the first input data value in this time slice. */
pdata = ( (float *) (data->pntr)[ 0 ] ) + itime*timeslice_size;
/* Get a FrameSet describing the spatial coordinate systems associated with
the current time slice of the current input data file. The base frame in
the FrameSet will be a 2D Frame in which axis 1 is detector number and
axis 2 is unused. The current Frame will be a SkyFrame (the SkyFrame
System may be any of the JCMT supported systems). The Epoch will be
set to the epoch of the time slice. */
smf_tslice_ast( data, itime, 1, NO_FTS, status );
swcsin = hdr->wcs;
/* Note the total exposure time (texp) for all the input spectra produced by
this time slice. */
ton = hdr->state->acs_exposure;
if( ton == 0.0 ) ton = VAL__BADR;
toff = hdr->state->acs_offexposure;
if( toff == 0.0 ) toff = VAL__BADR;
if( ton != VAL__BADR && toff != VAL__BADR ) {
texp = ton + toff;
teff = 4*ton*toff/( ton + toff );
} else {
texp = VAL__BADR;
teff = VAL__BADR;
}
/* If output variances are being calculated on the basis of Tsys values
in the input, find the constant factor associated with the current
time slice. */
tcon = AST__BAD;
if( genvar == 2 && fcon2 != AST__BAD && texp != VAL__BADR ) {
tcon = fcon2*( 1.0/ton + 1.0/toff );
/* Get a pointer to the start of the Tsys values for this time slice. */
tsys = hdr->tsys + hdr->ndet*itime;
}
/* We now create a Mapping from detector index to position in oskyframe. */
astInvert( swcsin );
ibasein = astGetI( swcsin, "Base" );
fs = astConvert( swcsin, oskyframe, "SKY" );
astSetI( swcsin, "Base", ibasein );
astInvert( swcsin );
if( fs == NULL ) {
if( *status == SAI__OK ) {
if (data->file) {
smf_smfFile_msg(data->file, "FILE", 1, "<unknown>");
} else {
msgSetc( "FILE", "<unknown>" );
}
*status = SAI__ERROR;
errRep( FUNC_NAME, "The spatial coordinate system in ^FILE "
"is not compatible with the spatial coordinate "
"system in the first input file.", status );
}
break;
}
/* Transform the positions of the detectors from input GRID to oskyframe
coords. */
astTran2( fs, (data->dims)[ 1 ], xin, yin, 1, xout, yout );
/* Loop round all detectors. */
for( irec = 0; irec < (data->dims)[ 1 ]; irec++ ) {
/* If the detector has a valid position, see if it produced any good
data values. */
if( xout[ irec ] != AST__BAD && yout[ irec ] != AST__BAD ) {
qdata = pdata;
good = 0;
for( ichan = 0; ichan < nchan; ichan++ ){
if( *(qdata++) != VAL__BADR ) {
good = 1;
break;
}
}
/* If it did, calculate the variance associated with each detector
sample (if required), based on the input Tsys values, and copy the
spectrum to the output NDF. */
if( good ) {
if( *ispec < dim[ 0 ] ){
rtsys = tsys ? (float) tsys[ irec ] : VAL__BADR;
if( rtsys <= 0.0 ) rtsys = VAL__BADR;
if( tcon != AST__BAD && genvar == 2 && rtsys != VAL__BADR ) {
var_array[ *ispec ] = tcon*rtsys*rtsys;
} else if( var_array ) {
var_array[ *ispec ] = VAL__BADR;
}
if( texp != VAL__BADR ) {
texp_array[ *ispec ] = texp;
teff_array[ *ispec ] = teff;
}
for( ichan = 0; ichan < nchan; ichan++, pdata++ ) {
iz = spectab[ ichan ] - 1;
if( iz >= 0 && iz < dim[ 2 ] ) {
iv = *ispec + dim[ 0 ]*iz;
data_array[ iv ] = *pdata;
}
}
(*ispec)++;
} else if( *status == SAI__OK ){
*status = SAI__ERROR;
msgSeti( "DIM", dim[ 0 ] );
errRep( " ", "Too many spectra (more than ^DIM) for "
"the output NDF (programming error).", status );
break;
}
/* If this detector does not have any valid data values, increment the data
pointer to point at the first sample for the next detector. */
} else {
pdata += nchan;
}
/* If this detector does not have a valid position, increment the data
pointer to point at the first sample for the next detector. */
} else {
pdata += nchan;
}
}
/* For efficiency, explicitly annul the AST Objects created in this tight
loop. */
fs = astAnnul( fs );
}
/* Free resources */
spectab = astFree( spectab );
xin = astFree( xin );
yin = astFree( yin );
xout = astFree( xout );
yout = astFree( yout );
/* End the AST context. This will annul all AST objects created within the
context (except for those that have been exported from the context). */
astEnd;
}
static void smf1_fit_qui_job( void *job_data, int *status ) {
/*
* Name:
* smf1_fit_qui_job
* Purpose:
* Calculate I, Q and U for a block of bolometers.
* Invocation:
* void smf1_fit_qui_job( void *job_data, int *status )
* Arguments:
* job_data = void * (Given)
* Pointer to the data needed by the job. Should be a pointer to a
* smfFitQUIJobData structure.
* status = int * (Given and Returned)
* Pointer to global status.
* Description:
* This routine calculate the I, Q and U values for each bolometer in
* a block of bolometers. It runs within a thread instigated by
* smf_fit_qui.
*/
/* Local Variables: */
AstFrameSet *wcs; /* WCS FrameSet for current time slice */
AstMapping *g2s; /* GRID to SKY mapping */
AstMapping *s2f; /* SKY to focal plane mapping */
const JCMTState *allstates;/* Pointer to array of JCMTState structures */
const JCMTState *state; /* JCMTState info for current time slice */
dim_t b1; /* First bolometer index */
dim_t b2; /* Last bolometer index */
dim_t box_size; /* NFirst time slice in box */
dim_t ibolo; /* Bolometer index */
dim_t ibox;
dim_t ncol;
dim_t nbolo; /* Total number of bolometers */
double *dat; /* Pointer to start of input data values */
double *din; /* Pointer to input data array for bolo/time */
double *ipi; /* Pointer to output I array */
double *ipq; /* Pointer to output Q array */
double *ipu; /* Pointer to output U array */
double *ipv; /* Pointer to output weights array */
double *pm;
double *ps;
double angle; /* Phase angle for FFT */
double angrot; /* Angle from focal plane X axis to fixed analyser */
double c1;
double c2;
double c4;
double c8;
double cosval; /* Cos of angrot */
double fit;
double fx[2]; /* Focal plane X coord at bolometer and northern point*/
double fy[2]; /* Focal plane Y coord at bolometer and northern point*/
double gx; /* GRID X coord at bolometer */
double gy; /* GRID Y coord at bolometer */
double matrix[ NPAR*NPAR ];
double paoff; /* WPLATE value corresponding to POL_ANG=0.0 */
double phi; /* Angle from fixed analyser to effective analyser */
double res;
double s1; /* Sum of weighted cosine terms */
double s2; /* Sum of weighted sine terms */
double s4;
double s8;
double sinval; /* Sin of angrot */
double solution[ NPAR ];
double sum1; /* Sum of squared residuals */
double sums[NSUM]; /* Sum of bolometer values */
double sx[2]; /* SKY X coord at bolometer and northern point*/
double sy[2]; /* SKY Y coord at bolometer and northern point*/
double tr_angle;
double twophi;
double vector[ NPAR ];
double wplate; /* Angle from fixed analyser to have-wave plate */
gsl_matrix_view gsl_m;
gsl_vector_view gsl_b;
gsl_vector_view gsl_x;
int ipolcrd; /* Reference direction for pol_ang */
int nsum1;
int pasign; /* +1 or -1 indicating sense of POL_ANG value */
smfFitQUIJobData *pdata; /* Pointer to job data */
smf_qual_t *qin; /* Pointer to input quality array for bolo/time */
smf_qual_t *qua; /* Pointer to start of input quality values */
/* Check inherited status */
if( *status != SAI__OK ) return;
/* Begin an AST context */
astBegin;
/* Create views of the matrix and vector buffers that can be used by GSL. */
gsl_m = gsl_matrix_view_array( matrix, NPAR, NPAR );
gsl_b = gsl_vector_view_array( vector, NPAR );
gsl_x = gsl_vector_view_array( solution, NPAR );
/* Get a pointer to the job data, and then extract its contents into a
set of local variables. */
pdata = (smfFitQUIJobData *) job_data;
b1 = pdata->b1;
b2 = pdata->b2;
nbolo = pdata->nbolo;
ncol = pdata->ncol;
dat = pdata->dat + b1;
qua = pdata->qua + b1;
allstates = pdata->allstates;
ipi = pdata->ipi ? pdata->ipi + b1 : NULL;
ipq = pdata->ipq + b1;
ipu = pdata->ipu + b1;
ipv = pdata->ipv + b1;
ipolcrd = pdata->ipolcrd;
pasign = pdata->pasign;
paoff = pdata->paoff;
angrot = pdata->angrot;
box_size = pdata->box_size;
wcs = pdata->wcs;
if( wcs ) {
astLock( wcs, 0 );
/* Get the mapping from GRID to SKY. */
g2s = astSimplify( astGetMapping( wcs, AST__BASE, AST__CURRENT ));
/* Get the mapping from SKY to focal plane (x,y) (the index of the FPLANE
Frame is fixed at 3 by file sc2ast.c). */
s2f = astSimplify( astGetMapping( wcs, AST__CURRENT, 3 ) );
} else{
g2s = s2f = NULL;
}
/* Check we have something to do. */
if( b1 < nbolo && *status == SAI__OK ) {
/* Loop round all bolometers to be processed by this thread. */
for( ibolo = b1; ibolo <= b2; ibolo++,qua++,dat++ ) {
/* If the returned Stokes parameters are to be with respect to Tracking
North, get the angle from tracking north at the current bolometer to
focal plane Y, measured positive in the sense of rotation from focal
plane Y to focal plane X (note this angle may change across the focal
plane due to focal plane distortion). Otherwise, use zero. */
if( pdata->wcs ) {
/* Get the grid coords of the current bolometer, and transform them to SKY
coordinates using the FrameSet. */
gx = ibolo % ncol + 1;
gy = ibolo / ncol + 1;
astTran2( g2s, 1, &gx, &gy, 1, sx, sy );
/* Increment the sky position slightly to the north. */
sx[ 1 ] = sx[ 0 ];
sy[ 1 ] = sy[ 0 ] + 1.0E-6;
/* Transform both sky positions into focal plane coords. */
astTran2( s2f, 2, sx, sy, 1, fx, fy );
/* Get the angle from north to focal plane Y, measured positive in the
sense of rotation from focal plane Y to focal plane X. */
if( fx[0] != VAL__BADD && fy[0] != VAL__BADD &&
fx[1] != VAL__BADD && fy[1] != VAL__BADD ) {
tr_angle = atan2( fx[0] - fx[1], fy[1] - fy[0] );
} else {
tr_angle = VAL__BADD;
}
} else {
tr_angle = 0.0;
}
/* If the whole bolometer is bad, put bad values into the outputs. */
if( *qua & SMF__Q_BADB || tr_angle == VAL__BADD ) {
if( ipi ) *(ipi++) = VAL__BADD;
*(ipq++) = VAL__BADD;
*(ipu++) = VAL__BADD;
*(ipv++) = VAL__BADD;
/* If the bolometer is good, calculate and store the output i, q and u
values. */
} else {
/* Initialise pointers to the first input data value, quality value and
state info to be used in the current fitting box. */
din = dat;
qin = qua;
state = allstates;
/* Form the sums needed to calculate the best fit Q, U and I. This
involves looping over all input samples that fall within the fitting box
centred on the current output sample. The 44 sums are stored in the
"sums" array. Initialise it to hold zeros. */
memset( sums, 0, NSUM*sizeof(*sums) );
for( ibox = 0; ibox < box_size; ibox++,state++ ) {
/* Get the POL_ANG value for this time slice. */
angle = state->pol_ang;
/* Check the input sample has not been flagged during cleaning and is
not bad. */
if( !( *qin & SMF__Q_FIT ) && *din != VAL__BADD &&
angle != VAL__BADD ) {
/* Following SUN/223 (section "Single-beam polarimetry"/"The Polarimeter"),
get the angle from the fixed analyser to the half-waveplate axis, in radians.
Positive rotation is from focal plane axis 1 (x) to focal plane axis 2 (y).
Not sure about the sign of tcs_az/tr_ang at the moment so do not use them
yet. */
wplate = 0.0;
if( ipolcrd == 0 ) {
wplate = pasign*angle + paoff;
} else if( *status == SAI__OK ) {
*status = SAI__ERROR;
errRepf( "", "smf_fit_qui: currently only POL_CRD = "
"FPLANE is supported.", status );
}
/*
if( ipolcrd == 1 ) {
wplate += state->tcs_az_ang;
} else if( ipolcrd == 2 ) {
wplate += state->tcs_tr_ang;
}
*/
/* Get the angle from the fixed analyser to the effective analyser
position (see SUN/223 again). The effective analyser angle rotates twice
as fast as the half-wave plate which is why there is a factor of 2 here. */
phi = 2*wplate;
twophi = 2*phi;
/* Form the trig values needed for the sums. */
s8 = sin( 2*twophi );
c8 = cos( 2*twophi );
s4 = sin( twophi );
c4 = cos( twophi );
s2 = sin( phi );
c2 = cos( phi );
s1 = sin( wplate );
c1 = cos( wplate );
/* Update the sums. The order of the following lines define the index
within "sums" at which each sum is stored. */
ps = sums;
*(ps++) += s4*s4;
*(ps++) += s4*c4;
*(ps++) += s4*s2;
*(ps++) += s4*c2;
*(ps++) += s4*s1;
*(ps++) += s4*c1;
*(ps++) += s4*ibox;
*(ps++) += s4;
*(ps++) += s4*(*din);
*(ps++) += s2*c4;
*(ps++) += s2*s2;
*(ps++) += s2*c2;
*(ps++) += s2*s1;
*(ps++) += s2*c1;
*(ps++) += s2*ibox;
*(ps++) += s2;
*(ps++) += s2*(*din);
*(ps++) += s1*c4;
*(ps++) += s1*c2;
*(ps++) += s1*s1;
*(ps++) += s1*c1;
*(ps++) += s1*ibox;
*(ps++) += s1;
*(ps++) += s1*(*din);
*(ps++) += c4*c4;
*(ps++) += c4*c2;
*(ps++) += c4*c1;
*(ps++) += c4*ibox;
*(ps++) += c4;
*(ps++) += c4*(*din);
*(ps++) += c2*c2;
*(ps++) += c2*c1;
*(ps++) += c2*ibox;
*(ps++) += c2;
*(ps++) += c2*(*din);
*(ps++) += c1*c1;
*(ps++) += c1*ibox;
*(ps++) += c1;
*(ps++) += c1*(*din);
*(ps++) += ibox*ibox;
*(ps++) += ibox;
*(ps++) += ibox*(*din);
*(ps++) += 1.0;
*(ps++) += *din;
*(ps++) += s4*s8;
*(ps++) += s4*c8;
*(ps++) += s2*s8;
*(ps++) += s2*c8;
*(ps++) += s1*s8;
*(ps++) += s1*c8;
*(ps++) += s8*c4;
*(ps++) += s8*c2;
*(ps++) += s8*c1;
*(ps++) += s8*ibox;
*(ps++) += s8;
*(ps++) += s8*(*din);
*(ps++) += s8*s8;
*(ps++) += s8*c8;
*(ps++) += c4*c8;
*(ps++) += c2*c8;
*(ps++) += c1*c8;
*(ps++) += c8*ibox;
*(ps++) += c8;
*(ps++) += c8*(*din);
*(ps++) += c8*c8;
}
din += nbolo;
qin += nbolo;
}
/* Now find the parameters of the best fit. First check that there were
sufficient good samples in the fitting box. */
if( sums[42] > 0.8*box_size ) {
/* Copy the sums to the correct elements of the 10x10 matrix. */
pm = matrix;
*(pm++) = sums[ 0 ];
*(pm++) = sums[ 1 ];
*(pm++) = sums[ 2 ];
*(pm++) = sums[ 3 ];
*(pm++) = sums[ 4 ];
*(pm++) = sums[ 5 ];
*(pm++) = sums[ 6 ];
*(pm++) = sums[ 7 ];
*(pm++) = sums[ 44 ];
*(pm++) = sums[ 45 ];
*(pm++) = sums[ 1 ];
*(pm++) = sums[ 24 ];
*(pm++) = sums[ 9 ];
*(pm++) = sums[ 25 ];
*(pm++) = sums[ 17 ];
*(pm++) = sums[ 26 ];
*(pm++) = sums[ 27 ];
*(pm++) = sums[ 28 ];
*(pm++) = sums[ 50 ];
*(pm++) = sums[ 58 ];
*(pm++) = sums[ 2 ];
*(pm++) = sums[ 9 ];
*(pm++) = sums[ 10 ];
*(pm++) = sums[ 11 ];
*(pm++) = sums[ 12 ];
*(pm++) = sums[ 13 ];
*(pm++) = sums[ 14 ];
*(pm++) = sums[ 15 ];
*(pm++) = sums[ 46 ];
*(pm++) = sums[ 47 ];
*(pm++) = sums[ 3 ];
*(pm++) = sums[ 25 ];
*(pm++) = sums[ 11 ];
*(pm++) = sums[ 30 ];
*(pm++) = sums[ 18 ];
*(pm++) = sums[ 31 ];
*(pm++) = sums[ 32 ];
*(pm++) = sums[ 33 ];
*(pm++) = sums[ 51 ];
*(pm++) = sums[ 59 ];
*(pm++) = sums[ 4 ];
*(pm++) = sums[ 17 ];
*(pm++) = sums[ 12 ];
*(pm++) = sums[ 18 ];
*(pm++) = sums[ 19 ];
*(pm++) = sums[ 20 ];
*(pm++) = sums[ 21 ];
*(pm++) = sums[ 22 ];
*(pm++) = sums[ 48 ];
*(pm++) = sums[ 49 ];
*(pm++) = sums[ 5 ];
*(pm++) = sums[ 26 ];
*(pm++) = sums[ 13 ];
*(pm++) = sums[ 31 ];
*(pm++) = sums[ 20 ];
*(pm++) = sums[ 35 ];
*(pm++) = sums[ 36 ];
*(pm++) = sums[ 37 ];
*(pm++) = sums[ 52 ];
*(pm++) = sums[ 60 ];
*(pm++) = sums[ 6 ];
*(pm++) = sums[ 27 ];
*(pm++) = sums[ 14 ];
*(pm++) = sums[ 32 ];
*(pm++) = sums[ 21 ];
*(pm++) = sums[ 36 ];
*(pm++) = sums[ 39 ];
*(pm++) = sums[ 40 ];
*(pm++) = sums[ 53 ];
*(pm++) = sums[ 61 ];
*(pm++) = sums[ 7 ];
*(pm++) = sums[ 28 ];
*(pm++) = sums[ 15 ];
*(pm++) = sums[ 33 ];
*(pm++) = sums[ 22 ];
*(pm++) = sums[ 37 ];
*(pm++) = sums[ 40 ];
*(pm++) = sums[ 42 ];
*(pm++) = sums[ 54 ];
*(pm++) = sums[ 62 ];
*(pm++) = sums[ 44 ];
*(pm++) = sums[ 50 ];
*(pm++) = sums[ 46 ];
*(pm++) = sums[ 51 ];
*(pm++) = sums[ 48 ];
*(pm++) = sums[ 52 ];
*(pm++) = sums[ 53 ];
*(pm++) = sums[ 54 ];
*(pm++) = sums[ 56 ];
*(pm++) = sums[ 57 ];
*(pm++) = sums[ 45 ];
*(pm++) = sums[ 58 ];
*(pm++) = sums[ 47 ];
*(pm++) = sums[ 59 ];
*(pm++) = sums[ 49 ];
*(pm++) = sums[ 60 ];
*(pm++) = sums[ 61 ];
*(pm++) = sums[ 62 ];
*(pm++) = sums[ 57 ];
*(pm++) = sums[ 64 ];
/* Copy the remaining sums to the correct elements of the 8 vector. */
pm = vector;
*(pm++) = sums[ 8 ];
*(pm++) = sums[ 29 ];
*(pm++) = sums[ 16 ];
*(pm++) = sums[ 34 ];
*(pm++) = sums[ 23 ];
*(pm++) = sums[ 38 ];
*(pm++) = sums[ 41 ];
*(pm++) = sums[ 43 ];
*(pm++) = sums[ 55 ];
*(pm++) = sums[ 63 ];
/* Find the solution to the 10x10 set of linear equations. The matrix is
symmetric and positive-definite so use Cholesky decomposition. */
memset( solution, 0, NPAR*sizeof(*solution) );
gsl_linalg_cholesky_decomp( &gsl_m.matrix );
gsl_linalg_cholesky_solve( &gsl_m.matrix, &gsl_b.vector,
&gsl_x.vector );
/* Modify Q and U so they use the requested reference direction, and store in
the output arrays. */
cosval = cos( 2*( angrot - tr_angle ) );
sinval = sin( 2*( angrot - tr_angle ) );
*(ipq++) = 2*( -solution[ 1 ]*cosval + solution[ 0 ]*sinval );
*(ipu++) = 2*( -solution[ 1 ]*sinval - solution[ 0 ]*cosval );
/* Store the correspoinding I value. */
if( ipi ) *(ipi++) = solution[ 6 ]*box_size + 2*solution[ 7 ];
/* Loop over the data again in the same way to calculate the variance of the
residuals between the above fit and the supplied data. */
din = dat;
qin = qua;
state = allstates;
sum1 = 0.0;
nsum1 = 0;
for( ibox = 0; ibox < box_size; ibox++,state++ ) {
angle = state->pol_ang;
if( !( *qin & SMF__Q_FIT ) && *din != VAL__BADD &&
angle != VAL__BADD ) {
wplate = pasign*angle + paoff;
/*
if( ipolcrd == 1 ) {
wplate += state->tcs_az_ang;
} else if( ipolcrd == 2 ) {
wplate += state->tcs_tr_ang;
}
*/
phi = 2*wplate;
twophi = 2*phi;
s8 = sin( 2*twophi );
c8 = cos( 2*twophi );
s4 = sin( twophi );
c4 = cos( twophi );
s2 = sin( phi );
c2 = cos( phi );
s1 = sin( wplate );
c1 = cos( wplate );
fit = solution[0]*s4 +
solution[1]*c4 +
solution[2]*s2 +
solution[3]*c2 +
solution[4]*s1 +
solution[5]*c1 +
solution[6]*ibox +
solution[7] +
solution[8]*s8 +
solution[9]*c8;
res = *din - fit;
sum1 += res*res;
nsum1++;
}
din += nbolo;
qin += nbolo;
}
/* Calculate the variance of the residuals, and then scale it to get the
notional variance for the returned Q,. U and I values. The scaling
factor is determined emprically to get reasonable agreement between these
notional variances and the noise actually seen in the Q and U values
for 10 test observations. The reason for storing these as Q/U variances
rather than as a weights component in the SMURF extension is so that
makemap can pick them up easily and use them to initialise the NOI
model, which is used for weighting the bolometer data when forming the
COM model on the first iteration. */
*(ipv++) = 0.0253*sum1/nsum1;
/* Store bad values if there were too few good samples in the fitting
box. */
} else {
if( ipi ) *(ipi++) = VAL__BADD;
*(ipq++) = VAL__BADD;
*(ipu++) = VAL__BADD;
*(ipv++) = VAL__BADD;
}
}
}
}
if( wcs ) {
g2s = astAnnul( g2s );
s2f = astAnnul( s2f );
astUnlock( wcs, 1 );
}
/* End the AST context */
astEnd;
}