bool do_enx(int fp,t_enxframe *fr)
{
int i,block;
bool bRead,bOK,bOK1,bSane;
real tmp1,tmp2;
bOK = TRUE;
bRead = gmx_fio_getread(fp);
if (!bRead) {
fr->e_size = fr->nre*sizeof(fr->ener[0].e)*4;
fr->d_size = fr->ndisre*(sizeof(fr->rav[0]) +
sizeof(fr->rt[0]));
}
gmx_fio_select(fp);
if (!do_eheader(fp,fr,&bOK)) {
if (bRead) {
fprintf(stderr,"\rLast frame read %d ",framenr-1);
if (!bOK)
fprintf(stderr,"\nWARNING: Incomplete frame: nr %6d time %8.3f\n",
framenr,fr->t);
}
return FALSE;
}
if (bRead) {
if ( ( framenr<10 ) || ( framenr%10 == 0) )
fprintf(stderr,"\rReading frame %6d time %8.3f ",framenr,fr->t);
framenr++;
}
/* Check sanity of this header */
bSane = (fr->nre > 0 || fr->ndisre > 0);
for(block=0; block<fr->nblock; block++)
bSane = bSane || (fr->nr[block] > 0);
if (!((fr->step >= 0) && bSane)) {
fprintf(stderr,"\nWARNING: there may be something wrong with energy file %s\n",
gmx_fio_getname(fp));
fprintf(stderr,"Found: step=%d, nre=%d, ndisre=%d, nblock=%d, time=%g.\n"
"Trying to skip frame expect a crash though\n",
fr->step,fr->nre,fr->ndisre,fr->nblock,fr->t);
}
if (bRead && fr->nre>fr->e_alloc) {
srenew(fr->ener,fr->nre);
fr->e_alloc = fr->nre;
}
for(i=0; i<fr->nre; i++) {
bOK = bOK && do_real(fr->ener[i].e);
tmp1 = fr->ener[i].eav;
if((tmp1/(fr->step+1))<GMX_REAL_EPS)
tmp1=0;
bOK = bOK && do_real(tmp1);
fr->ener[i].eav = tmp1;
/* This is to save only in single precision (unless compiled in DP) */
tmp2 = fr->ener[i].esum;
bOK = bOK && do_real(tmp2);
fr->ener[i].esum = tmp2;
bOK = bOK && do_real(fr->ener[i].e2sum);
}
if (fr->ndisre) {
if (bRead && fr->ndisre>fr->d_alloc) {
srenew(fr->rav,fr->ndisre);
srenew(fr->rt,fr->ndisre);
fr->d_alloc = fr->ndisre;
}
ndo_real(fr->rav,fr->ndisre,bOK1);
bOK = bOK && bOK1;
ndo_real(fr->rt,fr->ndisre,bOK1);
bOK = bOK && bOK1;
}
for(block=0; block<fr->nblock; block++) {
if (bRead && fr->nr[block]>fr->b_alloc[block]) {
srenew(fr->block[block],fr->nr[block]);
fr->b_alloc[block] = fr->nr[block];
}
ndo_real(fr->block[block],fr->nr[block],bOK1);
bOK = bOK && bOK1;
}
if (!bOK) {
if (bRead) {
fprintf(stderr,"\nLast frame read %d ",
framenr-1);
fprintf(stderr,"\nWARNING: Incomplete frame: nr %6d time %8.3f \n",
framenr,fr->t);
} else
fatal_error(-1,"could not write energies");
return FALSE;
}
return TRUE;
}
int open_enx(char *fn,char *mode)
{
int fp,nre,i;
char **nm=NULL;
t_enxframe *fr;
bool bDum=TRUE;
/* Energy files should always be opened as binary files,
* but that is checked in gmx_fio_open.
*/
if (mode[0]=='r') {
fp=gmx_fio_open(fn,mode);
gmx_fio_select(fp);
gmx_fio_setprecision(fp,FALSE);
do_enxnms(fp,&nre,&nm);
snew(fr,1);
do_eheader(fp,fr,&bDum);
/* Now check whether this file is in single precision */
if (((fr->e_size && (fr->nre == nre) &&
(nre*4*sizeof(float) == fr->e_size)) ||
(fr->d_size &&
(fr->ndisre*sizeof(float)*2+sizeof(int) == fr->d_size)))){
fprintf(stderr,"Opened %s as single precision energy file\n",fn);
for(i=0; (i<nre); i++)
sfree(nm[i]);
sfree(nm);
}
else {
gmx_fio_rewind(fp);
gmx_fio_select(fp);
gmx_fio_setprecision(fp,TRUE);
do_enxnms(fp,&nre,&nm);
do_eheader(fp,fr,&bDum);
if (((fr->e_size && (fr->nre == nre) &&
(nre*4*sizeof(double) == fr->e_size)) ||
(fr->d_size &&
(fr->ndisre*sizeof(double)*2+sizeof(int) == fr->d_size))))
fprintf(stderr,"Opened %s as double precision energy file\n",fn);
else {
if (empty_file(fn))
fatal_error(0,"File %s is empty",fn);
else
fatal_error(0,"Energy file %s not recognized, maybe different CPU?",
fn);
}
for(i=0; (i<nre); i++)
sfree(nm[i]);
sfree(nm);
}
free_enxframe(fr);
sfree(fr);
gmx_fio_rewind(fp);
}
else
fp = gmx_fio_open(fn,mode);
framenr=0;
return fp;
}
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;
}
bool do_enx(int fp,t_enxframe *fr)
{
int file_version=-1;
int i,block;
bool bRead,bOK,bOK1,bSane;
real tmp1,tmp2,rdum;
char buf[22];
bOK = TRUE;
bRead = gmx_fio_getread(fp);
if (!bRead)
{
fr->e_size = fr->nre*sizeof(fr->ener[0].e)*4;
fr->d_size = fr->ndisre*(sizeof(fr->disre_rm3tav[0]) +
sizeof(fr->disre_rt[0]));
}
gmx_fio_select(fp);
if (!do_eheader(fp,&file_version,fr,FALSE,&bOK))
{
if (bRead)
{
fprintf(stderr,"\rLast energy frame read %d time %8.3f ",
framenr-1,frametime);
if (!bOK)
{
fprintf(stderr,
"\nWARNING: Incomplete energy frame: nr %d time %8.3f\n",
framenr,fr->t);
}
}
else
{
gmx_file("Cannot write energy file header; maybe you are out of quota?");
}
return FALSE;
}
if (bRead)
{
if ((framenr < 20 || framenr % 10 == 0) &&
(framenr < 200 || framenr % 100 == 0) &&
(framenr < 2000 || framenr % 1000 == 0))
{
fprintf(stderr,"\rReading energy frame %6d time %8.3f ",
framenr,fr->t);
}
framenr++;
frametime = fr->t;
}
/* Check sanity of this header */
bSane = (fr->nre > 0 || fr->ndisre > 0);
for(block=0; block<fr->nblock; block++)
{
bSane = bSane || (fr->nr[block] > 0);
}
if (!((fr->step >= 0) && bSane))
{
fprintf(stderr,"\nWARNING: there may be something wrong with energy file %s\n",
gmx_fio_getname(fp));
fprintf(stderr,"Found: step=%s, nre=%d, ndisre=%d, nblock=%d, time=%g.\n"
"Trying to skip frame expect a crash though\n",
gmx_step_str(fr->step,buf),fr->nre,fr->ndisre,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 && do_real(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 && do_real(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 && do_real(tmp2);
if (bRead)
fr->ener[i].esum = tmp2;
if (file_version == 1)
{
/* Old, unused real */
rdum = 0;
bOK = bOK && do_real(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 && fp < ener_old_nalloc && ener_old[fp].bOldFileOpen)
{
/* Convert old full simulation sums to sums between energy frames */
convert_full_sums(&ener_old[fp],fr);
}
if (fr->ndisre)
{
if (bRead && fr->ndisre>fr->d_alloc)
{
srenew(fr->disre_rm3tav,fr->ndisre);
srenew(fr->disre_rt,fr->ndisre);
fr->d_alloc = fr->ndisre;
}
ndo_real(fr->disre_rm3tav,fr->ndisre,bOK1);
bOK = bOK && bOK1;
ndo_real(fr->disre_rt,fr->ndisre,bOK1);
bOK = bOK && bOK1;
}
for(block=0; block<fr->nblock; block++)
{
if (bRead && fr->nr[block]>fr->b_alloc[block])
{
srenew(fr->block[block],fr->nr[block]);
fr->b_alloc[block] = fr->nr[block];
}
ndo_real(fr->block[block],fr->nr[block],bOK1);
bOK = bOK && bOK1;
}
if(!bRead)
{
if( gmx_fio_flush(fp) != 0)
{
gmx_file("Cannot write energy file; maybe you are out of quota?");
}
}
if (!bOK)
{
if (bRead)
{
fprintf(stderr,"\nLast energy frame read %d",
framenr-1);
fprintf(stderr,"\nWARNING: Incomplete energy frame: nr %d time %8.3f\n",
framenr,fr->t);
}
else
{
gmx_fatal(FARGS,"could not write energies");
}
return FALSE;
}
return TRUE;
}
int open_enx(const char *fn,const char *mode)
{
int fp,nre,i;
gmx_enxnm_t *nms=NULL;
int file_version=-1;
t_enxframe *fr;
bool bDum=TRUE;
if (mode[0]=='r') {
fp=gmx_fio_open(fn,mode);
gmx_fio_select(fp);
gmx_fio_setprecision(fp,FALSE);
do_enxnms(fp,&nre,&nms);
snew(fr,1);
do_eheader(fp,&file_version,fr,TRUE,&bDum);
if(!bDum)
{
gmx_file("Cannot read energy file header. Corrupt file?");
}
/* Now check whether this file is in single precision */
if (((fr->e_size && (fr->nre == nre) &&
(nre*4*sizeof(float) == fr->e_size)) ||
(fr->d_size &&
(fr->ndisre*sizeof(float)*2+sizeof(int) == fr->d_size)))){
fprintf(stderr,"Opened %s as single precision energy file\n",fn);
free_enxnms(nre,nms);
}
else {
gmx_fio_rewind(fp);
gmx_fio_select(fp);
gmx_fio_setprecision(fp,TRUE);
do_enxnms(fp,&nre,&nms);
do_eheader(fp,&file_version,fr,TRUE,&bDum);
if(!bDum)
{
gmx_file("Cannot write energy file header; maybe you are out of quota?");
}
if (((fr->e_size && (fr->nre == nre) &&
(nre*4*sizeof(double) == fr->e_size)) ||
(fr->d_size &&
(fr->ndisre*sizeof(double)*2+sizeof(int) == fr->d_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(fp);
}
else
fp = gmx_fio_open(fn,mode);
framenr=0;
frametime=0;
return fp;
}
