static AstTable *ReadNextTable( FILE *fd, const char *fname, int *iline,
int *status ) {
/*
* Name:
* ReadOneTable
* Purpose:
* Reads a single Table from a text file.
* Description:
* This function reads text from the supplied file descriptor until it
* reaches the end of file or encounters an end-of-table marker (a line
* consisting just of two or more minus signs with no leading spaces).
* It creates an AstTable from the text and returns a pointer to it.
* Arguments:
* fd
* The file descriptor.
* fname
* The file name - used for error messages.
* iline
* Pointer to an int holding the number of lines read from the
* file so far. Updated on exit to include the lines read by the
* invocation of this function.
* status
* Pointer to the global status variable.
* Returned Value:
* A pointer to the Table read from the file, or NULL if an error occurs.
*/
/* Local Variables: */
AstTable *result;
AstTable *subtable;
char **cols;
char **words;
char *last_com;
char *line;
char *p;
char *tname;
char key[ 200 ];
const char *cval;
const char *oldname;
const char *newname;
double dval;
int *types;
int blank;
int c;
int com;
int eot;
int first;
int icol;
int irow;
int ival;
int iword;
int line_len;
int max_line_len;
int more;
int nc;
int ncol;
int nrow;
int nword;
int skip;
size_t len;
/* Initialise */
result = NULL;
/* Check the inherited status. */
if( *status != SAI__OK ) return result;
/* Create an empty Table. */
result = astTable( " " );
/* Allocate a buffer for one one line of text. This will be increased in
size as required. */
max_line_len = 80;
line = astMalloc( max_line_len*sizeof( *line ) );
/* Read each line of text from the file. */
eot = 0;
skip = 1;
line_len = 0;
more = 1;
last_com = NULL;
cols = NULL;
first = 1;
irow = 0;
types = NULL;
while( more && *status == SAI__OK ) {
(*iline)++;
line_len = 0;
/* Loop reading characters from the file until a newline or the end of file is
reached. */
while( ( c = fgetc( fd ) ) != EOF && c != '\n' ) {
/* Increment the current line length, and double the size of the line buffer
if it is full. */
if( ++line_len >= max_line_len ) {
max_line_len *= 2;
line = astRealloc( line, max_line_len*sizeof( *line ) );
if( *status != SAI__OK ) break;
}
/* Store the character. Ignore leading white space. */
if( skip ) {
if( ! isspace( c ) ) {
line[ line_len - 1 ] = c;
skip = 0;
} else {
line_len--;
}
} else {
line[ line_len - 1 ] = c;
}
}
/* If the end-of-file was reached indicate that we should leave the main
loop after processing the current line. */
if( c == EOF ) more = 0;
/* Terminate the line. */
line[ line_len ] = 0;
/* Terminate it again to exclude trailing white space. */
line[ astChrLen( line ) ] = 0;
/* Assume the line is a blank non-comment, and store a pointer to the first
character to use. */
blank = 1;
com = 0;
p = line;
/* Skip blank lines. */
if( line[ 0 ] ) {
/* If the line starts with a comment character... */
if( line[ 0 ] == '#' || line[ 0 ] == '!' ) {
com = 1;
/* Get a pointer to the first non-space/tab character after the comment
character. */
p = line + 1;
while( *p == ' ' || *p == '\t' ) p++;
/* Note if it is blank. */
if( *p ) blank = 0;
/* If it is not a comment line, then the line is not blank. */
} else {
blank = 0;
/* See if it is the end-of-table marker - a line containing just two or
more minus signs with no leading spaces. */
eot = ( strspn( line, "-" ) > 1 );
}
}
/* Skip blank lines, whether comment or not. */
if( ! blank ) {
/* First handle comment lines. */
if( com ) {
/* Does it look like a parameter assignment... */
words = astChrSplitRE( p, "^\\s*(\\w+)\\s*=\\s*(.*)$", &nword, NULL );
if( words ) {
/* Add a parameter declaration to the Table. */
astAddParameter( result, words[ 0 ] );
/* Store the parameter value, using an appropriate data type. */
len = strlen( words[ 1 ] );
if( nc = 0, ( 1 == astSscanf( words[ 1 ], "%d%n", &ival, &nc ) )
&& ( nc >= len ) ) {
astMapPut0I( result, words[ 0 ], ival, NULL );
} else if( nc = 0, ( 1 == astSscanf( words[ 1 ], "%lg%n", &dval, &nc ) )
&& ( nc >= len ) ) {
astMapPut0D( result, words[ 0 ], dval, NULL );
} else {
astMapPut0C( result, words[ 0 ], words[ 1 ], NULL );
}
/* Free the words returned by astChrSplitRE. */
for( iword = 0; iword < nword; iword++ ) {
words[ iword ] = astFree( words[ iword ] );
}
words = astFree( words );
/* If it does not look like a parameter assignment... */
} else {
/* Save a copy of it in case it turns out to be the last non-blank comment
line before the first row of data values (in which case it should
contain the column names). */
last_com = astStore( last_com, p, strlen( p ) + 1 );
}
/* If the line is not a comment see if it is an end of table marker. If so
indicate that we should leave the loop. */
} else if( eot ) {
more = 0;
/* If the line is not a comment or an end of table marker ... */
} else {
/* Get the words from the row. */
words = astChrSplit( p, &nword );
/* If this is the first non-blank non-comment line, get the column names from
the previous non-blank comment line. */
if( first ) {
if( last_com ) {
first = 0;
cols = astChrSplit( last_com, &ncol );
/* Create an array to hold the data type for each colum, and initialise
them to "integer". */
types = astMalloc( ncol*sizeof( int ) ) ;
for( iword = 0; iword < nword && astOK; iword++ ) {
if( iword < ncol ) {
types[ iword ] = AST__INTTYPE;
/* The columns are stored initially using interim names which have "T_"
prepended to the names given in the file. */
tname = NULL;
nc = 0;
tname = astAppendString( tname, &nc, "T_" );
tname = astAppendString( tname, &nc, cols[ iword ] );
astFree( cols[ iword ] );
cols[ iword ] = tname;
/* Create the column definition within the returned Table. We store them
initially as strings and then convert to the appropriate column data type
later (once all rows have been read and the the data types are known). */
astAddColumn( result, cols[ iword ], AST__STRINGTYPE,
0, NULL, " " );
}
}
} else if( *status == SAI__OK ) {
*status = SAI__ERROR;
msgSetc( "F", fname );
errRep( " ", "No column headers found in file ^F.", status );
}
}
/* Report an error if the line has the wrong number of values. */
if( nword != ncol ) {
if( *status == SAI__OK ) {
*status = SAI__ERROR;
msgSeti( "N", nword );
msgSeti( "I", (*iline) );
msgSeti( "M", ncol );
msgSetc( "F", fname );
errRep( " ", "Wrong number of values (^N) at line ^I in "
"file ^F (should be ^M).", status );
}
/* Otherwise increment the number of rows read. */
} else {
irow++;
/* Store each string value in the table, excluding "null" strings. Also check
the data type of each string an dupdate the column data types if necessary. */
for( iword = 0; iword < nword && *status == SAI__OK; iword++ ) {
if( strcmp( words[ iword ], "null" ) ) {
sprintf( key, "%s(%d)", cols[ iword ], irow );
astMapPut0C( result, key, words[ iword ], NULL );
/* If the column is currently thought to hold integers, check that the
current word looks like an integer. If not, down-grade the column type
to double. */
len = strlen( words[ iword ] );
if( types[ iword ] == AST__INTTYPE ) {
if( nc = 0, ( 1 != astSscanf( words[ iword ], "%d%n",
&ival, &nc ) ) ||
( nc < len ) ) {
types[ iword ] = AST__DOUBLETYPE;
}
}
/* If the column is currently thought to hold doubles, check that the
current word looks like an doubler. If not, down-grade the column type
to string. */
if( types[ iword ] == AST__DOUBLETYPE ) {
if( nc = 0, ( 1 != astSscanf( words[ iword ], "%lg%n",
&dval, &nc ) ) ||
( nc < len ) ) {
types[ iword ] = AST__STRINGTYPE;
}
}
}
}
}
/* Free the words returned by astChrSplit. */
for( iword = 0; iword < nword; iword++ ) {
words[ iword ] = astFree( words[ iword ] );
}
words = astFree( words );
}
}
}
/* The entire file has now been read, and a Table created in which every
column holds strings. We also have flags indicating whether the values
in each column are all integers or doubles. Modify the type of the
column within the Table to match these flags. */
nrow = astGetI( result, "Nrow" );
for( icol = 0; icol < ncol && *status == SAI__OK; icol++ ) {
/* The column will be re-named from "T_<name>" to "<name>". */
oldname = cols[ icol ];
newname = oldname + 2;
/* First convert string columns to integer columns if all the values in
the column look like integers. */
if( types[ icol ] == AST__INTTYPE ) {
/* Create the new column */
astAddColumn( result, newname, AST__INTTYPE, 0, NULL, " " );
/* Copy each cell of the current column, converting from string to integer. */
for( irow = 1; irow <= nrow; irow++ ) {
sprintf( key, "%s(%d)", oldname, irow );
if( astMapGet0I( result, key, &ival ) ) {
sprintf( key, "%s(%d)", newname, irow );
astMapPut0I( result, key, ival, NULL );
}
}
/* Now do double columns in the same way. */
} else if( types[ icol ] == AST__DOUBLETYPE ) {
astAddColumn( result, newname, AST__DOUBLETYPE, 0, NULL, " " );
for( irow = 1; irow <= nrow; irow++ ) {
sprintf( key, "%s(%d)", oldname, irow );
if( astMapGet0D( result, key, &dval ) ) {
sprintf( key, "%s(%d)", newname, irow );
astMapPut0D( result, key, dval, NULL );
}
}
/* Copy string values without change. */
} else {
astAddColumn( result, newname, AST__STRINGTYPE, 0, NULL, " " );
for( irow = 1; irow <= nrow; irow++ ) {
sprintf( key, "%s(%d)", oldname, irow );
if( astMapGet0C( result, key, &cval ) ) {
sprintf( key, "%s(%d)", newname, irow );
astMapPut0C( result, key, cval, NULL );
}
}
}
/* Remove the old column. */
astRemoveColumn( result, oldname );
}
/* Free resources. */
line = astFree( line );
last_com = astFree( last_com );
types = astFree( types );
if( cols ) {
for( icol = 0; icol < ncol; icol++ ) {
cols[ icol ] = astFree( cols[ icol ] );
}
cols = astFree( cols );
}
/* If the table ended with an end-of-table marker, there may be another
Table in the file. Call this function recursively to read it. */
if( eot ) {
subtable = ReadNextTable( fd, fname, iline, status );
/* Store the subtable as a table parameter in the returned table. */
if( subtable ) {
astAddParameter( result, "SubTable" );
astMapPut0A( result, "SubTable", subtable, NULL );
/* The Table clones the pointer, so we must annull our local copy of it. */
subtable = astAnnul( subtable );
}
}
/* Return the Table pointer. */
return result;
}
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); }
}
void smurf_jsatileinfo( int *status ) {
/* Local Variables */
AstCmpRegion *overlap;
AstFitsChan *fc;
AstFrameSet *fs;
AstObject *obj;
AstRegion *region;
AstRegion *target;
HDSLoc *cloc = NULL;
HDSLoc *xloc = NULL;
char *jcmt_tiles;
char *tilendf = NULL;
char text[ 200 ];
double dec[ 8 ];
double dist;
double dlbnd[ 2 ];
double dubnd[ 2 ];
double gx[ 8 ];
double gy[ 8 ];
double maxdist;
double norm_radec[2];
double point1[ 2 ];
double point2[ 2 ];
double ra[ 8 ];
double ra0;
double dec0;
int *ipntr;
int axes[ 2 ];
int create;
int dirlen;
int el;
int exists;
int flag;
int i;
int indf1;
int indf2;
int indf3;
int itile;
int iv;
int jtile;
int lbnd[ 2 ];
int local_origin;
int nc;
int place;
int tlbnd[ 2 ];
int tubnd[ 2 ];
int ubnd[ 2 ];
smf_jsaproj_t proj;
int xt;
int yt;
smfJSATiling skytiling;
void *pntr;
/* Check inherited status */
if( *status != SAI__OK ) return;
/* Start a new AST context. */
astBegin;
/* Get the instrument to use abnd get the parameters describing the
layout of its JSA tiles. */
smf_jsainstrument( "INSTRUMENT", NULL, SMF__INST_NONE, &skytiling,
status );
/* Return the maximum tile index. */
parPut0i( "MAXTILE", skytiling.ntiles - 1, status );
/* Abort if an error has occurred. */
if( *status != SAI__OK ) goto L999;
/* Decide what sort of projection to use. */
parChoic( "PROJ", "HPX", "HPX,HPX12,XPHN,XPHS", 1, text, sizeof(text),
status );
proj = smf_jsaproj_fromstr( text, 1, status );
/* If required, create an all-sky NDF in which each pixel covers the area
of a single tile, and holds the integer tile index. The NDF has an
initial size of 1x1 pixels, but is expanded later to the required size. */
lbnd[ 0 ] = ubnd[ 0 ] = lbnd[ 1 ] = ubnd[ 1 ] = 1;
ndfCreat( "ALLSKY", "_INTEGER", 2, lbnd, ubnd, &indf3, status );
/* If a null (!) value was supplied for parameter ALLSKY, annull the
error and pass on. */
if( *status == PAR__NULL ) {
errAnnul( status );
/* Otherwise, create a FrameSet describing the whole sky in which each
pixel corresponds to a single tile. */
} else {
smf_jsatile( -1, &skytiling, 0, proj, NULL, &fs, NULL, lbnd, ubnd,
status );
/* Change the bounds of the output NDF. */
ndfSbnd( 2, lbnd, ubnd, indf3, status );
/* Store the FrameSet in the NDF. */
ndfPtwcs( fs, indf3, status );
/* Map the data array. */
ndfMap( indf3, "Data", "_INTEGER", "WRITE/BAD", (void **) &ipntr, &el,
status );
/* Create all-sky map using XPH projection. */
if( *status == SAI__OK ) {
/* Loop round every tile index. */
for( jtile = 0; jtile < skytiling.ntiles; jtile++ ) {
/* Get the zero-based (x,y) indices of the tile within an HPX projection.
This flips the bottom left half-facet up to the top right. */
smf_jsatilei2xy( jtile, &skytiling, &xt, &yt, NULL, status );
/* Convert these HPX indices to the corresponding indices within the
required projection. Note, the lower left facet is split by the above
call to smf_jsatilei2xy tile (i.e. (xt,yt) indices are *not* in the
"raw" mode). For instance, (0,0) is not a valid tile. */
smf_jsatilexyconv( &skytiling, proj, xt, yt, 0, &xt, &yt, status );
/* Get the vector index of the corresponding element of the all-sky NDF. */
if( proj == SMF__JSA_HPX || proj == SMF__JSA_HPX12 ) {
iv = xt + 5*skytiling.ntpf*yt;
} else {
iv = xt + 4*skytiling.ntpf*yt;
}
/* Report an error if this element has already been assigned a tile
index. Otherwise, store the tile index. */
if( ipntr[ iv ] == VAL__BADI ) {
ipntr[ iv ] = jtile;
} else if( *status == SAI__OK ) {
*status = SAI__ERROR;
errRepf( "", "%s projection assigns multiple tiles to "
"pixel (%d,%d).", status, text, xt, yt );
break;
}
}
}
/* Store NDF title. */
sprintf( text, "JSA tile indices for %s data", skytiling.name );
ndfCput( text, indf3, "TITLE", status );
/* Store the instrument as a component in the SMURF extension. */
ndfXnew( indf3, "SMURF", "INSTRUMENT", 0, 0, &xloc, status );
ndfXpt0c( skytiling.name, indf3, "SMURF", "INSTRUMENT", status );
datAnnul( &xloc, status );
/* Close the NDF. */
ndfAnnul( &indf3, status );
}
/* Abort if an error has occurred. */
if( *status != SAI__OK ) goto L999;
/* Get the zero-based index of the required tile. If a null value is
supplied, annull the error and skip to the end. */
parGdr0i( "ITILE", 0, 0, skytiling.ntiles - 1, 0, &itile, status );
if( *status == PAR__NULL ) {
errAnnul( status );
goto L999;
}
/* See if the pixel origin is to be at the centre of the tile. */
parGet0l( "LOCAL", &local_origin, status );
/* Display the tile number. */
msgBlank( status );
msgSeti( "ITILE", itile );
msgSeti( "MAXTILE", skytiling.ntiles - 1);
msgOut( " ", " Tile ^ITILE (from 0 to ^MAXTILE):", status );
/* Get the FITS header, FrameSet and Region defining the tile, and the tile
bounds in pixel indices. */
smf_jsatile( itile, &skytiling, local_origin, proj, &fc, &fs, ®ion,
lbnd, ubnd, status );
/* Write the FITS headers out to a file, annulling the error if the
header is not required. */
if( *status == SAI__OK ) {
atlDumpFits( "HEADER", fc, status );
if( *status == PAR__NULL ) errAnnul( status );
}
/* If required, write the Region out to a text file. */
if( *status == SAI__OK ) {
atlCreat( "REGION", (AstObject *) region, status );
if( *status == PAR__NULL ) errAnnul( status );
}
/* Store the lower and upper pixel bounds of the tile. */
parPut1i( "LBND", 2, lbnd, status );
parPut1i( "UBND", 2, ubnd, status );
/* Display pixel bounds on the screen. */
msgSeti( "XL", lbnd[ 0 ] );
msgSeti( "XU", ubnd[ 0 ] );
msgSeti( "YL", lbnd[ 1 ] );
msgSeti( "YU", ubnd[ 1 ] );
msgOut( " ", " Pixel bounds: (^XL:^XU,^YL:^YU)", status );
/* Get the RA,Dec at the tile centre. */
if( astTest( fs, "SkyRef" ) ) {
ra0 = astGetD( fs, "SkyRef(1)" );
dec0 = astGetD( fs, "SkyRef(2)" );
/* Format the central RA and Dec. and display. Call astNorm on the
coordinates provided that the frame set has the correct number of
axes (which it should as it comes from smf_jsatile). */
norm_radec[0] = ra0;
norm_radec[1] = dec0;
if (astGetI(fs, "Naxes") == 2) astNorm(fs, norm_radec);
msgSetc( "RACEN", astFormat( fs, 1, norm_radec[ 0 ] ));
msgSetc( "DECCEN", astFormat( fs, 2, norm_radec[ 1 ] ));
msgOut( " ", " Centre (ICRS): RA=^RACEN DEC=^DECCEN", status );
/* Transform a collection of points on the edge of the region (corners and
side mid-points) from GRID coords to RA,Dec. */
point1[ 0 ] = 0.5;
point1[ 1 ] = 0.5;
point2[ 0 ] = ubnd[ 0 ] - lbnd[ 0 ] + 1;
point2[ 1 ] = ubnd[ 1 ] - lbnd[ 1 ] + 1;
gx[ 0 ] = point1[ 0 ]; /* Bottom left */
gy[ 0 ] = point1[ 1 ];
gx[ 1 ] = point1[ 0 ]; /* Centre left */
gy[ 1 ] = gy[ 0 ];
gx[ 2 ] = point1[ 0 ]; /* Top left */
gy[ 2 ] = point2[ 1 ];
gx[ 3 ] = gx[ 0 ]; /* Top centre */
gy[ 3 ] = point2[ 1 ];
gx[ 4 ] = point2[ 0 ]; /* Top right */
gy[ 4 ] = point2[ 1 ];
gx[ 5 ] = point2[ 0 ]; /* Centre right */
gy[ 5 ] = gy[ 0 ];
gx[ 6 ] = point2[ 0 ]; /* Bottom right */
gy[ 6 ] = point1[ 1 ];
gx[ 7 ] = gx[ 0 ]; /* Bottom centre */
gy[ 7 ] = point1[ 1 ];
astTran2( fs, 8, gx, gy, 1, ra, dec );
/* Find the arc-distance from the centre to the furthest point from the
centre. */
point1[ 0 ] = ra0;
point1[ 1 ] = dec0;
maxdist = -1.0;
for( i = 1; i < 8; i++ ) {
if( ra[ i ] != AST__BAD && dec[ i ] != AST__BAD ) {
point2[ 0 ] = ra[ i ];
point2[ 1 ] = dec[ i ];
dist = astDistance( fs, point1, point2 );
if( dist > maxdist ) maxdist = dist;
}
}
/* Convert from radius to diameter. */
maxdist *= 2.0;
/* Format this size as a dec value (i.e. arc-distance) and display it. */
if( maxdist > 0.0 ) {
msgSetc( "SIZE", astFormat( fs, 2, maxdist ) );
msgOut( " ", " Size: ^SIZE", status );
} else {
maxdist = AST__BAD;
msgOut( " ", " Size: <unknown>", status );
}
/* If a discontinuity passes through the tile, the centre and size may be
unknown. */
} else {
ra0 = AST__BAD;
dec0 = AST__BAD;
maxdist = AST__BAD;
msgOut( " ", " Centre (ICRS): RA=<unknown> DEC=<unknown>", status );
msgOut( " ", " Size: <unknown>", status );
}
/* Write the tile centre ra and dec in radians to the output parameters. */
parPut0d( "RACEN", norm_radec[ 0 ], status );
parPut0d( "DECCEN", norm_radec[ 1 ], status );
/* Write the size to the output parameter as radians. */
parPut0d( "SIZE", maxdist, status );
/* Get the translation of the environment variable JSA_TILE_DIR. */
jcmt_tiles = getenv( "JSA_TILE_DIR" );
/* Initialise the path to the tile's NDF to hold the root directory.
Use the current working directory if JSA_TILE_DIR is undefined. */
if( jcmt_tiles ) {
nc = 0;
tilendf = astAppendString( tilendf, &nc, jcmt_tiles );
} else {
nc = 512;
jcmt_tiles = astMalloc( nc );
while( !getcwd( jcmt_tiles, nc ) ) {
nc *= 2;
jcmt_tiles = astRealloc( jcmt_tiles, nc );
}
nc = 0;
tilendf = astAppendString( tilendf, &nc, jcmt_tiles );
jcmt_tiles = astFree( jcmt_tiles );
}
/* Complete the path to the tile's NDF. */
tilendf = astAppendString( tilendf, &nc, "/" );
tilendf = astAppendString( tilendf, &nc, skytiling.subdir );
dirlen = nc;
sprintf( text, "/tile_%d.sdf", itile );
tilendf = astAppendString( tilendf, &nc, text );
/* Write it to the output parameter. */
parPut0c( "TILENDF", tilendf, status );
/* See if the NDF exists, and store the flag in the output parameter. */
exists = access( tilendf, F_OK ) ? 0 : 1;
parPut0l( "EXISTS", exists, status );
/* If the NDF does not exist, create it if required. */
parGet0l( "CREATE", &create, status );
if( !exists && create && *status == SAI__OK ) {
/* Write the NDF info to the screen. */
msgSetc( "NDF", tilendf );
msgOutif( MSG__NORM, " ", " NDF: ^NDF (created)", status );
/* Temporarily terminate the NDF path at the end of the subdirectory. */
tilendf[ dirlen ] = 0;
/* Create the required directory (does nothing if the directory
already exists). It is given read/write/search permissions for owner
and group, and read/search permissions for others. */
(void) mkdir( tilendf, S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH );
/* Replace the character temporarily overwritten above. */
tilendf[ dirlen ] = '/';
/* Now create the tile's NDF. */
ndfPlace( NULL, tilendf, &place, status );
ndfNew( skytiling.type, 2, lbnd, ubnd, &place, &indf1, status );
/* Fill its data array with zeros. */
ndfMap( indf1, "Data", skytiling.type, "WRITE/ZERO", &pntr, &el,
status );
/* Store the WCS FrameSet. */
ndfPtwcs( fs, indf1, status );
/* If the instrument jsatiles.have variance, fill the variance array with zeros. */
if( skytiling.var ) {
ndfMap( indf1, "Variance", skytiling.type, "WRITE/ZERO", &pntr,
&el, status );
}
/* Create a SMURF extension. */
ndfXnew( indf1, SMURF__EXTNAME, SMURF__EXTTYPE, 0, NULL, &xloc, status );
/* Store the tile number and instrument name in the extension. */
datNew0I( xloc, "TILE", status );
datFind( xloc, "TILE", &cloc, status );
datPut0I( cloc, itile, status );
datAnnul( &cloc, status );
datNew0C( xloc, "INSTRUMENT", strlen( skytiling.name ), status );
datFind( xloc, "INSTRUMENT", &cloc, status );
datPut0C( cloc, skytiling.name, status );
datAnnul( &cloc, status );
/* Create a weights NDF within the SMURF extension, and fill its data
array with zeros. */
ndfPlace( xloc, "WEIGHTS", &place, status );
ndfNew( skytiling.type, 2, lbnd, ubnd, &place, &indf2, status );
ndfMap( indf2, "Data", skytiling.type, "WRITE/ZERO", &pntr, &el,
status );
ndfPtwcs( fs, indf2, status );
ndfAnnul( &indf2, status );
/* Annul the extension locator and the main NDF identifier. */
datAnnul( &xloc, status );
ndfAnnul( &indf1, status );
/* Write the NDF info to the screen. */
} else {
msgSetc( "NDF", tilendf );
msgSetc( "E", exists ? "exists" : "does not exist" );
msgOut( " ", " NDF: ^NDF (^E)", status );
}
/* Initialise TBND and TLBND to indicate no overlap. */
tlbnd[ 0 ] = 1;
tlbnd[ 1 ] = 1;
tubnd[ 0 ] = 0;
tubnd[ 1 ] = 0;
/* Attempt to to get an AST Region (assumed to be in some 2D sky coordinate
system) using parameter "TARGET". */
if( *status == SAI__OK ) {
kpg1Gtobj( "TARGET", "Region",
(void (*)( void )) F77_EXTERNAL_NAME(ast_isaregion),
&obj, status );
/* Annul the error if none was obtained. */
if( *status == PAR__NULL ) {
errAnnul( status );
/* Otherwise, use the supplied object. */
} else {
target = (AstRegion *) obj;
/* If the target Region is 3-dimensional, remove the third axis, which
is assumed to be a spectral axis. */
if( astGetI( target, "Naxes" ) == 3 ) {
axes[ 0 ] = 1;
axes[ 1 ] = 2;
target = astPickAxes( target, 2, axes, NULL );
}
/* See if there is any overlap between the target and the tile. */
overlap = NULL;
flag = astOverlap( region, target );
if( flag == 0 ) {
msgOut( "", " Cannot convert between the coordinate system of the "
"supplied target and the tile.", status );
} else if( flag == 1 || flag == 6 ) {
msgOut( "", " There is no overlap between the target and the tile.",
status );
} else if( flag == 2 ) {
msgOut( "", " The tile is contained within the target.",
status );
tlbnd[ 0 ] = lbnd[ 0 ];
tlbnd[ 1 ] = lbnd[ 1 ];
tubnd[ 0 ] = ubnd[ 0 ];
tubnd[ 1 ] = ubnd[ 1 ];
} else if( flag == 3 ) {
overlap = astCmpRegion( region, target, AST__AND, " " );
} else if( flag == 4 ) {
overlap = astCmpRegion( region, target, AST__AND, " " );
} else if( flag == 5 ) {
msgOut( "", " The target and tile are identical.",
status );
tlbnd[ 0 ] = lbnd[ 0 ];
tlbnd[ 1 ] = lbnd[ 1 ];
tubnd[ 0 ] = ubnd[ 0 ];
tubnd[ 1 ] = ubnd[ 1 ];
} else if( *status == SAI__OK ) {
*status = SAI__OK;
errRepf( "", "Unexpected value %d returned by astOverlap "
"(programming error).", status, flag );
}
/* If a region containing the intersection of the tile and target was
created above, map it into the grid coordinate system of the tile. */
if( overlap ) {
overlap = astMapRegion( overlap, astGetMapping( fs, AST__CURRENT,
AST__BASE ),
astGetFrame( fs, AST__BASE ) );
/* Get its GRID bounds. */
astGetRegionBounds( overlap, dlbnd, dubnd );
/* Convert to integer. */
tlbnd[ 0 ] = ceil( dlbnd[ 0 ] - 0.5 );
tlbnd[ 1 ] = ceil( dlbnd[ 1 ] - 0.5 );
tubnd[ 0 ] = ceil( dubnd[ 0 ] - 0.5 );
tubnd[ 1 ] = ceil( dubnd[ 1 ] - 0.5 );
/* Convert to PIXEL indices within the tile. */
tlbnd[ 0 ] += lbnd[ 0 ] - 1;
tlbnd[ 1 ] += lbnd[ 1 ] - 1;
tubnd[ 0 ] += lbnd[ 0 ] - 1;
tubnd[ 1 ] += lbnd[ 1 ] - 1;
msgOutf( "", " The target overlaps section (%d:%d,%d:%d).",
status, tlbnd[ 0 ], tubnd[ 0 ], tlbnd[ 1 ], tubnd[ 1 ] );
}
}
}
/* Store the pixel index bounds of the tiles overlap with the target. */
parPut1i( "TLBND", 2, tlbnd, status );
parPut1i( "TUBND", 2, tubnd, status );
/* Arrive here if an error occurs. */
L999:;
/* Free resources. */
tilendf = astFree( tilendf );
/* End the AST context. */
astEnd;
/* Issue a status indication.*/
msgBlank( status );
if( *status == SAI__OK ) {
msgOutif( MSG__VERB, "", "JSATILEINFO succeeded.", status);
} else {
msgOutif( MSG__VERB, "", "JSATILEINFO failed.", status);
}
}