int read_complex_scidac_xml(QIO_Reader *infile, complex *dest, int count,
QIO_String *recxml){
int status;
int typesize, datacount;
QIO_RecordInfo recinfo;
/* Read the lattice field: "count" complex numbers per site */
status = QIO_read_record_info(infile, &recinfo, recxml);
status = qio_status(status);
if(status < 0)return -1;
if(status > 0)terminate(1);
datacount = QIO_get_datacount(&recinfo);
if(datacount != count){
node0_printf("read_complex_scidac_xml: Got datacount %d but wanted %d\n",
datacount, count);
terminate(1);
}
typesize = QIO_get_typesize(&recinfo);
if(typesize == 2*4)
status = read_F_C_to_field(infile, recxml, dest, count);
else
status = read_D_C_to_field(infile, recxml, dest, count);
return status;
}
/* Utility for printing the record info */
void QIO_print_record_info(QIO_RecordInfo *record_info){
printf("Record header: datatype %s recordtype %d \n",
QIO_get_datatype(record_info),
QIO_get_recordtype(record_info));
printf("precision %s colors %d spins %d count %d\n",
QIO_get_precision(record_info),
QIO_get_colors(record_info),
QIO_get_spins(record_info),
QIO_get_datacount(record_info));
if(QIO_get_recordtype(record_info) == QIO_HYPER){
int i;
int n = QIO_get_hyper_spacetime(record_info);
int *lower = QIO_get_hyperlower(record_info);
int *upper = QIO_get_hyperupper(record_info);
printf("Hypercube lower");
for(i = 0; i < n; i++){
printf(" %d",lower[i]);
}
printf("\n");
printf("Hypercube upper");
for(i = 0; i < n; i++){
printf(" %d",upper[i]);
}
printf("\n");
}
}
int QIO_generic_read_record_data(QIO_Reader *in,
void (*put)(char *buf, size_t index, int count, void *arg),
size_t datum_size, int word_size, void *arg,
DML_Checksum *checksum, uint64_t *nbytes)
{
char myname[] = "QIO_generic_read_record_data";
int count;
LRL_RecordReader *lrl_record_in;
size_t datum_size_info;
DML_Layout *layout = in->layout;
int this_node = layout->this_node;
int status;
int recordtype;
int latdim;
QIO_RecordInfo *record_info = &in->record_info;
/* List of acceptable binary data LIME types */
int ntypes = 2;
/* Avoid a compiler bug */
LIME_type lime_type0 = QIO_LIMETYPE_BINARY_DATA;
LIME_type lime_type1 = QIO_LIMETYPE_ILDG_BINARY_DATA;
LIME_type lime_type_list[2] = {lime_type0, lime_type1};
// LIME_type lime_type_list[2] = {
// QIO_LIMETYPE_BINARY_DATA,
// QIO_LIMETYPE_ILDG_BINARY_DATA
// };
LIME_type lime_type;
/* It is an error to call for the data before reading the info
in a given record */
if(in->read_state != QIO_RECORD_DATA_NEXT){
printf("%s(%d): Bad read state %d\n",myname,this_node,in->read_state);
return QIO_ERR_INFO_MISSED;
}
/* Add record type and subset data to layout structure */
recordtype = QIO_get_recordtype(record_info);
layout->recordtype = recordtype;
status = DML_insert_subset_data(layout,
QIO_get_hyperlower(record_info),
QIO_get_hyperupper(record_info),
QIO_get_hyper_spacetime(record_info));
if(status != 0)
return QIO_ERR_BAD_SUBSET;
/* Require consistency between the byte count obtained from the
private record metadata and the datum_size and count parameters
(per site for field or hypercube data or total for global data) */
count = QIO_get_datacount(record_info);
if(datum_size != QIO_get_typesize(record_info) * count)
{
printf("%s(%d): requested byte count %lu disagrees with the record %d * %d\n",
myname,this_node,(unsigned long)datum_size,
QIO_get_typesize(record_info), count);
if(this_node == layout->master_io_node)
QIO_print_record_info(record_info);
return QIO_ERR_BAD_READ_BYTES;
}
/* Verify byte count per site (for field or hypercube) or total (for
global) */
datum_size_info = QIO_get_typesize(record_info) * count;
if(datum_size != datum_size_info){
printf("%s(%d): byte count mismatch request %lu != actual %lu\n",
myname, this_node, (unsigned long)datum_size,
(unsigned long)datum_size_info);
return QIO_ERR_BAD_READ_BYTES;
}
if(QIO_verbosity() >= QIO_VERB_DEBUG){
printf("%s(%d): Calling QIO_open_read_field\n",myname,this_node);fflush(stdout);
}
/* Nodes read the field */
/* Scan ahead and open the record with one of the listed LIME types */
lrl_record_in = QIO_open_read_field(in, recordtype, datum_size,
lime_type_list, ntypes, &lime_type, &status);
if(status != QIO_SUCCESS)return status;
if(QIO_verbosity() >= QIO_VERB_DEBUG){
printf("%s(%d): Calling QIO_read_field_data\n",
myname,this_node);fflush(stdout);
}
/* Then read the data and close the record */
status = QIO_read_field_data(in, lrl_record_in, recordtype,
put, count, datum_size, word_size,
arg, checksum, nbytes);
if(status != QIO_SUCCESS){
printf("%s(%d): Error reading field data\n",myname,this_node);
return status;
}
if(QIO_verbosity() >= QIO_VERB_DEBUG){
printf("%s(%d): done reading field\n",myname,this_node);fflush(stdout);
}
/* Copy most recent node checksum into reader */
memcpy(&(in->last_checksum), checksum, sizeof(DML_Checksum));
if(this_node == layout->master_io_node){
if(QIO_verbosity() >= QIO_VERB_REG){
printf("%s(%d): Read field\n",myname,this_node);
QIO_print_record_info(record_info);
}
}
in->read_state = QIO_RECORD_CHECKSUM_NEXT;
return QIO_SUCCESS;
}
/* Compare only fields that occur in the expected record info */
int QIO_compare_record_info(QIO_RecordInfo *found, QIO_RecordInfo *expect){
char myname[] = "QIO_compare_record_info";
if(QIO_defined_recordtype(expect))
if(!QIO_defined_recordtype(found) &&
QIO_get_recordtype(found) != QIO_get_recordtype(expect))
{
printf("%s:Recordtype flag mismatch expected %d found %d \n",myname,
QIO_get_recordtype(expect),QIO_get_recordtype(found));
return QIO_ERR_REC_INFO;
}
if(QIO_defined_datatype(expect))
if(!QIO_defined_datatype(found) &&
strncmp(QIO_get_datatype(found),QIO_get_datatype(expect),
QIO_MAXVALUESTRING))
{
printf("%s:Datatype mismatch expected %s found %s \n",myname,
QIO_get_datatype(expect),QIO_get_datatype(found));
return QIO_ERR_REC_INFO;
}
if(QIO_defined_precision(expect))
if(!QIO_defined_precision(found) &&
strncmp(QIO_get_precision(found),QIO_get_precision(expect),
QIO_MAXVALUESTRING))
{
printf("%s:Precision mismatch expected %s found %s \n",myname,
QIO_get_precision(expect),QIO_get_precision(found));
return QIO_ERR_REC_INFO;
}
if(QIO_defined_colors(expect))
if(!QIO_defined_colors(found) &&
QIO_get_colors(found) != QIO_get_colors(expect))
{
printf("%s:Colors mismatch expected %d found %d \n",myname,
QIO_get_colors(expect),QIO_get_colors(found));
return QIO_ERR_REC_INFO;
}
if(QIO_defined_spins(expect))
if(!QIO_defined_spins(found) &&
QIO_get_spins(found) != QIO_get_spins(expect))
{
printf("%s:Spins mismatch expected %d found %d \n",myname,
QIO_get_spins(expect),QIO_get_spins(found));
return QIO_ERR_REC_INFO;
}
if(QIO_defined_typesize(expect))
if(!QIO_defined_typesize(found) &&
QIO_get_typesize(found) != QIO_get_typesize(expect))
{
printf("%s:Typesize mismatch expected %d found %d \n",myname,
QIO_get_typesize(expect),QIO_get_typesize(found));
return QIO_ERR_REC_INFO;
}
if(QIO_defined_datacount(expect))
if(!QIO_defined_datacount(found) &&
QIO_get_datacount(found) != QIO_get_datacount(expect))
{
printf("%s:Datacount mismatch expected %d found %d \n",myname,
QIO_get_datacount(expect),QIO_get_datacount(found));
return QIO_ERR_REC_INFO;
}
return QIO_SUCCESS;
}
