/***********************************************************************//**
* @brief Read CTA cube background model from XML element
*
* @param[in] xml XML element.
*
* Set up CTA cube background model from the information provided by
* an XML element. The XML element is expected to have the following
* structure
*
* <source name="..." type="..." instrument="...">
* <spectrum type="...">
* ...
* </spectrum>
* </source>
*
* Optionally, a temporal model may be provided using the following
* syntax
*
* <source name="..." type="..." instrument="...">
* <spectrum type="...">
* ...
* </spectrum>
* <temporalModel type="...">
* ...
* </temporalModel>
* </source>
*
* If no temporal component is found a constant model is assumed.
***************************************************************************/
void GCTAModelCubeBackground::read(const GXmlElement& xml)
{
// Clear model
clear();
// Initialise XML elements
const GXmlElement* spectral = NULL;
const GXmlElement* temporal = NULL;
// Get pointer on spectrum
spectral = xml.element("spectrum", 0);
// Extract spectral model
m_spectral = xml_spectral(*spectral);
// Optionally get temporal model
if (xml.elements("temporalModel")) {
temporal = xml.element("temporalModel", 0);
m_temporal = xml_temporal(*temporal);
}
else {
GModelTemporalConst constant;
m_temporal = constant.clone();
}
// Read model attributes
read_attributes(xml);
// Set parameter pointers
set_pointers();
// Return
return;
}
/***********************************************************************//**
* @brief Read exposure cube from FITS object
*
* @param[in] fits FITS object.
*
* Read the exposure cube from a FITS object.
***************************************************************************/
void GCTACubeExposure::read(const GFits& fits)
{
// Clear object
clear();
// Get HDUs
const GFitsImage& hdu_expcube = *fits.image("Primary");
const GFitsTable& hdu_ebounds = *fits.table("EBOUNDS");
const GFitsTable& hdu_gti = *fits.table("GTI");
// Read cube
m_cube.read(hdu_expcube);
// Read cube attributes
read_attributes(hdu_expcube);
// Read energy boundaries
m_ebounds.read(hdu_ebounds);
// Read GTIs
m_gti.read(hdu_gti);
// Set energy node array
set_eng_axis();
// Return
return;
}
static int
read_container(char* contname)
{
struct stat sb;
int fd, num_exts, ret = 0, flags = 0;
if (ram_drive)
flags = O_RDONLY;
else
flags = O_RDONLY | O_DIRECT;
fd = open(contname, flags);
if (fd < 0) {
printf("open error: %d\n", errno);
exit(1);
}
if (print_temp || print_content_len || print_for_cliweb) {
attr_hash = g_hash_table_new(g_str_hash, g_str_equal);
if (read_attributes(contname)) {
ret = 0;
goto exit;
}
}
if (stat(contname, &sb) < 0) {
fprintf(stderr, "stat error: %d\n", errno);
exit(1);
}
/* If the container file is empty, return now */
if (!sb.st_size)
return ret;
num_exts = (sb.st_size - NKN_CONTAINER_HEADER_SZ) / DEV_BSIZE;
if (print_one_entry_per) {
combine_uri_segments(fd, contname, num_exts);
} else if (print_compact_output == 0)
default_output(fd, contname, num_exts);
else
compact_output(fd, contname, num_exts);
exit:
if (attr_hash) {
g_hash_table_foreach(attr_hash, free_an, NULL);
g_hash_table_destroy(attr_hash);
attr_hash = NULL;
}
close(fd);
return ret;
} /* read_container */
static readstat_error_t read_generic_list(int attributes, rdata_ctx_t *ctx) {
readstat_error_t retval = READSTAT_OK;
int32_t length;
int i;
rdata_sexptype_info_t sexptype_info;
if ((retval = read_length(&length, ctx)) != READSTAT_OK)
goto cleanup;
for (i=0; i<length; i++) {
if ((retval = read_sexptype_header(&sexptype_info, ctx)) != READSTAT_OK)
goto cleanup;
if (sexptype_info.header.type == RDATA_SEXPTYPE_CHARACTER_VECTOR) {
int32_t vec_length;
if ((retval = read_length(&vec_length, ctx)) != READSTAT_OK)
goto cleanup;
if (ctx->column_handler) {
if (ctx->column_handler(NULL, READSTAT_TYPE_STRING, NULL, NULL, vec_length, ctx->user_ctx)) {
retval = READSTAT_ERROR_USER_ABORT;
goto cleanup;
}
}
retval = read_string_vector(vec_length, ctx->text_value_handler, ctx->user_ctx, ctx);
} else {
retval = read_value_vector(sexptype_info.header, NULL, ctx);
}
if (retval != READSTAT_OK)
goto cleanup;
}
if (attributes) {
if ((retval = read_attributes(&handle_data_frame_attribute, ctx)) != READSTAT_OK)
goto cleanup;
}
cleanup:
return retval;
}
static void
combine_uri_segments(int fd,
char *contname,
unsigned num_exts)
{
GHashTable *uol_hash;
char *cont_head = NULL, *sector = NULL;
char *slash;
dm2_container_t *c;
DM2_disk_extent_t *dext;
DM2_disk_extent_v2_t *dext_v2;
GList *uol_list;
nkn_uol_wrap_t *uolw;
int nbytes;
unsigned i, deleted = 0;
if (print_content_len) {
attr_hash = g_hash_table_new(g_str_hash, g_str_equal);
if (read_attributes(contname))
goto free_mem;
}
uol_hash = g_hash_table_new(g_str_hash, g_str_equal);
if (posix_memalign((void *)&cont_head, DEV_BSIZE,
NKN_CONTAINER_HEADER_SZ)) {
printf("posix_memalign failed: %d %d\n", DEV_BSIZE,
NKN_CONTAINER_HEADER_SZ);
exit(1);
}
if (posix_memalign((void *)§or, DEV_BSIZE, DEV_BSIZE)) {
printf("posix_memalign failed: %d %d\n", DEV_BSIZE, DEV_BSIZE);
exit(1);
}
c = (dm2_container_t *)cont_head;
dext = (DM2_disk_extent_t *)sector;
dext_v2 = (DM2_disk_extent_v2_t *)sector;
nbytes = read(fd, cont_head, NKN_CONTAINER_HEADER_SZ);
if (nbytes != NKN_CONTAINER_HEADER_SZ) {
printf("ERROR: read header problem: %d %d\n",
nbytes, nbytes == -1 ? errno : 0);
goto free_mem;
}
slash = strrchr(contname, '/');
if (print_dirname) {
*slash = '\0';
printf("%s\n", contname);
} else
*(slash+1) = '\0';
if (print_header) {
if (print_content_len)
printf("%12s%12s%12s %s\n", "offset", "length", "content_len",
"URI");
else
printf("%12s%12s %s\n", "offset", "length", "URI");
}
for (i = 0; i < num_exts; i++) {
/* Take a nap to give room for other IO activities */
if (0 == (i % NAP_FREQUENCY))
usleep(NAP_TIME);
nbytes = read(fd, sector, DEV_BSIZE);
if (nbytes != DEV_BSIZE) {
printf("ERROR: read extent problem: %d %d %d\n", i, nbytes,
nbytes == -1 ? errno : 0);
goto free_mem;
}
if (dext->dext_header.dext_magic != DM2_DISK_EXT_DONE &&
dext->dext_header.dext_magic != DM2_DISK_EXT_MAGIC) {
printf("Bad MAGIC: URI=%s offset=%ld length=%ld "
"(expected=0x%x|0x%x/got=0x%x)\n", dext->dext_basename,
dext->dext_offset, dext->dext_length,
DM2_DISK_EXT_MAGIC, DM2_DISK_EXT_DONE,
dext->dext_header.dext_magic);
continue;
}
if (dext->dext_header.dext_version != DM2_DISK_EXT_VERSION &&
dext->dext_header.dext_version != DM2_DISK_EXT_VERSION_V2) {
printf("Bad Version: URI=%s offset=%ld length=%ld "
"(expected=%d,%d/got=%d)\n", dext->dext_basename,
dext->dext_offset, dext->dext_length,
DM2_DISK_EXT_VERSION, DM2_DISK_EXT_VERSION_V2,
dext->dext_header.dext_version);
continue;
}
deleted = 0;
/* Skip deleted entries */
if (skip_deleted && dext->dext_header.dext_magic == DM2_DISK_EXT_DONE)
continue;
if (dext->dext_header.dext_magic == DM2_DISK_EXT_DONE)
deleted = 1;
uolw = calloc(1, sizeof(nkn_uol_wrap_t));
if (dext->dext_header.dext_version == DM2_DISK_EXT_VERSION) {
uolw->uol.offset = dext->dext_offset;
uolw->uol.length = dext->dext_length;
uolw->uol.uri = strdup(dext->dext_basename);
} else {
uolw->uol.offset = dext_v2->dext_offset;
uolw->uol.length = dext_v2->dext_length;
uolw->uol.uri = strdup(dext->dext_basename);
}
if (deleted)
uolw->deleted = 1;
uol_list = g_hash_table_lookup(uol_hash, dext->dext_basename);
uol_list = g_list_prepend(uol_list, uolw);
g_hash_table_insert(uol_hash, uolw->uol.uri, uol_list);
}
g_hash_table_foreach(uol_hash, uol_print, contname);
g_hash_table_destroy(uol_hash);
free_mem:
if (cont_head)
free(cont_head);
if (sector)
free(sector);
} /* combine_uri_segments */
static readstat_error_t recursive_discard(rdata_sexptype_header_t sexptype_header, rdata_ctx_t *ctx) {
uint32_t length;
rdata_sexptype_info_t info;
rdata_sexptype_info_t prot, tag;
readstat_error_t error = 0;
int i;
switch (sexptype_header.type) {
case RDATA_SEXPTYPE_SYMBOL:
if ((error = read_sexptype_header(&info, ctx)) != READSTAT_OK)
goto cleanup;
if ((error = recursive_discard(info.header, ctx)) != READSTAT_OK)
goto cleanup;
break;
case RDATA_PSEUDO_SXP_PERSIST:
case RDATA_PSEUDO_SXP_NAMESPACE:
case RDATA_PSEUDO_SXP_PACKAGE:
if ((error = read_sexptype_header(&info, ctx)) != READSTAT_OK)
goto cleanup;
if ((error = recursive_discard(info.header, ctx)) != READSTAT_OK)
goto cleanup;
break;
case RDATA_SEXPTYPE_BUILTIN_FUNCTION:
case RDATA_SEXPTYPE_SPECIAL_FUNCTION:
error = discard_character_string(0, ctx);
break;
case RDATA_SEXPTYPE_PAIRLIST:
error = discard_pairlist(sexptype_header, ctx);
break;
case RDATA_SEXPTYPE_CHARACTER_STRING:
error = discard_character_string(1, ctx);
break;
case RDATA_SEXPTYPE_RAW_VECTOR:
error = discard_vector(sexptype_header, 1, ctx);
break;
case RDATA_SEXPTYPE_LOGICAL_VECTOR:
error = discard_vector(sexptype_header, 4, ctx);
break;
case RDATA_SEXPTYPE_INTEGER_VECTOR:
error = discard_vector(sexptype_header, 4, ctx);
break;
case RDATA_SEXPTYPE_REAL_VECTOR:
error = discard_vector(sexptype_header, 8, ctx);
break;
case RDATA_SEXPTYPE_COMPLEX_VECTOR:
error = discard_vector(sexptype_header, 16, ctx);
break;
case RDATA_SEXPTYPE_CHARACTER_VECTOR:
if (read_st(ctx, &length, sizeof(length)) != sizeof(length)) {
return READSTAT_ERROR_READ;
}
if (ctx->machine_needs_byteswap)
length = byteswap4(length);
for (i=0; i<length; i++) {
error = read_sexptype_header(&info, ctx);
if (error != READSTAT_OK)
goto cleanup;
if (info.header.type != RDATA_SEXPTYPE_CHARACTER_STRING) {
error = READSTAT_ERROR_PARSE;
goto cleanup;
}
error = discard_character_string(0, ctx);
if (error != READSTAT_OK)
goto cleanup;
}
break;
case RDATA_SEXPTYPE_GENERIC_VECTOR:
case RDATA_SEXPTYPE_EXPRESSION_VECTOR:
if (read_st(ctx, &length, sizeof(length)) != sizeof(length)) {
return READSTAT_ERROR_READ;
}
if (ctx->machine_needs_byteswap)
length = byteswap4(length);
for (i=0; i<length; i++) {
if ((error = read_sexptype_header(&info, ctx)) != READSTAT_OK)
goto cleanup;
if ((error = recursive_discard(info.header, ctx)) != READSTAT_OK)
goto cleanup;
}
if (sexptype_header.attributes) {
if ((error = read_attributes(NULL, ctx)) != READSTAT_OK)
goto cleanup;
}
break;
case RDATA_SEXPTYPE_DOT_DOT_DOT:
case RDATA_SEXPTYPE_PROMISE:
case RDATA_SEXPTYPE_LANGUAGE_OBJECT:
case RDATA_SEXPTYPE_CLOSURE:
if (sexptype_header.attributes) {
if ((error = read_sexptype_header(&info, ctx)) != READSTAT_OK)
goto cleanup;
if ((error = recursive_discard(info.header, ctx)) != READSTAT_OK)
goto cleanup;
}
if (sexptype_header.tag) {
if ((error = read_sexptype_header(&info, ctx)) != READSTAT_OK)
goto cleanup;
if ((error = recursive_discard(info.header, ctx)) != READSTAT_OK)
goto cleanup;
}
/* CAR */
if ((error = read_sexptype_header(&info, ctx)) != READSTAT_OK)
goto cleanup;
if ((error = recursive_discard(info.header, ctx)) != READSTAT_OK)
goto cleanup;
/* CDR */
if ((error = read_sexptype_header(&info, ctx)) != READSTAT_OK)
goto cleanup;
if ((error = recursive_discard(info.header, ctx)) != READSTAT_OK)
goto cleanup;
break;
case RDATA_SEXPTYPE_EXTERNAL_POINTER:
read_sexptype_header(&prot, ctx);
recursive_discard(prot.header, ctx);
read_sexptype_header(&tag, ctx);
recursive_discard(tag.header, ctx);
break;
case RDATA_SEXPTYPE_ENVIRONMENT:
/* locked */
if (lseek_st(ctx, sizeof(uint32_t)) == -1) {
return READSTAT_ERROR_READ;
}
rdata_sexptype_info_t enclosure, frame, hash_table, attributes;
read_sexptype_header(&enclosure, ctx);
recursive_discard(enclosure.header, ctx);
read_sexptype_header(&frame, ctx);
recursive_discard(frame.header, ctx);
read_sexptype_header(&hash_table, ctx);
recursive_discard(hash_table.header, ctx);
read_sexptype_header(&attributes, ctx);
recursive_discard(attributes.header, ctx);
/*
if (sexptype_header.attributes) {
if (lseek(ctx->fd, sizeof(uint32_t), SEEK_CUR) == -1) {
return READSTAT_ERROR_READ;
}
} */
break;
case RDATA_PSEUDO_SXP_REF:
case RDATA_PSEUDO_SXP_NIL:
case RDATA_PSEUDO_SXP_GLOBAL_ENVIRONMENT:
case RDATA_PSEUDO_SXP_UNBOUND_VALUE:
case RDATA_PSEUDO_SXP_MISSING_ARGUMENT:
case RDATA_PSEUDO_SXP_BASE_NAMESPACE:
case RDATA_PSEUDO_SXP_EMPTY_ENVIRONMENT:
case RDATA_PSEUDO_SXP_BASE_ENVIRONMENT:
break;
default:
return READSTAT_ERROR_READ;
}
cleanup:
return error;
}
static readstat_error_t read_value_vector(rdata_sexptype_header_t header, const char *name, rdata_ctx_t *ctx) {
readstat_error_t retval = READSTAT_OK;
int32_t length;
size_t input_elem_size = 0;
void *vals = NULL;
size_t buf_len = 0;
int output_data_type;
int i;
switch (header.type) {
case RDATA_SEXPTYPE_REAL_VECTOR:
input_elem_size = sizeof(double);
output_data_type = READSTAT_TYPE_DOUBLE;
break;
case RDATA_SEXPTYPE_INTEGER_VECTOR:
input_elem_size = sizeof(int32_t);
output_data_type = READSTAT_TYPE_DOUBLE;
break;
case RDATA_SEXPTYPE_LOGICAL_VECTOR:
input_elem_size = sizeof(int32_t);
output_data_type = READSTAT_TYPE_DOUBLE;
break;
default:
retval = READSTAT_ERROR_PARSE;
break;
}
if (retval != READSTAT_OK)
goto cleanup;
if ((retval = read_length(&length, ctx)) != READSTAT_OK)
goto cleanup;
buf_len = length * input_elem_size;
vals = malloc(buf_len);
if (vals == NULL) {
retval = READSTAT_ERROR_MALLOC;
goto cleanup;
}
if (read_st(ctx, vals, buf_len) != buf_len) {
retval = READSTAT_ERROR_READ;
goto cleanup;
}
if (ctx->machine_needs_byteswap) {
if (input_elem_size == sizeof(double)) {
double *d_vals = (double *)vals;
for (i=0; i<buf_len/sizeof(double); i++) {
d_vals[i] = byteswap_double(d_vals[i]);
}
} else {
uint32_t *i_vals = (uint32_t *)vals;
for (i=0; i<buf_len/sizeof(uint32_t); i++) {
i_vals[i] = byteswap4(i_vals[i]);
}
}
}
ctx->class_is_posixct = 0;
if (header.attributes) {
if ((retval = read_attributes(&handle_vector_attribute, ctx)) != READSTAT_OK)
goto cleanup;
}
if (ctx->column_handler) {
if (header.type == RDATA_SEXPTYPE_LOGICAL_VECTOR ||
header.type == RDATA_SEXPTYPE_INTEGER_VECTOR) {
double *real_vals = malloc(length * sizeof(double));
int32_t *i_vals = (int32_t *)vals;
for (i=0; i<length; i++) {
if (i_vals[i] == INT32_MIN) {
real_vals[i] = NAN;
} else {
real_vals[i] = i_vals[i];
}
}
if (ctx->column_handler(name, output_data_type, NULL, real_vals, length, ctx->user_ctx)) {
retval = READSTAT_ERROR_USER_ABORT;
goto cleanup;
}
free(real_vals);
} else {
if (ctx->column_handler(name, output_data_type, ctx->class_is_posixct ? "%ts" : NULL, vals, length, ctx->user_ctx)) {
retval = READSTAT_ERROR_USER_ABORT;
goto cleanup;
}
}
}
cleanup:
return retval;
}
/* Opens an HDF file and reads all its SDS metadata, returning an SDSInfo
* structure containing this metadata. Returns NULL on error.
*/
SDSInfo *open_h4_sds(const char *path)
{
int i, status;
int sd_id = SDstart(path, DFACC_READ);
CHECK_HDF_ERROR(path, sd_id);
// get dataset and global att counts
int32 n_datasets, n_global_atts;
status = SDfileinfo(sd_id, &n_datasets, &n_global_atts);
CHECK_HDF_ERROR(path, status);
SDSInfo *sds = NEW0(SDSInfo);
sds->path = xstrdup(path);
sds->type = SDS_HDF4_FILE;
sds->id = sd_id;
// read global attributes
sds->gatts = read_attributes(path, sd_id, n_global_atts);
// read variables ('datasets')
for (i = 0; i < n_datasets; i++) {
int sds_id = SDselect(sd_id, i);
CHECK_HDF_ERROR(path, sds_id);
char buf[_H4_MAX_SDS_NAME + 1];
memset(buf, 0, sizeof(buf));
int32 rank, dim_sizes[H4_MAX_VAR_DIMS], type, natts;
status = SDgetinfo(sds_id, buf, &rank, dim_sizes, &type, &natts);
CHECK_HDF_ERROR(path, status);
SDSVarInfo *var = NEW0(SDSVarInfo);
var->name = xstrdup(buf);
var->type = h4_to_sdstype(type);
var->iscoord = SDiscoordvar(sds_id);
var->ndims = rank;
var->dims = read_dimensions(sds, sds_id, rank, dim_sizes);
var->atts = read_attributes(path, sds_id, natts);
var->id = i; // actually the sds_index
comp_coder_t comp_type;
comp_info c_info;
status = SDgetcompinfo(sds_id, &comp_type, &c_info);
CHECK_HDF_ERROR(path, status);
switch (comp_type) {
case COMP_CODE_NONE:
var->compress = 0;
break;
case COMP_CODE_DEFLATE:
var->compress = c_info.deflate.level;
break;
default:
// any other compression method is 'worth' 1 imo *trollface*
// better than claiming 0 to the user
var->compress = 1;
break;
}
var->sds = sds;
var->next = sds->vars;
sds->vars = var;
status = SDendaccess(sds_id);
CHECK_HDF_ERROR(path, status);
}
sds->vars = (SDSVarInfo *)list_reverse((List *)sds->vars);
sds->dims = (SDSDimInfo *)list_reverse((List *)sds->dims);
sds->funcs = &h4_funcs;
return sds;
}