trunk/tcProps/readWrite.c

#define _FILE_OFFSET_BITS 64

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <string.h>

#include "params.h"
#include "tcProps.h"
#include "readWrite.h"


#define BUFFER_SIZE 2000
int isScanned;
int fileOpen;
int nFrames;
double *frameTimes;
FILE* inFile;


struct linkedPos{
  
  fpos_t *myPos;
  double timeStamp;
  double Hmat[3][3];
  struct linkedPos* next;
};

struct staticPos{
    
  fpos_t *myPos;
  double Hmat[3][3];
};
struct staticPos* posArray;

void parseDumpLine( char readBuffer[BUFFER_SIZE], int index, 
                    struct atomCoord* atoms );

void openFile( char* inName ){
  
  inFile = fopen(inName);
  if(inFile ==NULL){
    fprintf(stderr,
            "Error opening file \"%s\"\n",
            inName);
    exit(0);
  }

  fileOpen = 1;
}  

void closeFile( void ){

  fclose( inFile );

  fileOpen = 0;
}

int setFrames( void ){

  int i,j,k;
  struct linkedPos* headPos;
  struct linkedPos* currPos;
  fpos_t *currPT;
  char readBuffer[BUFFER_SIZE];
  char trash[BUFFER_SIZE];
  char* foo;
  int lineNum = 0;
  
  
  if( !fileOpen ){
    fprintf(stderr,
            "Attempt to scan the file without first opening the file.\n" );
    exit(0);
  }


  nFrames = 0;
  headPos = (struct linkedPos*)malloc(sizeof(struct linkedPos));
  currPos = headPos;
  while( !feof( inFile ) ){

    currPT = (fpos_t *)malloc(sizeof(fpos_t));
    fgetpos(inFile, currPT);
    
    fgets( readBuffer, sizeof( readBuffer ), inFile );
    lineNum++;
    if( feof( inFile ) ){
      fprintf( stderr,
               "File \"%s\" ended unexpectedly at line %d\n", 
               inName,
               lineNum );
      exit(0);
    }
    
    currPos->next = (struct linkedPos*)malloc(sizeof(struct linkedPos));
    currPos = currPos->next;
    currPos->myPos = currPT;      
    nFrames++;

    i = atoi(readBuffer);

    fgets( readBuffer, sizeof( readBuffer ), inFile );
    lineNum++;
    if( feof( inFile ) ){
      fprintf( stderr,
               "File \"%s\" ended unexpectedly at line %d\n", 
               inName,
               lineNum );
      exit(0);
    }
    
    
    // parse the comment line
    
    foo = strtok(readBuffer, " ,;\t");
      
    if(foo == NULL){
      fprintf(stderr,
              "error in reading time from %s at line %d\n",
              inName, lineNum );
      exit(0);
    }
    currPos->timeStamp = atof( foo );
      
    // get the Hx vector
      
    foo = strtok(NULL, " ,;\t");
    if(foo == NULL){
      fprintf(stderr,
              "error in reading Hx[0] from %s at line %d\n",
              inName, lineNum );
      exit(0);
    }
    currPos->Hmat[0][0] = atof( foo );
      
    foo = strtok(NULL, " ,;\t");
    if(foo == NULL){
      fprintf(stderr,
              "error in reading Hx[1] from %s at line %d\n",
              inName, lineNum );
      exit(0);
    }
    currPos->Hmat[1][0] = atof( foo );
      
    foo = strtok(NULL, " ,;\t");
    if(foo == NULL){
      fprintf(stderr,
              "error in reading Hx[2] from %s at line %d\n",
              inName, lineNum );
      exit(0);
    }
    currPos->Hmat[2][0] = atof( foo );    
      
    // get the Hy vector
      
    foo = strtok(NULL, " ,;\t");
    if(foo == NULL){
      fprintf(stderr,
              "error in reading Hy[0] from %s at line %d\n",
              inName, lineNum );
      exit(0);
    }
    currPos->Hmat[0][1] = atof( foo );
      
    foo = strtok(NULL, " ,;\t");
    if(foo == NULL){
      fprintf(stderr,
              "error in reading Hy[1] from %s at line %d\n",
              inName, lineNum );
      exit(0);
    }
    currPos->Hmat[1][1] = atof( foo );
      
    foo = strtok(NULL, " ,;\t");
    if(foo == NULL){
      fprintf(stderr,
              "error in reading Hy[2] from %s at line %d\n",
              inName, lineNum );
      exit(0);
    }
    currPos->Hmat[2][1] = atof( foo );    
      
    // get the Hz vector
      
    foo = strtok(NULL, " ,;\t");
    if(foo == NULL){
      fprintf(stderr,
              "error in reading Hz[0] from %s at line %d\n",
              inName, lineNum );
      exit(0);
    }
    currPos->Hmat[0][2] = atof( foo );
      
    foo = strtok(NULL, " ,;\t");
    if(foo == NULL){
      fprintf(stderr,
              "error in reading Hz[1] from %s at line %d\n",
              inName, lineNum );
      exit(0);
    }
    currPos->Hmat[1][2] = atof( foo );
      
    foo = strtok(NULL, " ,;\t");
    if(foo == NULL){
      fprintf(stderr,
              "error in reading Hz[2] from %s at line %d\n",
              inName, lineNum );
      exit(0);
    }
    currPos->Hmat[2][2] = atof( foo );
    
    // skip the atoms

    for(j=0; j<i; j++){
      
      fgets( readBuffer, sizeof( readBuffer ), inFile );
      lineNum++;    
      if( feof( inFile ) ){
        fprintf( stderr,
                 "File \"%s\" ended unexpectedly at line %d,"
                 " with atom %d\n", 
                 inName,
                 lineNum, 
                 j );
        exit(0);
      }
    }
  }
  
  // allocate the static position array

  posArray = (struct staticPos*)calloc(nFrames, sizeof(struct staticPos));
  frameTimes = (double *)calloc(nFrames, sizeof(double) );

  i=0;
  currPos = headPos->next;
  while( currPos != NULL ){
    
    if(i>=nFrames){
      
      fprintf( stderr,
               "The number of frame pointers exceeded the number of frames.\n"
               "  OOPS!\n" );
      exit(0);
    }
    
    frameTimes[i] = currPos->timeStamp;
    posArray[i].myPos = currPos->myPos;
    for(j=0;j<3;j++){
      for(k=0;k<3;k++){
        posArray[i].Hmat[j][k] = currPos->Hmat[j][k];
      }
    }

    i++;
    currPos = currPos->next;
  }  

  // clean up the linked list

  currPos = headPos;
  while( currPos != NULL ){
    headPos = currPos;
    currPos = headPos->next;
    free(headPos);
  }


  isScanned = 1;
}


