AstKeyMap *smf_subinst_keymap( smf_subinst_t subinst, const smfData * indata,
const Grp * igrp, size_t idx, int * status ) {
const smfHead * hdr = NULL; /* Header of file to be examined */
size_t i;
smfData * sub_data = NULL; /* File to be examined */
AstKeyMap * sub_instruments; /* Keymap to be filled */
if (*status != SAI__OK) return NULL;
if (subinst == SMF__SUBINST_NONE && !indata && !igrp) {
*status = SAI__ERROR;
errRep( "", "Must supply either a subinst, a smfData or a Grp"
" (possible programming error)", status );
return NULL;
}
/* Create new keymap */
sub_instruments = astKeyMap( " " );
/* prefill with the list of known sub-instruments. */
for (i = 0; i < SMF__SUBINST_NSUBINST; i++ ) {
const char * substr = smf_subinst_str( i, status );
if (substr) astMapPut0I( sub_instruments, substr, 0, NULL );
}
/* If the current sub-instrument has not been supplied, get it from the file.
Use indata in preference to the group */
if( subinst == SMF__SUBINST_NONE ) {
if (indata) {
hdr = indata->hdr;
} else {
smf_open_file( igrp, idx, "READ", SMF__NOCREATE_DATA, &sub_data, status );
if (sub_data) {
hdr = sub_data->hdr;
}
}
if (hdr) subinst = smf_calc_subinst( hdr, status );
}
/* flag this as being the relevant sub-instrument */
if (subinst != SMF__SUBINST_NSUBINST ) {
const char * substr = smf_subinst_str( subinst, status );
if (substr) {
astMapPut0I( sub_instruments, substr, 1, NULL );
}
}
if (sub_data) smf_close_file( &sub_data, status );
/* Free the keymap if we have bad status */
if (*status != SAI__OK && sub_instruments) {
sub_instruments = astAnnul( sub_instruments );
}
return sub_instruments;
}
void smf_flat_smfData ( const smfData *data, smf_flatmeth * flatmethod,
double * refres, smfData ** powval, smfData **bolval,
int *status ) {
smfDA * da = NULL;
*powval = NULL;
*bolval = NULL;
*flatmethod = SMF__FLATMETH_NULL;
if (*status != SAI__OK) return;
if (!data) return;
if (!(data->da)) return;
da = data->da;
/* we need to malloc space to make sure that we do not free the pointers
twice. There really needs to be a way to tell smf_close_file to free
everything except the pointers to the data. */
smf_flat_malloc( da->nflat, data, powval, bolval, status );
/* flatpar is powval */
if (*status == SAI__OK) {
size_t nelem = (*bolval)->dims[0] * (*bolval)->dims[1] * (*bolval)->dims[2];
memcpy( (*powval)->pntr[0], da->flatpar, da->nflat * sizeof(*(da->flatpar)) );
memcpy( (*bolval)->pntr[0], da->flatcal, nelem * sizeof(*(da->flatcal)) );
}
*flatmethod = da->flatmeth;
*refres = da->refres;
if (*status != SAI__OK) {
if (*bolval) smf_close_file( bolval, status );
if (*powval) smf_close_file( powval, status );
}
return;
}
void smurf_rawrewrtsc2wcs( int * status ) {
size_t i;
Grp *igrp = NULL; /* Input group */
size_t size; /* Number of files in input group */
if (*status != SAI__OK) return;
ndfBegin();
/* Read the input file group */
kpg1Rgndf( "NDF", 0, 1, "", &igrp, &size, status );
for (i=1; i<=size && ( *status == SAI__OK ); i++) {
int indf = NDF__NOID;
smfData *data = NULL;
AstFrameSet * fixedwcs = NULL;
int isok = 1;
/* First open in READ mode as a sanity check */
smf_open_file( igrp, i, "READ", 0, &data, status );
if (*status != SAI__OK) break;
if (data->hdr->instrument != INST__SCUBA2) {
isok = 0;
msgOut( "", "This command only works on SCUBA-2 data files", status );
}
/* Get a fixed WCS frameset */
if (isok) {
smf_create_tswcs( data->hdr, &fixedwcs, status );
}
/* close up and skip if this is not a good file */
smf_close_file( &data, status );
if (!isok) continue;
/* Now we try to update the file using NDF */
ndgNdfas( igrp, i, "UPDATE", &indf, status );
ndfPtwcs( fixedwcs, indf, status );
ndfAnnul( &indf, status );
}
/* Cleanup */
grpDelet( &igrp, status);
ndfEnd( status );
}
/* Main entry */
void smurf_checkcoords( int *status ) {
/* Local Variables */
Grp *igrp = NULL;
size_t i;
size_t size;
smfData *data = NULL;
/* Check inherited status */
if (*status != SAI__OK) return;
/* begin an NDF context. */
ndfBegin();
/* Get a group of input files */
kpg1Rgndf( "IN", 0, 1, " Give more NDFs...", &igrp, &size, status );
/* Loop round each one. */
for( i = 1; i <= size; i++ ) {
/* Open the file. */
smf_open_file( NULL, igrp, i, "READ", SMF__NOCREATE_DATA, &data, status );
/* Check the detector positions (for ACSIS data). */
msgBlank( status );
smf_check_detpos( data, 1, status );
/* Calculate and display statistics of the AZEL <> TRACKING separations
in the current file. */
smf_check_coords( data, status );
/* Close the file. */
smf_close_file( NULL, &data, status);
}
/* Free resources. */
grpDelet( &igrp, status );
/* End the NDF context. */
ndfEnd( status );
/* If anything went wrong issue a context message. */
if( *status != SAI__OK ) msgOutif( MSG__VERB, " ", "CHECKCOORDS failed.",
status );
}
void smf_open_asdouble( const Grp *igrp, size_t index, const smfArray* darks,
const smfArray* flatramps, AstKeyMap * heateffmap,
int ensureflat, smfData **data, int *status ) {
if( *status != SAI__OK ) return;
/* Load data, flatfielding and/or opening raw as double as necessary */
if( ensureflat ) {
smf_open_and_flatfield( igrp, NULL, index, darks, flatramps, heateffmap,
data, status );
} else {
/* open as raw if raw else just open as whatever we have */
smfData *tmpdata = NULL;
smf_open_file( igrp, index, "READ", SMF__NOCREATE_DATA, &tmpdata, status );
if (tmpdata && tmpdata->file && tmpdata->file->isSc2store) {
smf_open_raw_asdouble( igrp, index, darks, data, status );
} else {
smf_open_and_flatfield( igrp, NULL, index, darks, flatramps, heateffmap,
data, status );
}
smf_close_file( &tmpdata, 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;
}
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 smurf_sc2pca( int *status ) {
smfData *amplitudes=NULL; /* Amplitudes of each component */
smfArray *bbms=NULL; /* Bad bolometer masks */
smfData *components=NULL; /* Components */
smfArray *darks=NULL ; /* Dark data */
int ensureflat; /* Flag for flatfielding data */
smfData *data=NULL; /* Pointer to input smfData */
Grp *fgrp=NULL; /* Filtered group, no darks */
smfArray *flatramps=NULL; /* Flatfield ramps */
AstKeyMap *heateffmap = NULL; /* Heater efficiency data */
size_t i=0; /* Counter, index */
Grp *igrp=NULL; /* Input group of files */
Grp *outampgrp=NULL; /* Output amplitude group of files */
Grp *outcompgrp=NULL; /* Output component group of files */
size_t outampsize; /* Total number of NDF names in ocompgrp */
size_t outcompsize; /* Total number of NDF names in ocompgrp */
size_t size; /* Number of files in input group */
ThrWorkForce *wf=NULL; /* Pointer to a pool of worker threads */
/* Main routine */
ndfBegin();
/* Find the number of cores/processors available and create a pool of
threads of the same size. */
wf = thrGetWorkforce( thrGetNThread( SMF__THREADS, status ), status );
/* Get input file(s) */
kpg1Rgndf( "IN", 0, 1, "", &igrp, &size, status );
/* Are we flatfielding? */
parGet0l( "FLAT", &ensureflat, status );
/* Filter out useful data (revert to darks if no science data) */
smf_find_science( wf, igrp, &fgrp, 1, NULL, NULL, 1, 1, SMF__NULL, &darks,
&flatramps, &heateffmap, NULL, status );
/* input group is now the filtered group so we can use that and
free the old input group */
size = grpGrpsz( fgrp, status );
grpDelet( &igrp, status);
igrp = fgrp;
fgrp = NULL;
if( size > 0 ) {
/* Get output file(s) */
kpg1Wgndf( "OUTAMP", igrp, size, size, "More output files required...",
&outampgrp, &outampsize, status );
kpg1Wgndf( "OUTCOMP", igrp, size, size, "More output files required...",
&outcompgrp, &outcompsize, status );
} else {
msgOutif(MSG__NORM, " ","All supplied input frames were DARK,"
" nothing to flatfield", status );
}
/* Get group of bolometer masks and read them into a smfArray */
smf_request_mask( wf, "BBM", &bbms, status );
for( i=1; i<=size; i++ ) {
if( *status != SAI__OK ) break;
/* Load data, flatfielding and/or opening raw as double as necessary */
smf_open_asdouble( wf, igrp, i, darks, flatramps, heateffmap, ensureflat, &data, status );
/* Mask out bad bolometers */
smf_apply_mask( wf, data, bbms, SMF__BBM_DATA|SMF__BBM_QUAL, 0, status );
/* Sync quality with bad values */
smf_update_quality( wf, data, 1, NULL, 0, 0.05, status );
/* Calculate the PCA */
smf_clean_pca( wf, data, 0, 0, 0, &components, &litudes, 0, 1, NULL,
status );
/* Write out to the new files */
smf_write_smfData( wf, amplitudes, NULL, NULL, outampgrp, i, 0, MSG__VERB,
0, status );
smf_write_smfData( wf, components, NULL, NULL, outcompgrp, i, 0, MSG__VERB,
0, status );
/* Free resources for output data */
smf_close_file( wf, &data, status );
smf_close_file( wf, &litudes, status );
smf_close_file( wf, &components, status );
}
/* Write out the list of output NDF names, annulling the error if a null
parameter value is supplied. */
if( *status == SAI__OK && outampgrp ) {
grpList( "OUTAMPFILES", 0, 0, NULL, outampgrp, status );
if( *status == PAR__NULL ) errAnnul( status );
}
if( *status == SAI__OK && outcompgrp ) {
grpList( "OUTCOMPFILES", 0, 0, NULL, outcompgrp, status );
if( *status == PAR__NULL ) errAnnul( status );
}
/* Tidy up after ourselves: release the resources used by the grp routines */
if( igrp ) grpDelet( &igrp, status);
if( outampgrp ) grpDelet( &outampgrp, status);
if( outcompgrp ) grpDelet( &outcompgrp, status);
if( darks ) smf_close_related( wf, &darks, status );
if( bbms ) smf_close_related( wf, &bbms, status );
if( flatramps ) smf_close_related( wf, &flatramps, status );
if (heateffmap) heateffmap = smf_free_effmap( heateffmap, status );
ndfEnd( status );
}
void smf_mask_noisy( ThrWorkForce *wf, smfData *data, smfData **noise,
double sigcliphigh, double sigcliplow, int cliplog,
int zeropad, int * status ) {
size_t i;
dim_t nbolo = 0; /* Number of bolometers */
double *noisedata = NULL; /* Pointer to the noise data array */
smfData * noisemap = NULL; /* Somewhere to receive the result */
double *work = NULL; /* Temporary work array */
if (*status != SAI__OK) return;
if( (sigcliphigh <= 0.0) && (sigcliplow <= 0.0) ) return;
/* Work out how many bolometers we have */
smf_get_dims( data, NULL, NULL, &nbolo, NULL, NULL,
NULL, NULL, status );
/* Create some space for the result */
smf_create_bolfile( wf, NULL, 1, data, "Noise", "blahs s**0.5",
SMF__MAP_VAR, &noisemap, status );
if (noisemap) noisedata = (noisemap->pntr)[0];
/* Calculate the noise on each bolometer */
smf_bolonoise( wf, data, -1.0, 0, 0.5, SMF__F_WHITELO,
SMF__F_WHITEHI, 0, zeropad ? SMF__MAXAPLEN : SMF__BADSZT,
(noisemap->pntr)[0], NULL, NULL, status );
/* Now need to convert this to noise by square rooting */
if (*status == SAI__OK) {
for (i=0; i<nbolo; i++) {
if (noisedata[i] != VAL__BADD) {
noisedata[i] = sqrt( noisedata[i] );
}
}
}
/* Now create a mask and then mask the quality. We only mask bolometers
that are too noisy. We also do not mask bolometers that were already
masked. We want the statistics to reflect what we actually masked
and not any previous masking. This will miss any bolometers masked
out by smf_bolonoise because they had zero power. */
msgOutif( MSG__VERB, "", FUNC_NAME
": Checking for bolometers with outlier noise values. ", status );
msgOutiff( MSG__VERB, "", FUNC_NAME
": Units are (%s s**0.5): ", status, data->hdr->units );
work = astCalloc( nbolo, sizeof(*work) );
if( *status == SAI__OK ) memcpy( work, noisedata, nbolo*sizeof(*work) );
smf_clipnoise( noisedata, nbolo, cliplog, sigcliplow, sigcliphigh, NULL,
status );
/* The only bad values that should appear in noisedata are new bolometers
that were clipped by smf_clipnoise, not bolometers that were bad before
for other reasons. */
if( *status == SAI__OK ) {
for( i=0; i<nbolo; i++ ) {
if( (noisedata[i]==VAL__BADD) && (work[i] == VAL__BADD) ) {
noisedata[i] = 0;
}
}
}
if( work ) work = astFree( work );
/* The mask has to be inside a smfArray */
if (*status == SAI__OK) {
smfArray *masks = smf_create_smfArray( status );
if (masks) masks->owndata = 0; /* someone else owns the smfData */
smf_addto_smfArray( masks, noisemap, status );
smf_apply_mask( wf, data, masks, SMF__BBM_QUAL, SMF__Q_NOISE,
status );
smf_close_related( wf, &masks, status );
}
/* Give noisemap back to caller if requested, or close it */
if( noise ) {
*noise = noisemap;
} else {
smf_close_file( wf, &noisemap, status );
}
}
void smf_calc_mapcoord( ThrWorkForce *wf, AstKeyMap *config, smfData *data,
AstFrameSet *outfset, int moving, int *lbnd_out,
int *ubnd_out, fts2Port fts_port, int flags,
int *status ) {
/* Local Variables */
AstSkyFrame *abskyfrm = NULL;/* Output SkyFrame (always absolute) */
AstMapping *bolo2map=NULL; /* Combined mapping bolo->map coordinates */
int bndndf=NDF__NOID; /* NDF identifier for map bounds */
void *data_pntr[1]; /* Array of pointers to mapped arrays in ndf */
int *data_index; /* Mapped DATA_ARRAY part of NDF */
int docalc=1; /* If set calculate the LUT */
int doextension=0; /* Try to write LUT to MAPCOORD extension */
smfFile *file=NULL; /* smfFile pointer */
AstObject *fstemp = NULL; /* AstObject version of outfset */
int ii; /* loop counter */
int indf_lat = NDF__NOID; /* Identifier for NDF to receive lat values */
int indf_lon = NDF__NOID; /* Identifier for NDF to receive lon values */
smfCalcMapcoordData *job_data=NULL; /* Array of job */
int lbnd[1]; /* Pixel bounds for 1d pointing array */
int lbnd_old[2]; /* Pixel bounds for existing LUT */
int lbnd_temp[1]; /* Bounds for bounds NDF component */
int lutndf=NDF__NOID; /* NDF identifier for coordinates */
AstMapping *map2sky_old=NULL;/* Existing mapping map->celestial coord. */
HDSLoc *mapcoordloc=NULL; /* HDS locator to the MAPCOORD extension */
int nw; /* Number of worker threads */
AstFrameSet *oldfset=NULL; /* Pointer to existing WCS info */
AstSkyFrame *oskyfrm = NULL; /* SkyFrame from the output WCS Frameset */
smfCalcMapcoordData *pdata=NULL; /* Pointer to job data */
double *lat_ptr = NULL; /* Pointer to array to receive lat values */
double *lon_ptr = NULL; /* Pointer to array to receive lon values */
int ubnd[1]; /* Pixel bounds for 1d pointing array */
int ubnd_old[2]; /* Pixel bounds for existing LUT */
int ubnd_temp[1]; /* Bounds for bounds NDF component */
int *lut = NULL; /* The lookup table */
dim_t nbolo=0; /* Number of bolometers */
dim_t ntslice=0; /* Number of time slices */
int nmap; /* Number of mapped elements */
AstMapping *sky2map=NULL; /* Mapping celestial->map coordinates */
size_t step; /* step size for dividing up work */
AstCmpMap *testcmpmap=NULL; /* Combined forward/inverse mapping */
AstMapping *testsimpmap=NULL;/* Simplified testcmpmap */
double *theta = NULL; /* Scan direction at each time slice */
int tstep; /* Time slices between full Mapping calculations */
int exportlonlat; /* Dump longitude and latitude values? */
/* Main routine */
if (*status != SAI__OK) return;
/* How many threads do we get to play with */
nw = wf ? wf->nworker : 1;
/* Initialize bounds to avoid compiler warnings */
lbnd_old[0] = 0;
lbnd_old[1] = 0;
ubnd_old[0] = 0;
ubnd_old[1] = 0;
/* Check for pre-existing LUT and de-allocate it. This will only waste
time if the MAPCOORD extension is found to be valid and it has
to be re-loaded from disk. */
smf_close_mapcoord( data, status );
/* Assert ICD data order */
smf_dataOrder( data, 1, status );
/* Get the data dimensions */
smf_get_dims( data, NULL, NULL, &nbolo, &ntslice, NULL, NULL, NULL, status );
/* If SMF__NOCREATE_FILE is not set, and file associated with an NDF,
map a new MAPCOORD extension (or verify an existing one) */
if( !(flags & SMF__NOCREATE_FILE) && data->file ) {
doextension = 1;
} else {
doextension = 0;
docalc = 1;
}
/* Create / check for existing MAPCOORD extension */
if( doextension ) {
file = data->file;
/* Check type of file before proceeding */
if( file->isSc2store ) {
*status = SAI__ERROR;
errRep(FUNC_NAME,
"File was opened by sc2store library (raw data?)",
status);
}
if( !file->isTstream ) {
*status = SAI__ERROR;
errRep(FUNC_NAME, "File does not contain time stream data",status);
}
/* Get HDS locator to the MAPCOORD extension */
mapcoordloc = smf_get_xloc( data, "MAPCOORD", "MAP_PROJECTION", "UPDATE",
0, 0, status );
/* Obtain NDF identifier/placeholder for LUT in MAPCOORD extension*/
lbnd[0] = 0;
ubnd[0] = nbolo*ntslice-1;
lutndf = smf_get_ndfid( mapcoordloc, "LUT", "UPDATE", "UNKNOWN",
"_INTEGER", 1, lbnd, ubnd, status );
if( *status == SAI__OK ) {
/* store the NDF identifier */
file->mapcoordid = lutndf;
/* Create sky to output grid mapping using the base coordinates to
get the coordinates of the tangent point if it hasn't been done
yet. */
sky2map = astGetMapping( outfset, AST__CURRENT, AST__BASE );
}
/* Before mapping the LUT, first check for existing WCS information
and LBND/UBND for the output map. If they are already correct don't
bother re-calculating the LUT! */
if( *status == SAI__OK ) {
/* Try reading in the WCS information */
kpg1Wread( mapcoordloc, "WCS", &fstemp, status );
oldfset = (AstFrameSet*)fstemp;
if( *status == SAI__OK ) {
/* Check that the old and new mappings are the same by
checking that combining one with the inverse of the other
reduces to a UnitMap. */
map2sky_old = astGetMapping( oldfset, AST__BASE, AST__CURRENT );
testcmpmap = astCmpMap( map2sky_old, sky2map, 1, " " );
testsimpmap = astSimplify( testcmpmap );
if( astIsAUnitMap( testsimpmap ) ) {
/* The mappings are the same, now just check the pixel
bounds in the output map */
lbnd_temp[0] = 1;
ubnd_temp[0] = 2;
bndndf = smf_get_ndfid( mapcoordloc, "LBND", "READ", "UNKNOWN",
"_INTEGER", 1, lbnd_temp, ubnd_temp,
status );
if( *status == SAI__OK ) {
ndfMap( bndndf, "DATA", "_INTEGER", "READ", data_pntr, &nmap,
status );
data_index = data_pntr[0];
if( *status == SAI__OK ) {
lbnd_old[0] = data_index[0];
lbnd_old[1] = data_index[1];
}
ndfAnnul( &bndndf, status );
}
bndndf = smf_get_ndfid( mapcoordloc, "UBND", "READ", "UNKNOWN",
"_INTEGER", 1, lbnd_temp, ubnd_temp,
status );
if( *status == SAI__OK ) {
ndfMap( bndndf, "DATA", "_INTEGER", "READ", data_pntr, &nmap,
status );
data_index = data_pntr[0];
if( *status == SAI__OK ) {
ubnd_old[0] = data_index[0];
ubnd_old[1] = data_index[1];
}
ndfAnnul( &bndndf, status );
}
if( *status == SAI__OK ) {
/* If we get this far finally do the bounds check! */
if( (lbnd_old[0] == lbnd_out[0]) &&
(lbnd_old[1] == lbnd_out[1]) &&
(ubnd_old[0] == ubnd_out[0]) &&
(ubnd_old[1] == ubnd_out[1]) ) {
docalc = 0; /* We don't have to re-calculate the LUT */
msgOutif(MSG__VERB," ",FUNC_NAME ": Existing LUT OK",
status);
}
}
}
/* Bad status / AST errors at this point due to problems with
MAPCOORD. Annul and continue calculating new MAPCOORD extension. */
astClearStatus;
errAnnul(status);
} else {
/* Bad status due to non-existence of MAPCOORD. Annul and continue */
errAnnul(status);
}
}
}
/* If we need to calculate the LUT do it here */
if( docalc && (*status == SAI__OK) ) {
msgOutif(MSG__VERB," ", FUNC_NAME ": Calculate new LUT",
status);
/* Get the increment in time slices between full Mapping calculations.
The Mapping for intermediate time slices will be approximated. */
dim_t dimval;
smf_get_nsamp( config, "TSTEP", data, &dimval, status );
tstep = dimval;
/* Get space for the LUT */
if( doextension ) {
/* Map the LUT array */
ndfMap( lutndf, "DATA", "_INTEGER", "WRITE", data_pntr, &nmap,
status );
data_index = data_pntr[0];
if( *status == SAI__OK ) {
lut = data_index;
} else {
errRep( FUNC_NAME, "Unable to map LUT in MAPCOORD extension",
status);
}
} else {
/* alloc the LUT and THETA arrays */
lut = astMalloc( (nbolo*ntslice)*sizeof(*(data->lut)) );
theta = astMalloc( ntslice*sizeof(*(data->theta)) );
}
/* Retrieve the sky2map mapping from the output frameset (actually
map2sky) */
oskyfrm = astGetFrame( outfset, AST__CURRENT );
sky2map = astGetMapping( outfset, AST__BASE, AST__CURRENT );
/* If the longitude and latitude is being dumped, create new NDFs to
hold them, and map them. */
if( config ) {
astMapGet0I( config, "EXPORTLONLAT", &exportlonlat );
if( exportlonlat ) {
lon_ptr = smf1_calc_mapcoord1( data, nbolo, ntslice, oskyfrm,
&indf_lon, 1, status );
lat_ptr = smf1_calc_mapcoord1( data, nbolo, ntslice, oskyfrm,
&indf_lat, 2, status );
}
}
/* Invert the mapping to get Output SKY to output map coordinates */
astInvert( sky2map );
/* Create a SkyFrame in absolute coordinates */
abskyfrm = astCopy( oskyfrm );
astClear( abskyfrm, "SkyRefIs" );
astClear( abskyfrm, "SkyRef(1)" );
astClear( abskyfrm, "SkyRef(2)" );
if( *status == SAI__OK ) {
/* --- Begin parellelized portion ------------------------------------ */
/* Start a new job context. Each call to thrWait within this
context will wait until all jobs created within the context have
completed. Jobs created in higher contexts are ignored by thrWait. */
thrBeginJobContext( wf, status );
/* Allocate job data for threads */
job_data = astCalloc( nw, sizeof(*job_data) );
if( *status == SAI__OK ) {
/* Set up job data, and start calculating pointing for blocks of
time slices in different threads */
if( nw > (int) ntslice ) {
step = 1;
} else {
step = ntslice/nw;
}
for( ii=0; (*status==SAI__OK)&&(ii<nw); ii++ ) {
pdata = job_data + ii;
/* Blocks of time slices */
pdata->t1 = ii*step;
pdata->t2 = (ii+1)*step-1;
/* Ensure that the last thread picks up any left-over tslices */
if( (ii==(nw-1)) && (pdata->t1<(ntslice-1)) ) {
pdata->t2=ntslice-1;
}
pdata->ijob = -1;
pdata->lut = lut;
pdata->theta = theta;
pdata->lbnd_out = lbnd_out;
pdata->moving = moving;
pdata->ubnd_out = ubnd_out;
pdata->tstep = tstep;
pdata->lat_ptr = lat_ptr;
pdata->lon_ptr = lon_ptr;
pdata->fts_port = fts_port;
/* Make deep copies of AST objects and unlock them so that each
thread can then lock them for their own exclusive use */
pdata->abskyfrm = astCopy( abskyfrm );
astUnlock( pdata->abskyfrm, 1 );
pdata->sky2map = astCopy( sky2map );
astUnlock( pdata->sky2map, 1 );
/* Similarly, make a copy of the smfData, including only the header
information which each thread will need in order to make calls to
smf_rebin_totmap */
pdata->data = smf_deepcopy_smfData( data, 0, SMF__NOCREATE_FILE |
SMF__NOCREATE_DA |
SMF__NOCREATE_FTS |
SMF__NOCREATE_DATA |
SMF__NOCREATE_VARIANCE |
SMF__NOCREATE_QUALITY, 0, 0,
status );
smf_lock_data( pdata->data, 0, status );
}
for( ii=0; ii<nw; ii++ ) {
/* Submit the job */
pdata = job_data + ii;
pdata->ijob = thrAddJob( wf, THR__REPORT_JOB, pdata,
smfCalcMapcoordPar, 0, NULL, status );
}
/* Wait until all of the jobs submitted within the current job
context have completed */
thrWait( wf, status );
}
/* End the current job context. */
thrEndJobContext( wf, status );
/* --- End parellelized portion -------------------------------------- */
/* Set the lut pointer in data to the buffer */
data->lut = lut;
data->theta = theta;
/* Write the WCS for the projection to the extension */
if( doextension ) {
kpg1Wwrt( (AstObject*)outfset, "WCS", mapcoordloc, status );
/* Write the pixel bounds for the map to the extension */
lbnd_temp[0] = 1; /* Don't get confused! Bounds for NDF that will */
ubnd_temp[0] = 2; /* contain the bounds for the output 2d map! */
bndndf = smf_get_ndfid( mapcoordloc, "LBND", "UPDATE", "UNKNOWN",
"_INTEGER", 1, lbnd_temp, ubnd_temp, status );
ndfMap( bndndf, "DATA", "_INTEGER", "WRITE", data_pntr, &nmap,
status );
data_index = data_pntr[0];
if( *status == SAI__OK ) {
data_index[0] = lbnd_out[0];
data_index[1] = lbnd_out[1];
} else {
errRep( FUNC_NAME, "Unable to map LBND in MAPCOORD extension",
status);
}
ndfAnnul( &bndndf, status );
bndndf = smf_get_ndfid( mapcoordloc, "UBND", "UPDATE", "UNKNOWN",
"_INTEGER", 1, lbnd_temp, ubnd_temp, status );
ndfMap( bndndf, "DATA", "_INTEGER", "WRITE", data_pntr, &nmap,
status );
data_index = data_pntr[0];
if( *status == SAI__OK ) {
data_index[0] = ubnd_out[0];
data_index[1] = ubnd_out[1];
} else {
errRep( FUNC_NAME, "Unable to map UBND in MAPCOORD extension",
status);
}
ndfAnnul( &bndndf, status );
}
}
}
/* Clean Up */
if( testsimpmap ) testsimpmap = astAnnul( testsimpmap );
if( testcmpmap ) testcmpmap = astAnnul( testcmpmap );
if( map2sky_old ) map2sky_old = astAnnul( map2sky_old );
if( oldfset ) oldfset = astAnnul( oldfset );
if (sky2map) sky2map = astAnnul( sky2map );
if (bolo2map) bolo2map = astAnnul( bolo2map );
if( abskyfrm ) abskyfrm = astAnnul( abskyfrm );
if( oskyfrm ) oskyfrm = astAnnul( oskyfrm );
if( mapcoordloc ) datAnnul( &mapcoordloc, status );
if( indf_lat != NDF__NOID ) ndfAnnul( &indf_lat, status );
if( indf_lon != NDF__NOID ) ndfAnnul( &indf_lon, status );
/* If we get this far, docalc=0, and status is OK, there must be
a good LUT in there already. Map it so that it is accessible to
the caller; "UPDATE" so that the caller can modify it if desired. */
if( (*status == SAI__OK) && (docalc == 0) ) {
smf_open_mapcoord( data, "UPDATE", status );
}
/* Clean up job data */
if( job_data ) {
for( ii=0; (*status==SAI__OK)&&(ii<nw); ii++ ) {
pdata = job_data + ii;
if( pdata->data ) {
smf_lock_data( pdata->data, 1, status );
smf_close_file( &(pdata->data), status );
}
astLock( pdata->abskyfrm, 0 );
pdata->abskyfrm = astAnnul( pdata->abskyfrm );
astLock( pdata->sky2map, 0 );
pdata->sky2map = astAnnul( pdata->sky2map );
}
job_data = astFree( job_data );
}
}
void smf_close_file( smfData ** data, int * status ) {
void *buf=NULL; /* Buffer pointer */
size_t buflen=0; /* Size of buffer */
smfDA * da; /* pointer to smfDA in smfData */
smfFts* fts; /* pointer to smfFts in smfData */
size_t datalen=0; /* Size of data buffer in bytes */
smfDream *dream = NULL; /* Pointer to smfDream in smfData */
smfFile * file; /* pointer to smfFile in smfData */
int freedata = 0; /* should the data arrays be freed? */
smfHead * hdr; /* pointer to smfHead in smfData */
size_t headlen=0; /* Size of header (mmap'd files) in bytes */
size_t i; /* loop counter */
smfDIMMHead *temphead=NULL; /* Pointer to DIMM header */
/* we need to be able to clean up even if input status is bad -
this requires some defensive programming. */
if ( *data == NULL ) {
if ( *status == SAI__OK ) {
/* Status is good so we have a problem */
*status = SAI__ERROR;
errRep( ERRFUNC, "Attempt to close file when smfData pointer is NULL (possible programming error)",
status );
}
/* null pointer so just return since there is nothing to free */
return;
}
/* Process reference count */
/* Only proceed if the decremented reference count is 0 */
(*data)->refcount--;
if ((*data)->refcount > 0 ) return;
/* Get the header and file, since we need them for checking */
hdr = (*data)->hdr;
/* Before annulling close NDF try closing SCU2RED.MAPCOORD */
smf_close_mapcoord( *data, status );
/* Display any warnings generated by AST and stored in the FitsChan. */
file = (*data)->file;
if( hdr && hdr->fitshdr ) {
fts1Astwn( hdr->fitshdr,
file ? file->ndfid : NDF__NOID,
status );
}
/* now file information */
if (file != NULL) {
if ( file->isSc2store ) {
/* Nothing to free here except for data */
freedata = 1;
} else if ( file->ndfid != NDF__NOID ) {
/* Handle quality as a special case */
if ( (*data)->qual) {
(*data)->qual = smf_qual_unmap( file->ndfid, (*data)->qfamily,
(*data)->qual, status );
}
/* Annul the NDF (which will unmap things) */
ndfAnnul( &(file->ndfid), status );
} else if( file->fd ) {
/* Array was mmap'd to a file, and must now be sync'd and unmapped,
and the file descriptor closed */
/* Get the size of the header and data section */
smf_calc_mmapsize( sizeof(*temphead), *data, &headlen, &datalen,
&buflen, status );
/* The header is in the same mapped array as the data array,
but headlen bytes earlier. Point temphead to this location and
update relevant header values before closing */
buf = ((char*)((*data)->pntr[0]) - headlen);
temphead = (smfDIMMHead *) buf;
temphead->data.isTordered = (*data)->isTordered;
temphead->data.dtype = (*data)->dtype;
temphead->data.ndims = (*data)->ndims;
memcpy( temphead->data.dims, (*data)->dims, sizeof( temphead->data.dims));
if( msync( buf, buflen, MS_ASYNC ) == -1 ) {
*status = SAI__ERROR;
errRep( ERRFUNC, "Unable to synch model container file", status );
} else if( munmap( buf, buflen ) == -1 ) {
*status = SAI__ERROR;
errRep( ERRFUNC, "Unable to unmap model container file", status );
} else if( close( file->fd ) == -1 ) {
*status = SAI__ERROR;
errRep( ERRFUNC, "Unable to close model container file", status );
} else {
file->fd = 0;
}
} else {
/* No file so free the data */
freedata = 1;
}
(*data)->file = astFree( (*data)->file );
} else {
/* no file - data is ours to free */
freedata = 1;
}
/* Tidy up the header */
if (hdr != NULL) {
if (hdr->wcs != NULL) hdr->wcs = astAnnul( hdr->wcs );
if (hdr->tswcs != NULL) hdr->tswcs = astAnnul( hdr->tswcs );
if (hdr->fitshdr != NULL) hdr->fitshdr = astAnnul( hdr->fitshdr );
if( hdr->cache1 ) hdr->cache1 = sc2ast_createwcs2( SC2AST__NULLSUB, NULL, 0.0, NULL, NULL, NULL,
hdr->cache1, status );
if( hdr->cache2 ) hdr->cache2 = smf_create_lutwcs( 1, NULL, NULL, 0, NULL, 0.0, NULL,
NULL, NULL, hdr->cache2, status );
if( hdr->cache3 ) hdr->cache3 = smf_detpos_wcs( NULL, -1, 0.0, NULL, NULL, hdr->cache3,
status );
if (!hdr->isCloned) {
/* We are responsible for this memory - although what happens
when we are cloned and the original is freed first? Need
to think carefully about memory management. */
if (hdr->allState != NULL) {
hdr->allState = astFree( hdr->allState );
}
if (hdr->fplanex) hdr->fplanex = astFree( hdr->fplanex );
if (hdr->fplaney) hdr->fplaney = astFree( hdr->fplaney );
if (hdr->detpos) hdr->detpos = astFree( hdr->detpos );
if (hdr->tsys) hdr->tsys = astFree( hdr->tsys );
if (hdr->detname) hdr->detname = astFree( hdr->detname );
if (hdr->ocsconfig) hdr->ocsconfig = astFree( hdr->ocsconfig );
}
hdr = astFree( hdr );
}
/* Now the smfDA itself */
if ( (*data)->da != NULL ) {
da = (*data)->da;
da->flatcal = astFree( da->flatcal );
da->flatpar = astFree( da->flatpar );
if( da->dksquid) smf_close_file( &da->dksquid, status );
da->heatval = astFree( da->heatval );
da = astFree( da );
}
/* Free smfFts */
if((*data)->fts != NULL) {
fts = (*data)->fts;
if(fts->zpd) { smf_close_file(&fts->zpd, status); }
if(fts->fpm) { smf_close_file(&fts->fpm, status); }
if(fts->sigma) { smf_close_file(&fts->sigma, status); }
fts = astFree(fts);
}
/* Free smfDream */
if ( (*data)->dream != NULL ) {
dream = (*data)->dream;
if ( dream->gridwts != NULL)
dream->gridwts = astFree( dream->gridwts );
if ( dream->invmatx != NULL)
dream->invmatx = astFree( dream->invmatx );
dream= astFree( dream );
}
/* Free up other pointers in the smfData: */
if ( (*data)->poly ) {
(*data)->poly = astFree( (*data)->poly );
}
if ( (*data)->lut ) {
(*data)->lut = astFree( (*data)->lut );
}
if( (*data)->theta ) {
(*data)->theta = astFree( (*data)->theta );
}
/* Free the data arrays if they are non-null (they should have been
freed if they were mapped to a file but not if they were stored
in a separate action as temp storage */
if (freedata) {
for (i = 0; i < 2; i++ ) {
if ( ((*data)->pntr)[i] != NULL )
((*data)->pntr)[i] = astFree( ((*data)->pntr)[i] );
}
if ( (*data)->qual ) {
(*data)->qual = astFree( (*data)->qual );
}
}
/* finally free smfData */
*data = astFree( *data );
}
void smf_bolonoise( ThrWorkForce *wf, smfData *data, double gfrac,
size_t window, double f_low,
double f_white1, double f_white2,
int nep, size_t len, double *whitenoise, double *fratio,
smfData **fftpow,int *status ) {
double *base=NULL; /* Pointer to base coordinates of array */
size_t bstride; /* bolometer index stride */
double df=1; /* Frequency step size in Hz */
size_t i; /* Loop counter */
size_t i_low; /* Index in power spectrum to f_low */
size_t i_w1; /* Index in power spectrum to f_white1 */
size_t i_w2; /* Index in power spectrum to f_white2 */
size_t j; /* Loop counter */
size_t mingood; /* Min. required no. of good values in bolometer */
dim_t nbolo; /* Number of bolometers */
dim_t ndata; /* Number of data points */
dim_t nf=0; /* Number of frequencies */
size_t ngood; /* Number of good samples */
dim_t ntslice; /* Number of time slices */
double p_low; /* Power at f_low */
double p_white; /* Average power from f_white1 to f_white2 */
smfData *pow=NULL; /* Pointer to power spectrum data */
smf_qual_t *qua=NULL; /* Pointer to quality component */
double steptime=1; /* Length of a sample in seconds */
size_t tstride; /* time index stride */
if (*status != SAI__OK) return;
/* Check inputs */
if (!smf_dtype_check_fatal( data, NULL, SMF__DOUBLE, status )) return;
if( !data->hdr ) {
*status = SAI__ERROR;
errRep( "", FUNC_NAME ": smfData has no header", status );
return;
}
/* Obtain dimensions */
smf_get_dims( data, NULL, NULL, &nbolo, &ntslice, &ndata, &bstride, &tstride,
status );
if( *status==SAI__OK ) {
steptime = data->hdr->steptime;
if( steptime < VAL__SMLD ) {
*status = SAI__ERROR;
errRep("", FUNC_NAME ": FITS header error, STEPTIME must be > 0",
status);
} else {
/* Frequency steps in the FFT */
df = 1. / (steptime * (double) ntslice );
}
}
/* Initialize arrays */
if( whitenoise ) for(i=0; i<nbolo; i++) whitenoise[i] = VAL__BADD;
if( fratio ) for(i=0; i<nbolo; i++) fratio[i] = VAL__BADD;
/* FFT the data and convert to polar power spectral density form */
pow = smf_fft_data( wf, data, NULL, 0, len, status );
smf_convert_bad( wf, pow, status );
smf_fft_cart2pol( wf, pow, 0, 1, status );
{
dim_t fdims[2];
smf_isfft( pow, NULL, NULL, fdims, NULL, NULL, status );
if( *status == SAI__OK ) nf=fdims[0];
}
/* Check for reasonble frequencies, and integer offsets in the array */
i_low = smf_get_findex( f_low, df, nf, status );
i_w1 = smf_get_findex( f_white1, df, nf, status );
i_w2 = smf_get_findex( f_white2, df, nf, status );
/* Get the quality pointer from the smfData so that we can mask known
bad bolometer. */
qua = smf_select_qualpntr( data, NULL, status );
/* The minimum required number of good values in a bolometer. */
mingood = ( gfrac > 0.0 ) ? ntslice*gfrac : 0;
/* Loop over detectors */
for( i=0; (*status==SAI__OK)&&(i<nbolo); i++ )
if( !qua || !(qua[i*bstride]&SMF__Q_BADB) ) {
/* Pointer to start of power spectrum */
base = pow->pntr[0];
base += nf*i;
/* Smooth the power spectrum */
smf_boxcar1D( base, nf, 1, window, NULL, 0, 1, NULL, status );
/* Measure the power */
if( *status == SAI__OK ) {
p_low = base[i_low];
smf_stats1D( base+i_w1, 1, i_w2-i_w1+1, NULL, 0, 0, &p_white, NULL, NULL,
&ngood, status );
/* It's OK if bad status was generated as long as a mean was calculated */
if( *status==SMF__INSMP ) {
errAnnul( status );
/* if we had no good data there was probably a problem with SMF__Q_BADB
so we simply go to the next bolometer */
if (ngood == 0) continue;
}
/* Count the number of initially good values for the current
bolometer. */
if( (*status==SAI__OK) && qua ) {
ngood = 0;
for( j=0; j<ntslice; j++ ) {
if( qua[i*bstride + j*tstride] == 0 ) ngood++;
}
/* Set bolometer to bad if no power detected, or the number of good
values is too low. */
if( (p_low <= 0) || (p_white <= 0) || (ngood < mingood) ) {
for( j=0; j<ntslice; j++ ) {
qua[i*bstride + j*tstride] |= SMF__Q_BADB;
}
}
}
}
if( (*status==SAI__OK) && (!qua || !(qua[i*bstride]&SMF__Q_BADB)) ) {
/* Power ratio requested */
if ( fratio ) {
fratio[i] = p_low/p_white;
}
/* Store values */
if( whitenoise ) {
/* Integrate the PSD by multiplying the average white noise
level by total number of samples and the frequency spacing:
this calculates the time-domain variance (in 200 Hz SCUBA-2
samples for example) assuming this level holds at all
frequencies. */
whitenoise[i] = p_white * ntslice * df;
/* If NEP set, scale this to variance in a 1-second average by
dividing by the sampling frequency (equivalent to
multiplying by sample length). */
if( nep ) {
whitenoise[i] *= steptime;
}
}
}
}
/* Clean up if the caller does not want to take over the power spectrum */
if( pow ) {
if (fftpow) {
*fftpow = pow;
} else {
smf_close_file( &pow, status );
}
}
}
void smurf_extinction( int * status ) {
/* Local Variables */
smfArray *bbms = NULL; /* Bad bolometer masks */
smfArray *darks = NULL; /* Dark data */
AstKeyMap *extpars = NULL; /* Tau relation keymap */
Grp *fgrp = NULL; /* Filtered group, no darks */
smfArray *flatramps = NULL;/* Flatfield ramps */
int has_been_sky_removed = 0;/* Data are sky-removed */
AstKeyMap *heateffmap = NULL; /* Heater efficiency data */
size_t i; /* Loop counter */
Grp *igrp = NULL; /* Input group */
AstKeyMap *keymap=NULL; /* Keymap for storing parameters */
smf_tausrc tausrc; /* enum value of optical depth source */
smf_extmeth extmeth; /* Extinction correction method */
char tausource[LEN__METHOD]; /* String for optical depth source */
char method[LEN__METHOD]; /* String for extinction airmass method */
smfData *odata = NULL; /* Output data struct */
Grp *ogrp = NULL; /* Output group */
size_t outsize; /* Total number of NDF names in the output group */
size_t size; /* Number of files in input group */
double tau = 0.0; /* Zenith tau at this wavelength */
ThrWorkForce *wf = NULL; /* Pointer to a pool of worker threads */
if (*status != SAI__OK) return;
/* Main routine */
ndfBegin();
/* Find the number of cores/processors available and create a pool of
threads of the same size. */
wf = thrGetWorkforce( thrGetNThread( SMF__THREADS, status ), status );
/* Read the input file */
kpg1Rgndf( "IN", 0, 1, "", &igrp, &size, status );
/* Filter out darks */
smf_find_science( igrp, &fgrp, 0, NULL, NULL, 1, 1, SMF__NULL, &darks,
&flatramps, &heateffmap, NULL, status );
/* input group is now the filtered group so we can use that and
free the old input group */
size = grpGrpsz( fgrp, status );
grpDelet( &igrp, status);
igrp = fgrp;
fgrp = NULL;
if (size > 0) {
/* Get output file(s) */
kpg1Wgndf( "OUT", igrp, size, size, "More output files required...",
&ogrp, &outsize, status );
} else {
msgOutif(MSG__NORM, " ","All supplied input frames were DARK,"
" nothing to extinction correct", status );
}
/* Get group of pixel masks and read them into a smfArray */
smf_request_mask( "BBM", &bbms, status );
/* Read the tau relations from config file or group. We do not
allow sub instrument overloading because these are all values
based on filter name. */
keymap = kpg1Config( "TAUREL", "$SMURF_DIR/smurf_extinction.def", NULL,
1, status );
/* and we need to use the EXT entry */
astMapGet0A( keymap, "EXT", &extpars );
keymap = astAnnul( keymap );
/* Get tau source */
parChoic( "TAUSRC", "Auto",
"Auto,CSOtau,CSOFit, Filtertau, WVMraw", 1,
tausource, sizeof(tausource), status);
/* Decide how the correction is to be applied - convert to flag */
parChoic( "METHOD", "ADAPTIVE",
"Adaptive,Quick,Full,", 1, method, sizeof(method), status);
/* Place parameters into a keymap and extract values */
if( *status == SAI__OK ) {
keymap = astKeyMap( " " );
if( astOK ) {
astMapPut0C( keymap, "TAUSRC", tausource, NULL );
astMapPut0C( keymap, "TAUMETHOD", method, NULL );
smf_get_extpar( keymap, &tausrc, &extmeth, NULL, status );
}
}
for (i=1; i<=size && ( *status == SAI__OK ); i++) {
/* Flatfield - if necessary */
smf_open_and_flatfield( igrp, ogrp, i, darks, flatramps, heateffmap,
&odata, status );
if (*status != SAI__OK) {
/* Error flatfielding: tell the user which file it was */
msgSeti("I",i);
errRep(TASK_NAME, "Unable to open the ^I th file", status);
}
/* Mask out bad pixels - mask data array not quality array */
smf_apply_mask( odata, bbms, SMF__BBM_DATA, 0, status );
/* Now check that the data are sky-subtracted */
if ( !smf_history_check( odata, "smf_subtract_plane", status ) ) {
/* Should we override remsky check? */
parGet0l("HASSKYREM", &has_been_sky_removed, status);
if ( !has_been_sky_removed && *status == SAI__OK ) {
*status = SAI__ERROR;
msgSeti("I",i);
errRep("", "Input data from file ^I are not sky-subtracted", status);
}
}
/* If status is OK, make decisions on source keywords the first
time through. */
if ( *status == SAI__OK && i == 1 ) {
if (tausrc == SMF__TAUSRC_CSOTAU ||
tausrc == SMF__TAUSRC_AUTO ||
tausrc == SMF__TAUSRC_TAU) {
double deftau;
const char * param = NULL;
smfHead *ohdr = odata->hdr;
/* get default CSO tau -- this could be calculated from CSO fits */
deftau = smf_calc_meantau( ohdr, status );
/* Now ask for desired CSO tau */
if ( tausrc == SMF__TAUSRC_CSOTAU || tausrc == SMF__TAUSRC_AUTO) {
param = "CSOTAU";
} else if (tausrc == SMF__TAUSRC_TAU) {
param = "FILTERTAU";
deftau = smf_cso2filt_tau( ohdr, deftau, extpars, status );
}
parGdr0d( param, deftau, 0.0,1.0, 1, &tau, status );
} else if ( tausrc == SMF__TAUSRC_CSOFIT || tausrc == SMF__TAUSRC_WVMRAW ) {
/* Defer a message until after extinction correction */
} else {
*status = SAI__ERROR;
errRep("", "Unsupported opacity source. Possible programming error.",
status);
}
}
/* Apply extinction correction - note that a check is made to
determine whether the data have already been extinction
corrected */
smf_correct_extinction( wf, odata, &tausrc, extmeth, extpars, tau, NULL, NULL, status );
if ( tausrc == SMF__TAUSRC_WVMRAW ) {
msgOutif(MSG__VERB," ", "Used Raw WVM data for extinction correction", status);
} else if ( tausrc == SMF__TAUSRC_CSOFIT ) {
msgOutif(MSG__VERB," ", "Used fit to CSO data for extinction correction", status);
} else if ( tausrc == SMF__TAUSRC_CSOTAU ) {
msgOutif(MSG__VERB," ", "Used an explicit CSO tau value for extinction correction", status);
} else if ( tausrc == SMF__TAUSRC_TAU ) {
msgOutif(MSG__VERB," ", "Used an explicit filter tau value for extinction correction", status);
} else {
if (*status == SAI__OK) {
const char * taustr = smf_tausrc_str( tausrc, status );
*status = SAI__ERROR;
errRepf( "", "Unexpected opacity source used for extinction correction of %s."
" Possible programming error.", status, taustr );
}
}
/* Set character labels */
smf_set_clabels( "Extinction corrected",NULL, NULL, odata->hdr, status);
smf_write_clabels( odata, status );
/* Free resources for output data */
smf_close_file( &odata, status );
}
/* Write out the list of output NDF names, annulling the error if a null
parameter value is supplied. */
if( *status == SAI__OK && ogrp ) {
grpList( "OUTFILES", 0, 0, NULL, ogrp, status );
if( *status == PAR__NULL ) errAnnul( status );
}
/* Tidy up after ourselves: release the resources used by the grp routines */
if (darks) smf_close_related( &darks, status );
if (bbms) smf_close_related( &bbms, status );
if( flatramps ) smf_close_related( &flatramps, status );
if (heateffmap) heateffmap = smf_free_effmap( heateffmap, status );
grpDelet( &igrp, status);
grpDelet( &ogrp, status);
if( keymap ) keymap = astAnnul( keymap );
if (extpars) extpars = astAnnul( extpars );
ndfEnd( status );
}
void smurf_dreamweights ( int *status ) {
/* Local Variables */
Grp *confgrp = NULL; /* Group containing configuration file */
smfData *data = NULL; /* Input data */
const int defgridminmax[] = { -4, 4, -4, 4 }; /* Default extent xmin,xmax,ymin,ymax */
int gridminmax[4]; /* Extent of grid points array */
int gridpts[DREAM__MXGRID][2]; /* Array of points for reconstruction grid */
double gridstep; /* Size of reconstruction grid in arcsec */
size_t i; /* Loop counter */
Grp *igrp = NULL; /* Input group of NDFs */
size_t size; /* Size of input Grp of files */
AstKeyMap *keymap = NULL; /* Pointer to keymap of config settings */
size_t ksize; /* Size of group containing CONFIG file */
int ngrid; /* Number of points in reconstruction grid */
Grp *ogrp = NULL; /* Group of output weights files */
size_t outsize; /* Size of output Grp of files */
/* Main routine */
ndfBegin();
/* Get group of input raw data NDFs */
kpg1Rgndf( "NDF", 0, 1, "", &igrp, &size, status );
/* Get group of output files from user: assume 1 output file for
every input file */
kpg1Wgndf( "OUT", igrp, size, size, "More output files required...",
&ogrp, &outsize, status );
/* Read configuration settings into keymap */
if (*status == SAI__OK) {
kpg1Gtgrp( "CONFIG", &confgrp, &ksize, status );
if (*status == PAR__NULL) {
/* NULL value so provide defaults */
errAnnul( status );
msgOutif(MSG__VERB, " ", "No config file specified - assuming default configuration parameters", status);
keymap = astKeyMap(" " );
astMapPut1I( keymap, "GRIDMINMAX", 4, (int*)defgridminmax, " " );
astMapPut0D( keymap, "GRIDSTEP", 6.28, " " );
} else {
kpg1Kymap( confgrp, &keymap, status );
}
if( confgrp ) grpDelet( &confgrp, status );
}
/* Determine grid parameters from inputs given above */
smf_dream_getgrid( keymap, &gridstep, &ngrid, gridminmax, gridpts, status);
/* Annul keymap immediately as it is no longer required */
if (keymap) keymap = astAnnul( keymap );
/* Loop over number of files */
for ( i=1; (i<= size) && (*status == SAI__OK); i++) {
/* Open file */
smf_open_file( NULL, igrp, i, "READ", 0, &data, status );
/* Calculate weights based on this file */
smf_dream_calcweights( data, ogrp, i, gridstep, ngrid, gridminmax,
&(gridpts[0]), status);
/* Immediately check status on return and abort if an error occured */
if ( *status != SAI__OK ) {
msgSeti("I",i);
msgSeti("N",size);
errRep(FUNC_NAME, "Unable to determine DREAM weights for file ^I of ^N",
status);
}
smf_close_file( NULL, &data, status );
}
/* Free up resources */
if ( ogrp != NULL ) {
grpDelet( &ogrp, status);
}
if ( igrp != NULL ) {
grpDelet( &igrp, status);
}
ndfEnd( status );
msgOutif(MSG__VERB," ", "DREAM weights calculation completed successfully",
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 smf_write_itermap( ThrWorkForce *wf, const double *map, const double *mapvar,
const smf_qual_t *mapqua, dim_t msize,
const Grp *iterrootgrp, size_t contchunk, int iter,
const int *lbnd_out, const int *ubnd_out,
AstFrameSet *outfset, const smfHead *hdr,
const smfArray *qua, int *status ) {
int flags; /* Flags indicating required NDF components */
Grp *mgrp=NULL; /* Temporary group to hold map name */
smfData *imapdata=NULL; /* smfData for this iteration map */
char name[GRP__SZNAM+1]; /* Buffer for storing name */
char *pname=NULL; /* Poiner to name */
char tmpname[GRP__SZNAM+1]; /* temp name buffer */
char tempstr[20];
if( *status != SAI__OK ) return;
if( !map || !mapvar || !iterrootgrp || !lbnd_out || !ubnd_out || !outfset ) {
*status = SAI__ERROR;
errRep( "", FUNC_NAME ": NULL inputs supplied", status );
return;
}
if( hdr && !qua ) {
*status = SAI__ERROR;
errRep( "", FUNC_NAME ": hdr supplied but qua is NULL", status );
return;
}
/* Create a name for this iteration map, take into
account the chunk number. Only required if we are
using a single output container. */
pname = tmpname;
grpGet( iterrootgrp, 1, 1, &pname, sizeof(tmpname), status );
one_strlcpy( name, tmpname, sizeof(name), status );
one_strlcat( name, ".", sizeof(name), status );
/* Continuous chunk number */
sprintf(tempstr, "CH%02zd", contchunk);
one_strlcat( name, tempstr, sizeof(name), status );
/* Iteration number */
sprintf( tempstr, "I%03i", iter+1 );
one_strlcat( name, tempstr, sizeof(name), status );
mgrp = grpNew( "itermap", status );
grpPut1( mgrp, name, 0, status );
msgOutf( "", "*** Writing map from this iteration to %s", status,
name );
flags = SMF__MAP_VAR;
if( mapqua ) flags |= SMF__MAP_QUAL;
smf_open_newfile ( wf, mgrp, 1, SMF__DOUBLE, 2, lbnd_out,
ubnd_out, flags, &imapdata, status);
/* Copy over the signal and variance maps */
if( *status == SAI__OK ) {
memcpy( imapdata->pntr[0], map, msize*sizeof(*map) );
memcpy( imapdata->pntr[1], mapvar, msize*sizeof(*mapvar) );
if( mapqua ) memcpy( imapdata->qual, mapqua, msize*sizeof(*mapqua) );
}
/* Write out a FITS header */
if( (*status == SAI__OK) && hdr && hdr->allState ) {
AstFitsChan *fitschan=NULL;
JCMTState *allState = hdr->allState;
char *obsidss=NULL;
char obsidssbuf[SZFITSTR];
double iter_nboloeff;
size_t nmap;
size_t ngood_tslices;
dim_t ntslice; /* Number of time slices */
fitschan = astFitsChan ( NULL, NULL, " " );
obsidss = smf_getobsidss( hdr->fitshdr,
NULL, 0, obsidssbuf,
sizeof(obsidssbuf), status );
if( obsidss ) {
atlPtfts( fitschan, "OBSIDSS", obsidss,
"Unique observation subsys identifier", status );
}
atlPtfti( fitschan, "SEQSTART", allState[0].rts_num,
"RTS index number of first frame", status );
ntslice = hdr->nframes;
atlPtfti( fitschan, "SEQEND", allState[ntslice-1].rts_num,
"RTS index number of last frame", status );
/* calculate the effective number of bolometers for this
iteration */
smf_qualstats_model( wf, SMF__QFAM_TSERIES, 1, qua, NULL, NULL, &nmap,
NULL, NULL, &ngood_tslices, NULL, NULL, status );
iter_nboloeff = (double)nmap / (double)ngood_tslices;
atlPtftd( fitschan, "NBOLOEFF", iter_nboloeff,
"Effective bolometer count", status );
kpgPtfts( imapdata->file->ndfid, fitschan, status );
if( fitschan ) fitschan = astAnnul( fitschan );
}
/* Write WCS (protecting the pointer dereference) */
smf_set_moving(outfset,NULL,status);
if (*status == SAI__OK && imapdata) {
ndfPtwcs( outfset, imapdata->file->ndfid, status );
}
/* Clean up */
if( mgrp ) grpDelet( &mgrp, status );
smf_close_file( wf, &imapdata, status );
}
void smf_write_bolomap( ThrWorkForce *wf, smfArray *res, smfArray *lut,
smfArray *qua, smfDIMMData *dat, dim_t msize,
const Grp *bolrootgrp, int varmapmethod,
const int *lbnd_out, const int *ubnd_out,
AstFrameSet *outfset, int *status ) {
int addtomap=0; /* Set if adding to existing map */
size_t bstride; /* Bolometer stride */
double *curmap=NULL; /* Pointer to current map being rebinned */
double *curvar=NULL; /* Pointer to variance associate with curmap */
dim_t dsize; /* Size of data arrays in containers */
size_t idx=0; /* index within subgroup */
size_t k; /* loop counter */
int *lut_data=NULL; /* Pointer to DATA component of lut */
char name[GRP__SZNAM+1]; /* Buffer for storing names */
dim_t nbolo; /* Number of bolometers */
size_t nbolomaps = 0; /* Number of bolomaps written */
char *pname=NULL; /* Poiner to name */
smf_qual_t *qua_data=NULL; /* Pointer to DATA component of qua */
double *res_data=NULL; /* Pointer to DATA component of res */
if( *status != SAI__OK ) return;
if( !res || !lut || !qua || !dat || !bolrootgrp ||
!lbnd_out || !ubnd_out || !outfset ) {
*status = SAI__ERROR;
errRep( "", FUNC_NAME ": NULL inputs supplied", status );
return;
}
/* Loop over subgroup index (subarray) */
for( idx=0; idx<res->ndat; idx++ ) {
smf_qual_t *bolomask = NULL;
double *bmapweight = NULL;
double *bmapweightsq = NULL;
int *bhitsmap = NULL;
/* Pointers to everything we need */
res_data = res->sdata[idx]->pntr[0];
lut_data = lut->sdata[idx]->pntr[0];
qua_data = qua->sdata[idx]->pntr[0];
smf_get_dims( res->sdata[idx], NULL, NULL, &nbolo, NULL,
&dsize, &bstride, NULL, status );
/* Make a copy of the quality at first time slice as a good
bolo mask, and then set quality to SMF__Q_BADB. Later we
will unset BADB for one bolo at a time to make individual
maps. */
bolomask = astMalloc( nbolo*sizeof(*bolomask) );
bmapweight = astMalloc( msize*sizeof(*bmapweight) );
bmapweightsq = astMalloc( msize*sizeof(*bmapweightsq) );
bhitsmap = astMalloc( msize*sizeof(*bhitsmap) );
if( *status == SAI__OK ) {
for( k=0; k<nbolo; k++ ) {
bolomask[k] = qua_data[k*bstride];
qua_data[k*bstride] = SMF__Q_BADB;
}
/* Identify good bolos in the copied mask and produce a map */
for( k=0; (k<nbolo)&&(*status==SAI__OK); k++ ) {
if( !(bolomask[k]&SMF__Q_BADB) ) {
Grp *mgrp=NULL; /* Temporary group to hold map names */
smfData *mapdata=NULL;/* smfData for new map */
char tmpname[GRP__SZNAM+1]; /* temp name buffer */
char thisbol[20]; /* name particular to this bolometer */
size_t col, row;
char subarray[10];
nbolomaps++;
/* Set the quality back to good for this single bolometer */
qua_data[k*bstride] = bolomask[k];
/* Create a name for the new map, take into account the
chunk number and subarray. Only required if we are using a single
output container. */
pname = tmpname;
grpGet( bolrootgrp, 1, 1, &pname, sizeof(tmpname), status );
one_strlcpy( name, tmpname, sizeof(name), status );
one_strlcat( name, ".", sizeof(name), status );
/* Subarray, column and row. HDS does not care about case but we
convert to upper case anyhow. */
smf_find_subarray( res->sdata[idx]->hdr, subarray, sizeof(subarray),
NULL, status );
if (*status == SAI__OK) {
size_t len = strlen(subarray);
size_t n = 0;
for (n=0; n<len; n++) {
subarray[n] = toupper(subarray[n]);
}
}
col = (k % res->sdata[idx]->dims[1])+1;
row = (k / res->sdata[idx]->dims[1])+1;
sprintf( thisbol, "%3sC%02zuR%02zu",
subarray,
col, /* x-coord */
row ); /* y-coord */
one_strlcat( name, thisbol, sizeof(name), status );
mgrp = grpNew( "bolomap", status );
grpPut1( mgrp, name, 0, status );
msgOutf( "", "*** Writing single bolo map %s", status,
name );
/* Try to open an existing extention first. Create a new map
array, and then later we'll add it to the existing
one. If it isn't there, create it. */
smf_open_file( mgrp, 1, "UPDATE", 0, &mapdata, status );
if( *status == SAI__OK ) {
/* Allocate memory for the new rebinned data */
curmap = astCalloc( msize, sizeof(*curmap) );
curvar = astCalloc( msize, sizeof(*curvar) );
addtomap = 1;
} else if( *status == DAT__NAMIN ) {
/* Create a new extension */
errAnnul( status );
smf_open_newfile ( mgrp, 1, SMF__DOUBLE, 2, lbnd_out,
ubnd_out, SMF__MAP_VAR, &mapdata, status);
/* Rebin directly into the newly mapped space */
if( *status == SAI__OK ) {
curmap = mapdata->pntr[0];
curvar = mapdata->pntr[1];
addtomap = 0;
}
}
/* Rebin the data for this single bolometer. Don't care
about variance weighting because all samples from
same detector are about the same. */
smf_rebinmap1( wf, res->sdata[idx],
dat->noi ? dat->noi[0]->sdata[idx] : NULL,
lut_data, 0, 0, 0, NULL, 0,
SMF__Q_GOOD, varmapmethod,
AST__REBININIT | AST__REBINEND,
curmap, bmapweight, bmapweightsq, bhitsmap,
curvar, msize, NULL, status );
/* If required, add this new map to the existing one */
if( addtomap ) {
size_t i;
double *oldmap=NULL;
double *oldvar=NULL;
double weight;
if( *status == SAI__OK ) {
oldmap = mapdata->pntr[0];
oldvar = mapdata->pntr[1];
for( i=0; i<msize; i++ ) {
if( oldmap[i]==VAL__BADD ) {
/* No data in this pixel in the old map, just copy */
oldmap[i] = curmap[i];
oldvar[i] = curvar[i];
} else if( curmap[i]!=VAL__BADD &&
oldvar[i]!=VAL__BADD && oldvar[i]!=0 &&
curvar[i]!=VAL__BADD && curvar[i]!=0 ) {
/* Both old and new values available */
weight = 1/oldvar[i] + 1/curvar[i];
oldmap[i] = (oldmap[i]/oldvar[i] + curmap[i]/curvar[i]) /
weight;
oldvar[i] = 1/weight;
}
}
}
/* Free up temporary arrays */
curmap = astFree( curmap );
curvar = astFree( curvar );
}
/* Write out COLNUM and ROWNUM to FITS header */
if( *status == SAI__OK ) {
AstFitsChan *fitschan=NULL;
fitschan = astFitsChan ( NULL, NULL, " " );
atlPtfti( fitschan, "COLNUM", col, "bolometer column", status);
atlPtfti( fitschan, "ROWNUM", row, "bolometer row", status );
atlPtfts( fitschan, "SUBARRAY", subarray, "Subarray identifier",
status );
kpgPtfts( mapdata->file->ndfid, fitschan, status );
if( fitschan ) fitschan = astAnnul( fitschan );
/* Set the bolo to bad quality again */
qua_data[k*bstride] = SMF__Q_BADB;
/* Write WCS */
smf_set_moving(outfset,NULL,status);
ndfPtwcs( outfset, mapdata->file->ndfid, status );
}
/* Clean up */
if( mgrp ) grpDelet( &mgrp, status );
if( mapdata ) smf_close_file( &mapdata, status );
}
}
/* Set quality back to its original state */
for( k=0; k<nbolo; k++ ) {
qua_data[k*bstride] = bolomask[k];
}
}
/* Free up memory */
bolomask = astFree( bolomask );
bmapweight = astFree( bmapweight );
bmapweightsq = astFree( bmapweightsq );
bhitsmap = astFree( bhitsmap );
}
msgOutf( "", "*** Wrote %zu bolo maps", status, nbolomaps );
}
/* Main entry */
void smurf_fixsteps( int *status ) {
/* Local Variables */
AstKeyMap *keymap; /* Default config parameter values */
AstKeyMap *sub_instruments; /* Info about sub-instruments */
FILE *fd = NULL; /* File descriptor */
Grp *igrp = NULL; /* Input group of files */
Grp *ogrp = NULL; /* Output group of files */
dim_t dcfitbox; /* DCFITBOX config parameter */
dim_t dcsmooth; /* DCSMOOTH config parameter */
dim_t nx; /* Length of first pixel axis */
double dcthresh; /* DCTHRESH config parameter */
double sizetol; /* Tolerance allowed on step height */
int changed; /* Have any step fixes changed? */
int dclimcorr; /* DCLIMCORR config parameter */
int dcmaxsteps; /* DCMAXSTEPS config parameter */
int first; /* Index of first change to report */
int itemp; /* Intermediate value */
int meanshift; /* Use a mean shift filter? */
int nnew; /* Number of new step fixes */
int nold; /* Number of old step fixes */
size_t nrej; /* Number of rejected bolometers */
size_t outsize; /* Total number of NDF names in the output group */
size_t size; /* Number of files in input group */
smfData *data = NULL; /* Output smfData */
smfData *indata = NULL; /* Input smfData */
smfStepFix *newsteps = NULL; /* New step fix descriptions */
smfStepFix *oldsteps = NULL; /* Old step fix descriptions */
ThrWorkForce *wf = NULL; /* Pointer to a pool of worker threads */
/* Check inherited status */
if (*status != SAI__OK) return;
/* begin an NDF context. */
ndfBegin();
/* Get the name of the input NDF. */
kpg1Rgndf( "IN", 1, 1, "", &igrp, &size, status );
/* Get output file(s) */
kpg1Wgndf( "OUT", igrp, size, 0, "More output files required...",
&ogrp, &outsize, status );
/* Open the input data file, read-only. */
smf_open_file( igrp, 1, "Read", 0, &indata, status );
/* Since we will be modifying the data values, we need a deep copy. */
data = smf_deepcopy_smfData( indata, 0, 0, 0, 0, status );
/* Place cleaning parameters into a keymap and set defaults. Note that we
use the map-maker defaults file here so that we populate the locked
keymap with all the parameters that people may come across to allow
them to load their map-maker config directly this application. */
sub_instruments = smf_subinst_keymap( SMF__SUBINST_NONE, data, NULL, 0,
status );
keymap = kpg1Config( "CONFIG", "$SMURF_DIR/smurf_makemap.def",
sub_instruments, status );
sub_instruments = astAnnul( sub_instruments );
/* Set the default for each of the step fixing config parameters. */
astMapGet0I( keymap, "DCSMOOTH", &itemp );
parDef0i( "DCSMOOTH", itemp, status );
astMapGet0I( keymap, "DCFITBOX", &itemp );
parDef0i( "DCFITBOX", itemp, status );
astMapGet0I( keymap, "DCMAXSTEPS", &itemp );
parDef0i( "DCMAXSTEPS", itemp, status );
astMapGet0I( keymap, "DCLIMCORR", &itemp );
parDef0i( "DCLIMCORR", itemp, status );
astMapGet0D( keymap, "DCTHRESH", &dcthresh );
parDef0d( "DCTHRESH", dcthresh, status );
/* Get values for the config params */
parGet0i( "DCSMOOTH", &itemp, status );
dcsmooth = itemp;
parGet0i( "DCFITBOX", &itemp, status );
dcfitbox = itemp;
parGet0i( "DCMAXSTEPS", &itemp, status );
dcmaxsteps = itemp;
parGet0i( "DCLIMCORR", &itemp, status );
dclimcorr = itemp;
parGet0d( "DCTHRESH", &dcthresh, status );
parGet0l( "MEANSHIFT", &meanshift, status );
/* Find the number of cores/processors available and create a pool of
threads of the same size. */
wf = thrGetWorkforce( thrGetNThread( SMF__THREADS, status ), status );
/* Fix the steps. */
smf_fix_steps( wf, data, dcthresh, dcsmooth, dcfitbox, dcmaxsteps,
dclimcorr, meanshift, &nrej, &newsteps, &nnew, status );
/* Display a summary of what was done by the step fixer. */
msgBlank( status );
if( nrej == 0 ) {
msgOut( "", "No bolometers were rejected", status );
} else if( nrej == 1 ) {
msgOut( "", "One bolometer was rejected", status );
} else {
msgSeti( "NREJ", nrej );
msgOut( "", "^NREJ bolometers were rejected", status );
}
parPut0i( "NREJECTED", nrej, status );
if( nnew == 0 ) {
msgOut( "", "No steps were fixed", status );
} else if( nnew == 1 ) {
msgOut( "", "One step was fixed", status );
} else {
msgSeti( "NNEW", nnew );
msgOut( "", "^NNEW steps were fixed", status );
}
parPut0i( "NFIXED", nnew, status );
/* If required, write out to a text file details of the steps that were
fixed. */
fd = smf_open_textfile( "NEWSTEPS", "w", "<none>", status );
if( fd ) {
smf1_write_steps( fd, indata, nnew, newsteps, dcthresh, dcsmooth,
dcfitbox, dcmaxsteps, dclimcorr, nrej, status );
fclose( fd );
}
/* If required, create the output NDF. */
if( outsize > 0 && indata && indata->file ) {
smf_write_smfData( data, NULL, NULL, ogrp, 1,
indata->file->ndfid, MSG__VERB, 0, status );
}
/* Save the length of the first pixel axis. */
nx = data ? data->dims[ 0 ] : 0;
/* Close the NDFs. */
smf_close_file( &data, status );
smf_close_file( &indata, status );
/* Attempt to open a file containing descriptions of steps fixed by a
previous invocation of this program. */
fd = smf_open_textfile( "OLDSTEPS", "r", "<none>", status );
if( fd ) {
/* Get SIZETOL - the minimum significant fractional error in step sizes. */
parGet0d( "SIZETOL", &sizetol, status );
/* Read the contents of the file, issuing a warning if the global
properties read from the file (e.g. parameters used, no. of steps
found, etc) differ from those of the current invocation. */
msgBlank( status );
oldsteps = smf1_read_steps( fd, dcthresh, dcsmooth,
dcfitbox, dcmaxsteps, dclimcorr,
nrej, nnew, &nold, status );
/* Get the index of the first change to report. */
parGet0i( "FIRST", &first, status );
/* Compare the new step fixes with the old step fixes, issuing a warning
for the first step fix that has changed. */
changed = smf1_check_steps( "CONTINUE", first, nx, sizetol,
nold, nnew, oldsteps, newsteps, status );
/* Store a flag indicating if any sstep fixes have chnaged. */
parPut0l( "CHANGED", changed, status );
/* Tell the user if nothing has changed. */
if( ! changed ) {
msgOut( "", "There are no significant differences "
"between old and new step fixes.", status );
}
msgBlank( status );
/* Close the old steps file, and free the memory holding the old step
descriptions. */
fclose( fd );
oldsteps = astFree( oldsteps );
}
/* Free resources. */
newsteps = astFree( newsteps );
grpDelet( &igrp, status );
grpDelet( &ogrp, status );
/* End the NDF context. */
ndfEnd( status );
/* If anything went wrong issue a context message. */
if( *status != SAI__OK ) msgOutif( MSG__VERB, " ", "FIXSTEPS failed.",
status );
}
void smf_calcmodel_noi( ThrWorkForce *wf, smfDIMMData *dat, int chunk,
AstKeyMap *keymap, smfArray **allmodel, int flags,
int *status) {
/* Local Variables */
dim_t bolostep; /* Number of bolos per thread */
dim_t boxsize; /* No. of time slices in each noise box */
smfData *box = NULL; /* SmfData holding one box of input data */
size_t bstride; /* bolometer stride */
int calcfirst=0; /* Were bolo noises already measured? */
int dclimcorr; /* Min number of correlated steps */
int dcmaxsteps; /* Maximum allowed number of dc jumps */
dim_t dcfitbox; /* Width of box for DC step detection */
double dcthresh; /* Threshold for DC step detection */
dim_t dcsmooth; /* Width of median filter in DC step detection*/
double *din; /* Pointer to next input value */
double *dout; /* Pointer to next output value */
int fillgaps; /* If set perform gap filling */
dim_t i; /* Loop counter */
dim_t ibolo; /* Bolometer index */
int ibox; /* Index of current noise box */
dim_t itime; /* Time slice index */
dim_t idx=0; /* Index within subgroup */
JCMTState *instate=NULL; /* Pointer to input JCMTState */
int iw; /* Thread index */
dim_t j; /* Loop counter */
AstKeyMap *kmap=NULL; /* Local keymap */
size_t mbstride; /* model bolometer stride */
dim_t mntslice; /* Number of model time slices */
size_t mtstride; /* model time slice stride */
smfArray *model=NULL; /* Pointer to model at chunk */
double *model_data=NULL; /* Pointer to DATA component of model */
dim_t nbolo; /* Number of bolometers */
int nbox = 0; /* Number of noise boxes */
size_t nchisq; /* Number of data points in chisq calc */
dim_t nelbox; /* Number of data points in a noise box */
dim_t ndata; /* Total number of data points */
size_t nflag; /* Number of new flags */
int nleft; /* Number of samples not in a noise box */
dim_t ntslice; /* Number of time slices */
int nw; /* Number of worker threads */
size_t pend; /* Last non-PAD sample */
size_t pstart; /* First non-PAD sample */
smf_qual_t *qin; /* Pointer to next input quality value */
smf_qual_t *qout; /* Pointer to next output quality value */
smfArray *qua=NULL; /* Pointer to RES at chunk */
smf_qual_t *qua_data=NULL; /* Pointer to RES at chunk */
smfArray *res=NULL; /* Pointer to RES at chunk */
double *res_data=NULL; /* Pointer to DATA component of res */
dim_t spikebox=0; /* Box size for spike detection */
double spikethresh=0; /* Threshold for spike detection */
size_t tend; /* Last input sample to copy */
size_t tstart; /* First input sample to copy */
size_t tstride; /* time slice stride */
double *var=NULL; /* Sample variance */
size_t xbstride; /* Box bolometer stride */
int zeropad; /* Pad with zeros? */
/* Main routine */
if (*status != SAI__OK) return;
/* Obtain pointer to sub-keymap containing NOI parameters */
astMapGet0A( keymap, "NOI", &kmap );
/* Assert bolo-ordered data */
smf_model_dataOrder( dat, allmodel, chunk, SMF__RES|SMF__QUA, 0, status );
/* Obtain pointers to relevant smfArrays for this chunk */
res = dat->res[chunk];
qua = dat->qua[chunk];
model = allmodel[chunk];
/* Obtain parameters for NOI */
/* Data-cleaning parameters */
smf_get_cleanpar( kmap, res->sdata[0], NULL, &dcfitbox, &dcmaxsteps, &dcthresh,
&dcsmooth, &dclimcorr, NULL, &fillgaps, &zeropad, NULL,
NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
&spikethresh, &spikebox, NULL, NULL, NULL, NULL, NULL, NULL,
NULL, NULL, NULL, NULL, status );
/* Did we already calculate the noise on each detector? */
astMapGet0I( kmap, "CALCFIRST", &calcfirst );
/* Initialize chisquared */
dat->chisquared[chunk] = 0;
nchisq = 0;
/* Loop over index in subgrp (subarray) */
for( idx=0; idx<res->ndat; idx++ ) {
/* Get pointers to DATA components */
res_data = (res->sdata[idx]->pntr)[0];
model_data = (model->sdata[idx]->pntr)[0];
qua_data = (qua->sdata[idx]->pntr)[0];
if( (res_data == NULL) || (model_data == NULL) || (qua_data == NULL) ) {
*status = SAI__ERROR;
errRep( "", FUNC_NAME ": Null data in inputs", status);
} else {
/* Get the raw data dimensions */
smf_get_dims( res->sdata[idx], NULL, NULL, &nbolo, &ntslice, &ndata,
&bstride, &tstride, status );
/* NOI model dimensions */
smf_get_dims( model->sdata[idx], NULL, NULL, NULL, &mntslice, NULL,
&mbstride, &mtstride, status );
/* Only estimate the white noise level once at the beginning - the
reason for this is to make measurements of the convergence
easier. We either do it prior to the start of iterations (in which
case the relative weights will be influeced by low-frequency noise,
this is initialized in smf_model_create), or else we calculate
the noise after the first iteration. */
if( (flags & SMF__DIMM_FIRSTITER) && (!calcfirst) ) {
/* There are two forms for the NOI model: one constant noise value
for each bolometer, or "ntslice" noise values for each bolometer.
Handle the first case now. */
if( mntslice == 1 ) {
var = astMalloc( nbolo*sizeof(*var) );
if (var) {
/* Measure the noise from power spectra */
smf_bolonoise( wf, res->sdata[idx], 0, 0.5, SMF__F_WHITELO,
SMF__F_WHITEHI, 0, zeropad ? SMF__MAXAPLEN : SMF__BADSZT,
var, NULL, NULL, status );
for( i=0; i<nbolo; i++ ) if( !(qua_data[i*bstride]&SMF__Q_BADB) ) {
/* Loop over time and store the variance for each sample */
for( j=0; j<mntslice; j++ ) {
model_data[i*mbstride+(j%mntslice)*mtstride] = var[i];
}
}
var = astFree( var );
}
/* If the NOI model is of the second form, the noise is estimated
in boxes of samples lasting "NOI.BOX_SIZE" seconds, and then the
noise level in the box is assigned to all samples in the box. */
} else if( mntslice == ntslice ) {
/* If not already done, get NOI.BOX_SIZE and convert from seconds to
samples. */
if( idx == 0 ) {
boxsize = 0;
smf_get_nsamp( kmap, "BOX_SIZE", res->sdata[0], &boxsize, status );
msgOutf( "", FUNC_NAME ": Calculating a NOI variance for each "
"box of %d samples.", status, (int) boxsize );
/* Find the indices of the first and last non-PAD sample. */
smf_get_goodrange( qua_data, ntslice, tstride, SMF__Q_PAD,
&pstart, &pend, status );
/* How many whole boxes fit into this range? */
nbox = ( pend - pstart + 1 ) / boxsize;
if( nbox == 0 ) nbox = 1;
/* How many samples would be left over at the end if we used this
many boxes? */
nleft = ( pend - pstart + 1 ) - nbox*boxsize;
/* Increase "boxsize" to reduce this number as far as possible.
Any samples that are left over after this increase of boxsize
will not be used when calculating the noise levels in each
bolometer. */
boxsize += nleft/nbox;
/* Create a smfData to hold one box-worth of input data. We
do not need to copy jcmtstate information. */
if( res->sdata[idx]->hdr ) {
instate = res->sdata[idx]->hdr->allState;
res->sdata[idx]->hdr->allState = NULL;
}
box = smf_deepcopy_smfData( res->sdata[idx], 0,
SMF__NOCREATE_DATA |
SMF__NOCREATE_VARIANCE |
SMF__NOCREATE_QUALITY,
0, 0, status );
if( instate ) res->sdata[idx]->hdr->allState = instate;
/* Set the length of the time axis to the box size plus padding,
and create empty data and quality arrays for it. */
if( *status == SAI__OK ) {
box->dims[ box->isTordered?2:0 ] = boxsize + pstart + (ntslice - pend - 1);
smf_get_dims( box, NULL, NULL, NULL, NULL, &nelbox,
&xbstride, NULL, status );
box->pntr[0] = astMalloc( sizeof( double )*nelbox );
box->qual = astMalloc( sizeof( smf_qual_t )*nelbox );
/* For every bolometer, flag the start and end of the quality
array as padding, and store zeros in the data array. */
for( ibolo = 0; ibolo < nbolo; ibolo++ ) {
dout = ((double *) box->pntr[0]) + xbstride*ibolo;
qout = box->qual + xbstride*ibolo;
for( itime = 0; itime < pstart; itime++ ) {
*(qout++) = SMF__Q_PAD;
*(dout++) = 0.0;
}
dout = ((double *) box->pntr[0]) + xbstride*ibolo + pstart + boxsize;;
qout = box->qual + xbstride*ibolo + pstart + boxsize;
for( itime = pend + 1; itime < ntslice; itime++ ) {
*(qout++) = SMF__Q_PAD;
*(dout++) = 0.0;
}
}
}
}
/* Work space to hold the variance for each bolometer in a box */
var = astMalloc( nbolo*sizeof(*var) );
if( *status == SAI__OK ) {
/* Index of the first time slice within the input smfData
that is included in the first box. */
tstart = pstart;
/* Loop round each noise box */
for( ibox = 0; ibox < nbox; ibox++ ) {
/* Copy the data and quality values for this box from the
input smfData into "box", leaving room for padding at
both ends of box. Note, data is bolo-ordered so we
can assume that "tstride" is 1. */
din = ((double *)(res->sdata[idx]->pntr[0])) + tstart;
dout = ((double *)(box->pntr[0])) + pstart;
qin = qua_data + tstart;
qout = box->qual + pstart;
for( ibolo = 0; ibolo < nbolo; ibolo++ ) {
memcpy( dout, din, boxsize*sizeof( *din ) );
memcpy( qout, qin, boxsize*sizeof( *qin ) );
din += bstride;
dout += xbstride;
qin += bstride;
qout += xbstride;
}
/* Measure the noise from power spectra in the box. */
smf_bolonoise( wf, box, 0, 0.5, SMF__F_WHITELO, SMF__F_WHITEHI,
0, zeropad ? SMF__MAXAPLEN : SMF__BADSZT, var,
NULL, NULL, status );
/* Loop over time and store the variance for each sample in
the NOI model. On the last box, pick up any left over time
slices. */
if( ibox < nbox - 1 ) {
tend = tstart + boxsize - 1;
} else {
tend = pend;
}
for( ibolo = 0; ibolo < nbolo; ibolo++ ) {
if( !( qua_data[ ibolo*bstride ] & SMF__Q_BADB ) ) {
dout = model_data + ibolo*bstride + tstart;
for( itime = tstart; itime <= tend; itime++ ) {
*(dout++) = var[ ibolo ];
}
}
}
/* Update the index of the first time slice within the input
smfData that is included in the next box. */
tstart += boxsize;
}
var = astFree( var );
}
/* Report an error if the number of samples for each bolometer in
the NOI model is not 1 or "ntslice". */
} else if( *status == SAI__OK ) {
*status = SAI__ERROR;
errRepf( "", FUNC_NAME ": NOI model has %d samples - should be "
"%d or 1.", status, (int) mntslice, (int) ntslice);
}
}
if( kmap ) {
/* Flag spikes in the residual after first iteration */
if( spikethresh && !(flags&SMF__DIMM_FIRSTITER) ) {
/* Now re-flag */
smf_flag_spikes( wf, res->sdata[idx], SMF__Q_MOD,
spikethresh, spikebox, &nflag, status );
msgOutiff(MSG__VERB," ", " flagged %zu new %lf-sig spikes",
status, nflag, spikethresh );
}
if( dcthresh && dcfitbox ) {
smf_fix_steps( wf, res->sdata[idx], dcthresh, dcsmooth,
dcfitbox, dcmaxsteps, dclimcorr, 1, &nflag, NULL,
NULL, status );
msgOutiff(MSG__VERB, ""," detected %zu bolos with DC steps\n",
status, nflag);
}
}
/* Now calculate contribution to chi^2. This bit takes along time
if there is a lot of data so share the work out amongst the available
worker threads. How many threads do we get to play with */
nw = wf ? wf->nworker : 1;
/* Find how many bolometers to process in each worker thread. */
bolostep = nbolo/nw;
if( bolostep == 0 ) bolostep = 1;
/* Allocate job data for threads, and store the range of bolos to be
processed by each one. Ensure that the last thread picks up any
left-over bolos. */
SmfCalcModelNoiData *job_data = astCalloc( nw, sizeof(*job_data) );
if( *status == SAI__OK ) {
SmfCalcModelNoiData *pdata;
for( iw = 0; iw < nw; iw++ ) {
pdata = job_data + iw;
pdata->b1 = iw*bolostep;
if( iw < nw - 1 ) {
pdata->b2 = pdata->b1 + bolostep - 1;
} else {
pdata->b2 = nbolo - 1 ;
}
/* Store other values common to all jobs. */
pdata->ntslice = ntslice;
pdata->mntslice = mntslice;
pdata->qua_data = qua_data;
pdata->model_data = model_data;
pdata->res_data = res_data;
pdata->bstride = bstride;
pdata->tstride = tstride;
pdata->mbstride = mbstride;
pdata->mtstride = mtstride;
/* Submit the job to the workforce. */
thrAddJob( wf, 0, pdata, smf1_calcmodel_noi, 0, NULL, status );
}
/* Wait for all jobs to complete. */
thrWait( wf, status );
/* Accumulate the results from all the worker threads. */
for( iw = 0; iw < nw; iw++ ) {
pdata = job_data + iw;
dat->chisquared[chunk] += pdata->chisquared;
nchisq += pdata->nchisq;
}
/* Free the job data. */
job_data = astFree( job_data );
}
}
}
/* Free resources */
if( box ) {
box->pntr[0] = astFree( box->pntr[0] );
box->qual = astFree( box->qual );
smf_close_file( &box, status );
}
/* Normalize chisquared for this chunk */
if( (*status == SAI__OK) && (nchisq >0) ) {
dat->chisquared[chunk] /= (double) nchisq;
}
/* Clean Up */
if( kmap ) kmap = astAnnul( kmap );
}
void smf_write_flagmap( ThrWorkForce *wf, smf_qual_t mask, smfArray *lut, smfArray *qua,
smfDIMMData *dat, const Grp *flagrootgrp,
size_t contchunk, const int *lbnd_out,
const int *ubnd_out, AstFrameSet *outfset,
int *status ) {
AstFrameSet *tfset; /* Temporary FrameSet pointer */
Grp *mgrp=NULL; /* Temporary group for map names */
char *pname=NULL; /* Poiner to name */
char name[GRP__SZNAM+1]; /* Buffer for storing names */
char tempstr[20]; /* Temporary string */
char tmpname[GRP__SZNAM+1]; /* temp name buffer */
dim_t nbolo; /* Number of bolometers */
dim_t ntslice; /* Number of time slices */
double shift[ 1 ]; /* Shift from GRID to bit number */
int *flagmap=NULL; /* pointer to flagmap data */
int *lut_data=NULL; /* Pointer to DATA component of lut */
int ibit; /* Quality bit number */
int lbnd3d[3]; /* Lower bounds for 3D output */
int npix; /* Number of pixels per plane */
int target; /* Target value for incrementing pixel count */
int ubnd3d[3]; /* Upper bounds for 3D output */
size_t bstride; /* Bolometer stride */
size_t i; /* loop counter */
size_t idx=0; /* index within subgroup */
size_t ii; /* array offset index */
size_t j; /* loop counter */
size_t tstride; /* Time stride */
smfData *mapdata=NULL; /* smfData for new map */
smf_qual_t *qua_data=NULL; /* Pointer to DATA component of qua */
if( *status != SAI__OK ) return;
if( !lut || !qua || !dat || !flagrootgrp || !lbnd_out || !ubnd_out ||
!outfset ) {
*status = SAI__ERROR;
errRep( "", FUNC_NAME ": NULL inputs supplied", status );
return;
}
/* Create a name for the flagmap, taking into account the chunk
number. Only required if we are using a single output
container. */
pname = tmpname;
grpGet( flagrootgrp, 1, 1, &pname, sizeof(tmpname), status );
one_strlcpy( name, tmpname, sizeof(name), status );
one_strlcat( name, ".", sizeof(name), status );
sprintf(tempstr, "CH%02zd", contchunk);
one_strlcat( name, tempstr, sizeof(name), status );
mgrp = grpNew( "flagmap", status );
grpPut1( mgrp, name, 0, status );
msgOutf( "", "*** Writing flagmap %s", status, name );
/* If a non-zero mask value wassupplied, the flagmap is 2-dimensional
and each pixel value counts the number of samples flagged by any of
the qualities included in the mask. */
if( mask ) {
smf_open_newfile( wf, mgrp, 1, SMF__INTEGER, 2, lbnd_out, ubnd_out, 0, &mapdata,
status);
flagmap = mapdata->pntr[0];
/* Loop over subgroup index (subarray) */
for( idx=0; (idx<qua->ndat)&&(*status==SAI__OK); idx++ ) {
smf_get_dims( qua->sdata[idx], NULL, NULL, &nbolo, &ntslice,
NULL, &bstride, &tstride, status );
qua_data = (qua->sdata[idx]->pntr)[0];
lut_data = (lut->sdata[idx]->pntr)[0];
/* Loop over bolometer and time slice and create map */
for( i=0; i<nbolo; i++ ) {
/* Skip bolometers only if SMF__Q_BADB is set both in the
data and the mask */
if( !(qua_data[i*bstride] & mask & SMF__Q_BADB) ) {
for( j=0; j<ntslice; j++ ) {
ii = i*bstride + j*tstride;
if( (qua_data[ii] & mask) && (lut_data[ii] != VAL__BADI) ) {
flagmap[lut_data[ii]]++;
}
}
}
}
}
/* Write WCS */
smf_set_moving( (AstFrame *) outfset, NULL, status );
ndfPtwcs( outfset, mapdata->file->ndfid, status );
/* If the mask is zero, the flagmap is 3-dimensional and contains a
plane for each quality bit, plus an additional plane (plane 1)
containing the number of unflagged samples in each pixel. */
} else {
lbnd3d[ 0 ] = lbnd_out[ 0 ];
lbnd3d[ 1 ] = lbnd_out[ 1 ];
lbnd3d[ 2 ] = -1;
ubnd3d[ 0 ] = ubnd_out[ 0 ];
ubnd3d[ 1 ] = ubnd_out[ 1 ];
ubnd3d[ 2 ] = SMF__NQBITS_TSERIES - 1;
smf_open_newfile( wf, mgrp, 1, SMF__INTEGER, 3, lbnd3d, ubnd3d, 0,
&mapdata, status);
flagmap = mapdata->pntr[0];
/* No. of pixels in one plane */
npix = ( ubnd3d[ 1 ] - lbnd3d[ 1 ] + 1 )*( ubnd3d[ 0 ] - lbnd3d[ 0 ] + 1 );
/* Loop over each quality bit (-1 == "no flags"). */
for( ibit = -1; ibit < SMF__NQBITS_TSERIES; ibit++ ) {
/* The test of each sample is performed by checking if the
sample's quality value ANDed with "mask" is equal to "target".
This is requires since ibit==-1 (i.e. "count all samples that
have no flags set") requires a different logic to the other
ibit values. */
if( ibit == -1 ) {
mask = SMF__Q_GOOD;
target = 0;
} else {
mask = BIT_TO_VAL(ibit);
target = mask;
}
/* Loop over subgroup index (subarray) */
for( idx=0; (idx<qua->ndat)&&(*status==SAI__OK); idx++ ) {
smf_get_dims( qua->sdata[idx], NULL, NULL, &nbolo, &ntslice,
NULL, &bstride, &tstride, status );
qua_data = (qua->sdata[idx]->pntr)[0];
lut_data = (lut->sdata[idx]->pntr)[0];
/* Loop over bolometer and time slice and create map */
for( i=0; i<nbolo; i++ ) {
/* Skip bolometers only if SMF__Q_BADB is set both in the
data and the mask */
for( j=0; j<ntslice; j++ ) {
ii = i*bstride + j*tstride;
if( ( (qua_data[ii] & mask) == target ) &&
(lut_data[ii] != VAL__BADI) ) {
flagmap[lut_data[ii]]++;
}
}
}
}
/* Move the pointer on to th enext plane. */
flagmap += npix;
/* Next quality bit. */
}
/* Take a copy of the supplied FrameSet so we do not modify it. */
tfset = astCopy( outfset );
/* Set atributes for moving target if necessary. */
smf_set_moving( (AstFrame *) tfset, NULL, status );
/* Modify the WCS FrameSet so that the base and current Frames are
3-dimensional. The current Frame is expanded by adding in a simple
1D Frame representing quality bit, and the base Frame is expanded
by adding in a 3rd GRID axis. Other Frames are left unchanged.
The quality bit Frame and the new GRID axis are connected using
a ShiftMap that gives the right zero-based bit numbers (which
also correspond to PIXEL indices). */
shift[ 0 ] = -2.0;
atlAddWcsAxis( tfset, (AstMapping *) astShiftMap( 1, shift, " " ),
astFrame( 1, "Label(1)=Quality bit,Domain=QUALITY" ),
NULL, NULL, status );
/* Store the FrameSet in the 3D NDF. */
ndfPtwcs( tfset, mapdata->file->ndfid, status );
tfset = astAnnul( tfset );
}
/* Clean up */
if( mgrp ) grpDelet( &mgrp, status );
smf_close_file( wf, &mapdata, status );
}
void smf_filter2d_execute( ThrWorkForce *wf, smfData *data, smfFilter *filt,
int complement, int *status ) {
double *data_i=NULL; /* Imaginary part of the transformed data */
double *data_r=NULL; /* Real part of the transformed data */
smfData *fdata=NULL; /* Transform of data */
dim_t fdims[2]={0,0}; /* Frequency dimensions */
size_t i; /* loop counter */
size_t ndims=0; /* Number of real-space dimensions */
size_t nfdata; /* Total number of frequency data points */
smfData *varfilt=NULL; /* real-space square of supplied filter for var */
AstFrameSet *wcs=NULL; /* Copy of real-space WCS */
/* Main routine */
if (*status != SAI__OK) return;
/* Check for NULL pointers */
if( !data ) {
*status = SAI__ERROR;
errRep( "", FUNC_NAME ": NULL smfData pointer", status );
return;
}
if( !filt ) {
*status = SAI__ERROR;
errRep( "", FUNC_NAME ": NULL smfFilter pointer", status );
return;
}
if( filt->ndims != 2 ) {
*status = SAI__ERROR;
errRep( "", FUNC_NAME ": Filter must be 2-dimensional", status );
return;
}
if( smf_isfft( data, NULL, NULL, fdims, NULL, &ndims, status ) ) {
*status = SAI__ERROR;
errRep( "", FUNC_NAME ": FFT'd data supplied!", status );
return;
}
if( ndims != 2 ) {
*status = SAI__ERROR;
errRep( "", FUNC_NAME ": supplied data are not a 2-d map", status );
return;
}
/* Check that the filter dimensions are appropriate for the data */
for( i=0; i<ndims; i++ ) {
if( fdims[i] != filt->fdims[i] ) {
*status = SAI__ERROR;
errRepf( "", FUNC_NAME
": Filter axis %zu has length %zu, doesn't match data %zu",
status, i, filt->fdims[i], fdims[i] );
return;
}
}
/* Dimensions of the transformed data */
nfdata = 1;
for( i=0; i<ndims; i++ ) {
if( filt->fdims[i] != fdims[i] ) {
*status = SAI__ERROR;
errRepf( "", FUNC_NAME
": Filter axis %zu has dim %zu doesn't match data dim %zu",
status, i, filt->fdims[i], fdims[i]);
return;
}
nfdata *= fdims[i];
}
/* Using complement of the filter? */
if( complement ) smf_filter_complement( filt, status );
/* Get a copy of the wcs of the input map */
if( data->hdr && data->hdr->wcs ) {
wcs = astCopy( data->hdr->wcs );
}
/* Transform the data */
fdata = smf_fft_data( wf, data, NULL, 0, 0, status );
/* Copy the FFT of the data if we will also be filtering the VARIANCE
since this will get us a useful container of the correct dimensions
for the squared filter */
if( data->pntr[1] ) {
varfilt = smf_deepcopy_smfData( wf, fdata, 0, SMF__NOCREATE_VARIANCE |
SMF__NOCREATE_QUALITY |
SMF__NOCREATE_FILE |
SMF__NOCREATE_DA, 0, 0, status );
}
/* Apply the frequency-domain filter. */
if( *status == SAI__OK ) {
data_r = fdata->pntr[0];
data_i = data_r + nfdata;
if( filt->isComplex ) {
double ac, bd, aPb, cPd;
for( i=0; i<nfdata; i++ ) {
ac = data_r[i] * filt->real[i];
bd = data_i[i] * filt->imag[i];
aPb = data_r[i] + data_i[i];
cPd = filt->real[i] + filt->imag[i];
}
} else {
for( i=0; i<nfdata; i++ ) {
data_r[i] *= filt->real[i];
data_i[i] *= filt->real[i];
}
}
}
/* Transform back */
smf_fft_data( wf, fdata, data, 1, 0, status );
/* Insert the copy of original real-space WCS into the smfHead since
smf_fft_data does not currently calculate it for inverse
transforms. */
if( data->hdr ) {
/* Annul current wcs if it exists */
if( data->hdr->wcs ) {
data->hdr->wcs = astAnnul( data->hdr->wcs );
}
data->hdr->wcs = wcs;
}
/* If we have a VARIANCE component we also need to smooth it. This
is slightly complicated because we have to do the equivalent of a
real-space convolution between the variance map and the
element-wise square of the real-space filter. So we first stuff
the supplied filter into a smfData (frequency space), take its
inverse to real space and square it. We then transform back to
frequency space, and run it through smf_filter2d_execute to apply
it to the VARIANCE map (which is also stuffed into its own
smfData and then copied into the correct location of the supplied
smfData when finished. */
if( (data->pntr[1]) && (*status==SAI__OK) ) {
dim_t ndata;
double *ptr=NULL;
smfData *realfilter=NULL; /* Real space smfData container for var filter */
smfData *vardata=NULL; /* smfData container for variance only */
smfFilter *vfilt=NULL; /* The var filter */
/* Copy the filter into the smfData container and transform into the
time domain. */
ptr = varfilt->pntr[0];
memcpy(ptr, filt->real, nfdata*sizeof(*ptr));
if( filt->imag) {
memcpy(ptr+nfdata, filt->imag, nfdata*sizeof(*ptr));
} else {
memset(ptr+nfdata, 0, nfdata*sizeof(*ptr));
}
realfilter = smf_fft_data( wf, varfilt, NULL, 1, 0, status );
smf_close_file( wf, &varfilt, status );
/* Square each element of the real-space filter and then transform
back to the frequency domain and stuff into a smfFilter
(vfilt). We just point the real and imaginary parts of the
smfFilter to the respective regions of the smfData to save
memory/time, but we need to be careful when freeing at the
end. */
if( *status == SAI__OK ) {
ptr = realfilter->pntr[0];
smf_get_dims( realfilter, NULL, NULL, NULL, NULL, &ndata, NULL, NULL,
status );
if( *status == SAI__OK ) {
double norm = 1. / (double) ndata;
for(i=0; i<ndata; i++) {
/* Note that we need an additional normalization of N samples */
ptr[i] *= ptr[i] * norm;
}
}
}
varfilt = smf_fft_data( wf, realfilter, NULL, 0, 0, status );
if( *status == SAI__OK ) {
ptr = varfilt->pntr[0];
vfilt = smf_create_smfFilter( data, status );
vfilt->real = ptr;
if( filt->isComplex ) {
/* Only worry about imaginary part if the original filter was
complex. */
vfilt->isComplex = 1;
vfilt->imag = ptr + nfdata;
}
}
/* Now stuff the variance array into a smfData and filter it. */
vardata = smf_deepcopy_smfData( wf, data, 0, SMF__NOCREATE_VARIANCE |
SMF__NOCREATE_QUALITY |
SMF__NOCREATE_FILE |
SMF__NOCREATE_DA, 0, 0, status );
if( *status == SAI__OK ) {
ptr = vardata->pntr[0];
memcpy( ptr, data->pntr[1], ndata*sizeof(*ptr) );
smf_filter2d_execute( wf, vardata, vfilt, 0, status );
}
/* Finally, copy the filtered variance into our output filtered smfData */
if( *status == SAI__OK ) {
ptr = data->pntr[1];
memcpy( ptr, vardata->pntr[0], ndata*sizeof(*ptr) );
}
/* Clean up */
if( realfilter ) smf_close_file( wf, &realfilter, status );
if( vardata ) smf_close_file( wf, &vardata, status );
if( vfilt ) {
vfilt->real = NULL;
vfilt->imag = NULL;
vfilt = smf_free_smfFilter( vfilt, status );
}
}
/* Return the filter to its original state if required */
if( complement == -1 ) smf_filter_complement( filt, status );
/* Clean up */
if( varfilt ) smf_close_file( wf, &varfilt, status );
if( fdata ) smf_close_file( wf, &fdata, status );
}
void smf_check_pol2( Grp *igrp, int size, int raw, int *status ) {
/* Local Variables */
smfData *data = NULL; /* pointer to SCUBA2 data struct */
int i; /* Loop counter */
/* Check inherited status */
if( *status != SAI__OK ) return;
/* Loop over all files in the Grp */
for( i = 1; i <= size && *status == SAI__OK; i++ ) {
/* Read header info from the ith input file in the group */
smf_open_file( NULL, igrp, i, "READ", SMF__NOCREATE_DATA, &data,
status );
/* Check there is a file. */
if( *status == SAI__OK && data->file == NULL ) {
*status = SAI__ERROR;
errRep( FUNC_NAME, "No smfFile associated with smfData.",
status );
/* Check there is a header. */
} else if( *status == SAI__OK && data->hdr == NULL ) {
smf_smfFile_msg( data->file, "FILE", 1, "<unknown>" );
*status = SAI__ERROR;
errRep( FUNC_NAME, "No smfHead associated with ^FILE.",
status );
}
/* Check that there are 3 pixel axes. */
if( *status == SAI__OK && data->ndims != 3) {
smf_smfFile_msg( data->file, "FILE", 1, "<unknown>" );
msgSeti( "NDIMS", data->ndims );
*status = SAI__ERROR;
errRep( FUNC_NAME, "^FILE has ^NDIMS pixel axes, should be 3.",
status );
}
/* Check that POL2 is in the beam. */
if( *status == SAI__OK && !(data->hdr->inbeam & SMF__INBEAM_POL) ) {
smf_smfFile_msg( data->file, "FILE", 1, "<unknown>" );
*status = SAI__ERROR;
errRep( FUNC_NAME, "^FILE does not contain POL2 data.",
status );
}
/* For raw data check that the NDF Label component is "Q" or "U". */
if( *status == SAI__OK ) {
if( raw ) {
if( strcmp( data->hdr->dlabel, "Signal" ) ) {
smf_smfFile_msg( data->file, "FILE", 1, "<unknown>" );
msgSetc( "L", data->hdr->dlabel );
*status = SAI__ERROR;
errRep( FUNC_NAME, "File ^FILE does not contain POL2 "
"analysed intensity data (NDF label is '^L' "
"but should be 'Signal').", status );
}
/* For Q/U data check that the NDF Label component is "Q" or "U". */
} else {
if( strcmp( data->hdr->dlabel, "Q" ) &&
strcmp( data->hdr->dlabel, "U" ) ) {
smf_smfFile_msg( data->file, "FILE", 1, "<unknown>" );
msgSetc( "L", data->hdr->dlabel );
*status = SAI__ERROR;
errRep( FUNC_NAME, "File ^FILE does not contain POL2 "
"Q or U data (NDF label is '^L' but should be "
"'Q' or 'U').", status );
}
}
}
/* Close the data file */
smf_close_file( NULL, &data, status);
}
}
void smf_mapbounds( int fast, Grp *igrp, int size, const char *system,
AstFrameSet *spacerefwcs, int alignsys, int *lbnd_out,
int *ubnd_out, AstFrameSet **outframeset, int *moving,
smfBox ** boxes, fts2Port fts_port, int *status ) {
/* Local Variables */
AstSkyFrame *abskyframe = NULL; /* Output Absolute SkyFrame */
int actval; /* Number of parameter values supplied */
AstMapping *bolo2map = NULL; /* Combined mapping bolo->map
coordinates, WCS->GRID Mapping from
input WCS FrameSet */
smfBox *box = NULL; /* smfBox for current file */
smfData *data = NULL; /* pointer to SCUBA2 data struct */
double dlbnd[ 2 ]; /* Floating point lower bounds for output map */
drcntrl_bits drcntrl_mask = 0;/* Mask to use for DRCONTROL on this instrument */
double dubnd[ 2 ]; /* Floating point upper bounds for output map */
AstMapping *fast_map = NULL; /* Mapping from tracking to absolute map coords */
smfFile *file = NULL; /* SCUBA2 data file information */
int first; /* Is this the first good subscan ? */
AstFitsChan *fitschan = NULL;/* Fits channels to construct WCS header */
AstFrameSet *fs = NULL; /* A general purpose FrameSet pointer */
smfHead *hdr = NULL; /* Pointer to data header this time slice */
int i; /* Loop counter */
dim_t j; /* Loop counter */
AstSkyFrame *junksky = NULL; /* Unused SkyFrame argument */
dim_t k; /* Loop counter */
int lbnd0[ 2 ]; /* Defaults for LBND parameter */
double map_pa=0; /* Map PA in output coord system (rads) */
dim_t maxloop; /* Number of times to go round the time slice loop */
dim_t nbadt = 0; /* Number of bad time slices */
dim_t ngoodt = 0; /* Number of good time slices */
double par[7]; /* Projection parameters */
double shift[ 2 ]; /* Shifts from PIXEL to GRID coords */
AstMapping *oskymap = NULL; /* Mapping celestial->map coordinates,
Sky <> PIXEL mapping in output
FrameSet */
AstSkyFrame *oskyframe = NULL;/* Output SkyFrame */
char *refsys = NULL; /* Sky system from supplied reference FrameSet */
dim_t textreme[4]; /* Time index corresponding to minmax TCS posn */
AstFrame *skyin = NULL; /* Sky Frame in input FrameSet */
double skyref[ 2 ]; /* Values for output SkyFrame SkyRef attribute */
struct timeval tv1; /* Timer */
struct timeval tv2; /* Timer */
AstMapping *tmap; /* Temporary Mapping */
int trim; /* Trim borders of bad pixels from o/p image? */
int ubnd0[ 2 ]; /* Defaults for UBND parameter */
double x_array_corners[4]; /* X-Indices for corner bolos in array */
double x_map[4]; /* Projected X-coordinates of corner bolos */
double y_array_corners[4]; /* Y-Indices for corner pixels in array */
double y_map[4]; /* Projected X-coordinates of corner bolos */
/* Main routine */
if (*status != SAI__OK) return;
/* Start a timer to see how long this takes */
smf_timerinit( &tv1, &tv2, status );
/* Initialize pointer to output FrameSet and moving-source flag */
*outframeset = NULL;
*moving = 0;
/* initialize double precision output bounds and the proj pars */
for( i = 0; i < 7; i++ ) par[ i ] = AST__BAD;
dlbnd[ 0 ] = VAL__MAXD;
dlbnd[ 1 ] = VAL__MAXD;
dubnd[ 0 ] = VAL__MIND;
dubnd[ 1 ] = VAL__MIND;
/* If we have a supplied reference WCS we can use that directly
without having to calculate it from the data. Replace the requested
system with the system from the reference FrameSet (take a copy of the
string since astGetC may re-use its buffer). */
if (spacerefwcs) {
oskyframe = astGetFrame( spacerefwcs, AST__CURRENT );
int nc = 0;
refsys = astAppendString( NULL, &nc, astGetC( oskyframe, "System" ) );
system = refsys;
}
/* Create array of returned smfBox structures and store a pointer
to the next one to be initialised. */
*boxes = astMalloc( sizeof( smfBox ) * size );
box = *boxes;
astBegin;
/* Loop over all files in the Grp */
first = 1;
for( i=1; i<=size; i++, box++ ) {
/* Initialise the spatial bounds of section of the the output cube that is
contributed to by the current ionput file. */
box->lbnd[ 0 ] = VAL__MAXD;
box->lbnd[ 1 ] = VAL__MAXD;
box->ubnd[ 0 ] = VAL__MIND;
box->ubnd[ 1 ] = VAL__MIND;
/* Read data from the ith input file in the group */
smf_open_file( NULL, igrp, i, "READ", SMF__NOCREATE_DATA, &data, status );
if (*status != SAI__OK) {
msgSeti( "I", i );
errRep( "smf_mapbounds", "Could not open data file no ^I.", status );
break;
} else {
if( *status == SAI__OK ) {
if( data->file == NULL ) {
*status = SAI__ERROR;
errRep( FUNC_NAME, "No smfFile associated with smfData.",
status );
break;
} else if( data->hdr == NULL ) {
*status = SAI__ERROR;
errRep( FUNC_NAME, "No smfHead associated with smfData.",
status );
break;
} else if( data->hdr->fitshdr == NULL ) {
*status = SAI__ERROR;
errRep( FUNC_NAME, "No FITS header associated with smfHead.",
status );
break;
}
}
}
/* convenience pointers */
file = data->file;
hdr = data->hdr;
/* report name of the input file */
smf_smfFile_msg( file, "FILE", 1, "<unknown>" );
msgSeti("I", i);
msgSeti("N", size);
msgOutif(MSG__VERB, " ",
"SMF_MAPBOUNDS: Processing ^I/^N ^FILE",
status);
/* Check that there are 3 pixel axes. */
if( data->ndims != 3 ) {
smf_smfFile_msg( file, "FILE", 1, "<unknown>" );
msgSeti( "NDIMS", data->ndims );
*status = SAI__ERROR;
errRep( FUNC_NAME, "^FILE has ^NDIMS pixel axes, should be 3.",
status );
break;
}
/* Check that the data dimensions are 3 (for time ordered data) */
if( *status == SAI__OK ) {
/* If OK Decide which detectors (GRID coord) to use for
checking bounds, depending on the instrument in use. */
switch( hdr->instrument ) {
case INST__SCUBA2:
drcntrl_mask = DRCNTRL__POSITION;
/* 4 corner bolometers of the subarray */
x_array_corners[0] = 1;
x_array_corners[1] = 1;
x_array_corners[2] = (data->dims)[0];
x_array_corners[3] = (data->dims)[0];
y_array_corners[0] = 1;
y_array_corners[1] = (data->dims)[1];
y_array_corners[2] = 1;
y_array_corners[3] = (data->dims)[1];
break;
case INST__AZTEC:
/* Rough guess for extreme bolometers around the edge */
x_array_corners[0] = 22;
x_array_corners[1] = 65;
x_array_corners[2] = 73;
x_array_corners[3] = 98;
y_array_corners[0] = 1; /* Always 1 for AzTEC */
y_array_corners[1] = 1;
y_array_corners[2] = 1;
y_array_corners[3] = 1;
break;
case INST__ACSIS:
smf_find_acsis_corners( data, x_array_corners, y_array_corners,
status);
break;
default:
*status = SAI__ERROR;
errRep(FUNC_NAME, "Don't know how to calculate mapbounds for data created with this instrument", status);
}
}
if( *status == SAI__OK) {
size_t goodidx = SMF__BADSZT;
/* Need to build up a frameset based on good telescope position.
We can not assume that we the first step will be a good TCS position
so we look for one. If we can not find anything we skip to the
next file. */
maxloop = (data->dims)[2];
for (j=0; j<maxloop; j++) {
JCMTState state = (hdr->allState)[j];
if (state.jos_drcontrol >= 0 && state.jos_drcontrol & drcntrl_mask ) {
/* bad TCS - so try again */
} else {
/* Good tcs */
goodidx = j;
break;
}
}
if (goodidx == SMF__BADSZT) {
smf_smfFile_msg( data->file, "FILE", 1, "<unknown>");
msgOutif( MSG__QUIET, "", "No good telescope positions found in file ^FILE. Ignoring",
status );
smf_close_file( NULL, &data, status );
continue;
}
/* If we are dealing with the first good file, create the output
SkyFrame. */
if( first ) {
first = 0;
/* Create output SkyFrame if it has not come from a reference */
if ( oskyframe == NULL ) {
/* smf_tslice_ast only needs to get called once to set up framesets */
if( hdr->wcs == NULL ) {
smf_tslice_ast( data, goodidx, 1, fts_port, status);
}
/* Retrieve input SkyFrame */
skyin = astGetFrame( hdr->wcs, AST__CURRENT );
smf_calc_skyframe( skyin, system, hdr, alignsys, &oskyframe, skyref,
moving, status );
/* Get the orientation of the map vertical within the output celestial
coordinate system. This is derived form the MAP_PA FITS header, which
gives the orientation of the map vertical within the tracking system. */
map_pa = smf_calc_mappa( hdr, system, skyin, status );
/* Provide a sensible default for the pixel size based on wavelength */
par[4] = smf_calc_telres( hdr->fitshdr, status );
par[4] *= AST__DD2R/3600.0;
par[5] = par[4];
/* Calculate the projection parameters. We do not enable autogrid determination
for SCUBA-2 so we do not need to obtain all the data before calculating
projection parameters. */
smf_get_projpar( oskyframe, skyref, *moving, 0, 0, NULL, 0,
map_pa, par, NULL, NULL, status );
if (skyin) skyin = astAnnul( skyin );
/* If the output skyframe has been supplied, we still need to
determine whether the source is moving or not, and set the
reference position. */
} else {
/* smf_tslice_ast only needs to get called once to set up framesets */
if( hdr->wcs == NULL ) {
smf_tslice_ast( data, goodidx, 1, fts_port, status);
}
/* Retrieve input SkyFrame */
skyin = astGetFrame( hdr->wcs, AST__CURRENT );
smf_calc_skyframe( skyin, system, hdr, alignsys, &junksky, skyref,
moving, status );
/* Store the sky reference position. If the target is moving,
ensure the returned SkyFrame represents offsets from the
reference position rather than absolute coords. */
astSetD( oskyframe, "SkyRef(1)", skyref[ 0 ] );
astSetD( oskyframe, "SkyRef(2)", skyref[ 1 ] );
if( *moving ) astSet( oskyframe, "SkyRefIs=Origin" );
/* Ensure the Epoch attribute in the map is set to the date of
the first data in the map, rather than the date in supplied
reference WCS. */
astSetD( oskyframe, "Epoch", astGetD( junksky, "Epoch" ) );
}
if ( *outframeset == NULL && oskyframe != NULL && (*status == SAI__OK)){
/* Now created a spatial Mapping. Use the supplied reference frameset
if supplied */
if (spacerefwcs) {
oskymap = astGetMapping( spacerefwcs, AST__BASE, AST__CURRENT );
} else {
/* Now populate a FitsChan with FITS-WCS headers describing
the required tan plane projection. The longitude and
latitude axis types are set to either (RA,Dec) or (AZ,EL)
to get the correct handedness. */
fitschan = astFitsChan ( NULL, NULL, " " );
smf_makefitschan( astGetC( oskyframe, "System"), &(par[0]),
&(par[2]), &(par[4]), par[6], fitschan, status );
astClear( fitschan, "Card" );
fs = astRead( fitschan );
/* Extract the output PIXEL->SKY Mapping. */
oskymap = astGetMapping( fs, AST__BASE, AST__CURRENT );
/* Tidy up */
fs = astAnnul( fs );
}
/* Create the output FrameSet */
*outframeset = astFrameSet( astFrame(2, "Domain=GRID"), " " );
/* Now add the SkyFrame to it */
astAddFrame( *outframeset, AST__BASE, oskymap, oskyframe );
/* Now add a POLANAL Frame if required (i.e. if the input time
series are POL-2 Q/U values). */
smf_addpolanal( *outframeset, hdr, status );
/* Invert the oskymap mapping */
astInvert( oskymap );
} /* End WCS FrameSet construction */
}
/* Get a copy of the output SkyFrame and ensure it represents
absolute coords rather than offset coords. */
abskyframe = astCopy( oskyframe );
astClear( abskyframe, "SkyRefIs" );
astClear( abskyframe, "AlignOffset" );
maxloop = (data->dims)[2];
if (fast) {
/* For scan map we scan through looking for largest telescope moves.
For dream/stare we just look at the start and end time slices to
account for sky rotation. */
if (hdr->obsmode != SMF__OBS_SCAN) {
textreme[0] = 0;
textreme[1] = (data->dims)[2] - 1;
maxloop = 2;
} else {
const char *tracksys;
double *ac1list, *ac2list, *bc1list, *bc2list, *p1, *p2, *p3, *p4;
double flbnd[4], fubnd[4];
JCMTState state;
/* If the output and tracking systems are different, get a
Mapping between them. */
tracksys = sc2ast_convert_system( (hdr->allState)[goodidx].tcs_tr_sys,
status );
if( strcmp( system, tracksys ) ) {
AstSkyFrame *tempsf = astCopy( abskyframe );
astSetC( tempsf, "System", tracksys );
AstFrameSet *tempfs = astConvert( tempsf, abskyframe, "" );
tmap = astGetMapping( tempfs, AST__BASE, AST__CURRENT );
fast_map = astSimplify( tmap );
tmap = astAnnul( tmap );
tempsf = astAnnul( tempsf );
tempfs = astAnnul( tempfs );
} else {
fast_map = NULL;
}
/* Copy all ac1/2 positions into two array, and transform them
from tracking to absolute output sky coords. */
ac1list = astMalloc( maxloop*sizeof( *ac1list ) );
ac2list = astMalloc( maxloop*sizeof( *ac2list ) );
if( *status == SAI__OK ) {
p1 = ac1list;
p2 = ac2list;
for( j = 0; j < maxloop; j++ ) {
state = (hdr->allState)[ j ];
*(p1++) = state.tcs_tr_ac1;
*(p2++) = state.tcs_tr_ac2;
}
if( fast_map ) astTran2( fast_map, maxloop, ac1list, ac2list, 1,
ac1list, ac2list );
}
/* If the target is moving, we need to adjust these ac1/2 values
to represent offsets from the base position. */
if( *moving ) {
/* Copy all bc1/2 positions into two arrays. */
bc1list = astMalloc( maxloop*sizeof( *bc1list ) );
bc2list = astMalloc( maxloop*sizeof( *bc2list ) );
if( *status == SAI__OK ) {
p1 = bc1list;
p2 = bc2list;
for( j = 0; j < maxloop; j++ ) {
state = (hdr->allState)[ j ];
*(p1++) = state.tcs_tr_bc1;
*(p2++) = state.tcs_tr_bc2;
}
/* Transform them from tracking to absolute output sky coords. */
if( fast_map ) astTran2( fast_map, maxloop, bc1list, bc2list,
1, bc1list, bc2list );
/* Replace each ac1/2 position with the offsets from the
corresponding base position. */
p1 = bc1list;
p2 = bc2list;
p3 = ac1list;
p4 = ac2list;
for( j = 0; j < maxloop; j++ ) {
smf_offsets( *(p1++), *(p2++), p3++, p4++, status );
}
}
/* We no longer need the base positions. */
bc1list = astFree( bc1list );
bc2list = astFree( bc2list );
}
/* Transform the ac1/2 position from output sky coords to
output pixel coords. */
astTran2( oskymap, maxloop, ac1list, ac2list, 1, ac1list, ac2list );
/* Find the bounding box containing these pixel coords and the
time slices at which the boresight touches each edge of this
box. */
flbnd[ 0 ] = VAL__MAXD;
flbnd[ 1 ] = VAL__MAXD;
fubnd[ 0 ] = VAL__MIND;
fubnd[ 1 ] = VAL__MIND;
for( j = 0; j < 4; j++ ) textreme[ j ] = (dim_t) VAL__BADI;
if( *status == SAI__OK ) {
p1 = ac1list;
p2 = ac2list;
for( j = 0; j < maxloop; j++,p1++,p2++ ) {
if( *p1 != VAL__BADD && *p2 != VAL__BADD ){
if ( *p1 < flbnd[0] ) { flbnd[0] = *p1; textreme[0] = j; }
if ( *p2 < flbnd[1] ) { flbnd[1] = *p2; textreme[1] = j; }
if ( *p1 > fubnd[0] ) { fubnd[0] = *p1; textreme[2] = j; }
if ( *p2 > fubnd[1] ) { fubnd[1] = *p2; textreme[3] = j; }
}
}
}
maxloop = 4;
msgSetd("X1", textreme[0]);
msgSetd("X2", textreme[1]);
msgSetd("X3", textreme[2]);
msgSetd("X4", textreme[3]);
msgOutif( MSG__DEBUG, " ",
"Extrema time slices are ^X1, ^X2, ^X3 and ^X4",
status);
ac1list = astFree( ac1list );
ac2list = astFree( ac2list );
}
}
/* Get the astrometry for all the relevant time slices in this data file */
for( j=0; j<maxloop; j++ ) {
dim_t ts; /* Actual time slice to use */
/* if we are doing the fast loop, we need to read the time slice
index from textreme. Else we just use the index */
if (fast) {
/* get the index but make sure it is good */
ts = textreme[j];
if (ts == (dim_t)VAL__BADI) continue;
} else {
ts = j;
}
/* Calculate the bolo to map-pixel transformation for this tslice */
bolo2map = smf_rebin_totmap( data, ts, abskyframe, oskymap,
*moving, fts_port, status );
if ( *status == SAI__OK ) {
/* skip if we did not get a mapping this time round */
if (!bolo2map) continue;
/* Check corner pixels in the array for their projected extent
on the sky to set the pixel bounds */
astTran2( bolo2map, 4, x_array_corners, y_array_corners, 1,
x_map, y_map );
/* Update min/max for this time slice */
for( k=0; k<4; k++ ) {
if( x_map[k] != AST__BAD && y_map[k] != AST__BAD ) {
if( x_map[k] < dlbnd[0] ) dlbnd[0] = x_map[k];
if( y_map[k] < dlbnd[1] ) dlbnd[1] = y_map[k];
if( x_map[k] > dubnd[0] ) dubnd[0] = x_map[k];
if( y_map[k] > dubnd[1] ) dubnd[1] = y_map[k];
if( x_map[k] < box->lbnd[0] ) box->lbnd[0] = x_map[k];
if( y_map[k] < box->lbnd[1] ) box->lbnd[1] = y_map[k];
if( x_map[k] > box->ubnd[0] ) box->ubnd[0] = x_map[k];
if( y_map[k] > box->ubnd[1] ) box->ubnd[1] = y_map[k];
} else if( *status == SAI__OK ) {
*status = SAI__ERROR;
errRep( FUNC_NAME, "Extreme positions are bad.", status );
break;
}
}
}
/* Explicitly annul these mappings each time slice for reduced
memory usage */
if (bolo2map) bolo2map = astAnnul( bolo2map );
if (fs) fs = astAnnul( fs );
/* Break out of loop over time slices if bad status */
if (*status != SAI__OK) goto CLEANUP;
}
/* Annul any remaining Ast objects before moving on to the next file */
if (fs) fs = astAnnul( fs );
if (bolo2map) bolo2map = astAnnul( bolo2map );
}
/* Close the data file */
smf_close_file( NULL, &data, status);
/* Break out of loop over data files if bad status */
if (*status != SAI__OK) goto CLEANUP;
}
/* make sure we got values - should not be possible with good status */
if (dlbnd[0] == VAL__MAXD || dlbnd[1] == VAL__MAXD) {
if (*status == SAI__OK) {
*status = SAI__ERROR;
errRep( " ", "Unable to find any valid map bounds", status );
}
}
if (nbadt > 0) {
msgOutf( "", " Processed %zu time slices to calculate bounds,"
" of which %zu had bad telescope data and were skipped",
status, (size_t)(ngoodt+nbadt), (size_t)nbadt );
}
/* If spatial reference wcs was supplied, store par values that result in
no change to the pixel origin. */
if( spacerefwcs ){
par[ 0 ] = 0.5;
par[ 1 ] = 0.5;
}
/* Need to re-align with the interim GRID coordinates */
lbnd_out[0] = ceil( dlbnd[0] - par[0] + 0.5 );
ubnd_out[0] = ceil( dubnd[0] - par[0] + 0.5 );
lbnd_out[1] = ceil( dlbnd[1] - par[1] + 0.5 );
ubnd_out[1] = ceil( dubnd[1] - par[1] + 0.5 );
/* Do the same with the individual input file bounding boxes */
box = *boxes;
for (i = 1; i <= size; i++, box++) {
box->lbnd[0] = ceil( box->lbnd[0] - par[0] + 0.5);
box->ubnd[0] = ceil( box->ubnd[0] - par[0] + 0.5);
box->lbnd[1] = ceil( box->lbnd[1] - par[1] + 0.5);
box->ubnd[1] = ceil( box->ubnd[1] - par[1] + 0.5);
}
/* Apply a ShiftMap to the output FrameSet to re-align the GRID
coordinates */
shift[0] = 2.0 - par[0] - lbnd_out[0];
shift[1] = 2.0 - par[1] - lbnd_out[1];
astRemapFrame( *outframeset, AST__BASE, astShiftMap( 2, shift, " " ) );
/* Set the dynamic defaults for lbnd/ubnd */
lbnd0[ 0 ] = lbnd_out[ 0 ];
lbnd0[ 1 ] = lbnd_out[ 1 ];
parDef1i( "LBND", 2, lbnd0, status );
ubnd0[ 0 ] = ubnd_out[ 0 ];
ubnd0[ 1 ] = ubnd_out[ 1 ];
parDef1i( "UBND", 2, ubnd0, status );
parGet1i( "LBND", 2, lbnd_out, &actval, status );
if( actval == 1 ) lbnd_out[ 1 ] = lbnd_out[ 0 ];
parGet1i( "UBND", 2, ubnd_out, &actval, status );
if( actval == 1 ) ubnd_out[ 1 ] = ubnd_out[ 0 ];
/* Ensure the bounds are the right way round. */
if( lbnd_out[ 0 ] > ubnd_out[ 0 ] ) {
int itmp = lbnd_out[ 0 ];
lbnd_out[ 0 ] = ubnd_out[ 0 ];
ubnd_out[ 0 ] = itmp;
}
if( lbnd_out[ 1 ] > ubnd_out[ 1 ] ) {
int itmp = lbnd_out[ 1 ];
lbnd_out[ 1 ] = ubnd_out[ 1 ];
ubnd_out[ 1 ] = itmp;
}
/* If borders of bad pixels are being trimmed from the output image,
then do not allow the user-specified bounds to extend outside the
default bounding box (since we know that the default bounding box
encloses all available data). */
parGet0l( "TRIM", &trim, status );
if( trim ) {
if( lbnd_out[ 0 ] < lbnd0[ 0 ] ) lbnd_out[ 0 ] = lbnd0[ 0 ];
if( lbnd_out[ 1 ] < lbnd0[ 1 ] ) lbnd_out[ 1 ] = lbnd0[ 1 ];
if( ubnd_out[ 0 ] > ubnd0[ 0 ] ) ubnd_out[ 0 ] = ubnd0[ 0 ];
if( ubnd_out[ 1 ] > ubnd0[ 1 ] ) ubnd_out[ 1 ] = ubnd0[ 1 ];
}
/* Modify the returned FrameSet to take account of the new pixel origin. */
shift[ 0 ] = lbnd0[ 0 ] - lbnd_out[ 0 ];
shift[ 1 ] = lbnd0[ 1 ] - lbnd_out[ 1 ];
if( shift[ 0 ] != 0.0 || shift[ 1 ] != 0.0 ) {
astRemapFrame( *outframeset, AST__BASE, astShiftMap( 2, shift, " " ) );
}
/* Report the pixel bounds of the cube. */
if( *status == SAI__OK ) {
msgOutif( MSG__NORM, " ", " ", status );
msgSeti( "XL", lbnd_out[ 0 ] );
msgSeti( "YL", lbnd_out[ 1 ] );
msgSeti( "XU", ubnd_out[ 0 ] );
msgSeti( "YU", ubnd_out[ 1 ] );
msgOutif( MSG__NORM, " ", " Output map pixel bounds: ( ^XL:^XU, ^YL:^YU )",
status );
if( ( ubnd_out[ 0 ] - lbnd_out[ 0 ] + 1 ) > MAX_DIM ||
( ubnd_out[ 1 ] - lbnd_out[ 1 ] + 1 ) > MAX_DIM ) {
*status = SAI__ERROR;
errRep( "", FUNC_NAME ": The map is too big. Check your list of input "
"data files does not include widely separated observations.",
status );
}
}
/* If no error has occurred, export the returned FrameSet pointer from the
current AST context so that it will not be annulled when the AST
context is ended. Otherwise, ensure a null pointer is returned. */
if( *status == SAI__OK ) {
astExport( *outframeset );
} else {
*outframeset = astAnnul( *outframeset );
}
msgOutiff( SMF__TIMER_MSG, "",
"Took %.3f s to calculate map bounds",
status, smf_timerupdate( &tv1, &tv2, status ) );
/* Clean Up */
CLEANUP:
if (*status != SAI__OK) {
errRep(FUNC_NAME, "Unable to determine map bounds", status);
}
if (oskymap) oskymap = astAnnul( oskymap );
if (bolo2map) bolo2map = astAnnul( bolo2map );
if (fitschan) fitschan = astAnnul( fitschan );
if( data != NULL )
smf_close_file( NULL, &data, status );
refsys = astFree( refsys );
astEnd;
}
void smurf_fts2_split(int* status)
{
if( *status != SAI__OK ) { return; }
const double STAGE_LENGTH = 450.0; /* mm */
int LR = 0; /* Treat as Low Resolution scan */
Grp* gIn = NULL; /* Input group */
Grp* gOut = NULL; /* Output group */
Grp* gTmp = NULL; /* Temporary group */
smfData* inData = NULL; /* Pointer to input data */
smfData* outData = NULL; /* Pointer to output data */
double* outData_pntr = NULL; /* Pointer to output data values array */
int nMirPos = 0; /* Number of frames where the mirror actually moves */
int nStart = 0; /* Frame index where the mirror starts moving */
int nStartNext = 0; /* Frame index where the mirror starts moving in the next scan */
int nStop = 0; /* Frame index where the mirror stops */
int lrStart = 0; /* Frame index where low resolution mirror limit starts */
int hrStop = 0; /* Frame index where high resolution mirror limit stops */
int hrStart = 0; /* Frame index where high resolution mirror limit starts */
int lrStop = 0; /* Frame index where low resolution mirror limit stops */
int lrCentre = 0; /* Frame index at centre of low resolution mirror positions */
int i = 0; /* Counter */
int j = 0; /* Counter */
int k = 0; /* Counter */
int n = 0; /* Counter */
double fNyquist = 0.0; /* Nyquist frequency */
double dz = 0.0; /* Step size in evenly spaced OPD grid */
double* MIRPOS = NULL; /* Mirror positions */
size_t nFiles = 0; /* Size of the input group */
size_t nOutFiles = 0; /* Size of the output group */
size_t fIndex = 0; /* File index */
size_t nWidth = 0; /* Data cube width */
size_t nHeight = 0; /* Data cube height */
size_t nFrames = 0; /* Data cube depth in input file */
size_t nFramesOut = 0; /* Data cube depth in output file */
size_t nFramesOutPrev = 0; /* Data cube depth in previous output file */
size_t hrFramesOut = 0; /* Data cube depth in high res output file */
size_t hrFramesOutPrev = 0; /* Data cube depth in previous high res output file */
size_t lrFramesOut = 0; /* Data cube depth in low res output file */
size_t lrFramesOutPrev = 0; /* Data cube depth in previous low res output file */
size_t nPixels = 0; /* Number of bolometers in the subarray */
char object[SZFITSTR];
char subarray[SZFITSTR];
char obsID[SZFITSTR];
char scanMode[SZFITSTR];
double scanVel = 0.0; /* Mirror speed in mm/sec */
double stepTime = 0.0; /* RTS step time, average sample rate */
double minOPD = 0; /* OPD minimum */
double maxOPD = 0; /* OPD maximum */
double ZPD = 0;
double lrmmBandPass = 0.0; /* low res mm +/- offset from centre */
int lrBandPassFrames = 0; /* Number of low res band pass frames from centre +/- length of lrmmBandPass */
int nTmp = 0;
int nMax = 0;
int nOPD = 0;
int bolIndex = 0;
int index = 0;
int indexIn = 0;
int indexOut = 0;
int badPixel = 0;
int k0 = 0;
int indexZPD = 0;
int done = 0; /* Track completion of extracting multiple scans */
int outDataCount = 0; /* The number of output data files being written */
double lenLeft,
lenRight,
minLenLeft,
minLenRight,
minLen,
minZPD,
maxZPD,
midZPD = 0.0; /* Mirror position half side measures */
int midZPDPos = 0; /* Middle ZPD position in mirror position array */
double EPSILON = 0.0;
char fileName[SMF_PATH_MAX+1];
char scanNumStr[5+1]; /* String form of scan number of the input file */
int scanNum = 0; /* Scan number of the input file */
int conNum = 0; /* Concatenation number of the input file (left shifted scanNum) */
int scanDir = 0; /* Scan direction: 1 -> back to front (positive), -1 -> front to back (negative) */
JCMTState *allState = NULL; /* Temporary buffer for reduced header allState array data */
/* Get Input, Output groups */
kpg1Rgndf("IN", 0, 1, "", &gIn, &nFiles, status);
kpg1Wgndf("OUT", gOut, nFiles, nFiles, "More output files expected!", &gOut, &nOutFiles, status);
/* Read in ADAM parameters */
parGet0d("BANDPASS", &lrmmBandPass, status); /* Low res mm band +/- offset from centre */
/* Treat as Low Resolution scan? */
if(lrmmBandPass > 0) {
LR = 1;
}
/* Eliminate the first record in the output group, since it will be replaced later */
gTmp = grpCopy(gOut, 1, 1, 1, status);
grpDelet(&gOut, status);
gOut = gTmp;
/* BEGIN NDF */
ndfBegin();
/* Loop through each input file */
for(fIndex = 1; fIndex <= nFiles; fIndex++) {
/* Open Observation file */
smf_open_file(gIn, fIndex, "READ", 0, &inData, status);
if(*status != SAI__OK) {
*status = SAI__ERROR;
errRep(FUNC_NAME, "Unable to open the source file!", status);
goto CLEANUP;
}
smf_fits_getS(inData->hdr, "OBJECT", object, sizeof(object), status);
smf_fits_getS(inData->hdr, "SUBARRAY", subarray, sizeof(subarray), status);
smf_fits_getS(inData->hdr, "OBSID", obsID, sizeof(obsID), status);
smf_fits_getS(inData->hdr, "FTS_MODE", scanMode, sizeof(scanMode), status);
smf_fits_getD(inData->hdr, "SCANVEL", &scanVel, status);
smf_fits_getD(inData->hdr, "STEPTIME", &stepTime, status);
/* Nyquist frequency */
fNyquist = 10.0 / (8.0 * scanVel * stepTime);
dz = 1.0 / (2.0 * fNyquist);
EPSILON = scanVel * stepTime / 2;
/* Extract the scan number from the input file to be incremented in the output files */
one_strlcpy(scanNumStr, &(inData->file->name[strlen(inData->file->name) - 8]),
astMIN(SMF_PATH_MAX + 1, 5), status);
if (*status == ONE__TRUNC) {
errRep(FUNC_NAME, "Error extracting scanNumStr!", status);
errAnnul(status);
}
/* Create a temporary base file name from input file name */
one_strlcpy(fileName, inData->file->name,
astMIN(SMF_PATH_MAX + 1, strlen(inData->file->name) - 7), status);
if (*status == ONE__TRUNC) {
errRep(FUNC_NAME, "Error extracting base fileName!", status);
errAnnul(status);
}
scanNum = (int) one_strtod(scanNumStr, status);
if (*status != SAI__OK) {
errRep(FUNC_NAME, "Error extracting scanNum!", status);
errAnnul(status);
}
/* Left shift scanNum to conNum as a prefix to make output scan number unique */
if(scanNum < 100) {
conNum = scanNum * 100;
} else if(scanNum < 1000) {
conNum = scanNum * 10;
}
/*printf("%s: Processing file: %s, having basename: %s and scanNumStr: %s, scanNum: %04d\n",
TASK_NAME, inData->file->name, fileName, scanNumStr, scanNum);*/
/* Data cube dimensions */
nWidth = inData->dims[0];
nHeight = inData->dims[1];
nFrames = inData->dims[2];
nPixels = nWidth * nHeight;
/* Mirror positions in mm */
nTmp = nFrames;
MIRPOS = astCalloc(nFrames, sizeof(*MIRPOS));
fts2_getmirrorpositions(inData, MIRPOS, &nTmp, status); // (mm)
if(*status != SAI__OK) {
*status = SAI__ERROR;
errRep( FUNC_NAME, "Unable to get the mirror positions!", status);
goto CLEANUP;
}
nStart = -1;
nStop = -1;
nStartNext = 0;
hrStart = -1;
hrStop = -1;
lrStart = -1;
lrStop = -1;
outDataCount = 0;
done = 0;
do {
/* Find the next range of single scan mirror positions for which to extract corresponding NDF data */
for(n=nStartNext; n<nFrames-1; n++){
if(hrStart < 0 && fabs(MIRPOS[n+1] - MIRPOS[n]) >= EPSILON) {
nStart = n;
hrStart = n;
/*printf("%s: Split nStart=%d\n", TASK_NAME, nStart);*/
}
if(hrStart >= 0 && hrStop < 0 && (fabs(MIRPOS[n+1] - MIRPOS[n]) < EPSILON || n+1 == nFrames-1)) {
hrStop = n+1;
hrFramesOutPrev = hrFramesOut;
hrFramesOut = abs(hrStop - hrStart) + 1;
outDataCount++;
nStop = hrStop;
nFramesOutPrev = hrFramesOutPrev;
nFramesOut = hrFramesOut;
/*printf("%s: Split: %d of %d frames found at hrStart=%d, hrStop=%d\n",
TASK_NAME, outDataCount, hrFramesOut, hrStart, hrStop);*/
break;
}
}
/* Determine scan direction */
if(MIRPOS[hrStart] < MIRPOS[hrStop]) {
scanDir = 1; /* Positive */
} else {
scanDir = -1; /* Negative */
}
/* Limit to specified mirror position range */
if(LR) {
/* Calculate how many frames correspond to the given +/- mm of LR bandpass */
lrBandPassFrames = lrmmBandPass / dz;
/* Find the centre of the current scan */
lrCentre = floor((abs(hrStop-hrStart)+1)/2);
/* Set low res start and stop values at corresponding frame offsets from centre */
lrStart = lrCentre - lrBandPassFrames;
lrStop = lrCentre + lrBandPassFrames;
lrFramesOutPrev = lrFramesOut;
lrFramesOut = abs(lrStop - lrStart) + 1;
nStart = lrStart;
nStop = lrStop;
nFramesOutPrev = lrFramesOutPrev;
nFramesOut = lrFramesOut;
/*printf("%s: LR Split: %d of %d frames found at lrStart=%d, lrStop=%d\n",
TASK_NAME, outDataCount, lrFramesOut, lrStart, lrStop);*/
}
/* Check for end of data condition */
if(hrStop < hrStart || hrStop >= nFrames-1) {
hrStop = nFrames-1;
done = 1;
}
/* Output scan if there is a start and stop position found,
and for the last scan if it's the only one
and if it's not too short (compared to the previous one) */
/*printf("%s: nStart=%d, nStop=%d, nFramesOutPrev=%d, nFramesOut=%d\n", TASK_NAME, nStart, nStop, nFramesOutPrev, nFramesOut);*/
if(nStart >=0 && nStop > 0 &&
(nFramesOutPrev == 0 ||
(nFramesOutPrev > 0 && nFramesOut > 0 && (double)hrFramesOut/(double)hrFramesOutPrev >= 0.5))) {
/* Copy single scan NDF data from input to output */
outData = smf_deepcopy_smfData(inData, 0, SMF__NOCREATE_DATA | SMF__NOCREATE_FTS, 0, 0, status);
outData->dtype = SMF__DOUBLE;
outData->ndims = 3;
outData->dims[0] = nWidth;
outData->dims[1] = nHeight;
outData->dims[2] = nFramesOut;
outData_pntr = (double*) astMalloc((nPixels * nFramesOut) * sizeof(*outData_pntr));
outData->pntr[0] = outData_pntr;
outData->hdr->nframes = nFramesOut;
for(i=0; i<nWidth; i++) {
for(j=0; j<nHeight; j++) {
bolIndex = i + j * nWidth;
for(k=nStart; k<=nStop; k++) {
indexIn = bolIndex + k * nPixels;
indexOut = bolIndex + (k-nStart) * nPixels;
*((double*)(outData->pntr[0]) + indexOut) = *((double*)(inData->pntr[0]) + indexIn);
}
}
}
/* Update the FITS headers */
outData->fts = smf_create_smfFts(status);
/* Update FITS component */
smf_fits_updateD(outData->hdr, "FNYQUIST", fNyquist, "Nyquist frequency (cm^-1)", status);
smf_fits_updateI(outData->hdr, "MIRSTART", 1, "Frame index in which the mirror starts moving", status);
smf_fits_updateI(outData->hdr, "MIRSTOP", nFramesOut, "Frame index in which the mirror stops moving", status);
smf_fits_updateI(outData->hdr, "SCANDIR", scanDir, "Scan direction", status);
smf_fits_updateD(outData->hdr, "OPDMIN", 0.0, "Minimum OPD", status);
smf_fits_updateD(outData->hdr, "OPDSTEP", 0.0, "OPD step size", status);
/* Update the JCMTSTATE header */
/* Reallocate outData header array memory to reduced size */
allState = (JCMTState*) astRealloc(outData->hdr->allState, nFramesOut * sizeof(*(outData->hdr->allState)));
if(*status == SAI__OK && allState) {
outData->hdr->allState = allState;
} else {
errRepf(TASK_NAME, "Error reallocating allState JCMTState header", status);
goto CLEANUP;
}
for(k=nStart; k<=nStop; k++) {
/* Copy over JCMTstate */
/*printf("%s: memcpy allState: %d to: %p from: %p size: %d\n",TASK_NAME, k,
(void *) &(outData->hdr->allState[k-nStart]), (void *) &(inData->hdr->allState[k]), sizeof(*(outData->hdr->allState)) );*/
memcpy( (void *) &(outData->hdr->allState[k-nStart]), (void *) &(inData->hdr->allState[k]), sizeof(*(outData->hdr->allState)) );
/*printf("%s: Scan: %d index: %d rts_num: %d\n", TASK_NAME, outDataCount, k-nStart, outData->hdr->allState[k-nStart].rts_num);*/
/*printf("%s: Scan: %d index: %d fts_pos: %f\n", TASK_NAME, outDataCount, k-nStart, outData->hdr->allState[k-nStart].fts_pos);*/
}
/* Write output */
/* Append unique suffix to fileName */
/* This must be modified by the concatenation file scan number to improve uniqueness */
n = one_snprintf(outData->file->name, SMF_PATH_MAX, "%s%04d_scn.sdf", status, fileName, conNum+outDataCount);
/*printf("%s: Writing outData->file->name: %s\n", TASK_NAME, outData->file->name);*/
if(n < 0 || n >= SMF_PATH_MAX) {
errRepf(TASK_NAME, "Error creating outData->file->name", status);
goto CLEANUP;
}
/* Update the list of output _scn file names */
grpPut1(gOut, outData->file->name, 0, status);
if(*status != SAI__OK) {
errRepf(TASK_NAME, "Error saving outData file name", status);
goto CLEANUP;
}
smf_write_smfData(outData, NULL, outData->file->name, gOut, fIndex, 0, MSG__VERB, 0, status);
if(*status != SAI__OK) {
errRepf(TASK_NAME, "Error writing outData file", status);
goto CLEANUP;
}
smf_close_file(&outData, status);
if(*status != SAI__OK) {
errRepf(TASK_NAME, "Error closing outData file", status);
goto CLEANUP;
}
if(*status != SAI__OK) {
errRepf(TASK_NAME, "Error closing outData file", status);
goto CLEANUP;
}
}/* else {
if(!(nStart >=0 && nStop)) printf("%s: Output scan condition failed: nStart(%d) >= nStop(%d) is FALSE\n",TASK_NAME, nStart, nStop);
if(!(nFramesOutPrev == 0 ||
(nFramesOutPrev > 0 && nFramesOut > 0 && (double)nFramesOut/(double)nFramesOutPrev >= 0.5))) printf("%s: Output scan condition failed: nFramesOutPrev(%d) == 0 || (nFramesOutPrev(%d) > 0 && nFramesOut(%d) > 0 && nFramesOut/nFramesOutPrev (%f) >= 0.5) is FALSE\n", TASK_NAME, nFramesOutPrev, nFramesOutPrev, nFramesOut, (double)nFramesOut/(double)nFramesOutPrev);
}*/
/* Prepare for next iteration */
nStartNext = hrStop + 1;
hrStart = -1;
hrStop = -1;
} while (!done);
/* Deallocate memory used by arrays */
if(MIRPOS) { MIRPOS = astFree(MIRPOS); }
/* Close the file */
smf_close_file(&inData, status);
}
CLEANUP:
/* Deallocate memory used by arrays */
if(inData) { smf_close_file(&inData, status); }
if(outData) { smf_close_file(&outData, status); }
/* END NDF */
ndfEnd(status);
/* Write out the list of output NDF names, annulling the error if a null
parameter value is supplied. */
if( *status == SAI__OK && gOut ) {
grpList( "OUTFILES", 0, 0, NULL, gOut, status );
if( *status == PAR__NULL ) {
errRep(FUNC_NAME, "Error writing OUTFILES!", status);
errAnnul( status );
}
}
/* Delete groups */
if(gIn) { grpDelet(&gIn, status); }
if(gOut) { grpDelet(&gOut, status); }
}
int *smf_jsatiles_data( Grp *igrp, size_t size, int *ntile, int *status ){
/* Local Variables */
AstFrame *frm = NULL;
AstFrameSet *fs;
JCMTState *state;
const char *trsys;
const char *trsys_last;
dim_t *hits = NULL;
dim_t *ph;
dim_t iframe;
double *gx = NULL;
double *gy = NULL;
double *p1;
double *p2;
double *px;
double *py;
double *trac1 = NULL;
double *trac2 = NULL;
double fov;
double point1[ 2 ];
double point2[ 2 ];
double search;
int *tiles = NULL;
int dim[ 2 ];
int i;
int ix;
int iy;
int lbnd[ 2 ];
int ubnd[ 2 ];
size_t ifile;
smfData *data = NULL;
smfHead *hdr = NULL;
smfJSATiling skytiling;
smf_inst_t inst = SMF__INST_NONE;
smf_inst_t instrument;
smf_subinst_t subinst;
/* Initialise */
*ntile = 0;
/* Check inherited status */
if( *status != SAI__OK ) return tiles;
/* Start an AST context so that all AST objects created in this function
are annulled automatically. */
astBegin;
/* Loop round all the input NDFs. */
trsys_last = "";
for( ifile = 1; ifile <= size && *status == SAI__OK; ifile++ ) {
/* Obtain information about the current input NDF. */
smf_open_file( igrp, ifile, "READ", SMF__NOCREATE_DATA, &data,
status );
/* Get a pointer to the header. */
hdr = data->hdr;
/* Get the instrument. */
if( hdr->instrument == INST__SCUBA2 ) {
subinst = smf_calc_subinst( hdr, status );
if( subinst == SMF__SUBINST_850 ) {
inst = SMF__INST_SCUBA_2_850;
} else {
inst = SMF__INST_SCUBA_2_450;
}
} else if( hdr->instrument == INST__ACSIS ) {
inst = SMF__INST_HARP;
} else if( *status == SAI__OK ) {
*status = SAI__ERROR;
smf_smfFile_msg( data->file, "FILE", 1, "<unknown>" );
errRep( "", "No tiles are yet defined for the instrument that "
"created ^FILE.", status );
}
/* If this is the first file, it defines the instrument in use. */
if( ifile == 1 ) {
instrument = inst;
/* Get the parameters that define the layout of sky tiles for the
instrument. */
smf_jsatiling( instrument, &skytiling, status );
/* Create a FrameSet describing the whole sky in which each pixel
corresponds to a single tile. The current Frame is ICRS (RA,Dec) and
the base Frame is grid coords in which each grid pixel corresponds to
a single tile. */
smf_jsatile( 0, &skytiling, 0, NULL, &fs, NULL, lbnd, ubnd, status );
/* Allocate an image with one pixel for each tile, and fill it with
zeros. */
dim[ 0 ] = ubnd[ 0 ] - lbnd[ 0 ] + 1;
dim[ 1 ] = ubnd[ 1 ] - lbnd[ 1 ] + 1;
hits = astCalloc( dim[0]*dim[1], sizeof( *hits ) );
/* Get the radius of the field of view in radians. */
fov = 0.5*(skytiling.fov*AST__DD2R)/3600.0;
/* If this is not the first file, report an error if the instrument has
changed... */
} else if( instrument != inst && *status == SAI__OK ) {
smf_smfFile_msg( data->file, "FILE", 1, "<unknown>" );
errRep( "", "The file ^FILE was created by a different instrument "
"to the previous files.", status );
}
/* Re-map the current Frame of the hits map WCS FrameSet to be the tracking
system used by the current file (if it has changed). */
trsys = sc2ast_convert_system( (hdr->allState)[0].tcs_tr_sys,
status );
if( *status == SAI__OK && strcmp( trsys, trsys_last ) ) {
astSetC( fs, "System", trsys );
trsys_last = trsys;
frm = astGetFrame( fs, AST__CURRENT );
}
/* Get the radius of the search circle. */
search = fov + sqrt( hdr->instap[ 0 ]*hdr->instap[ 0 ] +
hdr->instap[ 1 ]*hdr->instap[ 1 ] );
/* Ensure our work arrays are big enough to hold the current file. */
trac1 = astGrow( trac1, 4*hdr->nframes, sizeof( *trac1 ) );
trac2 = astGrow( trac2, 4*hdr->nframes, sizeof( *trac2 ) );
gx = astGrow( gx, 4*hdr->nframes, sizeof( *gx ) );
gy = astGrow( gy, 4*hdr->nframes, sizeof( *gy ) );
/* Check pointers can be used safely. */
if( *status == SAI__OK ) {
/* Loop round all time slices, getting the tracking coords at the corners
of a box that enclose the field of view. */
p1 = trac1;
p2 = trac2;
state = hdr->allState;
for( iframe = 0; iframe < hdr->nframes; iframe++,state++ ) {
point1[ 0 ] = state->tcs_tr_ac1;
point1[ 1 ] = state->tcs_tr_ac2;
for( i = 0; i < 4; i++ ) {
astOffset2( frm, point1, i*AST__DPIBY2, search, point2 );
*(p1++) = point2[ 0 ];
*(p2++) = point2[ 1 ];
}
}
/* Convert them to grid coords in the hits map. */
astTran2( fs, 4*hdr->nframes, trac1, trac2, 0, gx, gy );
/* Loop round them all again. Update the hits map to indicate how many
points fall in each tile. */
px = gx;
py = gy;
for( iframe = 0; iframe < 4*hdr->nframes; iframe++,px++,py++ ) {
ix = (int)( *px + 0.5 ) - 1;
iy = (int)( *py + 0.5 ) - 1;
hits[ ix + iy*dim[ 0 ] ]++;
}
}
/* Close the current input data file. */
smf_close_file( &data, status);
data = NULL;
}
/* Form a list of all the tiles that receive any data. */
ph = hits;
for( iy = 0; iy < dim[ 1 ]; iy++ ) {
for( ix = 0; ix < dim[ 0 ]; ix++,ph++ ) {
if( *ph > 0 ) {
tiles = astGrow( tiles, ++(*ntile), sizeof( *tiles ) );
if( *status == SAI__OK ) {
tiles[ *ntile - 1 ] = smf_jsatilexy2i( ix, iy, &skytiling,
status );
}
}
}
}
/* Free resources. */
hits = astFree( hits );
trac1 = astFree( trac1 );
trac2 = astFree( trac2 );
gx = astFree( gx );
gy = astFree( gy );
if( *status != SAI__OK ) {
tiles = astFree( tiles );
*ntile = 0;
}
astEnd;
return tiles;
}
void
smf_flat_params( const smfData * refdata, const char resistpar[],
const char methpar[], const char orderpar[], const char snrminpar[],
double * refohms, double **resistance, int * outrows,
int * outcols, smf_flatmeth *flatmeth,
int * order, double * snrmin, smfData ** heateff,
int * status ) {
dim_t datarows = 0; /* Number of rows in refdata */
dim_t datacols = 0; /* Number of columns in refdata */
size_t j = 0; /* Counter, index */
char method[SC2STORE_FLATLEN]; /* flatfield method string */
size_t nbols; /* Number of bolometers */
double refohmsval = 0.0; /* Internal version of refohms */
AstKeyMap * resmap = NULL; /* Resistor map */
AstKeyMap * subarrays = NULL; /* Subarray lookup table */
char thissub[32]; /* This sub-instrument string */
if (resistance) *resistance = NULL;
if (*status != SAI__OK) return;
if (!refdata) {
*status = SAI__ERROR;
errRep( "", "Must provide reference data file to calculate flatfield parameters"
" (possible programming error)", status );
return;
}
/* Based on refdata we now need to calculate the default reference
resistance and retrieve the correct heater efficiency file for each array.
We need the unique subarray string so that we can set up a look up keymap.
There is no code in SMURF to return all the known subarrays but
we need to know all the options in order to use kpg1Config. */
subarrays = astKeyMap( " " );
astMapPut0I( subarrays, "CG450MK2_M0907D0501", 0, NULL );
astMapPut0I( subarrays, "CG850MK2_M0904D0503", 0, NULL );
astMapPut0I( subarrays, "SG850_M0906D1005", 0, NULL );
astMapPut0I( subarrays, "SG850_M1002D1006", 0, NULL );
astMapPut0I( subarrays, "SG850_M1005D1007", 0, NULL );
astMapPut0I( subarrays, "SG850_M1003D1004", 0, NULL );
astMapPut0I( subarrays, "SG450_M1004D1000", 0, NULL );
astMapPut0I( subarrays, "SG450_M1007D1002", 0, NULL );
astMapPut0I( subarrays, "SG450_M1006D1003", 0, NULL );
astMapPut0I( subarrays, "SG450_M1009D1008", 0, NULL );
/* and indicate which subarray we are interested in (uppercased) */
smf_fits_getS( refdata->hdr, "ARRAYID", thissub, sizeof(thissub), status );
{ /* need to uppercase */
size_t l = strlen(thissub);
for (j=0;j<l;j++) {
thissub[j] = toupper(thissub[j]);
}
}
astMapPut0I( subarrays, thissub, 1, NULL );
/* Read the config file */
resmap = kpg1Config( resistpar, "$SMURF_DIR/smurf_calcflat.def",
subarrays, 1, status );
subarrays = astAnnul( subarrays );
if (*status != SAI__OK) goto CLEANUP;
/* Read the reference resistance */
astMapGet0D( resmap, "REFRES", &refohmsval );
if (refohms && *status == SAI__OK) {
*refohms = refohmsval;
msgOutiff(MSG__VERB, "",
"Read reference resistance for subarray %s of %g ohms\n",
status, thissub, *refohms );
}
/* We no longer want to read per-bolometer resistor values from the
config file. To retain backwards compatibility with the current
implementation of smf_flat_standardpow we simply fill the
per-bol resistance array with the reference resistance which
effectively disables smf_flat_standardpow */
smf_get_dims( refdata, &datarows, &datacols, NULL, NULL, NULL, NULL, NULL, status );
nbols = datacols * datarows;
if (*status == SAI__OK && resistance ) {
*resistance = astMalloc( nbols*sizeof(**resistance) );
for (j = 0; j < (size_t)nbols; j++) {
(*resistance)[j] = refohmsval;
}
}
/* Get the heater efficiency file */
if (heateff && astMapHasKey( resmap, "HEATEFF" ) ) {
const char * heateffstr = NULL;
if (astMapGet0C( resmap, "HEATEFF", &heateffstr )) {
Grp * heateffgrp = NULL;
smfData * heatefftmp = NULL;
heateffgrp = grpNew( "heateff", status );
grpPut1( heateffgrp, heateffstr, 0, status );
smf_open_file( NULL, heateffgrp, 1, "READ", SMF__NOTTSERIES|SMF__NOFIX_METADATA, &heatefftmp, status );
/* Divorce the smfData from the underlying file. This file stays open for the entire
duration of the data processing and can some times lead to issues when we attempt
to close it an hour after we opened it (it's usually on an NFS disk) */
if (*status == SAI__OK) {
*heateff = smf_deepcopy_smfData( NULL, heatefftmp, 0,
SMF__NOCREATE_FILE | SMF__NOCREATE_FTS |
SMF__NOCREATE_DA,
0, 0, status );
smf_close_file(NULL, &heatefftmp, status);
}
/* Check the dimensions */
if (*status == SAI__OK) {
dim_t heatrows = 0;
dim_t heatcols = 0;
smf_get_dims( *heateff, &heatrows, &heatcols, NULL, NULL, NULL, NULL, NULL, status );
if (*status == SAI__OK) {
if ( datarows != heatrows || datacols != heatcols ) {
*status = SAI__ERROR;
errRepf( "", "Dimensions of heater efficiency file %s are (%zu, %zu)"
" but flatfield has dimensions (%zu, %zu)",
status, heateffstr, (size_t)heatrows, (size_t)heatcols,
(size_t)datarows, (size_t)datacols);
}
}
if (*status == SAI__OK) {
smf_dtype_check_fatal( *heateff, NULL, SMF__DOUBLE, status );
if (*status == SMF__BDTYP) {
errRepf("", "Heater efficiency data in %s should be double precision",
status, heateffstr);
}
}
if (*status == SAI__OK) {
char heateffarrid[32];
smf_fits_getS( refdata->hdr, "ARRAYID", heateffarrid, sizeof(heateffarrid), status );
if (*status != SAI__OK) errAnnul( status );
if (strcasecmp( thissub, heateffarrid ) != 0 ) {
if (*status == SAI__OK) {
*status = SAI__ERROR;
errRepf("", "Subarray associated with heater efficiency image (%s)"
" does not match that of the data to be flatfielded (%s)",
status, heateffarrid, thissub );
}
}
}
}
if (heateffgrp) grpDelet( &heateffgrp, status );
}
}
if (methpar && flatmeth) {
/* See if we want to use TABLE or POLYNOMIAL mode */
parChoic( methpar, "POLYNOMIAL", "POLYNOMIAL, TABLE", 1,
method, sizeof(method), status );
*flatmeth = smf_flat_methcode( method, status );
if (*flatmeth == SMF__FLATMETH_POLY) {
/* need an order for the polynomial */
if (order && orderpar) {
parGdr0i( orderpar, 1, 1, 3, 1, order, status );
/* and if the order is 1 then we can ask for the snr min */
if (snrminpar && *order == 1) {
parGet0d( snrminpar, snrmin, status );
}
}
} else {
/* need an snr min for table mode responsivities */
if (snrminpar) parGet0d( snrminpar, snrmin, status );
}
}
if (outrows) *outrows = datarows;
if (outcols) *outcols = datacols;
CLEANUP:
resmap = astAnnul( resmap );
if (*status != SAI__OK) {
if (resistance && *resistance) *resistance = astFree( *resistance );
if (heateff && *heateff) smf_close_file( NULL, heateff, status );
}
return;
}
void smurf_sc2fft( int *status ) {
int avpspec=0; /* Flag for doing average power spectrum */
double avpspecthresh=0; /* Threshold noise for detectors in avpspec */
Grp * basegrp = NULL; /* Basis group for output filenames */
smfArray *bbms = NULL; /* Bad bolometer masks */
smfArray *concat=NULL; /* Pointer to a smfArray */
size_t contchunk; /* Continuous chunk counter */
smfArray *darks = NULL; /* dark frames */
int ensureflat; /* Flag for flatfielding data */
Grp *fgrp = NULL; /* Filtered group, no darks */
smfArray *flatramps = NULL;/* Flatfield ramps */
AstKeyMap *heateffmap = NULL; /* Heater efficiency data */
size_t gcount=0; /* Grp index counter */
size_t i; /* Loop counter */
smfGroup *igroup=NULL; /* smfGroup corresponding to igrp */
Grp *igrp = NULL; /* Input group of files */
int inverse=0; /* If set perform inverse transform */
int isfft=0; /* Are data fft or real space? */
dim_t maxconcat=0; /* Longest continuous chunk length in samples */
size_t ncontchunks=0; /* Number continuous chunks outside iter loop */
smfData *odata=NULL; /* Pointer to output smfData to be exported */
Grp *ogrp = NULL; /* Output group of files */
size_t outsize; /* Total number of NDF names in the output group */
int polar=0; /* Flag for FFT in polar coordinates */
int power=0; /* Flag for squaring amplitude coeffs */
size_t size; /* Number of files in input group */
smfData *tempdata=NULL; /* Temporary smfData pointer */
int weightavpspec=0; /* Flag for 1/noise^2 weighting */
ThrWorkForce *wf = NULL; /* Pointer to a pool of worker threads */
int zerobad; /* Zero VAL__BADD before taking FFT? */
/* Main routine */
ndfBegin();
/* Find the number of cores/processors available and create a pool of
threads of the same size. */
wf = thrGetWorkforce( thrGetNThread( SMF__THREADS, status ), status );
/* Get input file(s) */
kpg1Rgndf( "IN", 0, 1, "", &igrp, &size, status );
/* Filter out darks */
smf_find_science( igrp, &fgrp, 1, NULL, NULL, 1, 1, SMF__NULL, &darks,
&flatramps, &heateffmap, NULL, status );
/* input group is now the filtered group so we can use that and
free the old input group */
size = grpGrpsz( fgrp, status );
grpDelet( &igrp, status);
igrp = fgrp;
fgrp = NULL;
/* We now need to combine files from the same subarray and same sequence
to form a continuous time series */
smf_grp_related( igrp, size, 1, 0, 0, NULL, NULL, &maxconcat, NULL, &igroup,
&basegrp, NULL, status );
/* Get output file(s) */
size = grpGrpsz( basegrp, status );
if( size > 0 ) {
kpg1Wgndf( "OUT", basegrp, size, size, "More output files required...",
&ogrp, &outsize, status );
} else {
msgOutif(MSG__NORM, " ", TASK_NAME ": All supplied input frames were DARK,"
" nothing to do", status );
}
/* Get group of bolometer masks and read them into a smfArray */
smf_request_mask( "BBM", &bbms, status );
/* Obtain the number of continuous chunks and subarrays */
if( *status == SAI__OK ) {
ncontchunks = igroup->chunk[igroup->ngroups-1]+1;
}
msgOutiff( MSG__NORM, "", "Found %zu continuous chunk%s", status, ncontchunks,
(ncontchunks > 1 ? "s" : "") );
/* Are we flatfielding? */
parGet0l( "FLAT", &ensureflat, status );
/* Are we doing an inverse transform? */
parGet0l( "INVERSE", &inverse, status );
/* Are we using polar coordinates instead of cartesian for the FFT? */
parGet0l( "POLAR", &polar, status );
/* Are we going to assume amplitudes are squared? */
parGet0l( "POWER", &power, status );
/* Are we going to zero bad values first? */
parGet0l( "ZEROBAD", &zerobad, status );
/* Are we calculating the average power spectrum? */
parGet0l( "AVPSPEC", &avpspec, status );
if( avpspec ) {
power = 1;
parGet0d( "AVPSPECTHRESH", &avpspecthresh, status );
parGet0l( "WEIGHTAVPSPEC", &weightavpspec, status );
}
/* If power is true, we must be in polar form */
if( power && !polar) {
msgOutif( MSG__NORM, " ", TASK_NAME
": power spectrum requested so setting POLAR=TRUE", status );
polar = 1;
}
gcount = 1;
for( contchunk=0;(*status==SAI__OK)&&contchunk<ncontchunks; contchunk++ ) {
size_t idx;
/* Concatenate this continuous chunk but forcing a raw data read.
We will need quality. */
smf_concat_smfGroup( wf, NULL, igroup, darks, NULL, flatramps, heateffmap,
contchunk, ensureflat, 1, NULL, 0, NULL, NULL, 0, 0, 0,
&concat, NULL, status );
/* Now loop over each subarray */
/* Export concatenated data for each subarray to NDF file */
for( idx=0; (*status==SAI__OK)&&idx<concat->ndat; idx++ ) {
if( concat->sdata[idx] ) {
smfData * idata = concat->sdata[idx];
int provid = NDF__NOID;
dim_t nbolo; /* Number of detectors */
dim_t ndata; /* Number of data points */
/* Apply a mask to the quality array and data array */
smf_apply_mask( idata, bbms, SMF__BBM_QUAL|SMF__BBM_DATA, 0, status );
smf_get_dims( idata, NULL, NULL, &nbolo, NULL, &ndata, NULL, NULL,
status );
/* Check for double precision data */
if( idata->dtype != SMF__DOUBLE ) {
*status = SAI__ERROR;
errRep( "", FUNC_NAME ": data are not double precision.", status );
}
/* Are we zeroing VAL__BADD? */
if( (*status==SAI__OK) && zerobad ) {
double *data= (double *) idata->pntr[0];
for( i=0; i<ndata; i++ ) {
if( data[i] == VAL__BADD ) {
data[i] = 0;
}
}
}
/* Check whether we need to transform the data at all */
isfft = smf_isfft(idata,NULL,NULL,NULL,NULL,NULL,status);
if( isfft && avpspec && (*status == SAI__OK) ) {
*status = SAI__ERROR;
errRep( "", FUNC_NAME
": to calculate average power spectrum input data cannot "
"be FFT", status );
}
if( (*status == SAI__OK) && (isfft == inverse) ) {
if( avpspec ) {
/* If calculating average power spectrum do the transforms with
smf_bolonoise so that we can also measure the noise of
each detector */
double *whitenoise=NULL;
smf_qual_t *bolomask=NULL;
double mean, sig, freqlo;
size_t ngood, newgood;
whitenoise = astCalloc( nbolo, sizeof(*whitenoise) );
bolomask = astCalloc( nbolo, sizeof(*bolomask) );
freqlo = 1. / (idata->hdr->steptime * idata->hdr->nframes);
smf_bolonoise( wf, idata, 1, freqlo, SMF__F_WHITELO,
SMF__F_WHITEHI, 1, 0, whitenoise, NULL, &odata,
status );
/* Initialize quality */
for( i=0; i<nbolo; i++ ) {
if( whitenoise[i] == VAL__BADD ) {
bolomask[i] = SMF__Q_BADB;
} else {
/* smf_bolonoise returns a variance, so take sqrt */
whitenoise[i] = sqrt(whitenoise[i]);
}
}
ngood=-1;
newgood=0;
/* Iteratively cut n-sigma noisy outlier detectors */
while( ngood != newgood ) {
ngood = newgood;
smf_stats1D( whitenoise, 1, nbolo, bolomask, 1, SMF__Q_BADB,
&mean, &sig, NULL, NULL, status );
msgOutiff( MSG__DEBUG, "", TASK_NAME
": mean=%lf sig=%lf ngood=%li\n", status,
mean, sig, ngood);
newgood=0;
for( i=0; i<nbolo; i++ ) {
if( whitenoise[i] != VAL__BADD ){
if( (whitenoise[i] - mean) > avpspecthresh *sig ) {
whitenoise[i] = VAL__BADD;
bolomask[i] = SMF__Q_BADB;
} else {
newgood++;
}
}
}
}
msgOutf( "", TASK_NAME
": Calculating average power spectrum of best %li "
" bolometers.", status, newgood);
/* If using 1/noise^2 weights, calculate 1/whitenoise^2 in-place
to avoid allocating another array */
if( weightavpspec ) {
msgOutif( MSG__VERB, "", TASK_NAME ": using 1/noise^2 weights",
status );
for( i=0; i<nbolo; i++ ) {
if( whitenoise[i] && (whitenoise[i] != VAL__BADD) ) {
whitenoise[i] = 1/(whitenoise[i]*whitenoise[i]);
}
}
}
/* Calculate the average power spectrum of good detectors */
tempdata = smf_fft_avpspec( odata, bolomask, 1, SMF__Q_BADB,
weightavpspec ? whitenoise : NULL,
status );
smf_close_file( &odata, status );
whitenoise = astFree( whitenoise );
bolomask = astFree( bolomask );
odata = tempdata;
tempdata = NULL;
/* Store the number of good bolometers */
parPut0i( "NGOOD", newgood, status );
} else {
/* Otherwise do forward/inverse transforms here as needed */
/* If inverse transform convert to cartesian representation first */
if( inverse && polar ) {
smf_fft_cart2pol( wf, idata, 1, power, status );
}
/* Tranform the data */
odata = smf_fft_data( wf, idata, NULL, inverse, 0, status );
smf_convert_bad( wf, odata, status );
if( inverse ) {
/* If output is time-domain, ensure that it is ICD bolo-ordered */
smf_dataOrder( odata, 1, status );
} else if( polar ) {
/* Store FFT of data in polar form */
smf_fft_cart2pol( wf, odata, 0, power, status );
}
}
/* open a reference input file for provenance propagation */
ndgNdfas( basegrp, gcount, "READ", &provid, status );
/* Export the data to a new file */
smf_write_smfData( odata, NULL, NULL, ogrp, gcount, provid,
MSG__VERB, 0, status );
/* Free resources */
ndfAnnul( &provid, status );
smf_close_file( &odata, status );
} else {
msgOutif( MSG__NORM, " ",
"Data are already transformed. No output will be produced",
status );
}
}
/* Update index into group */
gcount++;
}
/* Close the smfArray */
smf_close_related( &concat, status );
}
/* Write out the list of output NDF names, annulling the error if a null
parameter value is supplied. */
if( *status == SAI__OK ) {
grpList( "OUTFILES", 0, 0, NULL, ogrp, status );
if( *status == PAR__NULL ) errAnnul( status );
}
/* Tidy up after ourselves: release the resources used by the grp routines */
grpDelet( &igrp, status);
grpDelet( &ogrp, status);
if (basegrp) grpDelet( &basegrp, status );
if( igroup ) smf_close_smfGroup( &igroup, status );
if( flatramps ) smf_close_related( &flatramps, status );
if (heateffmap) heateffmap = smf_free_effmap( heateffmap, status );
if (bbms) smf_close_related( &bbms, status );
ndfEnd( status );
/* Ensure that FFTW doesn't have any used memory kicking around */
fftw_cleanup();
}
void smf_find_science(const Grp * ingrp, Grp **outgrp, int reverttodark,
Grp **darkgrp, Grp **flatgrp, int reducedark,
int calcflat, smf_dtype darktype, smfArray ** darks,
smfArray **fflats, AstKeyMap ** heateffmap,
double * meanstep, int * status ) {
smfSortInfo *alldarks; /* array of sort structs for darks */
smfSortInfo *allfflats; /* array of fast flat info */
Grp * dgrp = NULL; /* Internal dark group */
double duration_darks = 0.0; /* total duration of all darks */
double duration_sci = 0.0; /* Duration of all science observations */
size_t dkcount = 0; /* Dark counter */
size_t ffcount = 0; /* Fast flat counter */
Grp * fgrp = NULL; /* Fast flat group */
size_t i; /* loop counter */
smfData *infile = NULL; /* input file */
size_t insize; /* number of input files */
size_t nsteps_dark = 0; /* Total number of steps for darks */
size_t nsteps_sci = 0; /* Total number of steps for science */
AstKeyMap * heatermap = NULL; /* Heater efficiency map */
AstKeyMap * obsmap = NULL; /* Info from all observations */
AstKeyMap * objmap = NULL; /* All the object names used */
AstKeyMap * scimap = NULL; /* All non-flat obs indexed by unique key */
Grp *ogrp = NULL; /* local copy of output group */
size_t sccount = 0; /* Number of accepted science files */
struct timeval tv1; /* Timer */
struct timeval tv2; /* Timer */
if (meanstep) *meanstep = VAL__BADD;
if (outgrp) *outgrp = NULL;
if (darkgrp) *darkgrp = NULL;
if (darks) *darks = NULL;
if (fflats) *fflats = NULL;
if (heateffmap) *heateffmap = NULL;
if (*status != SAI__OK) return;
/* Sanity check to make sure we return some information */
if ( outgrp == NULL && darkgrp == NULL && darks == NULL && fflats == NULL) {
*status = SAI__ERROR;
errRep( " ", FUNC_NAME ": Must have some non-NULL arguments"
" (possible programming error)", status);
return;
}
/* Start a timer to see how long this takes */
smf_timerinit( &tv1, &tv2, status );
/* Create new group for output files */
ogrp = smf_grp_new( ingrp, "Science", status );
/* and a new group for darks */
dgrp = smf_grp_new( ingrp, "DarkFiles", status );
/* and for fast flats */
fgrp = smf_grp_new( ingrp, "FastFlats", status );
/* and also create a keymap for the observation description */
obsmap = astKeyMap( "KeyError=1" );
/* and an object map */
objmap = astKeyMap( "KeyError=1" );
/* This keymap contains the sequence counters for each related
subarray/obsidss/heater/shutter combination and is used to decide
if a bad flat is relevant */
scimap = astKeyMap( "KeyError=1,KeyCase=0" );
/* This keymap is used to contain relevant heater efficiency data */
heatermap = astKeyMap( "KeyError=1,KeyCase=0" );
/* Work out how many input files we have and allocate sufficient sorting
space */
insize = grpGrpsz( ingrp, status );
alldarks = astCalloc( insize, sizeof(*alldarks) );
allfflats = astCalloc( insize, sizeof(*allfflats) );
/* check each file in turn */
for (i = 1; i <= insize; i++) {
int seqcount = 0;
char keystr[100]; /* Key for scimap entry */
/* open the file but just to get the header */
smf_open_file( ingrp, i, "READ", SMF__NOCREATE_DATA, &infile, status );
if (*status != SAI__OK) break;
/* Fill in the keymap with observation details */
smf_obsmap_fill( infile, obsmap, objmap, status );
/* Find the heater efficiency map if required */
if (*status == SAI__OK && heateffmap) {
char arrayidstr[32];
smf_fits_getS( infile->hdr, "ARRAYID", arrayidstr, sizeof(arrayidstr),
status );
if (!astMapHasKey( heatermap, arrayidstr ) ) {
smfData * heateff = NULL;
dim_t nbolos = 0;
smf_flat_params( infile, "RESIST", NULL, NULL, NULL, NULL, NULL,
NULL, NULL, NULL, NULL, NULL, &heateff, status );
smf_get_dims( heateff, NULL, NULL, &nbolos, NULL, NULL, NULL, NULL,
status );
if (heateff) astMapPut0P( heatermap, arrayidstr, heateff, NULL );
}
}
/* Get the sequence counter for the file. We do not worry about
duplicate sequence counters (at the moment) */
smf_find_seqcount( infile->hdr, &seqcount, status );
/* The key identifying this subarray/obsidss/heater/shutter combo */
smf__calc_flatobskey( infile->hdr, keystr, sizeof(keystr), status );
if (smf_isdark( infile, status )) {
/* Store the sorting information */
dkcount = smf__addto_sortinfo( infile, alldarks, i, dkcount, "Dark", status );
smf__addto_durations( infile, &duration_darks, &nsteps_dark, status );
astMapPutElemI( scimap, keystr, -1, seqcount );
} else {
/* compare sequence type with observation type and drop it (for now)
if they differ */
if ( infile->hdr->obstype == infile->hdr->seqtype ) {
/* Sanity check the header for corruption. Compare RTS_NUM with SEQSTART
and SEQEND. The first RTS_NUM must either be SEQSTART or else between
SEQSTART and SEQEND (if someone has giving us a section) */
int seqstart = 0;
int seqend = 0;
int firstnum = 0;
JCMTState *tmpState = NULL;
smf_getfitsi( infile->hdr, "SEQSTART", &seqstart, status );
smf_getfitsi( infile->hdr, "SEQEND", &seqend, status );
tmpState = infile->hdr->allState;
if( tmpState ) {
firstnum = (tmpState[0]).rts_num;
smf_smfFile_msg( infile->file, "F", 1, "<unknown file>");
if ( firstnum >= seqstart && firstnum <= seqend ) {
/* store the file in the output group */
ndgCpsup( ingrp, i, ogrp, status );
msgOutif(MSG__DEBUG, " ", "Non-dark file: ^F",status);
smf__addto_durations( infile, &duration_sci, &nsteps_sci, status );
astMapPutElemI( scimap, keystr, -1, seqcount );
sccount++;
} else {
msgOutif( MSG__QUIET, "",
"File ^F has a corrupt FITS header. Ignoring it.",
status );
}
} else {
smf_smfFile_msg( infile->file, "F", 1, "<unknown file>");
/* store the file in the output group */
ndgCpsup( ingrp, i, ogrp, status );
msgOutif( MSG__DEBUG, " ",
"File ^F lacks JCMTState: assuming it is non-dark",status);
smf__addto_durations( infile, &duration_sci, &nsteps_sci, status );
astMapPutElemI( scimap, keystr, -1, seqcount );
sccount++;
}
} else if (infile->hdr->seqtype == SMF__TYP_FASTFLAT ) {
ffcount = smf__addto_sortinfo( infile, allfflats, i, ffcount, "Fast flat", status );
} else {
smf_smfFile_msg( infile->file, "F", 1, "<unknown file>");
msgOutif(MSG__DEBUG, " ", "Sequence type mismatch with observation type: ^F",status);
}
}
/* close the file */
smf_close_file( &infile, status );
}
/* Store output group in return variable or else free it */
if (outgrp) {
*outgrp = ogrp;
} else {
grpDelet( &ogrp, status );
}
/* process flatfields if necessary */
if (ffcount > 0 && fflats ) {
smfArray * array = NULL;
/* sort flats into order */
qsort( allfflats, ffcount, sizeof(*allfflats), smf_sort_bydouble);
if (fflats) array = smf_create_smfArray( status );
/* now open the flats and store them if requested */
if (*status == SAI__OK && array && ffcount) {
size_t start_ffcount = ffcount;
AstKeyMap * flatmap = NULL;
if (calcflat) {
/* Use AgeUp so that we get the keys out in the sorted order
that allfflats used */
flatmap = astKeyMap( "KeyCase=0,KeyError=1,SortBy=AgeDown" );
}
/* Read each flatfield. Calculate a responsivity image and a flatfield
solution. Store these in a keymap along with related information
which is itself stored in a keymap indexed by a string made of
OBSIDSS, reference heater value, shutter and subarray.
*/
for (i = 0; i < start_ffcount; i++ ) {
size_t ori_index = (allfflats[i]).index;
smfData * outfile = NULL;
char keystr[100];
AstKeyMap * infomap = astKeyMap( "KeyError=1" );
int oplen = 0;
char thisfile[MSG__SZMSG];
int seqcount = 0;
/* read filename from group */
infile = NULL;
smf_open_file( ingrp, ori_index, "READ", 0, &infile, status );
if ( *status != SAI__OK ) {
/* This should not happen because we have already opened
the file. If it does happen we abort with error. */
if (infile) smf_close_file( &infile, status );
break;
}
/* Calculate the key for this observation */
smf__calc_flatobskey( infile->hdr, keystr, sizeof(keystr), status );
/* Get the file name for error messages */
smf_smfFile_msg( infile->file, "F", 1, "<unknown file>" );
msgLoad( "", "^F", thisfile, sizeof(thisfile), &oplen, status );
/* And the sequence counter to link against science observations */
smf_find_seqcount( infile->hdr, &seqcount, status );
/* Prefill infomap */
astMapPut0C( infomap, "FILENAME", thisfile, "");
astMapPut0I( infomap, "SEQCOUNT", seqcount, "");
/* Collapse it */
if (*status == SAI__OK) {
smf_flat_fastflat( infile, &outfile, status );
if (*status == SMF__BADFLAT) {
errFlush( status );
if (calcflat) {
/* Need to generate an outfile like smf_flat_fastflat
and one heater setting will force smf_flat_calcflat to fail */
smf_flat_malloc( 1, infile, NULL, &outfile, status );
} else {
if (outfile) smf_close_file( &outfile, status );
if (infile) smf_close_file( &infile, status );
infomap = astAnnul( infomap );
ffcount--;
continue;
}
}
}
if (outfile && *status == SAI__OK) {
smf_close_file( &infile, status );
infile = outfile;
if (calcflat) {
size_t ngood = 0;
smfData * curresp = NULL;
int utdate;
if (*status == SAI__OK) {
ngood = smf_flat_calcflat( MSG__VERB, NULL, "RESIST",
"FLATMETH", "FLATORDER", NULL, "RESPMASK",
"FLATSNR", NULL, infile, &curresp, status );
if (*status != SAI__OK) {
/* if we failed to calculate a flatfield we continue but force the
flatfield to be completely bad. This will force the science data associated
with the flatfield to be correctly blanked. We do not annul though
if we have a SUBPAR error telling us that we have failed to define
our parameters properly. */
if (*status != SUBPAR__NOPAR) errAnnul(status);
/* parameters of flatfield */
ngood = 0;
/* Generate a blank flatfield and blank responsivity image */
smf_flat_badflat( infile, &curresp, status );
}
/* Retrieve the UT date so we can decide whether to compare
flatfields */
smf_getfitsi( infile->hdr, "UTDATE", &utdate, status );
/* Store the responsivity data for later on and the processed
flatfield until we have vetted it */
astMapPut0P( infomap, "CALCFLAT", infile, "" );
astMapPut0P( infomap, "RESP", curresp, "" );
astMapPut0I( infomap, "UTDATE", utdate, "" );
astMapPut0I( infomap, "ISGOOD", 1, "" );
astMapPut0I( infomap, "NGOOD", ngood, "" );
astMapPut0I( infomap, "GRPINDEX", ori_index, "" );
astMapPut0I( infomap, "SMFTYP", infile->hdr->obstype, "" );
astMapPutElemA( flatmap, keystr, -1, infomap );
}
} else { /* if (calcflat) */
/* Store the collapsed flatfield - the processed flat is not stored here yet */
smf_addto_smfArray( array, infile, status );
/* Copy the group info */
ndgCpsup( ingrp, ori_index, fgrp, status );
}
} /* if (outfile) */
/* Annul the keymap (will be fine if it is has been stored in another keymap) */
infomap = astAnnul( infomap );
} /* End loop over flatfields */
/* Now we have to loop over the related flatfields to disable
bolometers that are not good and also decide whether we
need to set status to bad. */
if (*status == SAI__OK && calcflat ) {
size_t nkeys = astMapSize( flatmap );
for (i = 0; i < nkeys; i++ ) {
const char *key = astMapKey( flatmap, i );
int nf = 0;
AstKeyMap ** kmaps = NULL;
int nelem = astMapLength( flatmap, key );
kmaps = astMalloc( sizeof(*kmaps) * nelem );
astMapGet1A( flatmap, key, nelem, &nelem, kmaps );
for ( nf = 0; nf < nelem && *status == SAI__OK; nf++ ) {
AstKeyMap * infomap = kmaps[nf];
int isgood = 0;
astMapGet0I( infomap, "ISGOOD", &isgood );
if (isgood) {
/* The flatfield worked */
size_t ngood = 0;
int itemp;
int utdate = 0;
int ratioFlats = 0;
/* Get the UT date - we do not compare flatfields after
the time we enabled heater tracking at each sequence. */
astMapGet0I( infomap, "UTDATE", &utdate );
/* Get the number of good bolometers at this point */
astMapGet0I( infomap, "NGOOD", &itemp );
ngood = itemp;
/* Decide if we want to do the ratio test. We default to
not doing it between 20110901 and 20120827 which is
the period when we did mini-heater tracks before each
flat. ! indicates that we choose based on date. */
if (*status == SAI__OK) {
parGet0l( "FLATUSENEXT", &ratioFlats, status );
if ( *status == PAR__NULL ) {
errAnnul( status );
if (utdate >= 20110901 || utdate <= 20120827 ) {
ratioFlats = 0;
} else {
ratioFlats = 1;
}
}
}
/* Can we compare with the next flatfield? */
if (ngood < SMF__MINSTATSAMP || !ratioFlats ) {
/* no point doing all the ratio checking for this */
} else if ( nelem - nf >= 2 ) {
AstKeyMap * nextmap = kmaps[nf+1];
const char *nextfname = NULL;
const char *fname = NULL;
smfData * curresp = NULL;
smfData * nextresp = NULL;
smfData * curflat = NULL;
void *tmpvar = NULL;
size_t bol = 0;
smfData * ratio = NULL;
double *in1 = NULL;
double *in2 = NULL;
double mean = VAL__BADD;
size_t nbolo;
double *out = NULL;
double sigma = VAL__BADD;
float clips[] = { 5.0, 5.0 }; /* 5.0 sigma iterative clip */
size_t ngoodz = 0;
astMapGet0C( nextmap, "FILENAME", &nextfname );
astMapGet0C( infomap, "FILENAME", &fname );
/* Retrieve the responsivity images from the keymap */
astMapGet0P( infomap, "RESP", &tmpvar );
curresp = tmpvar;
astMapGet0P( nextmap, "RESP", &tmpvar );
nextresp = tmpvar;
astMapGet0P( infomap, "CALCFLAT", &tmpvar );
curflat = tmpvar;
nbolo = (curresp->dims)[0] * (curresp->dims)[1];
/* get some memory for the ratio if we have not already.
We could get some memory once assuming each flat has the
same number of bolometers... */
ratio = smf_deepcopy_smfData( curresp, 0, 0, 0, 0, status );
if( *status == SAI__OK ) {
/* divide: smf_divide_smfData ? */
in1 = (curresp->pntr)[0];
in2 = (nextresp->pntr)[0];
out = (ratio->pntr)[0];
for (bol=0; bol<nbolo;bol++) {
if ( in1[bol] != VAL__BADD && in1[bol] != 0.0 &&
in2[bol] != VAL__BADD && in2[bol] != 0.0 ) {
out[bol] = in1[bol] / in2[bol];
} else {
out[bol] = VAL__BADD;
}
}
}
/* find some statistics */
smf_clipped_stats1D( out, 2, clips, 1, nbolo, NULL, 0, 0, &mean,
&sigma, NULL, 0, &ngoodz, status );
if (*status == SMF__INSMP) {
errAnnul(status);
msgOutiff( MSG__QUIET, "",
"Flatfield ramp ratio of %s with %s had too few bolometers (%zu < %d).",
status, fname, nextfname, ngoodz, SMF__MINSTATSAMP );
ngood = ngoodz; /* Must be lower or equal to original ngood */
} else if (*status == SAI__OK && mean != VAL__BADD && sigma != VAL__BADD && curflat->da) {
/* Now flag the flatfield as bad for bolometers that have changed
more than n%. We expect the variation to be 1+/-a small bit */
const double pmrange = 0.10;
double thrlo = 1.0 - pmrange;
double thrhi = 1.0 + pmrange;
size_t nmasked = 0;
double *flatcal = curflat->da->flatcal;
msgOutiff( MSG__DEBUG, "", "Flatfield fast ramp ratio mean = %g +/- %g (%zu bolometers)",
status, mean, sigma, ngood);
/* we can just set the first slice of the flatcal to bad. That should
be enough to disable the entire bolometer. We have just read these
data so they should be in ICD order. */
for (bol=0; bol<nbolo;bol++) {
if ( out[bol] != VAL__BADD &&
(out[bol] < thrlo || out[bol] > thrhi ) ) {
flatcal[bol] = VAL__BADD;
nmasked++;
} else if ( in1[bol] != VAL__BADD && in2[bol] == VAL__BADD ) {
/* A bolometer is bad next time but good now so we must set it bad now */
flatcal[bol] = VAL__BADD;
nmasked++;
}
}
if ( nmasked > 0 ) {
msgOutiff( MSG__NORM, "", "Masked %zu bolometers in %s from unstable flatfield",
status, nmasked, fname );
/* update ngood to take into account the masking */
ngood -= nmasked;
}
}
smf_close_file( &ratio, status );
} /* End of flatfield responsivity comparison */
/* if we only have a few bolometers left we now consider this
a bad flat unless it is actually an engineering measurement
where expect some configurations to give zero bolometers */
if (ngood < SMF__MINSTATSAMP) {
const char *fname = NULL;
void * tmpvar = NULL;
int smftyp = 0;
smfData * curflat = NULL;
astMapGet0I( infomap, "SMFTYP", &smftyp );
astMapGet0C( infomap, "FILENAME", &fname );
if (smftyp != SMF__TYP_NEP) {
msgOutiff( MSG__QUIET, "",
"Flatfield %s has %zu good bolometer%s.%s",
status, fname, ngood, (ngood == 1 ? "" : "s"),
( ngood == 0 ? "" : " Keeping none.") );
isgood = 0;
/* Make sure that everything is blanked. */
if (ngood > 0) {
astMapGet0P( infomap, "CALCFLAT", &tmpvar );
curflat = tmpvar;
if (curflat && curflat->da) {
size_t bol;
size_t nbolo = (curflat->dims)[0] * (curflat->dims)[1];
double *flatcal = curflat->da->flatcal;
for (bol=0; bol<nbolo; bol++) {
/* Just need to set the first element to bad */
flatcal[bol] = VAL__BADD;
}
}
}
} else {
msgOutiff( MSG__NORM, "",
"Flatfield ramp file %s has %zu good bolometer%s. Eng mode.",
status, fname, ngood, (ngood == 1 ? "" : "s") );
}
}
/* We do not need the responsivity image again */
{
void *tmpvar = NULL;
smfData * resp = NULL;
astMapGet0P( infomap, "RESP", &tmpvar );
resp = tmpvar;
if (resp) smf_close_file( &resp, status );
astMapRemove( infomap, "RESP" );
}
} /* End of isgood comparison */
/* We are storing flats even if they failed. Let the downstream
software worry about it */
{
int ori_index;
smfData * flatfile = NULL;
void *tmpvar = NULL;
/* Store in the output group */
astMapGet0I( infomap, "GRPINDEX", &ori_index );
ndgCpsup( ingrp, ori_index, fgrp, status );
/* And store in the smfArray */
astMapGet0P( infomap, "CALCFLAT", &tmpvar );
astMapRemove( infomap, "CALCFLAT" );
flatfile = tmpvar;
smf_addto_smfArray( array, flatfile, status );
}
/* Free the object as we go */
kmaps[nf] = astAnnul( kmaps[nf] );
} /* End of loop over this obsidss/subarray/heater */
kmaps = astFree( kmaps );
}
}
if (array->ndat) {
if (fflats) *fflats = array;
} else {
smf_close_related(&array, status );
if (fflats) *fflats = NULL;
}
}
}
/* no need to do any more if neither darks nor darkgrp are defined or we might
be wanting to revert to darks. */
if (dkcount > 0 && (darks || darkgrp || reverttodark ) ) {
smfArray * array = NULL;
/* sort darks into order */
qsort( alldarks, dkcount, sizeof(*alldarks), smf_sort_bydouble);
if (darks) array = smf_create_smfArray( status );
/* now open the darks and store them if requested */
if (*status == SAI__OK) {
for (i = 0; i < dkcount; i++ ) {
size_t ori_index = (alldarks[i]).index;
/* Store the entry in the output group */
ndgCpsup( ingrp, ori_index, dgrp, status );
if (darks) {
/* read the value from the new group */
smf_open_file( dgrp, i+1, "READ", 0, &infile, status );
/* do we have to process these darks? */
if (reducedark) {
smfData *outfile = NULL;
smf_reduce_dark( infile, darktype, &outfile, status );
if (outfile) {
smf_close_file( &infile, status );
infile = outfile;
}
}
smf_addto_smfArray( array, infile, status );
}
}
if (darks) *darks = array;
}
}
/* free memory */
alldarks = astFree( alldarks );
allfflats = astFree( allfflats );
if( reverttodark && outgrp && (grpGrpsz(*outgrp,status)==0) &&
(grpGrpsz(dgrp,status)>0) ) {
/* If outgrp requested but no science observations were found, and
dark observations were found, return darks in outgrp and set
flatgrp and darkgrp to NULL. This is to handle cases where we
want to process data taken in the dark like normal science
data. To activate this behaviour set reverttodark */
msgOutiff( MSG__NORM, "", "Treating the dark%s as science data",
status, ( dkcount > 1 ? "s" : "" ) );
*outgrp = dgrp;
if( darkgrp ){
*darkgrp = NULL;
}
if( flatgrp ) {
*flatgrp = NULL;
}
grpDelet( &ogrp, status);
grpDelet( &fgrp, status);
if (meanstep && nsteps_dark > 0) *meanstep = duration_darks / nsteps_dark;
/* Have to clear the darks smfArray as well */
if (darks) smf_close_related( darks, status );
} else {
/* Store the output groups in the return variable or free it */
if (darkgrp) {
*darkgrp = dgrp;
} else {
grpDelet( &dgrp, status);
}
if (flatgrp) {
*flatgrp = fgrp;
} else {
grpDelet( &fgrp, status);
}
if (meanstep && nsteps_sci > 0) *meanstep = duration_sci / nsteps_sci;
}
msgSeti( "ND", sccount );
msgSeti( "DK", dkcount );
msgSeti( "FF", ffcount );
msgSeti( "TOT", insize );
if ( insize == 1 ) {
if (dkcount == 1) {
msgOutif( MSG__VERB, " ", "Single input file was a dark",
status);
} else if (ffcount == 1) {
msgOutif( MSG__VERB, " ", "Single input file was a fast flatfield",
status);
} else if (sccount == 1) {
msgOutif( MSG__VERB, " ", "Single input file was accepted (observation type same as sequence type)",
status);
} else {
msgOutif( MSG__VERB, " ", "Single input file was not accepted.",
status);
}
} else {
if (dkcount == 1) {
msgSetc( "DKTXT", "was a dark");
} else {
msgSetc( "DKTXT", "were darks");
}
if (ffcount == 1) {
msgSetc( "FFTXT", "was a fast flat");
} else {
msgSetc( "FFTXT", "were fast flats");
}
if (sccount == 1) {
msgSetc( "NDTXT", "was science");
} else {
msgSetc( "NDTXT", "were science");
}
/* This might be a useful message */
msgOutif( MSG__NORM, " ", "Out of ^TOT input files, ^DK ^DKTXT, ^FF ^FFTXT "
"and ^ND ^NDTXT", status );
}
if (meanstep && *meanstep != VAL__BADD) {
msgOutiff( MSG__VERB, "", "Mean step time for input files = %g sec",
status, *meanstep );
}
/* Store the heater efficiency map */
if (*status != SAI__OK) heatermap = smf_free_effmap( heatermap, status );
if (heateffmap) *heateffmap = heatermap;
/* Now report the details of the observation */
smf_obsmap_report( MSG__NORM, obsmap, objmap, status );
obsmap = astAnnul( obsmap );
objmap = astAnnul( objmap );
scimap = astAnnul( scimap );
msgOutiff( SMF__TIMER_MSG, "",
"Took %.3f s to find science observations",
status, smf_timerupdate( &tv1, &tv2, status ) );
return;
}
void
smf_flat_standardpow( const smfData * bolvald, double refohms,
const double resistance[],
smfData ** powrefd, smfData ** bolrefd, int * status) {
double current; /* current through heaters */
double *heatframe = NULL; /* Pointer to flatfield heater data */
double *heatframevar = NULL; /* Pointer to flatfield heatframe variance */
double * heatref = NULL; /* local copy of heater settings */
size_t i; /* loop counter */
size_t j; /* loop counter */
size_t k; /* loop counter */
size_t nheat; /* Number of input frames */
size_t numbol; /* Number of bolometers */
double *powbol = NULL; /* pointer to individual bolometer powers */
double s; /* interpolation slope factor */
double * powref = NULL; /* Data array inside powrefd */
double * bolref = NULL; /* Data array inside bolrefd */
double * bolrefvar = NULL; /* Variance inside bolrefd */
*powrefd = NULL;
*bolrefd = NULL;
if (*status != SAI__OK) return;
if ( !smf_dtype_check_fatal( bolvald, NULL, SMF__DOUBLE, status ) ) return;
if (!bolvald->da) {
*status = SAI__ERROR;
errRep( "", "Unable to proceed with flatfield calculation. Heater settings not "
"present in smfData", status);
return;
}
nheat = (bolvald->dims)[2];
numbol = (bolvald->dims)[0] * (bolvald->dims)[1];
heatref = bolvald->da->heatval;
/* Create a smfData for powref and bolref */
smf_flat_malloc( nheat, bolvald, powrefd, bolrefd, status );
if (*status == SAI__OK) {
powref = (*powrefd)->pntr[0];
bolref = (*bolrefd)->pntr[0];
bolrefvar = (*bolrefd)->pntr[1];
}
/* Get some memory -
bolometer power per heater setting */
powbol = astCalloc( nheat, sizeof(*powbol) );
/* pointers to the flatfield data and variance */
heatframe = (bolvald->pntr)[0];
heatframevar = (bolvald->pntr)[1];
/* Choose the reference heater powers to be the actual heater settings acting on
the adopted reference resistance. */
for ( j=0; j<nheat; j++ ) {
current = heatref[j] * SC2FLAT__DTOI;
powref[j] = SIMULT * current * current * refohms;
}
if (*status != SAI__OK) goto CLEANUP;
/* For each bolometer interpolate to find the measurement it would report at the
standard power input values */
for ( i=0; i<numbol; i++ )
{
/* Calculate the actual power seen by each bolometer at each heater setting */
for ( j=0; j<nheat; j++ )
{
current = heatref[j] * SC2FLAT__DTOI;
if ( resistance[i] == VAL__BADD )
{
powbol[j] = VAL__BADD;
}
else
{
powbol[j] = SIMULT * current * current * resistance[i];
}
}
/* Trap bolometers that have any bad values in their measurements */
for ( j=0; j<nheat; j++) {
if ( heatframe[i + j*numbol] == VAL__BADD) {
powbol[0] = VAL__BADD;
break;
}
}
/* Trap bolometers which are unresponsive */
if ( powbol[0] != VAL__BADD &&
(heatframe[i] == VAL__BADD || heatframe[i + (nheat-1)*numbol] == VAL__BADD ||
(fabs ( heatframe[i] - heatframe[i + (nheat-1)*numbol] ) < 1.0) ) )
{
powbol[0] = VAL__BADD;
}
for ( j=0; j<nheat; j++ )
{
if ( powbol[0] == VAL__BADD )
{
bolref[j*numbol+i] = VAL__BADD;
bolrefvar[j*numbol+i] = VAL__BADD;
}
else
{
if ( powref[j] < powbol[0] )
{
double var = VAL__BADD;
/* Standard point is below actual measured range for this bolometer,
extrapolate */
s = ( heatframe[i + 1*numbol] - heatframe[i + 0*numbol] ) /
( powbol[1] - powbol[0] );
/* calculate error in gradient using standard rules */
if (heatframevar && heatframevar[i+ 1*numbol] != VAL__BADD &&
heatframevar[i + 0*numbol] != VAL__BADD) {
var = ( heatframevar[i + 1*numbol] + heatframevar[i + 0*numbol] )
/ pow( powbol[1] - powbol[0], 2 );
}
bolref[j*numbol+i] = heatframe[i+ 0*numbol] +
s * ( powref[j] - powbol[0] );
if (var != VAL__BADD) {
bolrefvar[j*numbol+i] = heatframevar[i + 0*numbol] +
( var * pow( powref[j] - powbol[0], 2 ));
} else {
bolrefvar[j*numbol+i] = VAL__BADD;
}
}
else if ( powref[j] > powbol[nheat-1] )
{
double var = VAL__BADD;
/* Standard point is above actual measured range for this bolometer,
extrapolate */
s = ( heatframe[i + (nheat-1)*numbol] - heatframe[i + (nheat-2)*numbol] ) /
( powbol[nheat-1] - powbol[nheat-2] );
/* calculate error in gradient using standard rules */
if (heatframevar && heatframevar[i + (nheat-1)*numbol] != VAL__BADD &&
heatframevar[i + (nheat-2)*numbol] != VAL__BADD) {
var = ( heatframevar[i + (nheat-1)] + heatframevar[i + (nheat-2)*numbol] )
/ pow( powbol[nheat-1] - powbol[nheat-2], 2 );
}
bolref[j*numbol+i] = heatframe[i + (nheat-2)*numbol] +
s * ( powref[j] - powbol[nheat-2] );
if (var != VAL__BADD) {
bolrefvar[j*numbol+i] = heatframevar[i +(nheat-2)*numbol] +
( var * pow( powref[j] - powbol[nheat-2], 2 ));
} else {
bolrefvar[j*numbol+i] = VAL__BADD;
}
}
else
{
/* Standard point is within actual measured range for this bolometer,
search for the points to interpolate */
for ( k=1; k<nheat; k++ )
{
if ( powref[j] <= powbol[k] )
{
double var = VAL__BADD;
s = ( heatframe[i + k*numbol] -
heatframe[i + (k-1)*numbol] ) /
( powbol[k] - powbol[k-1] );
/* calculate error in gradient using standard rules */
if (heatframevar && heatframevar[i + k*numbol] != VAL__BADD &&
heatframevar[i +(k-1)*numbol] != VAL__BADD) {
var = ( heatframevar[i + k*numbol] + heatframevar[i + (k-1)*numbol] )
/ pow( powbol[k] - powbol[k-1], 2 );
}
bolref[j*numbol+i] = heatframe[i + (k-1)*numbol] +
s * ( powref[j] - powbol[k-1] );
if (var != VAL__BADD) {
bolrefvar[j*numbol+i] = heatframevar[i +(k-1)*numbol] +
( var * pow( powref[j] - powbol[k-1], 2 ));
} else {
bolrefvar[j*numbol+i] = VAL__BADD;
}
break;
}
}
}
}
}
}
CLEANUP:
if (powbol) powbol = astFree( powbol );
if (*status != SAI__OK) {
if (*bolrefd) smf_close_file( NULL, bolrefd, status );
if (*powrefd) smf_close_file( NULL, powrefd, status );
}
}
void smf_write_smfFilter( ThrWorkForce *wf, const smfFilter *filt, const char *filename,
const Grp * igrp, size_t grpindex, int *status ) {
double *d = NULL; /* Data array pointer */
smfData *data=NULL; /* smfData for output */
size_t i; /* Loop counter */
size_t nsamp; /* Number of samples in the filter */
if( *status != SAI__OK ) return;
if( !filt ) {
*status = SAI__ERROR;
errRep( "", FUNC_NAME ": NULL smfFilter supplied.", status );
return;
}
/* In case we change the data type of smfFilters in the future try
to catch that here */
if( sizeof(filt->real) != smf_dtype_sz(SMF__DOUBLE,status) ) {
*status = SAI__ERROR;
errRep( "", FUNC_NAME ": warning -- smfFilter seems to have changed type!",
status );
return;
}
/* We will pack the data into an array that has an extra dimension to
store the real/imaginary parts of the filter just like an FFT */
data = smf_create_smfData( 0, status );
if( *status == SAI__OK ) {
data->dtype = SMF__DOUBLE;
data->ndims = filt->ndims+1;
nsamp=1;
for( i=0; i<filt->ndims; i++ ) {
data->dims[i] = filt->fdims[i];
nsamp *= filt->fdims[i];
}
data->dims[data->ndims-1] = 2;
/* Copy the real and imaginary parts into our new array consecutively */
data->pntr[0] = astCalloc( nsamp*2, smf_dtype_sz(SMF__DOUBLE,status) );
if( *status == SAI__OK ) {
d = data->pntr[0];
memcpy( d, filt->real, nsamp*sizeof(d) );
if( filt->isComplex ) {
memcpy( d + nsamp, filt->imag, nsamp*sizeof(d) );
}
}
}
/* Write out the file */
smf_write_smfData( wf, data, NULL, filename, igrp, grpindex, 0, MSG__NORM,
0, NULL, NULL, status );
if( data ) smf_close_file( wf, &data, status );
}
