| 1 |
8 |
bertin |
/*
|
| 2 |
|
|
xml.c
|
| 3 |
|
|
|
| 4 |
|
|
*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
|
| 5 |
|
|
*
|
| 6 |
22 |
bertin |
* Part of: SExtractor
|
| 7 |
8 |
bertin |
*
|
| 8 |
|
|
* Author: E.BERTIN (IAP)
|
| 9 |
|
|
*
|
| 10 |
|
|
* Contents: XML logging.
|
| 11 |
|
|
*
|
| 12 |
219 |
bertin |
* Last modify: 21/01/2010
|
| 13 |
8 |
bertin |
*
|
| 14 |
|
|
*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
|
| 15 |
|
|
*/
|
| 16 |
|
|
|
| 17 |
|
|
#ifdef HAVE_CONFIG_H
|
| 18 |
|
|
#include "config.h"
|
| 19 |
|
|
#endif
|
| 20 |
|
|
|
| 21 |
|
|
#include <math.h>
|
| 22 |
|
|
#include <stdio.h>
|
| 23 |
|
|
#include <stdlib.h>
|
| 24 |
|
|
#include <string.h>
|
| 25 |
|
|
#include <time.h>
|
| 26 |
|
|
|
| 27 |
|
|
#include "define.h"
|
| 28 |
|
|
#include "globals.h"
|
| 29 |
|
|
#include "fits/fitscat.h"
|
| 30 |
|
|
#include "field.h"
|
| 31 |
9 |
bertin |
#include "key.h"
|
| 32 |
8 |
bertin |
#include "prefs.h"
|
| 33 |
|
|
#include "xml.h"
|
| 34 |
|
|
|
| 35 |
12 |
bertin |
extern time_t thetimet,thetimet2; /* from makeit.c */
|
| 36 |
|
|
extern pkeystruct key[]; /* from preflist.h */
|
| 37 |
|
|
extern char keylist[][32]; /* from preflist.h */
|
| 38 |
11 |
bertin |
xmlstruct *xmlstack = NULL;
|
| 39 |
12 |
bertin |
int nxml=0, nxmlmax=0;
|
| 40 |
8 |
bertin |
|
| 41 |
|
|
/****** init_xml ************************************************************
|
| 42 |
|
|
PROTO int init_xml(void)
|
| 43 |
|
|
PURPOSE Initialize a set of meta-data kept in memory before being written to the
|
| 44 |
|
|
XML file
|
| 45 |
|
|
INPUT Number of image extensions.
|
| 46 |
|
|
OUTPUT RETURN_OK if everything went fine, RETURN_ERROR otherwise.
|
| 47 |
|
|
NOTES -.
|
| 48 |
|
|
AUTHOR E. Bertin (IAP)
|
| 49 |
|
|
VERSION 03/07/2006
|
| 50 |
|
|
***/
|
| 51 |
|
|
int init_xml(int next)
|
| 52 |
|
|
{
|
| 53 |
|
|
QMALLOC(xmlstack, xmlstruct, next);
|
| 54 |
|
|
nxml = 0;
|
| 55 |
|
|
nxmlmax = next;
|
| 56 |
|
|
|
| 57 |
|
|
return EXIT_SUCCESS;
|
| 58 |
|
|
}
|
| 59 |
|
|
|
| 60 |
15 |
bertin |
|
| 61 |
|
|
/****** end_xml ************************************************************
|
| 62 |
|
|
PROTO int end_xml(void)
|
| 63 |
|
|
PURPOSE Free the set of meta-data kept in memory.
|
| 64 |
|
|
INPUT -.
|
| 65 |
|
|
OUTPUT RETURN_OK if everything went fine, RETURN_ERROR otherwise.
|
| 66 |
|
|
NOTES -.
|
| 67 |
|
|
AUTHOR E. Bertin (IAP)
|
| 68 |
|
|
VERSION 12/07/2006
|
| 69 |
|
|
***/
|
| 70 |
|
|
int end_xml(void)
|
| 71 |
|
|
{
|
| 72 |
|
|
free(xmlstack);
|
| 73 |
|
|
|
| 74 |
|
|
return EXIT_SUCCESS;
|
| 75 |
|
|
}
|
| 76 |
|
|
|
| 77 |
8 |
bertin |
/****** update_xml ***********************************************************
|
| 78 |
|
|
PROTO int update_xml(void)
|
| 79 |
|
|
PURPOSE Update a set of meta-data kept in memory before being written to the
|
| 80 |
|
|
XML file
|
| 81 |
|
|
INPUT -.
|
| 82 |
|
|
OUTPUT RETURN_OK if everything went fine, RETURN_ERROR otherwise.
|
| 83 |
|
|
NOTES -.
|
| 84 |
|
|
AUTHOR E. Bertin (IAP)
|
| 85 |
173 |
bertin |
VERSION 19/12/2007
|
| 86 |
8 |
bertin |
***/
|
| 87 |
9 |
bertin |
int update_xml(sexcatstruct *sexcat, picstruct *dfield, picstruct *field,
|
| 88 |
|
|
picstruct *dwfield, picstruct *wfield)
|
| 89 |
8 |
bertin |
{
|
| 90 |
9 |
bertin |
xmlstruct *x;
|
| 91 |
|
|
|
| 92 |
|
|
if (nxml >= nxmlmax)
|
| 93 |
8 |
bertin |
error(EXIT_FAILURE, "*Internal Error*: too many extensions in XML stack",
|
| 94 |
|
|
"");
|
| 95 |
9 |
bertin |
x = &xmlstack[nxml++];
|
| 96 |
|
|
x->currext = sexcat->currext;
|
| 97 |
|
|
x->ndetect = sexcat->ndetect;
|
| 98 |
|
|
x->ntotal = sexcat->ntotal;
|
| 99 |
|
|
strcpy(x->ext_date, sexcat->ext_date);
|
| 100 |
|
|
strcpy(x->ext_time, sexcat->ext_time);
|
| 101 |
|
|
x->ext_elapsed = sexcat->ext_elapsed;
|
| 102 |
14 |
bertin |
strcpy(x->ident[0], dfield->ident);
|
| 103 |
|
|
strcpy(x->ident[1], field->ident);
|
| 104 |
|
|
x->backmean[0] = dfield->backmean;
|
| 105 |
|
|
x->backmean[1] = field->backmean;
|
| 106 |
|
|
x->backsig[0] = dfield->backsig;
|
| 107 |
|
|
x->backsig[1] = field->backsig;
|
| 108 |
|
|
x->sigfac[0] = dfield->sigfac;
|
| 109 |
|
|
x->sigfac[1] = field->sigfac;
|
| 110 |
|
|
x->thresh[0] = dfield->dthresh;
|
| 111 |
|
|
x->thresh[1] = field->thresh;
|
| 112 |
|
|
x->pixscale[0] = dfield->pixscale;
|
| 113 |
|
|
x->pixscale[1] = field->pixscale;
|
| 114 |
|
|
x->epoch[0] = dfield->epoch;
|
| 115 |
|
|
x->epoch[1] = field->epoch;
|
| 116 |
173 |
bertin |
x->gain[0] = dfield->gain;
|
| 117 |
|
|
x->gain[1] = field->gain;
|
| 118 |
|
|
x->satur_level[0] = dfield->satur_level;
|
| 119 |
|
|
x->satur_level[1] = field->satur_level;
|
| 120 |
8 |
bertin |
|
| 121 |
|
|
return EXIT_SUCCESS;
|
| 122 |
|
|
}
|
| 123 |
|
|
|
| 124 |
17 |
bertin |
|
| 125 |
8 |
bertin |
/****** write_xml ************************************************************
|
| 126 |
17 |
bertin |
PROTO int write_xml(char *filename)
|
| 127 |
|
|
PURPOSE Save meta-data to an XML file/stream.
|
| 128 |
16 |
bertin |
INPUT XML file name.
|
| 129 |
8 |
bertin |
OUTPUT RETURN_OK if everything went fine, RETURN_ERROR otherwise.
|
| 130 |
|
|
NOTES -.
|
| 131 |
|
|
AUTHOR E. Bertin (IAP)
|
| 132 |
17 |
bertin |
VERSION 14/07/2006
|
| 133 |
8 |
bertin |
***/
|
| 134 |
17 |
bertin |
int write_xml(char *filename)
|
| 135 |
8 |
bertin |
{
|
| 136 |
17 |
bertin |
FILE *file;
|
| 137 |
8 |
bertin |
|
| 138 |
17 |
bertin |
if (!(file = fopen(prefs.xml_name, "w")))
|
| 139 |
|
|
return RETURN_ERROR;
|
| 140 |
14 |
bertin |
|
| 141 |
17 |
bertin |
write_xml_header(file);
|
| 142 |
|
|
write_vo_fields(file);
|
| 143 |
14 |
bertin |
|
| 144 |
17 |
bertin |
fprintf(file, " <DATA>\n");
|
| 145 |
|
|
if (prefs.cat_type == FITS_LDAC || prefs.cat_type == FITS_TPX
|
| 146 |
|
|
|| prefs.cat_type == FITS_10)
|
| 147 |
|
|
fprintf(file,
|
| 148 |
|
|
" <FITS extnum=\"%d\"><STREAM href=\"%s%s\" /> </FITS>",
|
| 149 |
|
|
prefs.cat_type == FITS_10? 1:2,
|
| 150 |
|
|
prefs.cat_name[0] == '/'? "file://" : "file:",
|
| 151 |
|
|
prefs.cat_name);
|
| 152 |
|
|
fprintf(file, " </DATA>\n");
|
| 153 |
|
|
fprintf(file, " </TABLE>\n");
|
| 154 |
12 |
bertin |
|
| 155 |
17 |
bertin |
write_xml_meta(file, (char *)NULL);
|
| 156 |
14 |
bertin |
|
| 157 |
17 |
bertin |
fprintf(file, "</RESOURCE>\n");
|
| 158 |
|
|
fprintf(file, "</VOTABLE>\n");
|
| 159 |
12 |
bertin |
|
| 160 |
17 |
bertin |
fclose(file);
|
| 161 |
|
|
|
| 162 |
|
|
return RETURN_OK;
|
| 163 |
|
|
}
|
| 164 |
|
|
|
| 165 |
|
|
|
| 166 |
|
|
/****** write_xml_header ******************************************************
|
| 167 |
|
|
PROTO int write_xml_header(FILE *file)
|
| 168 |
|
|
PURPOSE Save an XML-VOtable header to an XML file/stream
|
| 169 |
|
|
INPUT file or stream pointer.
|
| 170 |
|
|
OUTPUT RETURN_OK if everything went fine, RETURN_ERROR otherwise.
|
| 171 |
|
|
NOTES -.
|
| 172 |
|
|
AUTHOR E. Bertin (IAP)
|
| 173 |
|
|
VERSION 14/07/2006
|
| 174 |
|
|
***/
|
| 175 |
|
|
int write_xml_header(FILE *file)
|
| 176 |
|
|
{
|
| 177 |
|
|
char *filename, *rfilename;
|
| 178 |
|
|
|
| 179 |
16 |
bertin |
/* A short, "relative" version of the filename */
|
| 180 |
|
|
filename = prefs.image_name[prefs.nimage_name>1? 1:0];
|
| 181 |
|
|
if (!(rfilename = strrchr(filename, '/')))
|
| 182 |
|
|
rfilename = filename;
|
| 183 |
|
|
else
|
| 184 |
|
|
rfilename++;
|
| 185 |
|
|
|
| 186 |
|
|
fprintf(file, "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n");
|
| 187 |
17 |
bertin |
fprintf(file, "<?xml-stylesheet type=\"text/xsl\" href=\"%s\"?>\n",
|
| 188 |
|
|
prefs.xsl_name);
|
| 189 |
13 |
bertin |
fprintf(file, "<VOTABLE "
|
| 190 |
|
|
"xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" "
|
| 191 |
|
|
"xsi:noNamespaceSchemaLocation="
|
| 192 |
17 |
bertin |
"\"http://www.ivoa.net/xml/VOTable/v1.1\">\n");
|
| 193 |
16 |
bertin |
fprintf(file, "<DESCRIPTION>produced by %s</DESCRIPTION>\n", BANNER);
|
| 194 |
|
|
fprintf(file, "<!-- VOTable description at "
|
| 195 |
|
|
"http://www.ivoa.net/Documents/latest/VOT.html -->\n");
|
| 196 |
17 |
bertin |
fprintf(file, "<RESOURCE ID=\"%s\" name=\"%s\">\n", BANNER, rfilename);
|
| 197 |
16 |
bertin |
fprintf(file, " <DESCRIPTION>Catalog of sources extracted with %s"
|
| 198 |
|
|
"</DESCRIPTION>\n", BANNER);
|
| 199 |
|
|
fprintf(file, " <INFO name=\"QUERY_STATUS\" value=\"OK\" />\n");
|
| 200 |
|
|
fprintf(file, " <COOSYS ID=\"J2000\" equinox=\"J2000\""
|
| 201 |
|
|
" epoch=\"J%.10g\" system=\"%s\"/>\n", prefs.epoch, prefs.coosys);
|
| 202 |
|
|
fprintf(file, " <TABLE ID=\"Source_List\" name=\"%s/out\">\n", rfilename);
|
| 203 |
|
|
fprintf(file,
|
| 204 |
|
|
" <DESCRIPTION>Table of sources detected in image</DESCRIPTION>\n");
|
| 205 |
|
|
fprintf(file,
|
| 206 |
|
|
" <!-- Now comes the definition of each %s parameter -->\n", BANNER);
|
| 207 |
|
|
|
| 208 |
15 |
bertin |
return RETURN_OK;
|
| 209 |
|
|
}
|
| 210 |
|
|
|
| 211 |
|
|
|
| 212 |
|
|
/****** write_xml_meta ********************************************************
|
| 213 |
16 |
bertin |
PROTO int write_xml_meta(FILE *file, char *error)
|
| 214 |
15 |
bertin |
PURPOSE Save meta-data to an XML-VOTable file or stream
|
| 215 |
16 |
bertin |
INPUT Pointer to the output file (or stream),
|
| 216 |
|
|
Pointer to an error msg (or NULL).
|
| 217 |
15 |
bertin |
OUTPUT RETURN_OK if everything went fine, RETURN_ERROR otherwise.
|
| 218 |
|
|
NOTES -.
|
| 219 |
|
|
AUTHOR E. Bertin (IAP)
|
| 220 |
219 |
bertin |
VERSION 21/01/2010
|
| 221 |
15 |
bertin |
***/
|
| 222 |
16 |
bertin |
int write_xml_meta(FILE *file, char *error)
|
| 223 |
15 |
bertin |
{
|
| 224 |
|
|
char *pspath,*psuser, *pshost, *str;
|
| 225 |
16 |
bertin |
struct tm *tm;
|
| 226 |
15 |
bertin |
int n;
|
| 227 |
|
|
|
| 228 |
16 |
bertin |
/* Processing date and time if msg error present */
|
| 229 |
|
|
if (error)
|
| 230 |
|
|
{
|
| 231 |
|
|
thetimet2 = time(NULL);
|
| 232 |
|
|
tm = localtime(&thetimet2);
|
| 233 |
|
|
sprintf(prefs.sdate_end,"%04d-%02d-%02d",
|
| 234 |
|
|
tm->tm_year+1900, tm->tm_mon+1, tm->tm_mday);
|
| 235 |
|
|
sprintf(prefs.stime_end,"%02d:%02d:%02d",
|
| 236 |
|
|
tm->tm_hour, tm->tm_min, tm->tm_sec);
|
| 237 |
|
|
prefs.time_diff = difftime(thetimet2, thetimet);
|
| 238 |
|
|
}
|
| 239 |
|
|
|
| 240 |
15 |
bertin |
/* Username */
|
| 241 |
|
|
psuser = pspath = pshost = NULL;
|
| 242 |
|
|
#ifdef HAVE_GETENV
|
| 243 |
|
|
if (!(psuser=getenv("USERNAME"))) /* Cygwin,... */
|
| 244 |
|
|
psuser = getenv("LOGNAME"); /* Linux,... */
|
| 245 |
|
|
pspath = getenv("PWD");
|
| 246 |
|
|
pshost = getenv("HOSTNAME");
|
| 247 |
|
|
#endif
|
| 248 |
|
|
|
| 249 |
16 |
bertin |
fprintf(file, " <RESOURCE ID=\"MetaData\" name=\"MetaData\">\n");
|
| 250 |
13 |
bertin |
fprintf(file, " <DESCRIPTION>%s meta-data</DESCRIPTION>\n", BANNER);
|
| 251 |
15 |
bertin |
fprintf(file, " <INFO name=\"QUERY_STATUS\" value=\"OK\" />\n");
|
| 252 |
16 |
bertin |
fprintf(file, " <PARAM name=\"Software\" datatype=\"char\" arraysize=\"*\""
|
| 253 |
13 |
bertin |
" ucd=\"meta.title;meta.software\" value=\"%s\"/>\n",
|
| 254 |
|
|
BANNER);
|
| 255 |
16 |
bertin |
fprintf(file, " <PARAM name=\"Version\" datatype=\"char\" arraysize=\"*\""
|
| 256 |
13 |
bertin |
" ucd=\"meta.version;meta.software\" value=\"%s\"/>\n",
|
| 257 |
|
|
MYVERSION);
|
| 258 |
16 |
bertin |
fprintf(file, " <PARAM name=\"Soft_URL\" datatype=\"char\" arraysize=\"*\""
|
| 259 |
13 |
bertin |
" ucd=\"meta.ref.url;meta.software\" value=\"%s\"/>\n",
|
| 260 |
|
|
WEBSITE);
|
| 261 |
16 |
bertin |
fprintf(file, " <PARAM name=\"Soft_Auth\" datatype=\"char\" arraysize=\"*\""
|
| 262 |
13 |
bertin |
" ucd=\"meta.bib.author;meta.software\" value=\"%s\"/>\n",
|
| 263 |
|
|
"Emmanuel Bertin");
|
| 264 |
16 |
bertin |
fprintf(file, " <PARAM name=\"Soft_Ref\" datatype=\"char\" arraysize=\"*\""
|
| 265 |
13 |
bertin |
" ucd=\"meta.bib.bibcode;meta.software\" value=\"%s\"/>\n",
|
| 266 |
16 |
bertin |
"1996A&AS..117..393B");
|
| 267 |
|
|
fprintf(file, " <PARAM name=\"NThreads\" datatype=\"int\""
|
| 268 |
14 |
bertin |
" ucd=\"meta.number;meta.software\" value=\"%d\"/>\n",
|
| 269 |
13 |
bertin |
prefs.nthreads);
|
| 270 |
16 |
bertin |
fprintf(file, " <PARAM name=\"Date\" datatype=\"char\" arraysize=\"*\""
|
| 271 |
13 |
bertin |
" ucd=\"time.event.end;meta.software\" value=\"%s\"/>\n",
|
| 272 |
|
|
prefs.sdate_end);
|
| 273 |
16 |
bertin |
fprintf(file, " <PARAM name=\"Time\" datatype=\"char\" arraysize=\"*\""
|
| 274 |
13 |
bertin |
" ucd=\"time.event.end;meta.software\" value=\"%s\"/>\n",
|
| 275 |
|
|
prefs.stime_end);
|
| 276 |
16 |
bertin |
fprintf(file, " <PARAM name=\"Duration\" datatype=\"float\""
|
| 277 |
13 |
bertin |
" ucd=\"time.event;meta.software\" value=\"%.0f\" unit=\"s\"/>\n",
|
| 278 |
|
|
prefs.time_diff);
|
| 279 |
|
|
|
| 280 |
16 |
bertin |
fprintf(file, " <PARAM name=\"User\" datatype=\"char\" arraysize=\"*\""
|
| 281 |
13 |
bertin |
" ucd=\"meta.curation\" value=\"%s\"/>\n",
|
| 282 |
|
|
psuser);
|
| 283 |
16 |
bertin |
fprintf(file, " <PARAM name=\"Host\" datatype=\"char\" arraysize=\"*\""
|
| 284 |
13 |
bertin |
" ucd=\"meta.curation\" value=\"%s\"/>\n",
|
| 285 |
|
|
pshost);
|
| 286 |
16 |
bertin |
fprintf(file, " <PARAM name=\"Path\" datatype=\"char\" arraysize=\"*\""
|
| 287 |
13 |
bertin |
" ucd=\"meta.dataset\" value=\"%s\"/>\n",
|
| 288 |
|
|
pspath);
|
| 289 |
|
|
|
| 290 |
15 |
bertin |
fprintf(file,
|
| 291 |
17 |
bertin |
" <PARAM name=\"Image_Name\" datatype=\"char\" arraysize=\"*\""
|
| 292 |
15 |
bertin |
" ucd=\"obs.image;meta.fits\" value=\"%s", prefs.image_name[0]);
|
| 293 |
|
|
if (prefs.nimage_name>1)
|
| 294 |
|
|
fprintf(file, ",%s", prefs.image_name[1]);
|
| 295 |
|
|
fprintf(file, "\"/>\n");
|
| 296 |
16 |
bertin |
|
| 297 |
|
|
if (error)
|
| 298 |
17 |
bertin |
{
|
| 299 |
|
|
fprintf(file, "\n <!-- !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"
|
| 300 |
|
|
"!!!!!!!!!!!!!!!!!!!! -->\n");
|
| 301 |
|
|
fprintf(file, " <!-- !!!!!!!!!!!!!!!!!!!!!! an Error occured"
|
| 302 |
|
|
" !!!!!!!!!!!!!!!!!!!!! -->\n");
|
| 303 |
|
|
fprintf(file, " <!-- !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"
|
| 304 |
|
|
"!!!!!!!!!!!!!!!!!!!! -->\n");
|
| 305 |
16 |
bertin |
fprintf(file," <PARAM name=\"Error_Msg\" datatype=\"char\" arraysize=\"*\""
|
| 306 |
|
|
" ucd=\"meta\" value=\"%s\"/>\n", error);
|
| 307 |
17 |
bertin |
fprintf(file, " <!-- !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"
|
| 308 |
|
|
"!!!!!!!!!!!!!!!!!!!! -->\n");
|
| 309 |
|
|
fprintf(file, " <!-- !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"
|
| 310 |
|
|
"!!!!!!!!!!!!!!!!!!!! -->\n\n");
|
| 311 |
|
|
}
|
| 312 |
16 |
bertin |
|
| 313 |
|
|
/* Meta-data for each extension */
|
| 314 |
|
|
fprintf(file, " <TABLE ID=\"Extension_Data\" name=\"Extension_Data\">\n");
|
| 315 |
|
|
fprintf(file, " <DESCRIPTION>Data gathered by %s for every FITS"
|
| 316 |
|
|
" extension</DESCRIPTION>\n", BANNER);
|
| 317 |
|
|
fprintf(file, " <!-- NExtensions may be 0"
|
| 318 |
|
|
" if an error occurred early in the processing -->\n");
|
| 319 |
|
|
fprintf(file, " <PARAM name=\"NExtensions\" datatype=\"int\""
|
| 320 |
|
|
" ucd=\"meta.number;meta.dataset\" value=\"%d\"/>\n",
|
| 321 |
|
|
nxmlmax);
|
| 322 |
|
|
fprintf(file, " <!-- CurrExtension may differ fromq n_extensions"
|
| 323 |
|
|
" if an error occurred -->\n");
|
| 324 |
|
|
fprintf(file, " <PARAM name=\"CurrExtension\" datatype=\"int\""
|
| 325 |
|
|
" ucd=\"meta.number;meta.dataset\" value=\"%d\"/>\n",
|
| 326 |
|
|
nxml);
|
| 327 |
|
|
fprintf(file, " <FIELD name=\"Extension\" datatype=\"int\""
|
| 328 |
|
|
" ucd=\"meta.record\"/>\n");
|
| 329 |
|
|
fprintf(file, " <FIELD name=\"Date\" datatype=\"char\" arraysize=\"*\""
|
| 330 |
|
|
" ucd=\"meta.record;time.event.end\"/>\n");
|
| 331 |
|
|
fprintf(file, " <FIELD name=\"Time\" datatype=\"char\" arraysize=\"*\""
|
| 332 |
|
|
" ucd=\"meta.record;time.event.end\"/>\n");
|
| 333 |
|
|
fprintf(file, " <FIELD name=\"Duration\" datatype=\"float\""
|
| 334 |
|
|
" ucd=\"meta.record;time.event.end\"/>\n");
|
| 335 |
|
|
fprintf(file, " <FIELD name=\"NDetect\" datatype=\"int\""
|
| 336 |
|
|
" ucd=\"meta.number;src.sample\"/>\n");
|
| 337 |
|
|
fprintf(file, " <FIELD name=\"NSextracted\" datatype=\"int\""
|
| 338 |
|
|
" ucd=\"meta.number;src.sample\"/>\n");
|
| 339 |
|
|
fprintf(file, " <FIELD name=\"Image_Ident\" datatype=\"char\""
|
| 340 |
17 |
bertin |
" arraysize=\"*\" ucd=\"meta.id;obs\"/>\n");
|
| 341 |
16 |
bertin |
fprintf(file, " <FIELD name=\"Background_Mean\" datatype=\"float\""
|
| 342 |
|
|
" arraysize=\"%d\" ucd=\"instr.skyLevel;obs.image;stat.median\""
|
| 343 |
|
|
" unit=\"ct\"/>\n", prefs.nimage_name);
|
| 344 |
|
|
fprintf(file, " <FIELD name=\"Background_StDev\" datatype=\"float\""
|
| 345 |
|
|
" arraysize=\"%d\" ucd=\"stat.stdev;obs.image;stat.median\""
|
| 346 |
|
|
" unit=\"ct\"/>\n", prefs.nimage_name);
|
| 347 |
|
|
fprintf(file, " <FIELD name=\"Threshold\" datatype=\"float\""
|
| 348 |
|
|
" arraysize=\"%d\" ucd=\"instr.sensitivity;obs.image;stat.median\""
|
| 349 |
|
|
" unit=\"ct\"/>\n", prefs.nimage_name);
|
| 350 |
|
|
fprintf(file, " <FIELD name=\"Weight_Scaling\" datatype=\"float\""
|
| 351 |
|
|
" arraysize=\"%d\" ucd=\"arith.factor;obs.image;stat.median\"/>\n",
|
| 352 |
|
|
prefs.nimage_name);
|
| 353 |
|
|
fprintf(file, " <FIELD name=\"Pixel_Scale\" datatype=\"float\""
|
| 354 |
|
|
" arraysize=\"%d\" ucd=\"instr.scale;obs.image;stat.mean\""
|
| 355 |
|
|
" unit=\"arcsec\"/>\n", prefs.nimage_name);
|
| 356 |
|
|
fprintf(file, " <FIELD name=\"Epoch\" datatype=\"float\""
|
| 357 |
|
|
" arraysize=\"%d\" ucd=\"time.epoch;obs\" unit=\"yr\"/>\n",
|
| 358 |
|
|
prefs.nimage_name);
|
| 359 |
173 |
bertin |
fprintf(file, " <FIELD name=\"Gain\" datatype=\"float\""
|
| 360 |
|
|
" arraysize=\"%d\" ucd=\"instr.param;obs.param\"/>\n",
|
| 361 |
|
|
prefs.nimage_name);
|
| 362 |
|
|
fprintf(file, " <FIELD name=\"Satur_Level\" datatype=\"float\""
|
| 363 |
|
|
" arraysize=\"%d\" ucd=\"instr.saturation;phot.count\" unit=\"ct\"/>\n",
|
| 364 |
|
|
prefs.nimage_name);
|
| 365 |
16 |
bertin |
fprintf(file, " <DATA><TABLEDATA>\n");
|
| 366 |
|
|
for (n=0; n<nxml; n++)
|
| 367 |
|
|
if (prefs.nimage_name>1)
|
| 368 |
|
|
fprintf(file, " <TR>\n"
|
| 369 |
|
|
" <TD>%d</TD><TD>%s</TD><TD>%s</TD><TD>%.0f</TD>"
|
| 370 |
|
|
"<TD>%d</TD><TD>%d</TD>\n"
|
| 371 |
173 |
bertin |
" <TD>%s,%s</TD><TD>%g %g</TD>\n"
|
| 372 |
16 |
bertin |
" <TD>%g %g</TD><TD>%g %g</TD><TD>%g %g</TD>"
|
| 373 |
173 |
bertin |
"<TD>%g %g</TD><TD>%f %f</TD>\n"
|
| 374 |
|
|
" <TD>%g %g</TD><TD>%g %g</TD>\n"
|
| 375 |
16 |
bertin |
" </TR>\n",
|
| 376 |
|
|
xmlstack[n].currext,
|
| 377 |
|
|
xmlstack[n].ext_date,
|
| 378 |
|
|
xmlstack[n].ext_time,
|
| 379 |
|
|
xmlstack[n].ext_elapsed,
|
| 380 |
|
|
xmlstack[n].ndetect,
|
| 381 |
|
|
xmlstack[n].ntotal,
|
| 382 |
|
|
xmlstack[n].ident[0], xmlstack[n].ident[1],
|
| 383 |
|
|
xmlstack[n].backmean[0], xmlstack[n].backmean[1],
|
| 384 |
|
|
xmlstack[n].backsig[0], xmlstack[n].backsig[1],
|
| 385 |
|
|
xmlstack[n].sigfac[0], xmlstack[n].sigfac[1],
|
| 386 |
|
|
xmlstack[n].thresh[0], xmlstack[n].thresh[1],
|
| 387 |
173 |
bertin |
xmlstack[n].pixscale[0], xmlstack[n].pixscale[1],
|
| 388 |
|
|
xmlstack[n].epoch[0], xmlstack[n].epoch[1],
|
| 389 |
|
|
xmlstack[n].gain[0], xmlstack[n].gain[1],
|
| 390 |
|
|
xmlstack[n].satur_level[0], xmlstack[n].satur_level[1]);
|
| 391 |
16 |
bertin |
else
|
| 392 |
|
|
fprintf(file, " <TR>\n"
|
| 393 |
|
|
" <TD>%d</TD><TD>%s</TD><TD>%s</TD><TD>%.0f</TD>"
|
| 394 |
|
|
"<TD>%d</TD><TD>%d</TD>\n"
|
| 395 |
173 |
bertin |
" <TD>%s</TD><TD>%g</TD>\n"
|
| 396 |
|
|
" <TD>%g</TD><TD>%g</TD><TD>%g</TD><TD>%g</TD><TD>%f</TD>\n"
|
| 397 |
|
|
" <TD>%g</TD><TD>%g</TD>\n"
|
| 398 |
16 |
bertin |
" </TR>\n",
|
| 399 |
|
|
xmlstack[n].currext,
|
| 400 |
|
|
xmlstack[n].ext_date,
|
| 401 |
|
|
xmlstack[n].ext_time,
|
| 402 |
|
|
xmlstack[n].ext_elapsed,
|
| 403 |
|
|
xmlstack[n].ndetect,
|
| 404 |
|
|
xmlstack[n].ntotal,
|
| 405 |
|
|
xmlstack[n].ident[0],
|
| 406 |
|
|
xmlstack[n].backmean[0],
|
| 407 |
|
|
xmlstack[n].backsig[0],
|
| 408 |
|
|
xmlstack[n].sigfac[0],
|
| 409 |
|
|
xmlstack[n].thresh[0],
|
| 410 |
173 |
bertin |
xmlstack[n].pixscale[0],
|
| 411 |
|
|
xmlstack[n].epoch[0],
|
| 412 |
|
|
xmlstack[n].gain[0],
|
| 413 |
|
|
xmlstack[n].satur_level[0]);
|
| 414 |
16 |
bertin |
fprintf(file, " </TABLEDATA></DATA>\n");
|
| 415 |
|
|
fprintf(file, " </TABLE>\n");
|
| 416 |
|
|
|
| 417 |
|
|
/* Warnings */
|
| 418 |
|
|
fprintf(file, " <TABLE ID=\"Warnings\" name=\"Warnings\">\n");
|
| 419 |
|
|
fprintf(file,
|
| 420 |
|
|
" <DESCRIPTION>%s warnings (limited to the last %d)</DESCRIPTION>\n",
|
| 421 |
|
|
BANNER, WARNING_NMAX);
|
| 422 |
|
|
fprintf(file, " <FIELD name=\"Date\" datatype=\"char\" arraysize=\"*\""
|
| 423 |
|
|
" ucd=\"meta;time.event.end\"/>\n");
|
| 424 |
|
|
fprintf(file, " <FIELD name=\"Time\" datatype=\"char\" arraysize=\"*\""
|
| 425 |
|
|
" ucd=\"meta;time.event.end\"/>\n");
|
| 426 |
|
|
fprintf(file, " <FIELD name=\"Msg\" datatype=\"char\" arraysize=\"*\""
|
| 427 |
|
|
" ucd=\"meta\"/>\n");
|
| 428 |
|
|
fprintf(file, " <DATA><TABLEDATA>\n");
|
| 429 |
|
|
for (str = warning_history(); *str; str = warning_history())
|
| 430 |
|
|
fprintf(file, " <TR><TD>%10.10s</TD><TD>%8.8s</TD><TD>%s</TD></TR>\n",
|
| 431 |
|
|
str, str+11, str+22);
|
| 432 |
|
|
fprintf(file, " </TABLEDATA></DATA>\n");
|
| 433 |
|
|
fprintf(file, " </TABLE>\n");
|
| 434 |
|
|
|
| 435 |
|
|
/* Configuration file */
|
| 436 |
|
|
fprintf(file, " <RESOURCE ID=\"Config\" name=\"Config\">\n");
|
| 437 |
13 |
bertin |
fprintf(file, " <DESCRIPTION>%s configuration</DESCRIPTION>\n", BANNER);
|
| 438 |
|
|
fprintf(file,
|
| 439 |
16 |
bertin |
" <PARAM name=\"Command_Line\" datatype=\"char\" arraysize=\"*\""
|
| 440 |
14 |
bertin |
" ucd=\"obs.param\" value=\"%s",
|
| 441 |
13 |
bertin |
prefs.command_line[0]);
|
| 442 |
|
|
for (n=1; n<prefs.ncommand_line; n++)
|
| 443 |
|
|
fprintf(file, " %s", prefs.command_line[n]);
|
| 444 |
|
|
fprintf(file, "\"/>\n");
|
| 445 |
|
|
fprintf(file,
|
| 446 |
16 |
bertin |
" <PARAM name=\"Prefs_Name\" datatype=\"char\" arraysize=\"*\""
|
| 447 |
14 |
bertin |
" ucd=\"obs.param;meta.file\" value=\"%s\"/>\n",
|
| 448 |
13 |
bertin |
prefs.prefs_name);
|
| 449 |
16 |
bertin |
|
| 450 |
|
|
if (!error)
|
| 451 |
|
|
{
|
| 452 |
|
|
fprintf(file,
|
| 453 |
|
|
" <PARAM name=\"Catalog_Type\" datatype=\"char\" arraysize=\"*\""
|
| 454 |
13 |
bertin |
" ucd=\"meta\" value=\"%s\"/>\n",
|
| 455 |
|
|
key[findkeys("CATALOG_TYPE",keylist,
|
| 456 |
|
|
FIND_STRICT)].keylist[prefs.cat_type]);
|
| 457 |
16 |
bertin |
fprintf(file,
|
| 458 |
|
|
" <PARAM name=\"Catalog_Name\" datatype=\"char\" arraysize=\"*\""
|
| 459 |
14 |
bertin |
" ucd=\"meta.dataset;meta.file\" value=\"%s\"/>\n",
|
| 460 |
13 |
bertin |
prefs.cat_name);
|
| 461 |
16 |
bertin |
fprintf(file,
|
| 462 |
|
|
" <PARAM name=\"Parameters_Name\" datatype=\"char\" arraysize=\"*\""
|
| 463 |
14 |
bertin |
" ucd=\"obs.param;meta.file\" value=\"%s\"/>\n",
|
| 464 |
13 |
bertin |
prefs.param_name);
|
| 465 |
16 |
bertin |
fprintf(file,
|
| 466 |
|
|
" <PARAM name=\"Detect_Type\" datatype=\"char\" arraysize=\"*\""
|
| 467 |
14 |
bertin |
" ucd=\"meta.code;instr.det;obs.param\" value=\"%s\"/>\n",
|
| 468 |
13 |
bertin |
key[findkeys("DETECT_TYPE", keylist,
|
| 469 |
|
|
FIND_STRICT)].keylist[prefs.detect_type]);
|
| 470 |
16 |
bertin |
fprintf(file, " <PARAM name=\"Detect_MinArea\" datatype=\"int\""
|
| 471 |
219 |
bertin |
" ucd=\"phys.area;stat.min;obs.param;\" value=\"%d\" unit=\"pix2\"/>\n",
|
| 472 |
13 |
bertin |
prefs.ext_minarea);
|
| 473 |
14 |
bertin |
|
| 474 |
219 |
bertin |
fprintf(file, " <PARAM name=\"Detect_MaxArea\" datatype=\"int\""
|
| 475 |
|
|
" ucd=\"phys.area;stat.max;obs.param\" value=\"%d\" unit=\"pix2\"/>\n",
|
| 476 |
|
|
prefs.ext_maxarea);
|
| 477 |
|
|
|
| 478 |
16 |
bertin |
fprintf(file,
|
| 479 |
17 |
bertin |
" <PARAM name=\"Thresh_Type\" datatype=\"char\" arraysize=\"*\""
|
| 480 |
14 |
bertin |
" ucd=\"meta.code;instr.sensitivity;obs.param\" value=\"%s",
|
| 481 |
|
|
key[findkeys("THRESH_TYPE", keylist,
|
| 482 |
|
|
FIND_STRICT)].keylist[prefs.thresh_type[0]]);
|
| 483 |
16 |
bertin |
if (prefs.nthresh_type>1)
|
| 484 |
|
|
fprintf(file, ",%s", key[findkeys("THRESH_TYPE", keylist,
|
| 485 |
14 |
bertin |
FIND_STRICT)].keylist[prefs.thresh_type[1]]);
|
| 486 |
16 |
bertin |
fprintf(file, "\"/>\n");
|
| 487 |
14 |
bertin |
|
| 488 |
16 |
bertin |
fprintf(file, " <PARAM name=\"Detect_Thresh\" datatype=\"float\""
|
| 489 |
14 |
bertin |
" arraysize=\"%d\" ucd=\"instr.sensitivity;obs.param\" value=\"%g",
|
| 490 |
|
|
prefs.ndthresh, prefs.dthresh[0]);
|
| 491 |
16 |
bertin |
if (prefs.ndthresh>1)
|
| 492 |
|
|
fprintf(file, " %g", prefs.dthresh[1]);
|
| 493 |
|
|
fprintf(file, "\"/>\n");
|
| 494 |
14 |
bertin |
|
| 495 |
16 |
bertin |
fprintf(file, " <PARAM name=\"Analysis_Thresh\" datatype=\"float\""
|
| 496 |
14 |
bertin |
" arraysize=\"%d\" ucd=\"instr.sensitivity;obs.param\" value=\"%g",
|
| 497 |
|
|
prefs.nthresh, prefs.thresh[0]);
|
| 498 |
16 |
bertin |
if (prefs.nthresh>1)
|
| 499 |
|
|
fprintf(file, " %g", prefs.thresh[1]);
|
| 500 |
|
|
fprintf(file, "\"/>\n");
|
| 501 |
14 |
bertin |
|
| 502 |
16 |
bertin |
fprintf(file,
|
| 503 |
|
|
" <PARAM name=\"Filter\" datatype=\"boolean\""
|
| 504 |
14 |
bertin |
" ucd=\"meta.code;obs.param\" value=\"%c\"/>\n",
|
| 505 |
|
|
prefs.filter_flag? 'T':'F');
|
| 506 |
16 |
bertin |
fprintf(file,
|
| 507 |
|
|
" <PARAM name=\"Filter_Name\" datatype=\"char\" arraysize=\"*\""
|
| 508 |
14 |
bertin |
" ucd=\"meta.dataset;meta.file;obs.param\" value=\"%s\"/>\n",
|
| 509 |
|
|
prefs.filter_name);
|
| 510 |
|
|
|
| 511 |
16 |
bertin |
if (prefs.nfilter_thresh)
|
| 512 |
|
|
{
|
| 513 |
|
|
fprintf(file, " <PARAM name=\"Filter_Thresh\" datatype=\"float\""
|
| 514 |
14 |
bertin |
" arraysize=\"%d\" ucd=\"instr.sensitivity;obs.param\" value=\"%g",
|
| 515 |
|
|
prefs.nfilter_thresh, prefs.filter_thresh[0]);
|
| 516 |
16 |
bertin |
if (prefs.nfilter_thresh>1)
|
| 517 |
|
|
fprintf(file, " %g", prefs.filter_thresh[1]);
|
| 518 |
|
|
fprintf(file, "\"/>\n");
|
| 519 |
|
|
}
|
| 520 |
14 |
bertin |
|
| 521 |
16 |
bertin |
fprintf(file, " <PARAM name=\"Deblend_NThresh\" datatype=\"int\""
|
| 522 |
14 |
bertin |
" ucd=\"meta.number;obs.param\" value=\"%d\"/>\n",
|
| 523 |
13 |
bertin |
prefs.deblend_nthresh);
|
| 524 |
16 |
bertin |
fprintf(file, " <PARAM name=\"Deblend_MinCont\" datatype=\"float\""
|
| 525 |
14 |
bertin |
" ucd=\"obs.param;arith.ratio\" value=\"%g\"/>\n",
|
| 526 |
13 |
bertin |
prefs.deblend_mincont);
|
| 527 |
16 |
bertin |
fprintf(file,
|
| 528 |
|
|
" <PARAM name=\"Clean\" datatype=\"boolean\""
|
| 529 |
14 |
bertin |
" ucd=\"meta.code;obs.param\" value=\"%c\"/>\n",
|
| 530 |
|
|
prefs.clean_flag? 'T':'F');
|
| 531 |
16 |
bertin |
fprintf(file, " <PARAM name=\"Clean_Param\" datatype=\"float\""
|
| 532 |
14 |
bertin |
" ucd=\"meta\" value=\"%g\"/>\n",
|
| 533 |
|
|
prefs.clean_param);
|
| 534 |
16 |
bertin |
fprintf(file,
|
| 535 |
|
|
" <PARAM name=\"Mask_Type\" datatype=\"char\" arraysize=\"*\""
|
| 536 |
14 |
bertin |
" ucd=\"meta.code;obs.param;\" value=\"%s\"/>\n",
|
| 537 |
|
|
key[findkeys("MASK_TYPE", keylist,
|
| 538 |
|
|
FIND_STRICT)].keylist[prefs.mask_type]);
|
| 539 |
13 |
bertin |
|
| 540 |
16 |
bertin |
fprintf(file,
|
| 541 |
17 |
bertin |
" <PARAM name=\"Weight_Type\" datatype=\"char\" arraysize=\"*\""
|
| 542 |
14 |
bertin |
" ucd=\"meta.code;obs.param\" value=\"%s",
|
| 543 |
|
|
key[findkeys("WEIGHT_TYPE", keylist,
|
| 544 |
|
|
FIND_STRICT)].keylist[prefs.weight_type[0]]);
|
| 545 |
16 |
bertin |
if (prefs.nweight_type>1)
|
| 546 |
|
|
fprintf(file, ",%s", key[findkeys("WEIGHT_TYPE", keylist,
|
| 547 |
14 |
bertin |
FIND_STRICT)].keylist[prefs.weight_type[1]]);
|
| 548 |
16 |
bertin |
fprintf(file, "\"/>\n");
|
| 549 |
14 |
bertin |
|
| 550 |
16 |
bertin |
fprintf(file, " <PARAM name=\"Weight_Thresh\" datatype=\"float\""
|
| 551 |
14 |
bertin |
" arraysize=\"%d\" ucd=\"instr.sensitivity;obs.param\" value=\"%g",
|
| 552 |
|
|
prefs.nweight_thresh, prefs.weight_thresh[0]);
|
| 553 |
16 |
bertin |
if (prefs.nweight_thresh>1)
|
| 554 |
|
|
fprintf(file, " %g", prefs.weight_thresh[1]);
|
| 555 |
|
|
fprintf(file, "\"/>\n");
|
| 556 |
14 |
bertin |
|
| 557 |
16 |
bertin |
if ((prefs.weight_type[0] != WEIGHT_NONE
|
| 558 |
14 |
bertin |
&& prefs.weight_type[0] != WEIGHT_FROMBACK)
|
| 559 |
|
|
|| (prefs.weight_type[1] != WEIGHT_NONE
|
| 560 |
|
|
&& prefs.weight_type[1] != WEIGHT_FROMBACK))
|
| 561 |
16 |
bertin |
{
|
| 562 |
|
|
fprintf(file,
|
| 563 |
17 |
bertin |
" <PARAM name=\"Weight_Image\" datatype=\"char\" arraysize=\"*\""
|
| 564 |
14 |
bertin |
" ucd=\"obs.image;meta.fits;obs.param\" value=\"%s",
|
| 565 |
|
|
(prefs.weight_type[0] != WEIGHT_NONE
|
| 566 |
|
|
&& prefs.weight_type[0] != WEIGHT_FROMBACK) ?
|
| 567 |
|
|
prefs.wimage_name[0] : NULL);
|
| 568 |
16 |
bertin |
if (prefs.weight_type[1] != WEIGHT_NONE
|
| 569 |
14 |
bertin |
&& prefs.weight_type[1] != WEIGHT_FROMBACK)
|
| 570 |
16 |
bertin |
fprintf(file, ",%s", prefs.wimage_name[1]);
|
| 571 |
|
|
fprintf(file, "\"/>\n");
|
| 572 |
|
|
}
|
| 573 |
14 |
bertin |
|
| 574 |
16 |
bertin |
fprintf(file,
|
| 575 |
|
|
" <PARAM name=\"Weight_Gain\" datatype=\"boolean\""
|
| 576 |
14 |
bertin |
" ucd=\"meta.code;obs.param\" value=\"%c\"/>\n",
|
| 577 |
|
|
prefs.weightgain_flag? 'T':'F');
|
| 578 |
|
|
|
| 579 |
16 |
bertin |
if (prefs.nimaflag)
|
| 580 |
|
|
{
|
| 581 |
|
|
fprintf(file,
|
| 582 |
17 |
bertin |
" <PARAM name=\"Flag_Image\" datatype=\"char\" arraysize=\"*\""
|
| 583 |
14 |
bertin |
" ucd=\"obs.image;meta.fits\" value=\"%s",
|
| 584 |
|
|
prefs.fimage_name[0]);
|
| 585 |
16 |
bertin |
for (n=1; n<prefs.nimaflag; n++)
|
| 586 |
|
|
fprintf(file, ",%s", prefs.fimage_name[n]);
|
| 587 |
|
|
fprintf(file, "\"/>\n");
|
| 588 |
|
|
fprintf(file,
|
| 589 |
17 |
bertin |
" <PARAM name=\"Flag_Type\" datatype=\"char\" arraysize=\"*\""
|
| 590 |
14 |
bertin |
" ucd=\"meta.code\" value=\"%s",
|
| 591 |
|
|
key[findkeys("FLAG_TYPE", keylist,
|
| 592 |
|
|
FIND_STRICT)].keylist[prefs.flag_type[0]]);
|
| 593 |
16 |
bertin |
for (n=1; n<prefs.nimaflag; n++)
|
| 594 |
|
|
fprintf(file, ",%s", key[findkeys("FLAG_TYPE", keylist,
|
| 595 |
14 |
bertin |
FIND_STRICT)].keylist[prefs.flag_type[n]]);
|
| 596 |
16 |
bertin |
fprintf(file, "\"/>\n");
|
| 597 |
|
|
}
|
| 598 |
14 |
bertin |
|
| 599 |
16 |
bertin |
fprintf(file, " <PARAM name=\"Phot_Apertures\" datatype=\"float\""
|
| 600 |
14 |
bertin |
" arraysize=\"%d\" ucd=\"obs.param\" value=\"%g",
|
| 601 |
|
|
prefs.naper, prefs.apert[0]);
|
| 602 |
16 |
bertin |
for (n=1; n<prefs.naper; n++)
|
| 603 |
|
|
fprintf(file, " %g", prefs.apert[n]);
|
| 604 |
|
|
fprintf(file, "\" unit=\"pix\"/>\n");
|
| 605 |
14 |
bertin |
|
| 606 |
16 |
bertin |
fprintf(file, " <PARAM name=\"Phot_AutoParams\" datatype=\"float\""
|
| 607 |
14 |
bertin |
" arraysize=\"%d\" ucd=\"obs.param;phot\" value=\"%g",
|
| 608 |
|
|
prefs.nautoparam, prefs.autoparam[0]);
|
| 609 |
16 |
bertin |
for (n=1; n<prefs.nautoparam; n++)
|
| 610 |
|
|
fprintf(file, " %g", prefs.autoparam[n]);
|
| 611 |
|
|
fprintf(file, "\"/>\n");
|
| 612 |
14 |
bertin |
|
| 613 |
16 |
bertin |
fprintf(file, " <PARAM name=\"Phot_PetroParams\" datatype=\"float\""
|
| 614 |
14 |
bertin |
" arraysize=\"%d\" ucd=\"obs.param;phot\" value=\"%g",
|
| 615 |
|
|
prefs.npetroparam, prefs.petroparam[0]);
|
| 616 |
16 |
bertin |
for (n=1; n<prefs.npetroparam; n++)
|
| 617 |
|
|
fprintf(file, " %g", prefs.petroparam[n]);
|
| 618 |
|
|
fprintf(file, "\"/>\n");
|
| 619 |
14 |
bertin |
|
| 620 |
16 |
bertin |
fprintf(file, " <PARAM name=\"Phot_AutoApers\" datatype=\"float\""
|
| 621 |
14 |
bertin |
" arraysize=\"%d\" ucd=\"obs.param;phot\" value=\"%g",
|
| 622 |
|
|
prefs.nautoaper, prefs.autoaper[0]);
|
| 623 |
16 |
bertin |
for (n=1; n<prefs.nautoaper; n++)
|
| 624 |
|
|
fprintf(file, " %g", prefs.autoaper[n]);
|
| 625 |
|
|
fprintf(file, "\"/>\n");
|
| 626 |
14 |
bertin |
|
| 627 |
16 |
bertin |
fprintf(file, " <PARAM name=\"Phot_FluxFrac\" datatype=\"float\""
|
| 628 |
14 |
bertin |
" arraysize=\"%d\" ucd=\"arith.factor;obs.param;phot\" value=\"%g",
|
| 629 |
|
|
prefs.nflux_frac, prefs.flux_frac[0]);
|
| 630 |
16 |
bertin |
for (n=1; n<prefs.nflux_frac; n++)
|
| 631 |
|
|
fprintf(file, " %g", prefs.flux_frac[n]);
|
| 632 |
|
|
fprintf(file, "\"/>\n");
|
| 633 |
14 |
bertin |
|
| 634 |
16 |
bertin |
fprintf(file, " <PARAM name=\"Satur_Level\" datatype=\"float\""
|
| 635 |
14 |
bertin |
" ucd=\"instr.saturation;phot.count;obs.param\" value=\"%g\""
|
| 636 |
|
|
" unit=\"ct\"/>\n", prefs.satur_level);
|
| 637 |
16 |
bertin |
fprintf(file, " <PARAM name=\"Mag_ZeroPoint\" datatype=\"float\""
|
| 638 |
14 |
bertin |
" ucd=\"phot.calib;phot.mag;obs.param\" value=\"%g\" unit=\"mag\"/>\n",
|
| 639 |
|
|
prefs.mag_zeropoint);
|
| 640 |
16 |
bertin |
fprintf(file, " <PARAM name=\"Mag_Gamma\" datatype=\"float\""
|
| 641 |
14 |
bertin |
" ucd=\"phot.calib;obs.param\" value=\"%g\"/>\n",
|
| 642 |
|
|
prefs.mag_gamma);
|
| 643 |
16 |
bertin |
fprintf(file, " <PARAM name=\"Gain\" datatype=\"float\""
|
| 644 |
14 |
bertin |
" ucd=\"instr.param;obs.param\" value=\"%g\"/>\n",
|
| 645 |
|
|
prefs.gain);
|
| 646 |
16 |
bertin |
fprintf(file, " <PARAM name=\"Pixel_Scale\" datatype=\"float\""
|
| 647 |
14 |
bertin |
" ucd=\"instr.scale;obs.param\" value=\"%g\" unit=\"arcsec\"/>\n",
|
| 648 |
|
|
prefs.pixel_scale);
|
| 649 |
16 |
bertin |
fprintf(file, " <PARAM name=\"Seeing_FWHM\" datatype=\"float\""
|
| 650 |
14 |
bertin |
" ucd=\"instr.det.psf;stat.mean;obs.param\" value=\"%g\""
|
| 651 |
|
|
" unit=\"pix\"/>\n", prefs.seeing_fwhm);
|
| 652 |
16 |
bertin |
fprintf(file,
|
| 653 |
|
|
" <PARAM name=\"StarNNW_Name\" datatype=\"char\" arraysize=\"*\""
|
| 654 |
14 |
bertin |
" ucd=\"meta.dataset;meta.file;obs.param\" value=\"%s\"/>\n",
|
| 655 |
|
|
prefs.nnw_name);
|
| 656 |
|
|
|
| 657 |
16 |
bertin |
fprintf(file, " <PARAM name=\"Back_Size\" datatype=\"int\""
|
| 658 |
14 |
bertin |
" arraysize=\"%d\" ucd=\"obs.param\" value=\"%d",
|
| 659 |
|
|
prefs.nbacksize, prefs.backsize[0]);
|
| 660 |
16 |
bertin |
for (n=1; n<prefs.nbacksize; n++)
|
| 661 |
|
|
fprintf(file, " %d", prefs.backsize[n]);
|
| 662 |
|
|
fprintf(file, "\" unit=\"pix\"/>\n");
|
| 663 |
14 |
bertin |
|
| 664 |
16 |
bertin |
fprintf(file, " <PARAM name=\"Back_FilterSize\" datatype=\"int\""
|
| 665 |
14 |
bertin |
" arraysize=\"%d\" ucd=\"obs.param\" value=\"%d",
|
| 666 |
|
|
prefs.nbackfsize, prefs.backfsize[0]);
|
| 667 |
16 |
bertin |
for (n=1; n<prefs.nbackfsize; n++)
|
| 668 |
|
|
fprintf(file, " %d", prefs.backfsize[n]);
|
| 669 |
|
|
fprintf(file, "\"/>\n");
|
| 670 |
14 |
bertin |
|
| 671 |
16 |
bertin |
fprintf(file,
|
| 672 |
|
|
" <PARAM name=\"BackPhoto_Type\" datatype=\"char\" arraysize=\"*\""
|
| 673 |
14 |
bertin |
" ucd=\"meta.code;obs.param;\" value=\"%s\"/>\n",
|
| 674 |
|
|
key[findkeys("BACKPHOTO_TYPE", keylist,
|
| 675 |
|
|
FIND_STRICT)].keylist[prefs.pback_type]);
|
| 676 |
|
|
|
| 677 |
16 |
bertin |
fprintf(file, " <PARAM name=\"BackPhoto_Thick\" datatype=\"int\""
|
| 678 |
14 |
bertin |
" ucd=\"obs.param\" value=\"%d\" unit=\"pix\"/>\n",
|
| 679 |
|
|
prefs.pback_size);
|
| 680 |
|
|
|
| 681 |
16 |
bertin |
fprintf(file, " <PARAM name=\"Back_FiltThresh\" datatype=\"float\""
|
| 682 |
14 |
bertin |
" ucd=\"phot.count;arith.ratio;obs.param\" value=\"%g\"/>\n",
|
| 683 |
|
|
prefs.backfthresh);
|
| 684 |
|
|
|
| 685 |
16 |
bertin |
fprintf(file,
|
| 686 |
17 |
bertin |
" <PARAM name=\"CheckImage_Type\" datatype=\"char\" arraysize=\"*\""
|
| 687 |
14 |
bertin |
" ucd=\"meta.code\" value=\"%s",
|
| 688 |
|
|
key[findkeys("CHECKIMAGE_TYPE", keylist,
|
| 689 |
|
|
FIND_STRICT)].keylist[prefs.check_type[0]]);
|
| 690 |
16 |
bertin |
for (n=1; n<prefs.ncheck_type; n++)
|
| 691 |
|
|
fprintf(file,
|
| 692 |
14 |
bertin |
",%s",
|
| 693 |
|
|
key[findkeys("CHECKIMAGE_TYPE", keylist,
|
| 694 |
|
|
FIND_STRICT)].keylist[prefs.check_type[n]]);
|
| 695 |
16 |
bertin |
fprintf(file, "\"/>\n");
|
| 696 |
14 |
bertin |
|
| 697 |
16 |
bertin |
fprintf(file,
|
| 698 |
17 |
bertin |
" <PARAM name=\"CheckImage_Name\" datatype=\"char\" arraysize=\"*\""
|
| 699 |
14 |
bertin |
" ucd=\"meta.file\" value=\"%s",
|
| 700 |
|
|
prefs.check_name[0]);
|
| 701 |
16 |
bertin |
for (n=1; n<prefs.ncheck_type; n++)
|
| 702 |
|
|
if (prefs.check_type[n] != CHECK_NONE)
|
| 703 |
|
|
fprintf(file, ",%s", prefs.check_name[n]);
|
| 704 |
|
|
fprintf(file, "\"/>\n");
|
| 705 |
14 |
bertin |
|
| 706 |
16 |
bertin |
fprintf(file, " <PARAM name=\"Memory_ObjStack\" datatype=\"int\""
|
| 707 |
14 |
bertin |
" ucd=\"meta.number;src;obs.param\" value=\"%d\"/>\n",
|
| 708 |
|
|
prefs.clean_stacksize);
|
| 709 |
16 |
bertin |
fprintf(file, " <PARAM name=\"Memory_PixStack\" datatype=\"int\""
|
| 710 |
14 |
bertin |
" ucd=\"meta.number;obs.param\" value=\"%d\"/>\n",
|
| 711 |
|
|
prefs.mem_pixstack);
|
| 712 |
16 |
bertin |
fprintf(file, " <PARAM name=\"Memory_BufSize\" datatype=\"int\""
|
| 713 |
14 |
bertin |
" ucd=\"meta.number;obs.param\" value=\"%d\"/>\n",
|
| 714 |
|
|
prefs.mem_bufsize);
|
| 715 |
|
|
|
| 716 |
16 |
bertin |
fprintf(file,
|
| 717 |
|
|
" <PARAM name=\"Assoc_Name\" datatype=\"char\" arraysize=\"*\""
|
| 718 |
14 |
bertin |
" ucd=\"meta.dataset;meta.file\" value=\"%s\"/>\n",
|
| 719 |
|
|
prefs.assoc_name);
|
| 720 |
16 |
bertin |
if (prefs.nassoc_data)
|
| 721 |
|
|
{
|
| 722 |
|
|
fprintf(file, " <PARAM name=\"Assoc_Data\" datatype=\"int\""
|
| 723 |
14 |
bertin |
" arraysize=\"%d\" ucd=\"meta.code;obs.param\" value=\"%d",
|
| 724 |
|
|
prefs.nassoc_data, prefs.assoc_data[0]);
|
| 725 |
16 |
bertin |
for (n=1; n<prefs.nassoc_data; n++)
|
| 726 |
|
|
fprintf(file, " %d", prefs.assoc_data[n]);
|
| 727 |
|
|
fprintf(file, "\"/>\n");
|
| 728 |
|
|
}
|
| 729 |
|
|
if (prefs.nassoc_param)
|
| 730 |
|
|
{
|
| 731 |
|
|
fprintf(file, " <PARAM name=\"Assoc_Params\" datatype=\"int\""
|
| 732 |
14 |
bertin |
" arraysize=\"%d\" ucd=\"meta.code;obs.param\" value=\"%d",
|
| 733 |
16 |
bertin |
prefs.nassoc_param, prefs.assoc_param[0]);
|
| 734 |
|
|
for (n=1; n<prefs.nassoc_param; n++)
|
| 735 |
|
|
fprintf(file, " %d", prefs.assoc_param[n]);
|
| 736 |
|
|
fprintf(file, "\"/>\n");
|
| 737 |
|
|
}
|
| 738 |
|
|
fprintf(file, " <PARAM name=\"Assoc_Radius\" datatype=\"float\""
|
| 739 |
14 |
bertin |
" ucd=\"phys.size.radius;obs.param\" value=\"%g\" unit=\"pix\"/>\n",
|
| 740 |
|
|
prefs.assoc_radius);
|
| 741 |
16 |
bertin |
fprintf(file,
|
| 742 |
|
|
" <PARAM name=\"Assoc_Type\" datatype=\"char\" arraysize=\"*\""
|
| 743 |
14 |
bertin |
" ucd=\"meta.code;obs.param\" value=\"%s\"/>\n",
|
| 744 |
|
|
key[findkeys("ASSOC_TYPE", keylist,
|
| 745 |
|
|
FIND_STRICT)].keylist[prefs.assoc_type]);
|
| 746 |
16 |
bertin |
fprintf(file,
|
| 747 |
|
|
" <PARAM name=\"AssocSelec_Type\" datatype=\"char\" arraysize=\"*\""
|
| 748 |
14 |
bertin |
" ucd=\"meta.code;obs.param\" value=\"%s\"/>\n",
|
| 749 |
|
|
key[findkeys("ASSOCSELEC_TYPE", keylist,
|
| 750 |
|
|
FIND_STRICT)].keylist[prefs.assocselec_type]);
|
| 751 |
|
|
|
| 752 |
16 |
bertin |
fprintf(file,
|
| 753 |
|
|
" <PARAM name=\"Verbose_Type\" datatype=\"char\" arraysize=\"*\""
|
| 754 |
14 |
bertin |
" ucd=\"meta.code\" value=\"%s\"/>\n",
|
| 755 |
|
|
key[findkeys("VERBOSE_TYPE", keylist,
|
| 756 |
|
|
FIND_STRICT)].keylist[prefs.verbose_type]);
|
| 757 |
|
|
|
| 758 |
16 |
bertin |
fprintf(file,
|
| 759 |
|
|
" <PARAM name=\"FITS_Unsigned\" datatype=\"boolean\""
|
| 760 |
14 |
bertin |
" ucd=\"meta.code;obs.param\" value=\"%c\"/>\n",
|
| 761 |
|
|
prefs.fitsunsigned_flag? 'T':'F');
|
| 762 |
|
|
|
| 763 |
16 |
bertin |
fprintf(file,
|
| 764 |
|
|
" <PARAM name=\"PSF_Name\" datatype=\"char\" arraysize=\"*\""
|
| 765 |
14 |
bertin |
" ucd=\"meta.dataset;meta.file;obs.param\" value=\"%s\"/>\n",
|
| 766 |
|
|
prefs.psf_name[0]);
|
| 767 |
16 |
bertin |
fprintf(file, " <PARAM name=\"PSF_NMax\" datatype=\"int\""
|
| 768 |
14 |
bertin |
" ucd=\"meta.number;obs.param\" value=\"%d\"/>\n",
|
| 769 |
|
|
prefs.psf_npsfmax);
|
| 770 |
|
|
|
| 771 |
16 |
bertin |
fprintf(file,
|
| 772 |
|
|
" <PARAM name=\"SOM_Name\" datatype=\"char\" arraysize=\"*\""
|
| 773 |
14 |
bertin |
" ucd=\"meta.dataset;meta.file;obs.param\" value=\"%s\"/>\n",
|
| 774 |
|
|
prefs.som_name);
|
| 775 |
16 |
bertin |
}
|
| 776 |
14 |
bertin |
|
| 777 |
13 |
bertin |
fprintf(file, " </RESOURCE>\n");
|
| 778 |
|
|
fprintf(file, " </RESOURCE>\n");
|
| 779 |
8 |
bertin |
|
| 780 |
|
|
return RETURN_OK;
|
| 781 |
|
|
}
|
| 782 |
16 |
bertin |
|
| 783 |
|
|
|
| 784 |
|
|
|
| 785 |
|
|
|
| 786 |
15 |
bertin |
/****** write_xmlerror ******************************************************
|
| 787 |
16 |
bertin |
PROTO int write_xmlerror(char *error)
|
| 788 |
11 |
bertin |
PURPOSE Save meta-data to a simplified XML file in case of a catched error
|
| 789 |
16 |
bertin |
INPUT a character string.
|
| 790 |
11 |
bertin |
OUTPUT RETURN_OK if everything went fine, RETURN_ERROR otherwise.
|
| 791 |
|
|
NOTES -.
|
| 792 |
|
|
AUTHOR E. Bertin (IAP)
|
| 793 |
17 |
bertin |
VERSION 14/07/2006
|
| 794 |
11 |
bertin |
***/
|
| 795 |
16 |
bertin |
void write_xmlerror(char *filename, char *error)
|
| 796 |
11 |
bertin |
{
|
| 797 |
|
|
FILE *file;
|
| 798 |
|
|
|
| 799 |
17 |
bertin |
if (!(file = fopen(filename, "w")))
|
| 800 |
|
|
return;
|
| 801 |
15 |
bertin |
|
| 802 |
17 |
bertin |
write_xml_header(file);
|
| 803 |
15 |
bertin |
|
| 804 |
17 |
bertin |
fprintf(file, " </TABLE>\n");
|
| 805 |
|
|
|
| 806 |
|
|
write_xml_meta(file, error);
|
| 807 |
|
|
|
| 808 |
|
|
fprintf(file, "</RESOURCE>\n");
|
| 809 |
|
|
fprintf(file, "</VOTABLE>\n");
|
| 810 |
|
|
|
| 811 |
|
|
fclose(file);
|
| 812 |
|
|
|
| 813 |
11 |
bertin |
return;
|
| 814 |
|
|
}
|
| 815 |
|
|
|
| 816 |
16 |
bertin |
|
