void smf_flat_write( smf_flatmeth flatmeth, const char * flatname,
double refres, const smfData * bolval,
const smfData * powref, const smfData * bolref,
const smfData * polyfit, const Grp * prvgrp, int * status ) {
size_t colsize; /* number of columns */
double *dbuf = NULL; /* input double buffer for mean data */
double *dvar = NULL; /* input double buffer for variance of data */
char fitsrec[SC2STORE__MAXFITS*SZFITSCARD+1]; /* Store for FITS records */
int *ibuf = NULL; /* int buffer for mean data */
int indf = NDF__NOID; /* NDF identifier for output file */
size_t ncards; /* number of fits cards */
size_t numbols; /* number of bolometers */
double *outvar = NULL; /* buffer for variance of data */
int place = NDF__NOPL; /* Dummy placeholder for NDF */
size_t rowsize; /* number of rows */
JCMTState *state = NULL; /* State for this flatfield */
sc2ast_subarray_t subnum; /* subarray number */
AstFrameSet *result, *spacefset;
AstLutMap *heatmap;
AstFrame *heatfrm;
int *dksquid; /* pointer to dummy dark SQUID data */
size_t j; /* loop counter */
int jig_vert[1][2]; /* dummy jiggle vertices */
double jig_path[1][2]; /* dummy jiggle path */
size_t nframes = 0; /* Number of frames in bolval */
int npath = 0; /* size of jiggle path */
int nvert = 0; /* number of jiggle vertices */
char *xmlfile = NULL; /* dummy xmlfile name */
if (*status != SAI__OK) return;
if (!bolval->da) {
*status = SAI__ERROR;
errRep( "", "No flatfield solution provided for writing",
status );
return;
}
if (!bolval->da->heatval) {
*status = SAI__ERROR;
errRep( "", "Must provide heater values in DA struct to smf_flat_write"
" (possible programming error)", status );
return;
}
/* note that colsize is the number of rows and rowsize is the number of
columns */
colsize = (bolval->dims)[SC2STORE__ROW_INDEX];
rowsize = (bolval->dims)[SC2STORE__COL_INDEX];
numbols = colsize * rowsize;
nframes = (bolval->dims)[2];
/* Make sure we have a FLAT header that reflects this file
as the flatfield solution */
smf_fits_updateS( bolval->hdr, "FLAT", flatname, "Name of flat-field file",
status );
/* Create a FITS header for DA */
smf_fits_export2DA( bolval->hdr->fitshdr, &ncards, fitsrec, status );
/* Copy the data as integers so it can be written to data file. To
prevent overflow in the variance we store that as doubles */
ibuf = astMalloc( (numbols * nframes)*sizeof(*ibuf) );
outvar = astMalloc( (numbols * nframes)*sizeof(*outvar) );
dbuf = (bolval->pntr)[0];
dvar = (bolval->pntr)[1];
if (*status == SAI__OK) {
for (j = 0; j < (nframes * numbols); j++) {
/* These started off as integers so the mean value must fit in
an integer */
if ( dbuf[j] == VAL__BADD) {
ibuf[j] = VAL__BADI;
} else {
ibuf[j] = (int)dbuf[j];
}
/* Same data type so no need to convert bad values */
if (dvar) {
outvar[j] = dvar[j];
} else {
outvar[j] = VAL__BADD;
}
}
}
/* get subarray number */
smf_find_subarray( bolval->hdr, NULL, 0, &subnum, status );
/* Create dummy components for output file */
dksquid = astCalloc ( rowsize* nframes, sizeof(*dksquid) );
jig_vert[0][0] = 0;
jig_vert[0][1] = 0;
jig_path[0][0] = 0.0;
jig_path[0][1] = 0.0;
sc2store_setcompflag ( SC2STORE__NONE, status );
sc2store_wrtstream ( flatname, subnum, ncards,
fitsrec, colsize, rowsize, nframes,
(bolref->dims)[2], refres, 0, smf_flat_methstring( flatmeth, status ),
bolval->hdr->allState, NULL,
ibuf, dksquid, (bolref->pntr)[0], (powref->pntr)[0],
"FLATCAL", NULL, NULL, jig_vert,
nvert, jig_path, npath, xmlfile, status );
sc2store_free ( status );
/* To copy in the variance and modify fix up the WCS we need to reopen
the file */
ndfOpen( NULL, flatname, "UPDATE", "OLD", &indf, &place, status );
/* make sure that history is not written twice */
ndfHsmod( "SKIP", indf, status );
if (outvar) {
void *pntr[3];
int el;
ndfStype( "_DOUBLE", indf, "VARIANCE", status );
ndfMap( indf, "VARIANCE", "_DOUBLE", "WRITE", pntr, &el, status );
if (*status == SAI__OK) {
memcpy( pntr[0], outvar, sizeof(*outvar)*el );
}
}
/* For the WCS a time frame is less relevant than heater settings */
astBegin;
/* Create frame for focal plane coordinates */
sc2ast_createwcs( subnum, NULL, NULL, NULL, NO_FTS, &spacefset, status );
/* Copy it to make sure we do not mess with the cache */
result = astCopy( spacefset );
/* and switch to BOLO frame which is best for bolometer analysis */
{
int frnum = AST__NOFRAME;
kpg1Asffr( result, "BOLO", &frnum, status );
if (frnum != AST__NOFRAME) astSetI( result, "CURRENT", frnum );
}
/* Create a simple frame for heater settings */
heatfrm = astFrame( 1, "Domain=HEATER,Label(1)=Heater Setting" );
heatmap = astLutMap( nframes, bolval->da->heatval, 1.0, 1.0, " " );
/* Append the heater axis to the spatial frameset */
atlAddWcsAxis( result, (AstMapping *)heatmap, (AstFrame *) heatfrm,
NULL, NULL, status );
/* write it to the NDF */
ndfPtwcs( result, indf, status );
/* Write provenance information */
if (prvgrp) {
size_t size = grpGrpsz( prvgrp, status );
char prvname[ 2 * PAR__SZNAM + 1];
smf_get_taskname( NULL, prvname, status );
for (j=1; j<=size; j++) {
smf_accumulate_prov( NULL, prvgrp, j, indf, prvname, NULL, status );
}
}
/* Write the polynomial expansion into an extension */
if (polyfit) {
char fitfile[GRP__SZNAM+1];
int fndf = NDF__NOID;
place = NDF__NOPL;
one_strlcpy( fitfile, flatname, sizeof(fitfile), status );
one_strlcat( fitfile, ".MORE.SMURF.FLATFIT", sizeof(fitfile), status );
/* create the file */
smf_write_smfData( polyfit, NULL, fitfile, NULL, 0, NDF__NOID,
MSG__VERB, 0, status );
/* Same WCS as the main file */
ndfOpen( NULL, fitfile, "UPDATE", "OLD", &fndf, &place, status );
ndfPtwcs( result, fndf, status );
ndfAnnul( &fndf, status );
}
astEnd;
ndfAnnul( &indf, status);
if (ibuf) ibuf = astFree( ibuf );
if (outvar) outvar = astFree( outvar );
if (dksquid) dksquid = astFree( dksquid );
if (state) state = astFree( state );
}
void smurf_mon( int * status ) {
/* Local variables */
char taskname[PAR__SZNAM+1];
char appname[NDF__SZAPP+1];
char filter[PAR__SZNAM+PAR__SZNAM+1];
int ngrp0; /* Number of grp ids at start */
int ngrp1; /* Number of grp ids at end */
int nloc0; /* Number of active HDS Locators at start */
int nloc1; /* Number of active HDS Locators at end */
int memory_caching; /* Is AST current caching unused memory? */
int emslev1; /* EMS level on entry */
int emslev2; /* EMS level on exit */
if ( *status != SAI__OK ) return;
/* Read the input error message stack level */
emsLevel( &emslev1 );
/* Initialise AST */
astBegin;
memory_caching = astTune( "MemoryCaching", 1 );
/* Register our status variable with AST */
astWatch( status );
/* If we are watching a particular memory Id reported by astActiveMemory
we set the watch point here. */
/* astWatchMemory( 29 ); */
/* For debugging, watch one of the leaked GRP identifiers listed by the
call to grpWatch at the end of this routine (if any). */
/* grpWatch( 3129345, status ); */
/* Mark any currently active NDF parameters, so that they will
not be cancelled by the call to ndfCancl at the end of this
function. */
ndfCancl( "*", status );
/* Find out the task name and provenance name we were invoked with */
smf_get_taskname( taskname, NULL, status );
/* Get the GRP and HDS status for leak checking - need the task name
to mask out parameter names. Also need to mask out the monlith name */
one_strlcpy( filter, "!SMURF_MON,!", sizeof(filter), status);
one_strlcat( filter, taskname, sizeof(filter), status );
grpInfoi( NULL, 0, "NGRP", &ngrp0, status );
hdsInfoI( NULL, "LOCATORS", filter, &nloc0, status );
/* Update the application name in the NDF history recording
to include the version number of the application */
snprintf( appname, NDF__SZAPP, "%-*s (%s V%s)", PAR__SZNAM,
taskname, PACKAGE_UPCASE, PACKAGE_VERSION);
ndfHappn( appname, status );
/* Begin a GRP NDF history block. This causes the contents of GRP
groups to be appended to default history text added to any NDFs
during the block. */
ndgBeggh( status );
/* Call the subroutine associated with the requested task */
if (strcmp( taskname, "BADBOLOS" ) == 0 ) {
smurf_extinction( status );
} else if (strcmp( taskname, "CALCDARK" ) == 0 ) {
smurf_calcdark( status );
} else if (strcmp( taskname, "CALCFLAT" ) == 0 ) {
smurf_calcflat( status );
} else if (strcmp( taskname, "CALCNOISE" ) == 0 ) {
smurf_calcnoise( status );
} else if (strcmp( taskname, "CALCQU" ) == 0 ) {
smurf_calcqu( status );
} else if (strcmp( taskname, "CALCRESP" ) == 0 ) {
smurf_calcresp( status );
} else if (strcmp( taskname, "COPYFLAT" ) == 0 ) {
smurf_copyflat( status );
} else if (strcmp( taskname, "DREAMSOLVE" ) == 0 ) {
smurf_dreamsolve( status );
} else if (strcmp( taskname, "DREAMWEIGHTS" ) == 0 ) {
smurf_dreamweights( status );
} else if (strcmp( taskname, "DSUTILS" ) == 0 ) {
smurf_dsutils( status );
} else if (strcmp( taskname, "EXTINCTION" ) == 0 ) {
smurf_extinction( status );
} else if (strcmp( taskname, "FIT1D" ) == 0 ) {
smurf_fit1d( status );
} else if (strcmp( taskname, "FIXSTEPS" ) == 0 ) {
smurf_fixsteps( status );
} else if (strcmp( taskname, "FLATFIELD" ) == 0 ) {
smurf_flatfield( status );
} else if (strcmp( taskname, "FTS2DEGLITCH" ) == 0 ) {
smurf_fts2_deglitch( status );
} else if (strcmp( taskname, "FTS2FLATFIELD" ) == 0 ) {
smurf_fts2_flatfield( status );
} else if (strcmp( taskname, "FTS2FREQCORR" ) == 0 ) {
smurf_fts2_freqcorr( status );
} else if (strcmp( taskname, "FTS2SPLIT" ) == 0 ) {
smurf_fts2_split( status );
} else if (strcmp( taskname, "FTS2INIT" ) == 0 ) {
smurf_fts2_init( status );
} else if (strcmp( taskname, "FTS2MASKMAP" ) == 0 ) {
smurf_fts2_maskmap( status );
} else if (strcmp( taskname, "FTS2OPCORR" ) == 0 ) {
smurf_fts2_spatialwcs( status );
} else if (strcmp( taskname, "FTS2PHASECORR" ) == 0 ) {
smurf_fts2_phasecorr( status );
} else if (strcmp( taskname, "FTS2PHASECORRDS" ) == 0 ) {
smurf_fts2_phasecorrds( status );
} else if (strcmp( taskname, "FTS2PORTIMBAL" ) == 0 ) {
smurf_fts2_portimbal( status );
} else if (strcmp( taskname, "FTS2REMOVEBSE" ) == 0 ) {
smurf_fts2_removebse( status );
} else if (strcmp( taskname, "FTS2SPECTRUM" ) == 0 ) {
smurf_fts2_spectrum( status );
} else if (strcmp( taskname, "FTS2TRANSCORR" ) == 0 ) {
smurf_fts2_transcorr( status );
} else if (strcmp( taskname, "GSD2ACSIS" ) == 0 ) {
smurf_gsd2acsis( status );
} else if (strcmp( taskname, "GSDSHOW" ) == 0 ) {
smurf_gsdshow( status );
} else if (strcmp( taskname, "IMPAZTEC" ) == 0 ) {
smurf_impaztec( status );
} else if (strcmp( taskname, "MAKECUBE" ) == 0 ) {
smurf_makecube( status );
} else if (strcmp( taskname, "MAKEMAP" ) == 0 ) {
smurf_makemap( status );
} else if (strcmp( taskname, "RAWFIXMETA" ) == 0 ) {
smurf_rawfixmeta( status );
} else if (strcmp( taskname, "RAWPRESS" ) == 0 ) {
smurf_rawpress( status );
} else if (strcmp( taskname, "RAWRECREATEWCS" ) == 0 ) {
smurf_rawrecreatewcs( status );
} else if (strcmp( taskname, "RAWREWRTSC2WCS" ) == 0 ) {
smurf_rawrewrtsc2wcs( status );
} else if (strcmp( taskname, "RAWUNPRESS" ) == 0 ) {
smurf_rawunpress( status );
} else if (strcmp( taskname, "REMSKY" ) == 0 ) {
smurf_remsky( status );
} else if (strcmp( taskname, "SC2CLEAN" ) == 0 ) {
smurf_sc2clean( status );
} else if (strcmp( taskname, "SC2CONCAT" ) == 0 ) {
smurf_sc2concat( status );
} else if (strcmp( taskname, "SC2EXPANDMODEL" ) == 0 ) {
smurf_sc2expandmodel( status );
} else if (strcmp( taskname, "SC2FFT" ) == 0 ) {
smurf_sc2fft( status );
} else if (strcmp( taskname, "SC2FILTERMAP" ) == 0 ) {
smurf_sc2filtermap( status );
} else if (strcmp( taskname, "SC2MAPFFT" ) == 0 ) {
smurf_sc2mapfft( status );
} else if (strcmp( taskname, "SC2PCA" ) == 0 ) {
smurf_sc2pca( status );
} else if (strcmp( taskname, "SC2SIM" ) == 0 ) {
smurf_sc2sim( status );
} else if (strcmp( taskname, "SC2THREADTEST" ) == 0 ) {
smurf_sc2threadtest( status );
} else if (strcmp( taskname, "SKYNOISE" ) == 0 ) {
smurf_skynoise( status );
} else if (strcmp( taskname, "SMURFCOPY" ) == 0 ) {
smurf_smurfcopy( status );
} else if (strcmp( taskname, "SMURFHELP" ) == 0 ) {
smurf_smurfhelp( status );
} else if (strcmp( taskname, "STACKFRAMES" ) == 0 ) {
smurf_stackframes( status );
} else if (strcmp( taskname, "STARECALC" ) == 0 ) {
smurf_starecalc( status );
} else if (strcmp( taskname, "TILEINFO" ) == 0 ) {
smurf_tileinfo( status );
} else if (strcmp( taskname, "TILELIST" ) == 0 ) {
smurf_tilelist( status );
} else if (strcmp( taskname, "TIMESORT" ) == 0 ) {
smurf_timesort( status );
} else if (strcmp( taskname, "UNMAKECUBE" ) == 0 ) {
smurf_unmakecube( status );
} else if (strcmp( taskname, "UNMAKEMAP" ) == 0 ) {
smurf_unmakemap( status );
} else {
*status = SAI__ERROR;
msgSetc( "TASK", taskname );
errRep( "smurf_mon", "Unrecognized taskname: ^TASK", status);
}
/* End the GRP NDF history block. */
ndgEndgh( status );
/* Clear cached info from sc2ast_createwcs. */
sc2ast_createwcs(SC2AST__NULLSUB, NULL, NULL, NULL, NO_FTS, NULL, status);
/* Clear WVM caches (one for each thread). */
smf_calc_wvm_clear( status );
/* Free AST resources */
astTune( "MemoryCaching", memory_caching );
astEnd;
/* Check for GRP leaks Do this in a new error reporting context so
* that we get the correct value even if an error has occurred. */
errBegin( status );
grpInfoi( NULL, 0, "NGRP", &ngrp1, status );
/* If there are more active groups now than there were on entry,
* there must be a problem (GRP identifiers are not being freed
* somewhere). So report it. */
if (*status == SAI__OK && ngrp1 > ngrp0) {
msgBlank( status );
msgSetc( "NAME", taskname );
msgSeti( "NGRP0", ngrp0 );
msgSeti( "NGRP1", ngrp1 );
msgOut( " ", "WARNING: The number of active "
"GRP identifiers increased from ^NGRP0 to ^NGRP1 "
"during execution of ^NAME (" PACKAGE_UPCASE " programming "
" error).", status);
msgBlank(status);
grpWatch( 0, status );
}
errEnd( status );
/* The NDF library registers locators with SUBPAR for any NDFs that
are opened directly using ndfAssoc or ndfExist. These locators are
only annulled when the associated parameters are cancelled, but most
smurf applications do not explicitly cancel their NDF parameters.
This means that such locators are picked up by the following check
for dangling HDS locators. In order to prevent this, we cancel any
remaining NDF parameters now, excluding any that were marked by the
call to ndfCancl at the start of this routine. */
ndfCancl( " ", status );
/* Check for HDS leaks Do this in a new error reporting context so
* that we get the correct value even if an error has occurred. */
errBegin( status );
hdsInfoI( NULL, "LOCATORS", filter, &nloc1, status );
/* If there are more active locators now than there were on entry,
* there must be a problem (HDS locators are not being freed
* somewhere). So report it. */
if (*status == SAI__OK && nloc1 > nloc0) {
msgBlank( status );
msgSetc( "NAME", taskname );
msgSeti( "NLOC0", nloc0 );
msgSeti( "NLOC1", nloc1 );
msgOut( " ", "WARNING: The number of active "
"HDS Locators increased from ^NLOC0 to ^NLOC1 "
"during execution of ^NAME (" PACKAGE_UPCASE " programming "
" error).", status);
msgBlank(status);
hdsShow("LOCATORS", status);
hdsShow("FILES", status);
printf("filter - %s\n",filter);
}
errEnd( status );
/* Read the exitt error message stack level */
emsLevel( &emslev2 );
if (*status == SAI__OK && emslev1 != emslev2 ) {
errMark();
msgBlank( status );
msgSetc( "NAME", taskname );
msgSeti( "LV1", emslev1);
msgSeti( "LV2", emslev2);
msgOut( " ", "WARNING: EMS Stack level went from ^LV1 to ^LV2"
" during execution of ^NAME (" PACKAGE_UPCASE " programming"
" error).", status );
msgBlank(status);
errRlse();
}
/* configure AST --with-memdebug, and uncomment the following lines
to see how much memory usage SMURF hit at its peak */
/*
{
size_t memcurrent,mempeak;
astMemoryStats( 0, &mempeak, &memcurrent );
msgOutf( "", "SMURF: === current /peak memory usage: %zu / %zu MiB ===",
status, memcurrent/SMF__MIB, mempeak/SMF__MIB );
}
*/
/* The astCheckMemory function does nothing unless AST has been compiled
* with the MEM_DEBUG flag. If this is the case, then it reports the number
* of memory blocks that have not been freed (useful for identifying memory
* leaks). Use astActiveMemory() below to list all active memory and
* then use astWatchMemory() at the start of this routine to get reports
* when a particular ID is used. Set a breakpoint in the debugger for
* astMemoryAlarm_
*/
astActiveMemory("Exit:");
astCheckMemory;
}
void smf_store_image( smfData *data, HDSLoc *scu2redloc, int cycle, int ndim,
int dims[], int nsampcycle, int vxmin, int vymin,
double *image, double *zero, int *status) {
smfHead *hdr = NULL; /* Pointer to header struct */
HDSLoc *bz_imloc = NULL; /* HDS locator */
int bzindf; /* NDF identifier for bolometer zero points */
double *bzptr = NULL; /* Pointer to mapped space for zero points */
int el; /* Number of elements mapped */
int frame; /* Mean timeslice index for image */
AstFitsChan *imfits=NULL; /* FITS header for each reconstructed image */
char imname[DAT__SZNAM]; /* Name of structure for image */
double *imptr = NULL; /* Pointer to mapped space for image */
int j; /* Loop counter */
int lbnd[2]; /* Lower dimension bounds */
int ntot; /* Total number of elements */
int place; /* NDF placeholder */
char prvname[2*PAR__SZNAM +1]; /* Provenance creator */
int seqend; /* End index */
int seqstart; /* Starting index */
int slice; /* Index of current time slice */
int strnum; /* Structure element number */
sc2ast_subarray_t subnum; /* Subarray index number */
int ubnd[2]; /* Upper dimension bounds */
int uindf; /* NDF identifier */
AstFrameSet *wcs = NULL; /* WCS info */
if ( *status != SAI__OK ) return;
seqstart = cycle * nsampcycle;
seqend = seqstart + nsampcycle - 1;
slice = (int)( (seqstart + seqend ) /2);
smf_tslice_ast( data, slice, 1, status);
astBegin;
/* Old beginning */
/* Get structure for nth constructed image */
strnum = cycle + 1;
sprintf ( imname, "I%d", strnum );
ntot = 1;
for ( j=0; j<ndim; j++ ) {
lbnd[j] = 1;
ubnd[j] = lbnd[j] + dims[j] - 1;
ntot *= dims[j];
}
ndfPlace ( scu2redloc, imname, &place, status );
ndfNew ( "_DOUBLE", ndim, lbnd, ubnd, &place, &uindf, status );
ndfHcre ( uindf, status );
/* Map the data array */
ndfMap ( uindf, "DATA", "_DOUBLE", "WRITE", (void *)&imptr, &el,
status );
/* Copy image array */
if ( *status == SAI__OK ) {
memcpy( imptr, image, ntot*sizeof(*imptr));
}
/* Derive WCS */
hdr = data->hdr;
smf_find_subarray(hdr, NULL, 0, &subnum, status );
sc2ast_createwcs( subnum, hdr->state, hdr->instap, hdr->telpos, &wcs, status );
/* Shift the coord frame is either vxmin or vymin is non-zero */
if ( vxmin != 0 || vymin != 0 ) {
sc2ast_moveframe ( -(double)vxmin, -(double)vymin, wcs, status );
}
/* This should probably be a user-option but ICRS is probably a safe
assumption */
sc2ast_set_output_system( hdr->state->tcs_tr_sys, wcs, status );
/* Sort out provenance. */
smf_get_taskname( NULL, prvname, status );
smf_updateprov( uindf, data, NDF__NOID, prvname, NULL, status );
/* Store world coordinate transformations */
ndfPtwcs ( wcs, uindf, status );
/* Store the bolometer zero points as an NDF in the extension */
if (zero) {
ndfXnew ( uindf, "BOLZERO", "SCUBA2_ZER_ARR", 0, 0, &bz_imloc,
status );
ndfPlace ( bz_imloc, "ZERO", &place, status );
/* Create the array for bolometer zeros */
lbnd[0] = SC2STORE__BOL_LBND;
ubnd[0] = lbnd[0] + dims[0] - 1;
lbnd[1] = SC2STORE__BOL_LBND;
ubnd[1] = lbnd[1] + dims[1] - 1;
ndfNew ( "_DOUBLE", 2, lbnd, ubnd, &place, &bzindf, status );
ndfHcre ( bzindf, status );
/* Map the data array */
ndfMap ( bzindf, "DATA", "_DOUBLE", "WRITE", (void *)&bzptr, &el,
status );
/* Copy image array */
if ( *status == SAI__OK ) {
memcpy( bzptr, zero, dims[0]*dims[1]*sizeof(*zero));
}
/* Unmap the data array */
ndfUnmap ( bzindf, "DATA", status );
ndfAnnul ( &bzindf, status );
/* Free the locators for the frame */
datAnnul ( &bz_imloc, status );
}
/* Store the FITS headers */
frame = (int)( (seqstart + seqend ) /2);
/* Quick and dirty method - just copy the full FITS header */
imfits = astCopy( hdr->fitshdr );
astSetFitsI( imfits, "SUBSCAN", strnum,
"Subscan number of reconstructed image", 0);
kpgPtfts( uindf, imfits, status );
/* Unmap the data array */
ndfUnmap ( uindf, "DATA", status );
ndfAnnul ( &uindf, status );
astEnd;
}