void readFrame(int theFrame, struct atomCoord* atoms, double Hmat[3][3] ){

  // list of 'a priori' constants

  const int nLipAtoms = NL_ATOMS;
  const int nBonds    = NBONDS;
  const int nLipids   = NLIPIDS;
  const int nSSD      = NSSD;
  const int nAtoms    = nLipAtoms * nLipids + nSSD;

  fpos_t *framePos;
  char readBuffer[BUFFER_SIZE];

  int i, j, k;


  // quick checks

  if (theFrame >= nFrames){
    
    fprintf(stderr,
            "frame %d, is out of range\n",
            theFrame );
    exit(0);
  }

  if( !fileOpen ){
    
    fprintf( stderr,
             "File is closed, cannot read frame %d.\n"
             theFrame );
    exit(0);
  }

  // access the frame
  
  framePos = posArray[theFrame].myPos;
  fsetPos( inFile, framePos );

  for(j=0;j<3;j++){
    for(k=0;k<3;k++){
      Hmat[j][k] = posArray[theFrame].Hmat[j][k];
    }
  }
  
  fgets( readBuffer, sizeof( readBuffer ), inFile );
  if( feof( inFile ) ){
    fprintf( stderr,
             "File \"%s\" ended unexpectedly in Frame %d\n", 
             inName,
             theFrame );
    exit(0);
  }
  
  i = atoi( readBuffer );
  if( i != nAtoms ){
    fprintf( stderr,
             "Error in frame %d: frame atoms, %d, does not params atoms, %d\n",
             theFrame,
             i,
             nAtoms );
    exit(0);
  }

  // read and toss the comment line

  fgets( readBuffer, sizeof( readBuffer ), inFile );
  if( feof( inFile ) ){
    fprintf( stderr,
             "File \"%s\" ended unexpectedly in Frame %d\n", 
             inName,
             theFrame );
    exit(0);
  }

  // read the atoms

  for( i=0; i < nAtoms; i++){
    
    fgets( readBuffer, sizeof( readBuffer ), inFile );
    if( feof( inFile ) ){
      fprintf( stderr,
               "File \"%s\" ended unexpectedly in Frame %d at atom %d\n", 
               inName,
               theFrame,
               i );
      exit(0);
    }

    
    parseDumpLine( readBuffer, i, atoms );
  }
}

