int get_tpr_version(const char *infile)
{
char buf[STRLEN];
gmx_bool bDouble;
int precision,fver;
t_fileio *fio;
fio = open_tpx(infile,"r");
gmx_fio_checktype(fio);
precision = sizeof(real);
gmx_fio_do_string(fio,buf);
if (strncmp(buf,"VERSION",7))
gmx_fatal(FARGS,"Can not read file %s,\n"
" this file is from a Gromacs version which is older than 2.0\n"
" Make a new one with grompp or use a gro or pdb file, if possible",
gmx_fio_getname(fio));
gmx_fio_do_int(fio,precision);
bDouble = (precision == sizeof(double));
if ((precision != sizeof(float)) && !bDouble)
gmx_fatal(FARGS,"Unknown precision in file %s: real is %d bytes "
"instead of %d or %d",
gmx_fio_getname(fio),precision,sizeof(float),sizeof(double));
gmx_fio_setprecision(fio,bDouble);
fprintf(stderr,"Reading file %s, %s (%s precision)\n",
gmx_fio_getname(fio),buf,bDouble ? "double" : "single");
gmx_fio_do_int(fio,fver);
close_tpx(fio);
return fver;
}
static gmx_bool do_trnheader(t_fileio *fio, gmx_bool bRead, t_trnheader *sh, gmx_bool *bOK)
{
int magic = GROMACS_MAGIC;
static gmx_bool bFirst = TRUE;
char buf[256];
*bOK = TRUE;
gmx_fio_checktype(fio);
if (!gmx_fio_do_int(fio, magic) || magic != GROMACS_MAGIC)
{
return FALSE;
}
if (bRead)
{
*bOK = *bOK && gmx_fio_do_string(fio, buf);
if (bFirst)
{
fprintf(stderr, "trn version: %s ", buf);
}
}
else
{
sprintf(buf, "GMX_trn_file");
*bOK = *bOK && gmx_fio_do_string(fio, buf);
}
*bOK = *bOK && gmx_fio_do_int(fio, sh->ir_size);
*bOK = *bOK && gmx_fio_do_int(fio, sh->e_size);
*bOK = *bOK && gmx_fio_do_int(fio, sh->box_size);
*bOK = *bOK && gmx_fio_do_int(fio, sh->vir_size);
*bOK = *bOK && gmx_fio_do_int(fio, sh->pres_size);
*bOK = *bOK && gmx_fio_do_int(fio, sh->top_size);
*bOK = *bOK && gmx_fio_do_int(fio, sh->sym_size);
*bOK = *bOK && gmx_fio_do_int(fio, sh->x_size);
*bOK = *bOK && gmx_fio_do_int(fio, sh->v_size);
*bOK = *bOK && gmx_fio_do_int(fio, sh->f_size);
*bOK = *bOK && gmx_fio_do_int(fio, sh->natoms);
if (!*bOK)
{
return *bOK;
}
sh->bDouble = (nFloatSize(sh) == sizeof(double));
gmx_fio_setprecision(fio, sh->bDouble);
if (bRead && bFirst)
{
fprintf(stderr, "(%s precision)\n", sh->bDouble ? "double" : "single");
bFirst = FALSE;
}
*bOK = *bOK && gmx_fio_do_int(fio, sh->step);
*bOK = *bOK && gmx_fio_do_int(fio, sh->nre);
*bOK = *bOK && gmx_fio_do_real(fio, sh->t);
*bOK = *bOK && gmx_fio_do_real(fio, sh->lambda);
return *bOK;
}
void do_enxnms(ener_file_t ef,int *nre,gmx_enxnm_t **nms)
{
int magic=-55555;
XDR *xdr;
gmx_bool bRead = gmx_fio_getread(ef->fio);
int file_version;
int i;
gmx_fio_checktype(ef->fio);
xdr = gmx_fio_getxdr(ef->fio);
if (!xdr_int(xdr,&magic))
{
if(!bRead)
{
gmx_file("Cannot write energy names to file; maybe you are out of quota?");
}
*nre=0;
return;
}
if (magic > 0)
{
/* Assume this is an old edr format */
file_version = 1;
*nre = magic;
ef->eo.bOldFileOpen = TRUE;
ef->eo.bReadFirstStep = FALSE;
srenew(ef->eo.ener_prev,*nre);
}
else
{
ef->eo.bOldFileOpen=FALSE;
if (magic != -55555)
{
gmx_fatal(FARGS,"Energy names magic number mismatch, this is not a GROMACS edr file");
}
file_version = enx_version;
xdr_int(xdr,&file_version);
if (file_version > enx_version)
{
gmx_fatal(FARGS,"reading tpx file (%s) version %d with version %d program",gmx_fio_getname(ef->fio),file_version,enx_version);
}
xdr_int(xdr,nre);
}
if (file_version != enx_version)
{
fprintf(stderr,"Note: enx file_version %d, software version %d\n",
file_version,enx_version);
}
edr_strings(xdr,bRead,file_version,*nre,nms);
}
gmx_bool do_enx(ener_file_t ef,t_enxframe *fr)
{
int file_version=-1;
int i,b;
gmx_bool bRead,bOK,bOK1,bSane;
real tmp1,tmp2,rdum;
char buf[22];
/*int d_size;*/
bOK = TRUE;
bRead = gmx_fio_getread(ef->fio);
if (!bRead)
{
fr->e_size = fr->nre*sizeof(fr->ener[0].e)*4;
/*d_size = fr->ndisre*(sizeof(real)*2);*/
}
gmx_fio_checktype(ef->fio);
if (!do_eheader(ef,&file_version,fr,-1,NULL,&bOK))
{
if (bRead)
{
fprintf(stderr,"\rLast energy frame read %d time %8.3f ",
ef->framenr-1,ef->frametime);
if (!bOK)
{
fprintf(stderr,
"\nWARNING: Incomplete energy frame: nr %d time %8.3f\n",
ef->framenr,fr->t);
}
}
else
{
gmx_file("Cannot write energy file header; maybe you are out of quota?");
}
return FALSE;
}
if (bRead)
{
if ((ef->framenr < 20 || ef->framenr % 10 == 0) &&
(ef->framenr < 200 || ef->framenr % 100 == 0) &&
(ef->framenr < 2000 || ef->framenr % 1000 == 0))
{
fprintf(stderr,"\rReading energy frame %6d time %8.3f ",
ef->framenr,fr->t);
}
ef->framenr++;
ef->frametime = fr->t;
}
/* Check sanity of this header */
bSane = fr->nre > 0 ;
for(b=0; b<fr->nblock; b++)
{
bSane = bSane || (fr->block[b].nsub > 0);
}
if (!((fr->step >= 0) && bSane))
{
fprintf(stderr,"\nWARNING: there may be something wrong with energy file %s\n",
gmx_fio_getname(ef->fio));
fprintf(stderr,"Found: step=%s, nre=%d, nblock=%d, time=%g.\n"
"Trying to skip frame expect a crash though\n",
gmx_step_str(fr->step,buf),fr->nre,fr->nblock,fr->t);
}
if (bRead && fr->nre > fr->e_alloc)
{
srenew(fr->ener,fr->nre);
for(i=fr->e_alloc; (i<fr->nre); i++)
{
fr->ener[i].e = 0;
fr->ener[i].eav = 0;
fr->ener[i].esum = 0;
}
fr->e_alloc = fr->nre;
}
for(i=0; i<fr->nre; i++)
{
bOK = bOK && gmx_fio_do_real(ef->fio, fr->ener[i].e);
/* Do not store sums of length 1,
* since this does not add information.
*/
if (file_version == 1 ||
(bRead && fr->nsum > 0) || fr->nsum > 1)
{
tmp1 = fr->ener[i].eav;
bOK = bOK && gmx_fio_do_real(ef->fio, tmp1);
if (bRead)
fr->ener[i].eav = tmp1;
/* This is to save only in single precision (unless compiled in DP) */
tmp2 = fr->ener[i].esum;
bOK = bOK && gmx_fio_do_real(ef->fio, tmp2);
if (bRead)
fr->ener[i].esum = tmp2;
if (file_version == 1)
{
/* Old, unused real */
rdum = 0;
bOK = bOK && gmx_fio_do_real(ef->fio, rdum);
}
}
}
/* Here we can not check for file_version==1, since one could have
* continued an old format simulation with a new one with mdrun -append.
*/
if (bRead && ef->eo.bOldFileOpen)
{
/* Convert old full simulation sums to sums between energy frames */
convert_full_sums(&(ef->eo),fr);
}
/* read the blocks */
for(b=0; b<fr->nblock; b++)
{
/* now read the subblocks. */
int nsub=fr->block[b].nsub; /* shortcut */
int i;
for(i=0;i<nsub;i++)
{
t_enxsubblock *sub=&(fr->block[b].sub[i]); /* shortcut */
if (bRead)
{
enxsubblock_alloc(sub);
}
/* read/write data */
bOK1=TRUE;
switch (sub->type)
{
case xdr_datatype_float:
bOK1=gmx_fio_ndo_float(ef->fio, sub->fval, sub->nr);
break;
case xdr_datatype_double:
bOK1=gmx_fio_ndo_double(ef->fio, sub->dval, sub->nr);
break;
case xdr_datatype_int:
bOK1=gmx_fio_ndo_int(ef->fio, sub->ival, sub->nr);
break;
case xdr_datatype_large_int:
bOK1=gmx_fio_ndo_gmx_large_int(ef->fio, sub->lval, sub->nr);
break;
case xdr_datatype_char:
bOK1=gmx_fio_ndo_uchar(ef->fio, sub->cval, sub->nr);
break;
case xdr_datatype_string:
bOK1=gmx_fio_ndo_string(ef->fio, sub->sval, sub->nr);
break;
default:
gmx_incons("Reading unknown block data type: this file is corrupted or from the future");
}
bOK = bOK && bOK1;
}
}
if(!bRead)
{
if( gmx_fio_flush(ef->fio) != 0)
{
gmx_file("Cannot write energy file; maybe you are out of quota?");
}
}
if (!bOK)
{
if (bRead)
{
fprintf(stderr,"\nLast energy frame read %d",
ef->framenr-1);
fprintf(stderr,"\nWARNING: Incomplete energy frame: nr %d time %8.3f\n",
ef->framenr,fr->t);
}
else
{
gmx_fatal(FARGS,"could not write energies");
}
return FALSE;
}
return TRUE;
}
ener_file_t open_enx(const char *fn,const char *mode)
{
int nre,i;
gmx_enxnm_t *nms=NULL;
int file_version=-1;
t_enxframe *fr;
gmx_bool bWrongPrecision,bOK=TRUE;
struct ener_file *ef;
snew(ef,1);
if (mode[0]=='r') {
ef->fio=gmx_fio_open(fn,mode);
gmx_fio_checktype(ef->fio);
gmx_fio_setprecision(ef->fio,FALSE);
do_enxnms(ef,&nre,&nms);
snew(fr,1);
do_eheader(ef,&file_version,fr,nre,&bWrongPrecision,&bOK);
if(!bOK)
{
gmx_file("Cannot read energy file header. Corrupt file?");
}
/* Now check whether this file is in single precision */
if (!bWrongPrecision &&
((fr->e_size && (fr->nre == nre) &&
(nre*4*(long int)sizeof(float) == fr->e_size)) ) )
{
fprintf(stderr,"Opened %s as single precision energy file\n",fn);
free_enxnms(nre,nms);
}
else
{
gmx_fio_rewind(ef->fio);
gmx_fio_checktype(ef->fio);
gmx_fio_setprecision(ef->fio,TRUE);
do_enxnms(ef,&nre,&nms);
do_eheader(ef,&file_version,fr,nre,&bWrongPrecision,&bOK);
if(!bOK)
{
gmx_file("Cannot write energy file header; maybe you are out of quota?");
}
if (((fr->e_size && (fr->nre == nre) &&
(nre*4*(long int)sizeof(double) == fr->e_size)) ))
fprintf(stderr,"Opened %s as double precision energy file\n",
fn);
else {
if (empty_file(fn))
gmx_fatal(FARGS,"File %s is empty",fn);
else
gmx_fatal(FARGS,"Energy file %s not recognized, maybe different CPU?",
fn);
}
free_enxnms(nre,nms);
}
free_enxframe(fr);
sfree(fr);
gmx_fio_rewind(ef->fio);
}
else
ef->fio = gmx_fio_open(fn,mode);
ef->framenr=0;
ef->frametime=0;
return ef;
}
void gmx_mtxio_write(const char * filename,
int nrow,
int ncol,
real * full_matrix,
gmx_sparsematrix_t * sparse_matrix)
{
t_fileio *fio;
XDR * xd;
int i,j,prec;
gmx_bool bDum = TRUE;
gmx_bool bRead = FALSE;
size_t sz;
if(full_matrix!=NULL && sparse_matrix!=NULL)
{
gmx_fatal(FARGS,"Both full AND sparse matrix specified to gmx_mtxio_write().\n");
}
fio = gmx_fio_open(filename,"w");
gmx_fio_checktype(fio);
xd = gmx_fio_getxdr(fio);
/* Write magic number */
i = GMX_MTXIO_MAGIC_NUMBER;
gmx_fio_do_int(fio, i);
/* Write generating Gromacs version */
gmx_fio_write_string(fio, GromacsVersion());
/* Write 1 for double, 0 for single precision */
if(sizeof(real)==sizeof(double))
prec = 1;
else
prec = 0;
gmx_fio_do_int(fio, prec);
gmx_fio_do_int(fio, nrow);
gmx_fio_do_int(fio, ncol);
if(full_matrix!=NULL)
{
/* Full matrix storage format */
i = GMX_MTXIO_FULL_MATRIX;
gmx_fio_do_int(fio, i);
sz = nrow*ncol;
bDum=gmx_fio_ndo_real(fio, full_matrix,sz);
}
else
{
/* Sparse storage */
i = GMX_MTXIO_SPARSE_MATRIX;
gmx_fio_do_int(fio, i);
gmx_fio_do_gmx_bool(fio, sparse_matrix->compressed_symmetric);
gmx_fio_do_int(fio, sparse_matrix->nrow);
if(sparse_matrix->nrow != nrow)
{
gmx_fatal(FARGS,"Internal inconsistency in sparse matrix.\n");
}
bDum=gmx_fio_ndo_int(fio, sparse_matrix->ndata,sparse_matrix->nrow);
for(i=0;i<sparse_matrix->nrow;i++)
{
for(j=0;j<sparse_matrix->ndata[i];j++)
{
gmx_fio_do_int(fio, sparse_matrix->data[i][j].col);
gmx_fio_do_real(fio, sparse_matrix->data[i][j].value);
}
}
}
gmx_fio_close(fio);
}
void
gmx_mtxio_read (const char * filename,
int * nrow,
int * ncol,
real ** full_matrix,
gmx_sparsematrix_t ** sparse_matrix)
{
t_fileio *fio;
XDR * xd;
int i,j,prec;
gmx_bool bDum = TRUE;
gmx_bool bRead = TRUE;
char gmxver[256];
size_t sz;
fio = gmx_fio_open(filename,"r");
gmx_fio_checktype(fio);
xd = gmx_fio_getxdr(fio);
/* Read and check magic number */
i = GMX_MTXIO_MAGIC_NUMBER;
gmx_fio_do_int(fio, i);
if(i!=GMX_MTXIO_MAGIC_NUMBER)
{
gmx_fatal(FARGS,
"No matrix data found in file. Note that the Hessian matrix format changed\n"
"in Gromacs 3.3 to enable portable files and sparse matrix storage.\n");
}
/* Read generating Gromacs version */
gmx_fio_do_string(fio, gmxver);
/* Write 1 for double, 0 for single precision */
if(sizeof(real)==sizeof(double))
prec = 1;
else
prec = 0;
gmx_fio_do_int(fio, prec);
fprintf(stderr,"Reading %s precision matrix generated by Gromacs %s\n",
(prec == 1) ? "double" : "single",gmxver);
gmx_fio_do_int(fio, i);
*nrow=i;
gmx_fio_do_int(fio, i);
*ncol=i;
gmx_fio_do_int(fio, i);
if(i==GMX_MTXIO_FULL_MATRIX)
{
printf("Full matrix storage format, nrow=%d, ncols=%d\n",*nrow,*ncol);
sz = (*nrow) * (*ncol);
snew((*full_matrix),sz);
bDum=gmx_fio_ndo_real(fio, (*full_matrix),sz);
}
else
{
/* Sparse storage */
printf("Sparse matrix storage format, nrow=%d, ncols=%d\n",*nrow,*ncol);
snew((*sparse_matrix),1);
gmx_fio_do_gmx_bool(fio, (*sparse_matrix)->compressed_symmetric);
gmx_fio_do_int(fio, (*sparse_matrix)->nrow);
if((*sparse_matrix)->nrow != *nrow)
{
gmx_fatal(FARGS,"Internal inconsistency in sparse matrix.\n");
}
snew((*sparse_matrix)->ndata,(*sparse_matrix)->nrow);
snew((*sparse_matrix)->nalloc,(*sparse_matrix)->nrow);
snew((*sparse_matrix)->data,(*sparse_matrix)->nrow);
bDum=gmx_fio_ndo_int(fio, (*sparse_matrix)->ndata,
(*sparse_matrix)->nrow);
for(i=0;i<(*sparse_matrix)->nrow;i++)
{
(*sparse_matrix)->nalloc[i] = (*sparse_matrix)->ndata[i] + 10;
snew(((*sparse_matrix)->data[i]),(*sparse_matrix)->nalloc[i]);
for(j=0;j<(*sparse_matrix)->ndata[i];j++)
{
gmx_fio_do_int(fio, (*sparse_matrix)->data[i][j].col);
gmx_fio_do_real(fio, (*sparse_matrix)->data[i][j].value);
}
}
}
gmx_fio_close(fio);
}
