/* Save random number state. (SITERAND case only) */
void save_random_state_scidac_from_site(char *filename,
char *fileinfo, char *recinfo, int volfmt, field_offset src)
{
QIO_Layout layout;
QIO_Filesystem fs;
QIO_Writer *outfile;
QIO_String *filexml;
QIO_String *recxml;
int status;
#ifndef SITERAND
node0_printf("save_random_state_scidac_from_site: requires SITERAND. Save skipped\n");
if(1)return;
#endif
QIO_verbose(QIO_VERB_OFF);
/* Build the layout structure */
build_qio_layout(&layout);
/* Define the I/O system */
build_qio_filesystem(&fs);
/* Open file for writing */
filexml = QIO_string_create();
QIO_string_set(filexml, fileinfo);
outfile = open_scidac_output(filename, volfmt, QIO_SERIAL,
QIO_ILDGNO, NULL, &layout, &fs, filexml);
if(outfile == NULL)terminate(1);
QIO_string_destroy(filexml);
/* Write the lattice field */
recxml = QIO_string_create();
QIO_string_set(recxml, recinfo);
status = write_S_from_site(outfile, recxml, src);
QIO_string_destroy(recxml);
if(status)terminate(1);
/* Write information */
if(volfmt == QIO_SINGLEFILE){
node0_printf("Saved random state serially to binary file %s\n",
filename);
}
else if(volfmt == QIO_MULTIFILE){
node0_printf("Saved random state multifile to binary file %s\n",
filename);
}
else if(volfmt == QIO_PARTFILE){
node0_printf("Saved random state in partition format to binary file %s\n",
filename);
}
node0_printf("Checksums %x %x\n",
QIO_get_writer_last_checksuma(outfile),
QIO_get_writer_last_checksumb(outfile));
close_scidac_output(outfile);
}
void save_color_matrix_scidac_from_field(char *filename,
char *fileinfo, char *recinfo, int volfmt, su3_matrix *src, int count, int prec)
{
QIO_Layout layout;
QIO_Writer *outfile;
QIO_Filesystem fs;
QIO_String *filexml;
QIO_String *recxml;
int status;
QIO_verbose(QIO_VERB_OFF);
/* Build the layout structure */
build_qio_layout(&layout);
/* Build the structure defining the I/O nodes */
build_qio_filesystem(&fs);
/* Open file for writing */
filexml = QIO_string_create();
QIO_string_set(filexml, fileinfo);
outfile = open_scidac_output(filename, volfmt, QIO_SERIAL,
QIO_ILDGNO, NULL, &layout, &fs, filexml);
if(outfile == NULL)terminate(1);
QIO_string_destroy(filexml);
/* Write the lattice field */
recxml = QIO_string_create();
QIO_string_set(recxml, recinfo);
if(prec == 1)
status = write_F3_M_from_field(outfile, recxml, src, count);
else
status = write_D3_M_from_field(outfile, recxml, src, count);
if(status)terminate(1);
QIO_string_destroy(recxml);
/* Write information */
if(volfmt == QIO_SINGLEFILE){
node0_printf("Saved KS matrix serially to binary file %s\n",
filename);
}
else if(volfmt == QIO_MULTIFILE){
node0_printf("Saved KS matrix as multifile to binary file %s\n",
filename);
}
else if(volfmt == QIO_PARTFILE){
node0_printf("Saved KS matrix in partition format to binary file %s\n",
filename);
}
node0_printf("Checksums %x %x\n",
QIO_get_writer_last_checksuma(outfile),
QIO_get_writer_last_checksumb(outfile));
close_scidac_output(outfile);
}
/* Read random number state in SciDAC format (SITERAND case only) */
void restore_random_state_scidac_to_site(char *filename, field_offset dest){
QIO_Layout layout;
QIO_Filesystem fs;
QIO_Reader *infile;
QIO_String *recxml;
int status;
#ifndef SITERAND
node0_printf("restore_random_state_scidac_to_site: requires SITERAND. Save skipped\n");
if(1)return;
#endif
QIO_verbose(QIO_VERB_OFF);
/* Build the layout structure */
build_qio_layout(&layout);
/* Set the file system parameters */
build_qio_filesystem(&fs);
/* Open file for reading */
infile = open_scidac_input(filename, &layout, &fs, QIO_SERIAL);
if(infile == NULL)terminate(1);
/* Read the lattice field */
recxml = QIO_string_create();
status = read_S_to_site(infile, recxml, dest);
if(status)terminate(1);
/* Discard for now */
QIO_string_destroy(recxml);
close_scidac_input(infile);
}
QIO_Writer *open_usqcd_ksprop_write(char *filename, int volfmt,
int serpar, int ildgstyle,
char *stringLFN, int milc_type,
char *fileinfo){
QIO_Layout layout;
QIO_Filesystem fs;
QIO_Writer *outfile;
QIO_USQCDKSPropFileInfo *propfile_info;
QIO_String *filexml;
int usqcd_type = ks_prop_milc_to_usqcd(milc_type);
build_qio_layout(&layout);
build_qio_filesystem(&fs);
propfile_info = QIO_create_usqcd_kspropfile_info(usqcd_type, fileinfo);
filexml = QIO_string_create();
QIO_encode_usqcd_kspropfile_info(filexml, propfile_info);
QIO_destroy_usqcd_kspropfile_info(propfile_info);
outfile = open_scidac_output(filename, volfmt, serpar, ildgstyle,
stringLFN, &layout, &fs, filexml);
QIO_string_destroy(filexml);
return outfile;
}
int write_su3_field(QIO_Writer *outfile, int count,
suN_matrix *field_out[], char *myname){
QIO_String *xml_record_out;
char xml_write_field[] = "Dummy user record XML for su3 field";
int status;
QIO_RecordInfo *rec_info;
/* Create the record info for the field */
rec_info = QIO_create_record_info(QIO_FIELD, NULL, NULL, 0,
"QDP_F3_ColorMatrix", "F", 3,
0, sizeof(suN_matrix), count);
/* Create the record XML for the field */
xml_record_out = QIO_string_create();
QIO_string_set(xml_record_out,xml_write_field);
/* Write the record for the field */
status = QIO_write(outfile, rec_info, xml_record_out, vget_M,
count*sizeof(suN_matrix), sizeof(float), field_out);
printf("%s(%d): QIO_write returns status %d\n",myname,this_node,status);
if(status != QIO_SUCCESS)return 1;
QIO_destroy_record_info(rec_info);
QIO_string_destroy(xml_record_out);
return 0;
}
QIO_Writer *open_test_output(char *filename, int volfmt,
int serpar, int ildgstyle, char *myname){
QIO_String *xml_file_out;
char xml_write_file[] = "Dummy user file XML";
QIO_Writer *outfile;
QIO_Oflag oflag;
oflag.serpar = serpar;
oflag.ildgstyle = ildgstyle;
oflag.ildgLFN = QIO_string_create();
QIO_string_set(oflag.ildgLFN,"TestLFN");
oflag.mode = QIO_TRUNC;
QIO_verbose(QIO_VERB_DEBUG);
/* Create the file XML */
xml_file_out = QIO_string_create();
QIO_string_set(xml_file_out,xml_write_file);
/* Open the file for writing */
outfile = QIO_open_write(xml_file_out, filename, volfmt,
&layout, NULL, &oflag);
if(outfile == NULL){
printf("%s(%d): QIO_open_write returned NULL\n",myname,this_node);
fflush(stdout);
return NULL;
}
QIO_string_destroy(xml_file_out);
return outfile;
}
QIO_Reader *open_test_input(char *filename, int volfmt, int serpar,
char *myname){
QIO_String *xml_file_in;
QIO_Reader *infile;
QIO_Iflag iflag;
iflag.serpar = serpar;
iflag.volfmt = volfmt;
/* Create the file XML */
xml_file_in = QIO_string_create();
/* Open the file for reading */
infile = QIO_open_read(xml_file_in, filename, &layout, NULL, &iflag);
if(infile == NULL){
printf("%s(%d): QIO_open_read returns NULL.\n",myname,this_node);
return NULL;
}
printf("%s(%d): QIO_open_read done.\n",myname,this_node);
printf("%s(%d): User file info is \"%s\"\n",myname,this_node,
QIO_string_ptr(xml_file_in));
QIO_string_destroy(xml_file_in);
return infile;
}
QIO_Reader *open_usqcd_ksprop_read(char *filename, int serpar, char **fileinfo){
QIO_Layout layout;
QIO_Filesystem fs;
QIO_Reader *infile;
QIO_String *xml_file;
char *s;
int len;
xml_file = QIO_string_create();
build_qio_layout(&layout);
build_qio_filesystem(&fs);
infile = open_scidac_input_xml(filename, &layout, &fs, serpar, xml_file);
if(infile == NULL)terminate(1);
/* Make a copy of the file metadata */
s = QIO_string_ptr(xml_file);
len = strlen(s);
*fileinfo = (char *)malloc((len+1)*sizeof(char));
if(*fileinfo == NULL){
printf("open_usqcd_ksprop_read: No room for fileinfo\n");
terminate(1);
}
strncpy(*fileinfo, s, len);
(*fileinfo)[len] = '\0';
QIO_string_destroy(xml_file);
return infile;
}
int read_ksproprecord_usqcd(QIO_Reader *infile, int *color, su3_vector *dest)
{
QIO_USQCDKSPropRecordInfo proprecord_info;
QIO_String *recxml;
int status, typesize;
QIO_RecordInfo recinfo;
recxml = QIO_string_create();
/* Check the record type (double or single precision) */
status = QIO_read_record_info(infile, &recinfo, recxml);
if(status != QIO_SUCCESS)return status;
typesize = QIO_get_typesize(&recinfo);
if(typesize == 6*4)
/* Read as a single precision record */
status = read_F3_V_to_field(infile, recxml, dest, 1);
else
/* Read as a double precision record */
status = read_D3_V_to_field(infile, recxml, dest, 1);
if(status != QIO_SUCCESS)return status;
status = QIO_decode_usqcd_ksproprecord_info(&proprecord_info, recxml);
if(status != QIO_SUCCESS)terminate(1);
QIO_string_destroy(recxml);
*color = QIO_get_usqcd_ksproprecord_color(&proprecord_info);
return QIO_SUCCESS;
}
int write_real_field_subset(QIO_Writer *outfile, int count,
float *field_out[], int lower[],
int upper[], int dim, char *myname){
QIO_String *xml_record_out;
char xml_write_field[] = "Dummy user record XML for subset of real field";
int status;
QIO_RecordInfo *rec_info;
/* Create the record info for the field */
rec_info = QIO_create_record_info(QIO_HYPER, lower, upper, dim,
"QDP_F_Real", "F", 0,
0, sizeof(float), count);
/* Create the record XML for the field */
xml_record_out = QIO_string_create();
QIO_string_set(xml_record_out,xml_write_field);
/* Write the record for the field */
status = QIO_write(outfile, rec_info, xml_record_out, vget_R,
count*sizeof(float), sizeof(float), field_out);
printf("%s(%d): QIO_write returns status %d\n",myname,this_node,status);
if(status != QIO_SUCCESS)return 1;
QIO_destroy_record_info(rec_info);
QIO_string_destroy(xml_record_out);
return 0;
}
int save_complex_scidac(QIO_Writer *outfile, char *filename, char *recinfo,
int volfmt, complex *src, int count)
{
QIO_String *recxml;
int status;
recxml = QIO_string_create();
QIO_string_set(recxml, recinfo);
status = write_F_C_from_field(outfile, recxml, src, count);
QIO_string_destroy(recxml);
if(status)return status;
/* Write information */
if(volfmt == QIO_SINGLEFILE){
node0_printf("Saved complex field serially to binary file %s\n",
filename);
}
else if(volfmt == QIO_MULTIFILE){
node0_printf("Saved complex field as multifile to binary file %s\n",
filename);
}
else if(volfmt == QIO_PARTFILE){
node0_printf("Saved complex field in partition format to binary file %s\n",
filename);
}
node0_printf("Checksums %x %x\n",
QIO_get_writer_last_checksuma(outfile),
QIO_get_writer_last_checksumb(outfile));
return status;
}
int read_kspropsource_C_usqcd(QIO_Reader *infile, char *srcinfo, int n,
complex *dest)
{
QIO_USQCDKSPropSourceInfo propsource_info;
QIO_String *recxml;
char *info;
int status, typesize;
QIO_RecordInfo recinfo;
recxml = QIO_string_create();
/* Check the record type (double or single precision) */
status = QIO_read_record_info(infile, &recinfo, recxml);
if(status != QIO_SUCCESS)return status;
typesize = QIO_get_typesize(&recinfo);
if(typesize == 8)
status = read_F_C_to_field(infile, recxml, dest, 1);
else
status = read_D_C_to_field(infile, recxml, dest, 1);
if(status != QIO_SUCCESS)return status;
status = QIO_decode_usqcd_kspropsource_info(&propsource_info, recxml);
if(status != QIO_SUCCESS)terminate(1);
QIO_string_destroy(recxml);
info = QIO_get_usqcd_kspropsource_info(&propsource_info);
strncpy(srcinfo, info, n);
return QIO_SUCCESS;
}
void restore_real_scidac_to_field(char *filename, Real *dest, int count){
QIO_Layout layout;
QIO_Filesystem fs;
QIO_Reader *infile;
QIO_String *recxml;
int status;
QIO_verbose(QIO_VERB_OFF);
/* Build the layout structure */
build_qio_layout(&layout);
/* Set the file system parameters */
build_qio_filesystem(&fs);
/* Open file for reading */
infile = open_scidac_input(filename, &layout, &fs, QIO_SERIAL);
if(infile == NULL)terminate(1);
/* Read the lattice field */
recxml = QIO_string_create();
status = read_F_R_to_field(infile, recxml, dest, count);
if(status)terminate(1);
/* Discard for now */
QIO_string_destroy(recxml);
close_scidac_input(infile);
}
static gauge_file *restore_scidac(char *filename, int serpar){
QIO_Layout layout;
QIO_Filesystem fs;
QIO_Reader *infile;
QIO_RecordInfo recinfo;
QIO_String *recxml;
int status;
int typesize;
field_offset dest = F_OFFSET(link[0]);
gauge_file *gf;
QIO_verbose(QIO_VERB_OFF);
/* Build the layout structure */
build_qio_layout(&layout);
/* Define the I/O nodes */
build_qio_filesystem(&fs);
/* Make a dummy gauge file structure for MILC use */
gf = setup_input_gauge_file(filename);
/* Set the filename in the gauge_file structure */
gf->filename = filename;
/* Open file for reading */
infile = open_scidac_input(filename, &layout, &fs, serpar);
if(infile == NULL)terminate(1);
/* Check the record type (double or single precision) */
recxml = QIO_string_create();
status = QIO_read_record_info(infile, &recinfo, recxml);
if(status)terminate(1);
typesize = QIO_get_typesize(&recinfo);
/* Read the lattice field as single or double precision according to
the type size (bytes in a single SU(3) matrix) */
if(typesize == 72)
status = read_F3_M_to_site(infile, recxml, dest, LATDIM);
else if (typesize == 144)
status = read_D3_M_to_site(infile, recxml, dest, LATDIM);
else
{
node0_printf("restore_scidac: Bad typesize %d\n",typesize);
terminate(1);
}
if(status)terminate(1);
/* Discard for now */
QIO_string_destroy(recxml);
/* Close the file */
QIO_close_read(infile);
return gf;
}
QIO_Reader *r_open_complex_scidac_file(char *filename, int serpar)
{
QIO_Reader *infile;
QIO_String *xml_file;
/* Open file for reading */
xml_file = QIO_string_create();
infile = r_open_complex_scidac_file_xml(filename, serpar, xml_file);
QIO_string_destroy(xml_file);
return infile;
}
int read_complex_scidac(QIO_Reader *infile, complex *dest, int count){
QIO_String *recxml;
int status;
/* Read the lattice field: "count" complex numbers per site */
recxml = QIO_string_create();
status = read_complex_scidac_xml(infile, dest, count, recxml);
/* Discard for now */
QIO_string_destroy(recxml);
return status;
}
REQUIRES QIO
#else
#include <qio.h>
#endif
#include "../include/io_scidac.h"
#include "../include/io_scidac_ks.h"
#include <string.h>
/********************************************************************/
/* Generic color vector file (not USQCD) */
/* Write color vectors in SciDAC format, taking data from the site
structure */
int save_ks_vector_scidac(QIO_Writer *outfile, char *filename, char *recinfo,
int volfmt, su3_vector *src, int count, int prec)
{
QIO_String *recxml;
int status;
recxml = QIO_string_create();
QIO_string_set(recxml, recinfo);
if(prec == 1)
status = write_F3_V_from_field(outfile, recxml, src, count);
else
status = write_D3_V_from_field(outfile, recxml, src, count);
QIO_string_destroy(recxml);
if(status != QIO_SUCCESS)return status;
/* Write information */
if(volfmt == QIO_SINGLEFILE){
node0_printf("Saved KS vector serially to binary file %s\n",
filename);
}
else if(volfmt == QIO_MULTIFILE){
node0_printf("Saved KS vector as multifile to binary file %s\n",
filename);
}
else if(volfmt == QIO_PARTFILE){
node0_printf("Saved KS vector in partition format to binary file %s\n",
filename);
}
node0_printf("Checksums %x %x\n",
QIO_get_writer_last_checksuma(outfile),
QIO_get_writer_last_checksumb(outfile));
return status;
}
int write_kspropsource_V_usqcd(QIO_Writer *outfile, char *srcinfo,
su3_vector *src, int t0){
QIO_USQCDKSPropSourceInfo *propsource_info;
QIO_String *recxml;
int status;
propsource_info = QIO_create_usqcd_kspropsource_info(srcinfo);
recxml = QIO_string_create();
QIO_encode_usqcd_kspropsource_info(recxml, propsource_info);
QIO_destroy_usqcd_kspropsource_info(propsource_info);
status = write_kspropsource_V_usqcd_xml(outfile, recxml, src, t0);
QIO_string_destroy(recxml);
return status;
}
QIO_ChecksumInfo *QIO_read_checksum(QIO_Reader *in)
{
char myname[] = "QIO_read_checksum";
QIO_String *xml_checksum;
QIO_ChecksumInfo *checksum_info_expect = NULL;
int this_node = in->layout->this_node;
int status;
LIME_type lime_type=NULL;
if(in->read_state != QIO_RECORD_CHECKSUM_NEXT){
printf("%s(%d): Bad read state %d\n",myname,this_node,in->read_state);
return NULL;
}
/* Master node reads the checksum record */
status = QIO_SUCCESS; /* Changed if checksum does not match */
if(this_node == in->layout->master_io_node){
checksum_info_expect = QIO_create_checksum_info(0,0);
/* No checksum record for non-native files */
if(in->format == QIO_SCIDAC_NATIVE){
xml_checksum = QIO_string_create();
QIO_string_realloc(xml_checksum,QIO_STRINGALLOC);
if((status=QIO_read_string(in, xml_checksum, &lime_type))
!=QIO_SUCCESS){
printf("%s(%d): Error reading checksum\n",myname,this_node);
return NULL;
}
if(QIO_verbosity() >= QIO_VERB_DEBUG){
printf("%s(%d): checksum = %s\n",myname,this_node,
QIO_string_ptr(xml_checksum));
}
/* Extract checksum */
if((status=QIO_decode_checksum_info(checksum_info_expect, xml_checksum))
!=0){
printf("%s(%d): bad checksum record\n",myname,this_node);
return NULL;
}
QIO_string_destroy(xml_checksum);
}
}
in->read_state = QIO_RECORD_INFO_PRIVATE_NEXT;
return checksum_info_expect;
}
int QIO_close_write(QIO_Writer *out){
int status;
status = LRL_close_write_file(out->lrl_file_out);
if(out->layout){
free(out->layout->latsize);
if(out->layout->hyperupper)free(out->layout->hyperupper);
if(out->layout->hyperlower)free(out->layout->hyperlower);
free(out->layout);
}
DML_free_sitelist(out->sites);
if( out->ildgLFN != NULL )
QIO_string_destroy(out->ildgLFN);
free(out);
if(status != LRL_SUCCESS)return QIO_ERR_CLOSE;
return QIO_SUCCESS;
}
/*Write current record for the accumulated average over random sources */
static int
write_vector_current_record(QIO_Writer *outfile, int jrand, int nwrite, Real mass, Real *j_mu){
int status = QIO_SUCCESS;
QIO_String *recxml = QIO_string_create();
char recinfo[NRECINFO];
snprintf(recinfo, NRECINFO, "source index %d mass %g", jrand/nwrite, mass);
QIO_string_set(recxml, recinfo);
if(PRECISION == 1)
status = write_F_R_from_field(outfile, recxml, j_mu, NMU);
else
status = write_D_R_from_field(outfile, recxml, j_mu, NMU);
QIO_string_destroy(recxml);
node0_printf("Wrote current density for source %d and mass %g\n", jrand, mass);
return status;
}
/* Read color matrices in SciDAC format to a field */
void restore_color_matrix_scidac_to_field(char *filename,
su3_matrix *dest, int count, int prec){
QIO_Layout layout;
QIO_Filesystem fs;
QIO_Reader *infile;
QIO_String *recxml;
int status, typesize;
QIO_RecordInfo recinfo;
char myname[] = "restore_color_matrix_scidac_to_field";
QIO_verbose(QIO_VERB_OFF);
/* Build the layout structure */
build_qio_layout(&layout);
/* Set the file system parameters */
build_qio_filesystem(&fs);
/* Open file for reading */
infile = open_scidac_input(filename, &layout, &fs, QIO_SERIAL);
if(infile == NULL)terminate(1);
/* Check the record type (double or single precision) */
recxml = QIO_string_create();
status = QIO_read_record_info(infile, &recinfo, recxml);
if(status != QIO_SUCCESS)terminate(1);
typesize = QIO_get_typesize(&recinfo);
/* Read the lattice field */
if(typesize == 18*4)
status = read_F3_M_to_field(infile, recxml, dest, count);
else if(typesize == 18*8)
status = read_D3_M_to_field(infile, recxml, dest, count);
else {
node0_printf("%s: Incorrect data type size %d prec %d\n", myname, typesize, prec);
terminate(1);
}
if(status)terminate(1);
/* Discard for now */
QIO_string_destroy(recxml);
close_scidac_input(infile);
}
int peek_record_info(QIO_Reader *infile, char *myname){
QIO_String *xml_record_in;
QIO_RecordInfo rec_info;
int status;
printf("%s(%d) peeking\n",myname,this_node);
/* Create the record XML */
xml_record_in = QIO_string_create();
/* Create placeholder for record_info */
status = QIO_read_record_info(infile, &rec_info, xml_record_in);
if(status != QIO_SUCCESS)return 1;
printf("%s(%d): User record info is \"%s\"\n",myname,this_node,
QIO_string_ptr(xml_record_in));
QIO_string_destroy(xml_record_in);
return 0;
}
/* Open file for writing */
static QIO_Writer *
open_vector_current_file(char *filename){
char default_file_xml[] = "<?xml version=\"1.0\" encoding=\"UTF-8\"?><title>MILC ILDG disconnected vector current</title>";
int volfmt = QIO_SINGLEFILE;
int serpar = QIO_SERIAL;
QIO_String *filexml = QIO_string_create();
QIO_string_set(filexml, default_file_xml);
QIO_Layout layout;
QIO_Filesystem fs;
/* Build the layout structure */
build_qio_layout(&layout);
/* Define the I/O system */
build_qio_filesystem(&fs);
QIO_Writer *outfile = open_scidac_output(filename, volfmt, serpar, QIO_ILDGNO, NULL,
&layout, &fs, filexml);
QIO_string_destroy(filexml);
return outfile;
}
int write_ksprop_usqcd_c(QIO_Writer *outfile, su3_vector *src,
int color, char *recinfo)
{
QIO_USQCDKSPropRecordInfo *proprecord_info;
QIO_String *recxml;
int status;
proprecord_info = QIO_create_usqcd_ksproprecord_c_info(color, recinfo);
recxml = QIO_string_create();
QIO_encode_usqcd_ksproprecord_info(recxml, proprecord_info);
QIO_destroy_usqcd_ksproprecord_info(proprecord_info);
if(PRECISION == 1)
status = write_F3_V_from_field(outfile, recxml, src, 1);
else
status = write_D3_V_from_field(outfile, recxml, src, 1);
QIO_string_destroy(recxml);
return status;
}
QIO_Reader *open_scidac_input(char *filename, QIO_Layout *layout,
QIO_Filesystem *fs, int serpar){
QIO_String *xml_file_in;
QIO_Reader *infile;
/* Allocate for the file XML string */
xml_file_in = QIO_string_create();
infile = open_scidac_input_xml(filename, layout, fs, serpar, xml_file_in);
if(infile == NULL)return NULL;
if(this_node==0){
printf("Restoring binary SciDAC file %s\n",filename);
printf("File info \n\"%s\"\n",QIO_string_ptr(xml_file_in));
}
QIO_string_destroy(xml_file_in);
return infile;
}
int io_detect_ks_usqcd(char *filename){
QIO_Layout layout;
QIO_Filesystem fs;
QIO_Reader *infile;
QIO_String *xml_file_in;
QIO_USQCDKSPropFileInfo prop_info;
int status, usqcd_type, milc_type;
/* Allocate for the file XML string */
xml_file_in = QIO_string_create();
/* Build the layout structure */
build_qio_layout(&layout);
/* Define the I/O nodes */
build_qio_filesystem(&fs);
/* Open file for reading */
layout.latdim = 0; /* Force discovery of dimensions */
infile = open_scidac_input_xml(filename, &layout, &fs, QIO_SERIAL,
xml_file_in);
if(infile == NULL)terminate(1);
/* Decode the file XML */
status = QIO_decode_usqcd_kspropfile_info(&prop_info, xml_file_in);
QIO_string_destroy(xml_file_in);
if(status)return -1;
milc_type = -1;
if(QIO_defined_usqcd_kspropfile_type(&prop_info))
{
/* Translate the file type */
usqcd_type = QIO_get_usqcd_kspropfile_type(&prop_info);
milc_type = ks_prop_usqcd_to_milc(usqcd_type);
}
close_scidac_input(infile);
return milc_type;
}
QIO_Writer *w_open_complex_scidac_file(char *filename, char *fileinfo,
int volfmt, int serpar)
{
QIO_Layout layout;
QIO_Filesystem fs;
QIO_Writer *outfile;
QIO_String *filexml;
/* Build the layout structure */
build_qio_layout(&layout);
/* Define the I/O nodes */
build_qio_filesystem(&fs);
/* Open file for writing */
filexml = QIO_string_create();
QIO_string_set(filexml, fileinfo);
outfile = open_scidac_output(filename, volfmt, serpar, QIO_ILDGNO,
NULL, &layout, &fs, filexml);
QIO_string_destroy(filexml);
return outfile;
}
int read_real_global(QIO_Reader *infile, int count,
float array_in[], char *myname)
{
QIO_String *xml_record_in;
QIO_RecordInfo rec_info;
int status;
/* Create the record XML */
xml_record_in = QIO_string_create();
/* Read the global array record */
status = QIO_read(infile, &rec_info, xml_record_in,
vput_r, sizeof(float)*count, sizeof(float), array_in);
printf("%s(%d): QIO_read returns status %d\n",
myname,this_node,status);
if(status != QIO_SUCCESS)return 1;
printf("%s(%d): User record info is \"%s\"\n",myname,this_node,
QIO_string_ptr(xml_record_in));
QIO_string_destroy(xml_record_in);
return 0;
}
int write_real_global(QIO_Writer *outfile, int count, float array_out[],
char *myname){
QIO_String *xml_record_out;
char xml_write_global[] = "Dummy user record XML for global";
int status;
QIO_RecordInfo *rec_info;
/* Create the record info for the global array */
xml_record_out = QIO_string_create();
QIO_string_set(xml_record_out,xml_write_global);
rec_info = QIO_create_record_info(QIO_GLOBAL, NULL, NULL, 0,
"QLA_F_Real", "F", 0,
0, sizeof(float), count);
/* Write the array to a file */
status = QIO_write(outfile, rec_info, xml_record_out, vget_r,
count*sizeof(float), sizeof(float), array_out);
printf("%s(%d): QIO_write returns status %d\n",myname,this_node,status);
if(status != QIO_SUCCESS)return 1;
QIO_destroy_record_info(rec_info);
QIO_string_destroy(xml_record_out);
return 0;
}