void parseDumpLine( char readLine[BUFFER_SIZE], int index, 
                    struct atomCoord* atoms ){
  char* foo;
  double q[4];

  // set the string tokenizer
  
  foo = strtok(readLine, " ,;\t");
  
  // check the atom ID

  switch( atoms[index].type ){
    
  case HEAD:
    if( strcmp(foo, "HEAD") ){
      fprintf( stderr,
               "Atom %s does not match master array type \"HEAD\".\n"
               foo );
      exit(0);
    }
    break;

  case CH:
    if( strcmp(foo, "CH") ){
      fprintf( stderr,
               "Atom %s does not match master array type \"CH\".\n"
               foo );
      exit(0);
    }
    break;

  case CH2:
    if( strcmp(foo, "CH2") ){
      fprintf( stderr,
               "Atom %s does not match master array type \"CH2\".\n"
               foo );
      exit(0);
    }
    break;

  case CH3:
    if( strcmp(foo, "CH3") ){
      fprintf( stderr,
               "Atom %s does not match master array type \"CH3\".\n"
               foo );
      exit(0);
    }
    break;

  case SSD:
    if( strcmp(foo, "SSD") ){
      fprintf( stderr,
               "Atom %s does not match master array type \"SSD\".\n"
               foo );
      exit(0);
    }
    break;
      
  default:
    fprintf(stderr,
            "Atom %d is an unrecognized enumeration\n",
            index );
    exit(0);
  }
  
  // get the positions
  
  foo = strtok(NULL, " ,;\t");
  if(foo == NULL){
    fprintf( stderr,
             "error in reading postition x from %s\n"
             "natoms  = %d, index = %d\n",
             inName, nAtoms, index );
    exit(0);
  }
  atoms[i].pos[0] = atof( foo );
   
  foo = strtok(NULL, " ,;\t");
  if(foo == NULL){
    fprintf( stderr,
             "error in reading postition y from %s\n"
             "natoms  = %d, index = %d\n",
             inName, nAtoms, index );
    exit(0);
  }
  atoms[i].pos[1] = atof( foo );
     
  foo = strtok(NULL, " ,;\t");
  if(foo == NULL){
    fprintf( stderr,
             "error in reading postition z from %s\n"
             "natoms  = %d, index = %d\n",
             inName, nAtoms, index );
    exit(0);
  }
  atoms[i].pos[2] = atof( foo );    


  // get the velocities

  foo = strtok(NULL, " ,;\t");
  if(foo == NULL){
    fprintf( stderr,
             "error in reading velocity x from %s\n"
             "natoms  = %d, index = %d\n",
             inName, nAtoms, index );
    exit(0);
  }
  atoms[i].vel[0] = atof( foo );
    
  foo = strtok(NULL, " ,;\t");
  if(foo == NULL){
    fprintf( stderr,
             "error in reading velocity y from %s\n"
             "natoms  = %d, index = %d\n",
             inName, nAtoms, index );
    exit(0);
  }
  atoms[i].vel[1] = atof( foo );
    
  foo = strtok(NULL, " ,;\t");
  if(foo == NULL){
    fprintf( stderr,
             "error in reading velocity z from %s\n"
             "natoms  = %d, index = %d\n",
             inName, nAtoms, index );
    exit(0);
  }
  atoms[i].vel[2] = atof( foo );
    
    
  // get the quaternions
    
  if( (atoms[i].type == HEAD) || (atoms[i].type == SSD) ){
      
    foo = strtok(NULL, " ,;\t");
    if(foo == NULL){
      sprintf(painCave.errMsg,
              "error in reading quaternion 0 from %s\n"
              "natoms  = %d, index = %d\n",
              inName, nAtoms, index );
      exit(0);
    }
    q[0] = atof( foo );
      
    foo = strtok(NULL, " ,;\t");
    if(foo == NULL){
      fprintf( stderr,
               "error in reading quaternion 1 from %s\n"
               "natoms  = %d, index = %d\n",
               inName, nAtoms, index );
      exit(0);
    }
    q[1] = atof( foo );
      
    foo = strtok(NULL, " ,;\t");
    if(foo == NULL){
      fprintf( stderr,
               "error in reading quaternion 2 from %s\n"
               "natoms  = %d, index = %d\n",
               inName, nAtoms, index );
      exit(0);
    }
    q[2] = atof( foo );
      
    foo = strtok(NULL, " ,;\t");
    if(foo == NULL){
      fprintf( stderr,
               "error in reading quaternion 3 from %s\n"
               "natoms  = %d, index = %d\n",
               inName, nAtoms, index );
      exit(0);
    }
    q[3] = atof( foo );
  }


}
Revision:	1056
Committed:	Tue Feb 17 14:30:48 2004 UTC (20 years, 5 months ago) by mmeineke
Content type:	text/plain
File size:	11257 byte(s)
Log Message:	lmost finished with the readWrite routines
#	Content
1	#define _FILE_OFFSET_BITS 64
2
3	#include <stdio.h>
4	#include <stdlib.h>
5	#include <sys/types.h>
6	#include <sys/stat.h>
7	#include <string.h>
8
9	#include "params.h"
10	#include "tcProps.h"
11	#include "readWrite.h"
12
13
14	#define BUFFER_SIZE 2000
15	int isScanned;
16	int fileOpen;
17	int nFrames;
18	double *frameTimes;
19	FILE* inFile;
20
21
22	struct linkedPos{
23
24	fpos_t *myPos;
25	double timeStamp;
26	double Hmat[3][3];
27	struct linkedPos* next;
28	};
29
30	struct staticPos{
31
32	fpos_t *myPos;
33	double Hmat[3][3];
34	};
35	struct staticPos* posArray;
36
37	void parseDumpLine( char readBuffer[BUFFER_SIZE], int index,
38	struct atomCoord* atoms );
39
40	void openFile( char* inName ){
41
42	inFile = fopen(inName);
43	if(inFile ==NULL){
44	fprintf(stderr,
45	"Error opening file \"%s\"\n",
46	inName);
47	exit(0);
48	}
49
50	fileOpen = 1;
51	}
52
53	void closeFile( void ){
54
55	fclose( inFile );
56
57	fileOpen = 0;
58	}
59
60	int setFrames( void ){
61
62	int i,j,k;
63	struct linkedPos* headPos;
64	struct linkedPos* currPos;
65	fpos_t *currPT;
66	char readBuffer[BUFFER_SIZE];
67	char trash[BUFFER_SIZE];
68	char* foo;
69	int lineNum = 0;
70
71
72	if( !fileOpen ){
73	fprintf(stderr,
74	"Attempt to scan the file without first opening the file.\n" );
75	exit(0);
76	}
77
78
79	nFrames = 0;
80	headPos = (struct linkedPos*)malloc(sizeof(struct linkedPos));
81	currPos = headPos;
82	while( !feof( inFile ) ){
83
84	currPT = (fpos_t *)malloc(sizeof(fpos_t));
85	fgetpos(inFile, currPT);
86
87	fgets( readBuffer, sizeof( readBuffer ), inFile );
88	lineNum++;
89	if( feof( inFile ) ){
90	fprintf( stderr,
91	"File \"%s\" ended unexpectedly at line %d\n",
92	inName,
93	lineNum );
94	exit(0);
95	}
96
97	currPos->next = (struct linkedPos*)malloc(sizeof(struct linkedPos));
98	currPos = currPos->next;
99	currPos->myPos = currPT;
100	nFrames++;
101
102	i = atoi(readBuffer);
103
104	fgets( readBuffer, sizeof( readBuffer ), inFile );
105	lineNum++;
106	if( feof( inFile ) ){
107	fprintf( stderr,
108	"File \"%s\" ended unexpectedly at line %d\n",
109	inName,
110	lineNum );
111	exit(0);
112	}
113
114
115	// parse the comment line
116
117	foo = strtok(readBuffer, " ,;\t");
118
119	if(foo == NULL){
120	fprintf(stderr,
121	"error in reading time from %s at line %d\n",
122	inName, lineNum );
123	exit(0);
124	}
125	currPos->timeStamp = atof( foo );
126
127	// get the Hx vector
128
129	foo = strtok(NULL, " ,;\t");
130	if(foo == NULL){
131	fprintf(stderr,
132	"error in reading Hx[0] from %s at line %d\n",
133	inName, lineNum );
134	exit(0);
135	}
136	currPos->Hmat[0][0] = atof( foo );
137
138	foo = strtok(NULL, " ,;\t");
139	if(foo == NULL){
140	fprintf(stderr,
141	"error in reading Hx[1] from %s at line %d\n",
142	inName, lineNum );
143	exit(0);
144	}
145	currPos->Hmat[1][0] = atof( foo );
146
147	foo = strtok(NULL, " ,;\t");
148	if(foo == NULL){
149	fprintf(stderr,
150	"error in reading Hx[2] from %s at line %d\n",
151	inName, lineNum );
152	exit(0);
153	}
154	currPos->Hmat[2][0] = atof( foo );
155
156	// get the Hy vector
157
158	foo = strtok(NULL, " ,;\t");
159	if(foo == NULL){
160	fprintf(stderr,
161	"error in reading Hy[0] from %s at line %d\n",
162	inName, lineNum );
163	exit(0);
164	}
165	currPos->Hmat[0][1] = atof( foo );
166
167	foo = strtok(NULL, " ,;\t");
168	if(foo == NULL){
169	fprintf(stderr,
170	"error in reading Hy[1] from %s at line %d\n",
171	inName, lineNum );
172	exit(0);
173	}
174	currPos->Hmat[1][1] = atof( foo );
175
176	foo = strtok(NULL, " ,;\t");
177	if(foo == NULL){
178	fprintf(stderr,
179	"error in reading Hy[2] from %s at line %d\n",
180	inName, lineNum );
181	exit(0);
182	}
183	currPos->Hmat[2][1] = atof( foo );
184
185	// get the Hz vector
186
187	foo = strtok(NULL, " ,;\t");
188	if(foo == NULL){
189	fprintf(stderr,
190	"error in reading Hz[0] from %s at line %d\n",
191	inName, lineNum );
192	exit(0);
193	}
194	currPos->Hmat[0][2] = atof( foo );
195
196	foo = strtok(NULL, " ,;\t");
197	if(foo == NULL){
198	fprintf(stderr,
199	"error in reading Hz[1] from %s at line %d\n",
200	inName, lineNum );
201	exit(0);
202	}
203	currPos->Hmat[1][2] = atof( foo );
204
205	foo = strtok(NULL, " ,;\t");
206	if(foo == NULL){
207	fprintf(stderr,
208	"error in reading Hz[2] from %s at line %d\n",
209	inName, lineNum );
210	exit(0);
211	}
212	currPos->Hmat[2][2] = atof( foo );
213
214	// skip the atoms
215
216	for(j=0; j<i; j++){
217
218	fgets( readBuffer, sizeof( readBuffer ), inFile );
219	lineNum++;
220	if( feof( inFile ) ){
221	fprintf( stderr,
222	"File \"%s\" ended unexpectedly at line %d,"
223	" with atom %d\n",
224	inName,
225	lineNum,
226	j );
227	exit(0);
228	}
229	}
230	}
231
232	// allocate the static position array
233
234	posArray = (struct staticPos*)calloc(nFrames, sizeof(struct staticPos));
235	frameTimes = (double *)calloc(nFrames, sizeof(double) );
236
237	i=0;
238	currPos = headPos->next;
239	while( currPos != NULL ){
240
241	if(i>=nFrames){
242
243	fprintf( stderr,
244	"The number of frame pointers exceeded the number of frames.\n"
245	" OOPS!\n" );
246	exit(0);
247	}
248
249	frameTimes[i] = currPos->timeStamp;
250	posArray[i].myPos = currPos->myPos;
251	for(j=0;j<3;j++){
252	for(k=0;k<3;k++){
253	posArray[i].Hmat[j][k] = currPos->Hmat[j][k];
254	}
255	}
256
257	i++;
258	currPos = currPos->next;
259	}
260
261	// clean up the linked list
262
263	currPos = headPos;
264	while( currPos != NULL ){
265	headPos = currPos;
266	currPos = headPos->next;
267	free(headPos);
268	}
269
270
271	isScanned = 1;
272	}
273
274
275	void readFrame(int theFrame, struct atomCoord* atoms, double Hmat[3][3] ){
276
277	// list of 'a priori' constants
278
279	const int nLipAtoms = NL_ATOMS;
280	const int nBonds = NBONDS;
281	const int nLipids = NLIPIDS;
282	const int nSSD = NSSD;
283	const int nAtoms = nLipAtoms * nLipids + nSSD;
284
285	fpos_t *framePos;
286	char readBuffer[BUFFER_SIZE];
287
288	int i, j, k;
289
290
291	// quick checks
292
293	if (theFrame >= nFrames){
294
295	fprintf(stderr,
296	"frame %d, is out of range\n",
297	theFrame );
298	exit(0);
299	}
300
301	if( !fileOpen ){
302
303	fprintf( stderr,
304	"File is closed, cannot read frame %d.\n"
305	theFrame );
306	exit(0);
307	}
308
309	// access the frame
310
311	framePos = posArray[theFrame].myPos;
312	fsetPos( inFile, framePos );
313
314	for(j=0;j<3;j++){
315	for(k=0;k<3;k++){
316	Hmat[j][k] = posArray[theFrame].Hmat[j][k];
317	}
318	}
319
320	fgets( readBuffer, sizeof( readBuffer ), inFile );
321	if( feof( inFile ) ){
322	fprintf( stderr,
323	"File \"%s\" ended unexpectedly in Frame %d\n",
324	inName,
325	theFrame );
326	exit(0);
327	}
328
329	i = atoi( readBuffer );
330	if( i != nAtoms ){
331	fprintf( stderr,
332	"Error in frame %d: frame atoms, %d, does not params atoms, %d\n",
333	theFrame,
334	i,
335	nAtoms );
336	exit(0);
337	}
338
339	// read and toss the comment line
340
341	fgets( readBuffer, sizeof( readBuffer ), inFile );
342	if( feof( inFile ) ){
343	fprintf( stderr,
344	"File \"%s\" ended unexpectedly in Frame %d\n",
345	inName,
346	theFrame );
347	exit(0);
348	}
349
350	// read the atoms
351
352	for( i=0; i < nAtoms; i++){
353
354	fgets( readBuffer, sizeof( readBuffer ), inFile );
355	if( feof( inFile ) ){
356	fprintf( stderr,
357	"File \"%s\" ended unexpectedly in Frame %d at atom %d\n",
358	inName,
359	theFrame,
360	i );
361	exit(0);
362	}
363
364
365	parseDumpLine( readBuffer, i, atoms );
366	}
367	}
368
369	void parseDumpLine( char readLine[BUFFER_SIZE], int index,
370	struct atomCoord* atoms ){
371	char* foo;
372	double q[4];
373
374	// set the string tokenizer
375
376	foo = strtok(readLine, " ,;\t");
377
378	// check the atom ID
379
380	switch( atoms[index].type ){
381
382	case HEAD:
383	if( strcmp(foo, "HEAD") ){
384	fprintf( stderr,
385	"Atom %s does not match master array type \"HEAD\".\n"
386	foo );
387	exit(0);
388	}
389	break;
390
391	case CH:
392	if( strcmp(foo, "CH") ){
393	fprintf( stderr,
394	"Atom %s does not match master array type \"CH\".\n"
395	foo );
396	exit(0);
397	}
398	break;
399
400	case CH2:
401	if( strcmp(foo, "CH2") ){
402	fprintf( stderr,
403	"Atom %s does not match master array type \"CH2\".\n"
404	foo );
405	exit(0);
406	}
407	break;
408
409	case CH3:
410	if( strcmp(foo, "CH3") ){
411	fprintf( stderr,
412	"Atom %s does not match master array type \"CH3\".\n"
413	foo );
414	exit(0);
415	}
416	break;
417
418	case SSD:
419	if( strcmp(foo, "SSD") ){
420	fprintf( stderr,
421	"Atom %s does not match master array type \"SSD\".\n"
422	foo );
423	exit(0);
424	}
425	break;
426
427	default:
428	fprintf(stderr,
429	"Atom %d is an unrecognized enumeration\n",
430	index );
431	exit(0);
432	}
433
434	// get the positions
435
436	foo = strtok(NULL, " ,;\t");
437	if(foo == NULL){
438	fprintf( stderr,
439	"error in reading postition x from %s\n"
440	"natoms = %d, index = %d\n",
441	inName, nAtoms, index );
442	exit(0);
443	}
444	atoms[i].pos[0] = atof( foo );
445
446	foo = strtok(NULL, " ,;\t");
447	if(foo == NULL){
448	fprintf( stderr,
449	"error in reading postition y from %s\n"
450	"natoms = %d, index = %d\n",
451	inName, nAtoms, index );
452	exit(0);
453	}
454	atoms[i].pos[1] = atof( foo );
455
456	foo = strtok(NULL, " ,;\t");
457	if(foo == NULL){
458	fprintf( stderr,
459	"error in reading postition z from %s\n"
460	"natoms = %d, index = %d\n",
461	inName, nAtoms, index );
462	exit(0);
463	}
464	atoms[i].pos[2] = atof( foo );
465
466
467	// get the velocities
468
469	foo = strtok(NULL, " ,;\t");
470	if(foo == NULL){
471	fprintf( stderr,
472	"error in reading velocity x from %s\n"
473	"natoms = %d, index = %d\n",
474	inName, nAtoms, index );
475	exit(0);
476	}
477	atoms[i].vel[0] = atof( foo );
478
479	foo = strtok(NULL, " ,;\t");
480	if(foo == NULL){
481	fprintf( stderr,
482	"error in reading velocity y from %s\n"
483	"natoms = %d, index = %d\n",
484	inName, nAtoms, index );
485	exit(0);
486	}
487	atoms[i].vel[1] = atof( foo );
488
489	foo = strtok(NULL, " ,;\t");
490	if(foo == NULL){
491	fprintf( stderr,
492	"error in reading velocity z from %s\n"
493	"natoms = %d, index = %d\n",
494	inName, nAtoms, index );
495	exit(0);
496	}
497	atoms[i].vel[2] = atof( foo );
498
499
500	// get the quaternions
501
502	if( (atoms[i].type == HEAD) \|\| (atoms[i].type == SSD) ){
503
504	foo = strtok(NULL, " ,;\t");
505	if(foo == NULL){
506	sprintf(painCave.errMsg,
507	"error in reading quaternion 0 from %s\n"
508	"natoms = %d, index = %d\n",
509	inName, nAtoms, index );
510	exit(0);
511	}
512	q[0] = atof( foo );
513
514	foo = strtok(NULL, " ,;\t");
515	if(foo == NULL){
516	fprintf( stderr,
517	"error in reading quaternion 1 from %s\n"
518	"natoms = %d, index = %d\n",
519	inName, nAtoms, index );
520	exit(0);
521	}
522	q[1] = atof( foo );
523
524	foo = strtok(NULL, " ,;\t");
525	if(foo == NULL){
526	fprintf( stderr,
527	"error in reading quaternion 2 from %s\n"
528	"natoms = %d, index = %d\n",
529	inName, nAtoms, index );
530	exit(0);
531	}
532	q[2] = atof( foo );
533
534	foo = strtok(NULL, " ,;\t");
535	if(foo == NULL){
536	fprintf( stderr,
537	"error in reading quaternion 3 from %s\n"
538	"natoms = %d, index = %d\n",
539	inName, nAtoms, index );
540	exit(0);
541	}
542	q[3] = atof( foo );
543	}
544
545
546
547
548
549	}