forked from lijiext/lammps
426 lines
9.5 KiB
C
Executable File
426 lines
9.5 KiB
C
Executable File
/* **************************************************************** */
|
|
/* toascii.c - binary to ascii xmovie format converter */
|
|
/* */
|
|
/* Mike Uttormark - 8/11/92 */
|
|
/* Sandia Nat'l Labs 1421 */
|
|
/* On leave from University of Wisconsin--Madison */
|
|
/* **************************************************************** */
|
|
/* format of binary file: */
|
|
/* */
|
|
/* magic number - 4-byte integer */
|
|
/* version - 4-byte integer */
|
|
/* <records> */
|
|
/* */
|
|
/* generic record format: */
|
|
/* record id - 4-byte integer */
|
|
/* length (bytes) - 4-byte integer */
|
|
/* data */
|
|
/* **************************************************************** */
|
|
|
|
#define MagicNumber 12344321
|
|
#define Version 1001
|
|
|
|
#define TimeID 100
|
|
#define BoundID 101
|
|
#define PositionID 102
|
|
#define BondID 103
|
|
#define CopyBondID 104
|
|
#define CopyAtomID 105
|
|
|
|
#define LINELEN 256
|
|
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
|
|
#ifdef MISSINGDEFS
|
|
#include <unistd.h>
|
|
int fprintf(FILE *, char *, ...);
|
|
int fread(void *, size_t, size_t, FILE *);
|
|
int fseek(FILE *, long int, int);
|
|
#endif
|
|
|
|
#ifndef EXIT_SUCCESS
|
|
#define EXIT_SUCCESS 0
|
|
#endif
|
|
#ifndef EXIT_FAILURE
|
|
#define EXIT_FAILURE 1
|
|
#endif
|
|
|
|
#undef TRUE
|
|
#undef FALSE
|
|
#define TRUE 1
|
|
#define FALSE 0
|
|
|
|
/* **************************************************************** */
|
|
/* local typedefs */
|
|
|
|
typedef long INT4;
|
|
typedef float REAL4;
|
|
typedef void (*PFV)();
|
|
|
|
typedef struct {
|
|
INT4 index;
|
|
INT4 type;
|
|
REAL4 coord[3];
|
|
} POSITION;
|
|
|
|
typedef struct {
|
|
INT4 type;
|
|
INT4 index1;
|
|
INT4 index2;
|
|
} BOND;
|
|
|
|
typedef struct {
|
|
REAL4 low[3];
|
|
REAL4 high[3];
|
|
} BOUND;
|
|
|
|
typedef struct {
|
|
REAL4 time;
|
|
} TIME;
|
|
|
|
typedef INT4 RECORD;
|
|
typedef INT4 LENGTH;
|
|
typedef INT4 MAGIC;
|
|
typedef INT4 VERSION;
|
|
|
|
typedef struct {
|
|
RECORD record_id;
|
|
PFV writer;
|
|
} WRITER;
|
|
|
|
typedef struct {
|
|
RECORD record_id;
|
|
PFV reader;
|
|
} READER;
|
|
|
|
/* **************************************************************** */
|
|
/* function proto-types */
|
|
|
|
int main(int argc, char **argv);
|
|
int GetRecord(FILE *file);
|
|
void PutRecord(FILE *file);
|
|
|
|
void PutTime(FILE *f);
|
|
void PutBound(FILE *f);
|
|
void PutPosition(FILE *f);
|
|
void PutBond(FILE *f);
|
|
void PutCopyBond(FILE *f);
|
|
void PutCopyAtom(FILE *f);
|
|
|
|
WRITER *GetWriter(RECORD record);
|
|
|
|
void PrintError(char *s);
|
|
void *Realloc(void *ptr, size_t amt);
|
|
|
|
READER *GetReader(RECORD record);
|
|
|
|
void ReadHeader(FILE *f);
|
|
int ReadRecordHeader(FILE *f);
|
|
void ReadTime(FILE *f);
|
|
void ReadBound(FILE *f);
|
|
void ReadPosition(FILE *f);
|
|
void ReadBond(FILE *f);
|
|
void ReadDummy(FILE *f);
|
|
|
|
/* **************************************************************** */
|
|
/* local data */
|
|
|
|
static MAGIC magic = MagicNumber;
|
|
static VERSION version = Version;
|
|
static RECORD record;
|
|
static LENGTH length;
|
|
static POSITION *positions = (POSITION *) NULL;
|
|
static INT4 npositions = 0;
|
|
static INT4 maxpositions = 0;
|
|
static BOUND bounds;
|
|
static TIME time;
|
|
static BOND *bonds = (BOND *) NULL;
|
|
static INT4 nbonds = 0;
|
|
static INT4 maxbonds = 0;
|
|
|
|
static WRITER write_table[] = {
|
|
{ TimeID, PutTime },
|
|
{ BoundID, PutBound },
|
|
{ PositionID, PutPosition },
|
|
{ BondID, PutBond },
|
|
{ CopyBondID, PutCopyBond },
|
|
{ CopyAtomID, PutCopyAtom },
|
|
};
|
|
|
|
static READER read_table[] = {
|
|
{ TimeID, ReadTime },
|
|
{ BoundID, ReadBound },
|
|
{ PositionID, ReadPosition },
|
|
{ BondID, ReadBond },
|
|
{ CopyBondID, ReadDummy },
|
|
{ CopyAtomID, ReadDummy },
|
|
};
|
|
|
|
/* **************************************************************** */
|
|
|
|
/* ARGSUSED */
|
|
int main(int argc, char **argv)
|
|
{
|
|
ReadHeader(stdin);
|
|
|
|
while(GetRecord(stdin))
|
|
PutRecord(stdout);
|
|
|
|
exit(EXIT_SUCCESS);
|
|
}
|
|
|
|
/* **************************************************************** */
|
|
|
|
int GetRecord(FILE *f)
|
|
{
|
|
register READER *r;
|
|
|
|
while(1) {
|
|
if (!ReadRecordHeader(f)) return(FALSE);
|
|
r = GetReader(record);
|
|
if (r == (READER *) NULL) { /* dont recognize */
|
|
fseek(f, length, SEEK_CUR); /* skip */
|
|
continue;
|
|
}
|
|
(*r->reader)(f);
|
|
break;
|
|
}
|
|
return(TRUE);
|
|
}
|
|
|
|
/* **************************************************************** */
|
|
|
|
READER *GetReader(RECORD record)
|
|
{
|
|
register READER *r;
|
|
register int i;
|
|
|
|
i = sizeof(read_table)/sizeof(read_table[0]);
|
|
for(r = read_table; i ; i--, r++)
|
|
if (r->record_id == record) return(r);
|
|
|
|
return((READER *) NULL);
|
|
}
|
|
|
|
/* **************************************************************** */
|
|
|
|
void PutTime(FILE *f)
|
|
{
|
|
fprintf(f, "ITEM: TIME\n"
|
|
"%g\n", time.time);
|
|
|
|
}
|
|
|
|
/* **************************************************************** */
|
|
|
|
void PutBound(FILE *f)
|
|
{
|
|
register int i;
|
|
|
|
fprintf(f, "ITEM: BOUNDS\n");
|
|
|
|
for(i = 0; i < 3; i++)
|
|
fprintf(f, "%g %g\n", bounds.low[i], bounds.high[i]);
|
|
}
|
|
|
|
/* **************************************************************** */
|
|
|
|
void PutPosition(FILE *f)
|
|
{
|
|
register POSITION *p;
|
|
register int i;
|
|
|
|
fprintf(f,"ITEM: POSITIONS %i\n", npositions);
|
|
|
|
for(p = positions, i = npositions; i; i--, p++)
|
|
fprintf(f, "%i %i %g %g %g\n",p->index, p->type,
|
|
p->coord[0], p->coord[1], p->coord[2]);
|
|
}
|
|
|
|
/* **************************************************************** */
|
|
|
|
void PutBond(FILE *f)
|
|
{
|
|
register BOND *b;
|
|
register int i;
|
|
|
|
fprintf(f,"ITEM: BONDS %i\n", nbonds);
|
|
|
|
for(b = bonds, i = nbonds; i; i--, b++)
|
|
fprintf(f, "%i %i %i\n", b->type, b->index1, b->index2);
|
|
}
|
|
|
|
/* **************************************************************** */
|
|
|
|
void PutCopyBond(FILE *f)
|
|
{
|
|
fprintf(f, "ITEM: COPYBONDS\n");
|
|
}
|
|
|
|
/* **************************************************************** */
|
|
|
|
void PutCopyAtom(FILE *f)
|
|
{
|
|
fprintf(f, "ITEM: COPYATOMS\n");
|
|
}
|
|
|
|
/* **************************************************************** */
|
|
|
|
void PrintError(char *s)
|
|
{
|
|
fprintf(stderr,"%s", s);
|
|
exit(EXIT_FAILURE);
|
|
}
|
|
|
|
/* **************************************************************** */
|
|
|
|
void *Realloc(void *ptr, size_t amt)
|
|
{
|
|
ptr = (ptr == NULL) ? malloc(amt) : realloc(ptr, amt);
|
|
|
|
if (ptr != NULL) return(ptr);
|
|
|
|
PrintError("Error: unable to allocate space.\n");
|
|
}
|
|
|
|
/* **************************************************************** */
|
|
|
|
void PutRecord(FILE *f)
|
|
{
|
|
register WRITER *w;
|
|
|
|
w = GetWriter(record);
|
|
if (w == (WRITER *) NULL)
|
|
PrintError("Internal error: no writer.\n");
|
|
|
|
(*w->writer)(f);
|
|
}
|
|
|
|
/* **************************************************************** */
|
|
|
|
WRITER *GetWriter(RECORD r)
|
|
{
|
|
register int i;
|
|
register WRITER *w;
|
|
|
|
i = sizeof(write_table)/sizeof(write_table[0]);
|
|
for(w = write_table; i; i--, w++)
|
|
if (w->record_id == r) return(w);
|
|
|
|
return((WRITER *) NULL);
|
|
}
|
|
|
|
/* **************************************************************** */
|
|
|
|
|
|
void ReadHeader(FILE *f)
|
|
{
|
|
if (1 > fread(&magic, sizeof(magic), 1, f)) goto error;
|
|
if (1 > fread(&version, sizeof(version), 1, f)) goto error;
|
|
|
|
if (magic == MagicNumber) return;
|
|
|
|
error:
|
|
|
|
PrintError( "Error: magic number not found.\n"
|
|
"File is probably not binary.\n");
|
|
}
|
|
|
|
/* **************************************************************** */
|
|
|
|
void ReadTime(FILE *f)
|
|
{
|
|
if (1 == fread(&time.time, length, 1, f)) return;
|
|
|
|
PrintError("Error: unable to read time.\n");
|
|
}
|
|
|
|
/* **************************************************************** */
|
|
|
|
void ReadBound(FILE *f)
|
|
{
|
|
register int i;
|
|
|
|
for(i = 0; i < 3; i++) {
|
|
if (1 > fread(&bounds.low[i], sizeof(bounds.low[0]), 1, f))
|
|
goto error;
|
|
if (1 > fread(&bounds.high[i], sizeof(bounds.high[0]), 1, f))
|
|
goto error;
|
|
}
|
|
return;
|
|
|
|
error:
|
|
PrintError("Error: unable to read bounds.\n");
|
|
}
|
|
|
|
/* **************************************************************** */
|
|
|
|
void ReadPosition(FILE *f)
|
|
{
|
|
register int i;
|
|
register POSITION *p;
|
|
|
|
npositions = length /
|
|
(sizeof(p->index) + sizeof(p->type) + 3*sizeof(p->coord[0]));
|
|
|
|
if (npositions > maxpositions) {
|
|
maxpositions = npositions + 16;
|
|
positions = (POSITION *)
|
|
Realloc(positions, maxpositions * sizeof(*positions));
|
|
}
|
|
|
|
for(i = npositions, p = positions; i; i--, p++) {
|
|
if (1 > fread(&p->index, sizeof(p->index), 1, f)) goto error;
|
|
if (1 > fread(&p->type, sizeof(p->type), 1, f)) goto error;
|
|
if (1 > fread(&p->coord[0], sizeof(p->coord[0]), 1, f)) goto error;
|
|
if (1 > fread(&p->coord[1], sizeof(p->coord[0]), 1, f)) goto error;
|
|
if (1 > fread(&p->coord[2], sizeof(p->coord[0]), 1, f)) goto error;
|
|
}
|
|
return;
|
|
|
|
error:
|
|
PrintError("Error: unable to get atom positions.\n");
|
|
}
|
|
|
|
/* **************************************************************** */
|
|
|
|
void ReadBond(FILE *f)
|
|
{
|
|
register int i;
|
|
register BOND *b;
|
|
|
|
nbonds = length /
|
|
(sizeof(b->type) + sizeof(b->index1) + sizeof(b->index2));
|
|
|
|
if (nbonds > maxbonds) {
|
|
maxbonds = nbonds + 16;
|
|
bonds = (BOND *)
|
|
Realloc(bonds, maxbonds * sizeof(*bonds));
|
|
}
|
|
|
|
for(i = nbonds, b = bonds; i; i--, b++) {
|
|
if (1 > fread(&b->type, sizeof(b->type), 1, f)) goto error;
|
|
if (1 > fread(&b->index1, sizeof(b->index1), 1, f)) goto error;
|
|
if (1 > fread(&b->index2, sizeof(b->index2), 1, f)) goto error;
|
|
}
|
|
return;
|
|
|
|
error:
|
|
PrintError("Error: unable to get bonds.\n");
|
|
}
|
|
|
|
/* **************************************************************** */
|
|
|
|
int ReadRecordHeader(FILE *f)
|
|
{
|
|
if (1 > fread(&record, sizeof(record), 1, f)) return(FALSE);
|
|
if (1 > fread(&length, sizeof(length), 1, f)) return(FALSE);
|
|
}
|
|
|
|
/* **************************************************************** */
|
|
|
|
void ReadDummy(FILE *f)
|
|
{}
|