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); }
/* 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); }
int read_lat_dim_scidac(char *filename, int *ndim, int dims[]) { QIO_Layout layout; QIO_Filesystem fs; int i; int *latsize; QIO_Reader *infile; QIO_verbose(QIO_VERB_REG); /* Build the layout structure */ nx = 0; ny = 0; nz = 0; nt = 0; build_qio_layout(&layout); /* Forces discovery */ layout.latdim = 0; /* Set the file system parameters */ build_qio_filesystem(&fs); /* Get lattice dimensions from file */ infile = open_scidac_input(filename, &layout, &fs, QIO_SERIAL); if(!infile)return 1; *ndim = QIO_get_reader_latdim(infile); latsize = QIO_get_reader_latsize(infile); for(i = 0; i < *ndim; i++) dims[i] = latsize[i]; QIO_close_read(infile); return 0; }
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; }
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; }
/* 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); }
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_xml(char *filename, int serpar, QIO_String *xml_file) { QIO_Layout layout; QIO_Filesystem fs; QIO_Reader *infile; /* 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_xml(filename, &layout, &fs, serpar, xml_file); return infile; }
/* 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); }
/* 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 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 main(int argc, char *argv[]) { int ndim,dims[4]; gauge_file *gf; gauge_header *gh; FILE *fp; char *filename_milc,*filename_scidac; QIO_Layout layout; QIO_Reader *infile; QIO_RecordInfo rec_info; char *datatype; int status; int datum_size; int input_prec; int count = 4; int word_size; int typesize; w_serial_site_writer state; if(argc < 3) { fprintf(stderr,"Usage %s <SciDAC file> <MILC file>\n",argv[0]); exit(1); } filename_scidac = argv[1]; filename_milc = argv[2]; if(this_node == 0)printf("Converting file %s to MILC v5 file %s\n", filename_scidac, filename_milc); initialize_machine(&argc,&argv); #ifdef HAVE_QDP QDP_initialize(&argc, &argv); #endif this_node = mynode(); number_of_nodes = numnodes(); if(number_of_nodes != 1){ printf("This is single-processor code. Please rebuild as such.\n"); terminate(1); } /* Open the SciDAC file and discover the lattice dimensions. Then close. */ status = read_lat_dim_scidac(filename_scidac, &ndim, dims); if(status)terminate(1); if(ndim != 4){ printf("Wanted ndims = 4 in %s but got %d\n",filename_scidac,ndim); terminate(1); } nx = dims[0]; ny = dims[1]; nz = dims[2]; nt = dims[3]; volume = nx*ny*nz*nt; /* Finish setting up, now we know the dimensions */ setup(); /* Build the QIO layout */ build_qio_layout(&layout); /* Open the SciDAC file for reading */ infile = open_scidac_input(filename_scidac, &layout, 0, QIO_SERIAL); if(infile == NULL)terminate(1); /* Open the MILC v5 file for writing */ fp = fopen(filename_milc, "wb"); if(fp == NULL) { printf("Can't open file %s, error %d\n", filename_milc,errno);fflush(stdout); terminate(1); } gf = setup_output_gauge_file(); gh = gf->header; /* Read the SciDAC record header. */ xml_record_in = QIO_string_create(); status = QIO_read_record_info(infile, &rec_info, xml_record_in); if(status != QIO_SUCCESS)terminate(1); node0_printf("Record info \n\"%s\"\n",QIO_string_ptr(xml_record_in)); /* Make sure this is a lattice field */ datatype = QIO_get_datatype(&rec_info); typesize = QIO_get_typesize(&rec_info); if(strcmp(datatype, "QDP_F3_ColorMatrix") == 0 || strcmp(datatype, "USQCD_F3_ColorMatrix") == 0 || typesize == 72){ datum_size = sizeof(fsu3_matrix); input_prec = 1; word_size = sizeof(float); } else if(strcmp(datatype, "QDP_D3_ColorMatrix") == 0 || strcmp(datatype, "USQCD_F3_ColorMatrix") == 0 || typesize == 144){ datum_size = sizeof(dsu3_matrix); input_prec = 2; word_size = sizeof(double); } else { printf("Unrecognized datatype %s\n",datatype); terminate(1); } /* Copy the time stamp from the SciDAC file */ strncpy(gh->time_stamp, QIO_get_record_date(&rec_info), MAX_TIME_STAMP); gh->time_stamp[MAX_TIME_STAMP-1] = '\0'; /* Write the MILC v5 header */ gh->order = NATURAL_ORDER; /* Node 0 writes the header */ swrite_gauge_hdr(fp,gh); /* Assign values to file structure */ gf->fp = fp; gf->filename = filename_milc; gf->byterevflag = 0; /* Not used for writing */ gf->rank2rcv = NULL; /* Not used for writing */ gf->parallel = 0; /* Initialize writing the lattice data */ w_serial_start_lattice(gf, &state, input_prec); /* Read the SciDAC record data. The factory function writes the site links to a file. */ status = QIO_read_record_data(infile, w_serial_site_links, datum_size*count, word_size, (void *)&state); if(status != QIO_SUCCESS)terminate(1); node0_printf("SciDAC checksums %x %x\n", QIO_get_reader_last_checksuma(infile), QIO_get_reader_last_checksumb(infile)); /* Close the SciDAC file */ QIO_close_read(infile); /* Finish the MILC v5 file */ w_serial_finish_lattice(&state); w_serial_f(gf); QIO_string_destroy(xml_record_in); #ifdef HAVE_QDP QDP_finalize(); #endif normal_exit(0); return 0; }
static gauge_file *file_scan_scidac(char *filename, int serpar){ QIO_Layout layout; QIO_Filesystem fs; QIO_Reader *infile; QIO_RecordInfo recinfo; QIO_String *recxml; int status; int typesize; su3_matrix *dest = NULL; gauge_file *gf; int ndim; int dims[4]; /* Read header to get lattice dimensions and close the file */ read_lat_dim_scidac(filename, &ndim, dims); nx = dims[0]; ny = dims[1]; nz = dims[2]; nt = dims[3]; volume = nx*ny*nz*nt; /* Finish setting up, now we know the dimensions */ broadcast_bytes((char *)&nx,sizeof(int)); broadcast_bytes((char *)&ny,sizeof(int)); broadcast_bytes((char *)&nz,sizeof(int)); broadcast_bytes((char *)&nt,sizeof(int)); setup_layout(); /* 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; /* Reopen file for reading */ QIO_verbose(QIO_VERB_OFF); 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_null(infile, recxml, dest, LATDIM); else if (typesize == 144) status = read_D3_M_to_null(infile, recxml, dest, LATDIM); else { node0_printf("file_scan_scidac: Bad typesize %d\n",typesize); terminate(1); } if(status){ node0_printf("ERROR scanning file\n"); } else { node0_printf("SUCCESS scanning file\n"); } /* Discard for now */ QIO_string_destroy(recxml); /* Close the file */ QIO_close_read(infile); return gf; }
/* The QIO file is closed after writing the lattice */ gauge_file *save_scidac(char *filename, int volfmt, int serpar, int ildgstyle, char *stringLFN){ QIO_Layout layout; QIO_Filesystem fs; QIO_Writer *outfile; int status; field_offset src = F_OFFSET(link[0]); gauge_file *gf; char *info; QIO_String *filexml; QIO_String *recxml; char default_file_xml[] = "<?xml version=\"1.0\" encoding=\"UTF-8\"?><title>MILC ILDG archival gauge configuration</title>"; QIO_verbose(QIO_VERB_OFF); /* Build the layout structure */ build_qio_layout(&layout); /* Define the I/O system */ build_qio_filesystem(&fs); /* Make a dummy gauge file structure for MILC use */ gf = setup_output_gauge_file(); /* Set the filename in the gauge_file structure */ gf->filename = filename; /* Open file for writing */ filexml = QIO_string_create(); QIO_string_set(filexml, default_file_xml); outfile = open_scidac_output(filename, volfmt, serpar, ildgstyle, stringLFN, &layout, &fs, filexml); if(outfile == NULL)terminate(1); QIO_string_destroy(filexml); /* Create the QCDML string for this configuration */ info = create_QCDML(); recxml = QIO_string_create(); QIO_string_set(recxml, info); /* Write the lattice field */ status = write_F3_M_from_site(outfile, recxml, src, LATDIM); if(status)terminate(1); /* Discard for now */ QIO_string_destroy(recxml); /* Write information */ if(volfmt == QIO_SINGLEFILE){ node0_printf("Saved gauge configuration serially to binary file %s\n", filename); } else if(volfmt == QIO_MULTIFILE){ node0_printf("Saved gauge configuration as multifile to binary file %s\n", filename); } else if(volfmt == QIO_PARTFILE){ node0_printf("Saved gauge configuration in partition format to binary file %s\n", filename); } node0_printf("Time stamp %s\n",gf->header->time_stamp); node0_printf("Checksums %x %x\n", QIO_get_writer_last_checksuma(outfile), QIO_get_writer_last_checksumb(outfile)); /* Close the file */ QIO_close_write(outfile); free_QCDML(info); return gf; }