trunk/madProps/madProps.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>


#include "madProps.h"
#include "frameCount.h"

char *program_name; /*the name of the program */

void usage(void);

int main(argc, argv)
     int argc;
     char *argv[];
{


  struct xyz_frame *dumpArray;
  int nFrames; // the nu8mvber of frames
  int lineNum = 0; // keeps track of the line number
  int n_atoms; // the number of atoms
  int i,j; // loop counters
  int isFirst;

  char read_buffer[2000]; /*the line buffer for reading */
  char *foo; /*the pointer to the current string token */
  FILE *in_file; /* the input file */
  char *in_name = NULL; /*the name of the input file */
  char *out_prefix; // the output prefix
  char current_flag; // used in parseing the flags


  int done = 0; // multipurpose boolean
  int have_prefix = 0; // prefix boolean
  int calcRMSD = 0;

  int calcGofR = 0;
  char gofR1[30];
  char gofR2[30];

  int calcMuCorr = 0;
  char muCorr[30];

  int calcCosCorr = 0;
  char cosCorr1[30];
  char cosCorr2[30];

  program_name = argv[0]; /*save the program name in case we need it*/
  
  for( i = 1; i < argc; i++){
    
    if(argv[i][0] =='-'){

      // parse the option
      
      if(argv[i][1] == '-' ){

        // parse long word options
        
        if( !strcmp( argv[i], "--GofR" ) ){
          calcGofR = 1;
          i++;
          strcpy( gofR1, argv[i] );
          i++;
          strcpy( gofR2, argv[i] );
        }

        else if( !strcmp( argv[i], "--MuCorr") ){
          calcMuCorr = 1;
          i++;
          strcpy( muCorr, argv[i] );
        }
        
        else if( !strcmp( argv[i], "--CosCorr" ) ){
          calcCosCorr = 1;
          i++;
          strcpy( cosCorr1, argv[i] );
          i++;
          strcpy( cosCorr2, argv[i] );
        }

        else{
          fprintf( stderr, 
                   "Invalid option \"%s\"\n", argv[i] );
          usage();
        }
      }
      
      else{
        
        // parse single character options
        
        done =0;
        j = 1;
        current_flag = argv[i][j];
        while( (current_flag != '\0') && (!done) ){
          
          switch(current_flag){

          case 'o':
            // -o <prefix> => the output prefix.

            i++;
            out_prefix = argv[i];
            have_prefix = 1;
            done = 1;
            break;

          case 'h':
            // -h => give the usage
            
            usage();
            break;
        
          case 'r':
            // calculates the rmsd

            calcRMSD = 1;
            break;

          case 'g':
            // calculate all to all g(r)

            calcGofR = 1;
            strcpy( gofR1, "all" );
            strcpy( gofR2, "all" );
            break;

          default:

            fprintf( stderr, "about to print bad option\n" );

            (void)fprintf(stderr, "Bad option \"-%s\"\n", current_flag);
            usage();
          }
          j++;
          current_flag = argv[i][j];
        }
      }
    }

    else{
      
      if( in_name != NULL ){
        fprintf( stderr, 
                 "Error at \"%s\", program does not currently support\n"
                 "more than one input file.\n"
                 "\n",
                 argv[i]);
        usage();
      }

      in_name = argv[i];
    }
  }

  if(in_name == NULL){
    usage();
  }

  if( !have_prefix ) out_prefix = in_name;
  
  printf( "Counting number of frames..." );
  fflush( stdout );
  
  nFrames = frameCount( in_name );

  printf( "done.\n"
          "nframes = %d\n"
          "\n",
          nFrames );
  fflush( stdout );

  in_file = fopen(in_name, "r");
  if(in_file == NULL){
    printf("Cannot open file: %s\n", in_name);
    exit(8);
  }

  // create and initialize the array of frames

  dumpArray = (struct xyz_frame*)calloc( nFrames,
                                         sizeof( struct xyz_frame ) );
  for( i=0; i<nFrames; i++ ){
    dumpArray[i].nAtoms = 0;
    dumpArray[i].time   = 0.0;
    dumpArray[i].boxX   = 0.0;
    dumpArray[i].boxY   = 0.0;
    dumpArray[i].boxZ   = 0.0;
    dumpArray[i].r      = NULL;
    dumpArray[i].v      = NULL;
    dumpArray[i].names  = NULL;
  }

  // read the frames
  
  printf( "Reading the frames into the coordinate arrays..." );
  fflush( stdout );

  isFirst = 1;
  for(j =0; j<nFrames; j++ ){
    
    // read the number of atoms

    fgets(read_buffer, sizeof(read_buffer), in_file);
    lineNum++;

    n_atoms = atoi( read_buffer );
    dumpArray[j].nAtoms = n_atoms;

    dumpArray[j].r = 
      (struct coords *)calloc(n_atoms, sizeof(struct coords));
    
    if( isFirst ) {
      dumpArray[0].names = 
        (atomID *)calloc( n_atoms, sizeof(atomID) );
      isFirst = 0;
    }

    if( calcMuCorr || calcCosCorr ){
          dumpArray[j].v = 
            (struct vect *)calloc(n_atoms, sizeof(struct vect));
          printf( " (Note: reading in vectors)... " );
          fflush( stdout );
    }

    //read the time and the box sizes

    fgets(read_buffer, sizeof(read_buffer), in_file);
    lineNum++;
    
    foo = strtok(read_buffer, " ,;\t");
    if(foo == NULL){
      printf("error in reading time at line %d\n", lineNum);
      exit(8);
    }
    
    dumpArray[j].time = atof( foo );
    
    foo = strtok(NULL, " ,;\t");
    if(foo == NULL){
      printf("error in reading boxX at line %d\n", lineNum);
      exit(8);
    }
    
    dumpArray[j].boxX = atof( foo );

    foo = strtok(NULL, " ,;\t");
    if(foo == NULL){
      printf("error in reading boxY at line %d\n", lineNum);
      exit(8);
    }
    
    dumpArray[j].boxY = atof( foo );
    
    foo = strtok(NULL, " ,;\t");
    if(foo == NULL){
      printf("error in reading boxZ at line %d\n", lineNum);
      exit(8);
    }
    
    dumpArray[j].boxZ = atof( foo );


    for( i=0; i < n_atoms; i++){
      
      fgets(read_buffer, sizeof(read_buffer), in_file);
      lineNum++;
      
      // get the name and positions

      foo = strtok(read_buffer, " ,;\t");
      if(foo == NULL){
        printf("error in reading atom name at line %d\n", lineNum );
        exit(8);
      }
      
      strcpy(dumpArray[0].names[i], foo); /*copy the atom name */

      foo = strtok(NULL, " ,;\t");
      if(foo == NULL){
        printf("error in reading position x at line %d\n", lineNum);
        exit(8);
      }
      
      dumpArray[j].r[i].x = atof( foo );

      foo = strtok(NULL, " ,;\t");
      if(foo == NULL){
        printf("error in reading position y at line %d\n", lineNum);
        exit(8);
      }
      
      dumpArray[j].r[i].y = atof( foo );

      foo = strtok(NULL, " ,;\t");
      if(foo == NULL){
        printf("error in reading position z at line %d\n", lineNum);
        exit(8);
      }
      
      dumpArray[j].r[i].z = atof( foo );

      if( calcCosCorr || calcMuCorr ){
        
        foo = strtok(NULL, " ,;\t");
        if(foo == NULL){
                  
          dumpArray[j].v[i].x = 0.0;
          dumpArray[j].v[i].y = 0.0;
          dumpArray[j].v[i].z = 0.0;
        }
        else{

          dumpArray[j].v[i].x = atof( foo );
          
          foo = strtok(NULL, " ,;\t");
          if(foo == NULL){
            printf("error in reading vector y at line %d\n", lineNum);
            exit(8);
          }
          
          dumpArray[j].v[i].y = atof( foo );
          
          foo = strtok(NULL, " ,;\t");
          if(foo == NULL){
            printf("error in reading vector z at line %d\n", lineNum);
            exit(8);
          }
          
          dumpArray[j].v[i].z = atof( foo );
        }
      }
      
    }
  }
  
  (void)fclose(in_file);
  
  printf( "done\n"
          "\n" );
  fflush( stdout );
  
  
  // do calculations here.

  if( calcGofR ){
    
    fprintf( stdout,
             "Calculating the g(r) between atoms \"%s\" and \"%s\"...",
             gofR1, gofR2 );
    fflush( stdout );
    
    // gofr call
    GofR( out_prefix, gofR1, gofR2, dumpArray, nFrames );
    
    fprintf( stdout, 
             " done.\n"
             "\n");
    fflush(stdout);
  }

  if( calcRMSD ){
    
    fprintf( stdout,
             "Calculating the RMSD..." );
    fflush( stdout );
    
    // RMSD call

    
    fprintf( stdout, 
             " done.\n"
             "\n");
    fflush(stdout);
  }

  if( calcMuCorr ){
    
    fprintf( stdout,
             "Calculating the mu correlation for \"%s\"...",
             muCorr);
    fflush( stdout );
    
    // muCorr call

    
    fprintf( stdout, 
             " done.\n"
             "\n");
    fflush(stdout);
  }

  if( calcCosCorr ){
    
    fprintf( stdout,
             "Calculating the cos correlation between \"%s\" and \"%s\"...",
             cosCorr1, cosCorr2 );
    fflush( stdout );
    
    // cosCorr call

    
    fprintf( stdout, 
             " done.\n"
             "\n");
    fflush(stdout);
  }
  
  return 0;
  
}


/***************************************************************************
 * prints out the usage for the command line arguments, then exits.
 ***************************************************************************/

void usage(){
  (void)fprintf(stdout, 
                "The proper usage is: %s [options] <xyz_file>\n"
                "\n"
                "Options:\n"
                "\n"
                "   short:\n"
                "   ------\n"
                "   -h              Display this message\n"
                "   -o <prefix>     The output prefix\n"
                "   -r              Calculate the RMSD\n"
                "   -g              Calculate all to all g(r)\n"
                
                "\n"
                "   long:\n"
                "   -----\n"
                "   --GofR <atom1> <atom2>    Calculates g(r) between atom1 and atom 2\n"
                "                               -note: \"all\" will do all atoms\n"
                "   --MuCorr <atom>           Calculate mu correlation of atom\n"
                "   --CosCorr <atom1> <atom2> Calculate the cos correlation between atom1 and atom2\n"
                
                
                "\n"
                "\n",
                program_name);
  exit(8);
}
Revision:	45
Committed:	Tue Jul 23 16:08:35 2002 UTC (22 years ago) by mmeineke
Content type:	text/plain
File size:	8891 byte(s)
Log Message:	got the GofR code working, and slimmed down the memory usage.
#	User	Rev	Content
1	mmeineke	38	#include <stdio.h>
2			#include <stdlib.h>
3			#include <string.h>
4			#include <math.h>
5
6	mmeineke	43
7			#include "madProps.h"
8	mmeineke	38	#include "frameCount.h"
9
10			char program_name; /the name of the program */
11
12			void usage(void);
13
14			int main(argc, argv)
15			int argc;
16			char *argv[];
17			{
18
19
20			struct xyz_frame *dumpArray;
21			int nFrames; // the nu8mvber of frames
22			int lineNum = 0; // keeps track of the line number
23			int n_atoms; // the number of atoms
24			int i,j; // loop counters
25	mmeineke	45	int isFirst;
26	mmeineke	38
27			char read_buffer[2000]; /the line buffer for reading /
28			char foo; /the pointer to the current string token */
29			FILE in_file; / the input file */
30			char in_name = NULL; /the name of the input file */
31	mmeineke	43	char *out_prefix; // the output prefix
32			char current_flag; // used in parseing the flags
33	mmeineke	38
34
35	mmeineke	43
36			int done = 0; // multipurpose boolean
37			int have_prefix = 0; // prefix boolean
38			int calcRMSD = 0;
39
40			int calcGofR = 0;
41			char gofR1[30];
42			char gofR2[30];
43
44			int calcMuCorr = 0;
45			char muCorr[30];
46
47			int calcCosCorr = 0;
48			char cosCorr1[30];
49			char cosCorr2[30];
50
51	mmeineke	38	program_name = argv[0]; /save the program name in case we need it/
52
53	mmeineke	43	for( i = 1; i < argc; i++){
54	mmeineke	38
55			if(argv[i][0] =='-'){
56	mmeineke	43
57			// parse the option
58	mmeineke	38
59	mmeineke	43	if(argv[i][1] == '-' ){
60
61			// parse long word options
62
63			if( !strcmp( argv[i], "--GofR" ) ){
64			calcGofR = 1;
65			i++;
66			strcpy( gofR1, argv[i] );
67			i++;
68			strcpy( gofR2, argv[i] );
69			}
70
71			else if( !strcmp( argv[i], "--MuCorr") ){
72			calcMuCorr = 1;
73			i++;
74			strcpy( muCorr, argv[i] );
75			}
76
77			else if( !strcmp( argv[i], "--CosCorr" ) ){
78			calcCosCorr = 1;
79			i++;
80			strcpy( cosCorr1, argv[i] );
81			i++;
82			strcpy( cosCorr2, argv[i] );
83			}
84
85			else{
86			fprintf( stderr,
87			"Invalid option \"%s\"\n", argv[i] );
88			usage();
89			}
90			}
91	mmeineke	38
92	mmeineke	43	else{
93	mmeineke	38
94	mmeineke	43	// parse single character options
95
96			done =0;
97			j = 1;
98			current_flag = argv[i][j];
99			while( (current_flag != '\0') && (!done) ){
100
101			switch(current_flag){
102	mmeineke	38
103	mmeineke	43	case 'o':
104			// -o <prefix> => the output prefix.
105	mmeineke	38
106	mmeineke	43	i++;
107			out_prefix = argv[i];
108			have_prefix = 1;
109			done = 1;
110			break;
111
112			case 'h':
113			// -h => give the usage
114
115			usage();
116			break;
117
118			case 'r':
119			// calculates the rmsd
120
121			calcRMSD = 1;
122			break;
123
124			case 'g':
125			// calculate all to all g(r)
126
127			calcGofR = 1;
128			strcpy( gofR1, "all" );
129			strcpy( gofR2, "all" );
130			break;
131
132			default:
133
134			fprintf( stderr, "about to print bad option\n" );
135
136			(void)fprintf(stderr, "Bad option \"-%s\"\n", current_flag);
137			usage();
138			}
139			j++;
140			current_flag = argv[i][j];
141			}
142			}
143			}
144
145			else{
146
147			if( in_name != NULL ){
148			fprintf( stderr,
149			"Error at \"%s\", program does not currently support\n"
150			"more than one input file.\n"
151			"\n",
152			argv[i]);
153	mmeineke	38	usage();
154			}
155	mmeineke	43
156			in_name = argv[i];
157	mmeineke	38	}
158			}
159
160			if(in_name == NULL){
161			usage();
162			}
163	mmeineke	43
164			if( !have_prefix ) out_prefix = in_name;
165	mmeineke	38
166			printf( "Counting number of frames..." );
167			fflush( stdout );
168
169			nFrames = frameCount( in_name );
170
171			printf( "done.\n"
172			"nframes = %d\n"
173			"\n",
174			nFrames );
175			fflush( stdout );
176
177			in_file = fopen(in_name, "r");
178			if(in_file == NULL){
179			printf("Cannot open file: %s\n", in_name);
180			exit(8);
181			}
182
183	mmeineke	45	// create and initialize the array of frames
184	mmeineke	38
185			dumpArray = (struct xyz_frame*)calloc( nFrames,
186			sizeof( struct xyz_frame ) );
187	mmeineke	45	for( i=0; i<nFrames; i++ ){
188			dumpArray[i].nAtoms = 0;
189			dumpArray[i].time = 0.0;
190			dumpArray[i].boxX = 0.0;
191			dumpArray[i].boxY = 0.0;
192			dumpArray[i].boxZ = 0.0;
193			dumpArray[i].r = NULL;
194			dumpArray[i].v = NULL;
195			dumpArray[i].names = NULL;
196			}
197	mmeineke	38
198			// read the frames
199
200			printf( "Reading the frames into the coordinate arrays..." );
201			fflush( stdout );
202
203	mmeineke	45	isFirst = 1;
204	mmeineke	38	for(j =0; j<nFrames; j++ ){
205
206			// read the number of atoms
207
208			fgets(read_buffer, sizeof(read_buffer), in_file);
209			lineNum++;
210
211			n_atoms = atoi( read_buffer );
212			dumpArray[j].nAtoms = n_atoms;
213
214			dumpArray[j].r =
215			(struct coords *)calloc(n_atoms, sizeof(struct coords));
216	mmeineke	45
217			if( isFirst ) {
218			dumpArray[0].names =
219			(atomID *)calloc( n_atoms, sizeof(atomID) );
220			isFirst = 0;
221			}
222	mmeineke	38
223	mmeineke	43	if( calcMuCorr \|\| calcCosCorr ){
224			dumpArray[j].v =
225			(struct vect *)calloc(n_atoms, sizeof(struct vect));
226	mmeineke	45	printf( " (Note: reading in vectors)... " );
227			fflush( stdout );
228	mmeineke	43	}
229
230	mmeineke	38	//read the time and the box sizes
231
232			fgets(read_buffer, sizeof(read_buffer), in_file);
233			lineNum++;
234
235			foo = strtok(read_buffer, " ,;\t");
236			if(foo == NULL){
237			printf("error in reading time at line %d\n", lineNum);
238			exit(8);
239			}
240
241			dumpArray[j].time = atof( foo );
242
243			foo = strtok(NULL, " ,;\t");
244			if(foo == NULL){
245			printf("error in reading boxX at line %d\n", lineNum);
246			exit(8);
247			}
248
249			dumpArray[j].boxX = atof( foo );
250
251			foo = strtok(NULL, " ,;\t");
252			if(foo == NULL){
253			printf("error in reading boxY at line %d\n", lineNum);
254			exit(8);
255			}
256
257			dumpArray[j].boxY = atof( foo );
258
259			foo = strtok(NULL, " ,;\t");
260			if(foo == NULL){
261			printf("error in reading boxZ at line %d\n", lineNum);
262			exit(8);
263			}
264
265			dumpArray[j].boxZ = atof( foo );
266
267
268			for( i=0; i < n_atoms; i++){
269
270			fgets(read_buffer, sizeof(read_buffer), in_file);
271			lineNum++;
272
273			// get the name and positions
274
275			foo = strtok(read_buffer, " ,;\t");
276			if(foo == NULL){
277			printf("error in reading atom name at line %d\n", lineNum );
278			exit(8);
279			}
280
281	mmeineke	45	strcpy(dumpArray[0].names[i], foo); /copy the atom name /
282	mmeineke	38
283			foo = strtok(NULL, " ,;\t");
284			if(foo == NULL){
285			printf("error in reading position x at line %d\n", lineNum);
286			exit(8);
287			}
288
289			dumpArray[j].r[i].x = atof( foo );
290
291			foo = strtok(NULL, " ,;\t");
292			if(foo == NULL){
293			printf("error in reading position y at line %d\n", lineNum);
294			exit(8);
295			}
296
297			dumpArray[j].r[i].y = atof( foo );
298
299			foo = strtok(NULL, " ,;\t");
300			if(foo == NULL){
301			printf("error in reading position z at line %d\n", lineNum);
302			exit(8);
303			}
304
305			dumpArray[j].r[i].z = atof( foo );
306	mmeineke	43
307			if( calcCosCorr \|\| calcMuCorr ){
308
309			foo = strtok(NULL, " ,;\t");
310			if(foo == NULL){
311
312			dumpArray[j].v[i].x = 0.0;
313			dumpArray[j].v[i].y = 0.0;
314			dumpArray[j].v[i].z = 0.0;
315			}
316			else{
317
318			dumpArray[j].v[i].x = atof( foo );
319
320			foo = strtok(NULL, " ,;\t");
321			if(foo == NULL){
322			printf("error in reading vector y at line %d\n", lineNum);
323			exit(8);
324			}
325
326			dumpArray[j].v[i].y = atof( foo );
327
328			foo = strtok(NULL, " ,;\t");
329			if(foo == NULL){
330			printf("error in reading vector z at line %d\n", lineNum);
331			exit(8);
332			}
333
334			dumpArray[j].v[i].z = atof( foo );
335			}
336			}
337
338	mmeineke	38	}
339			}
340
341			(void)fclose(in_file);
342
343			printf( "done\n"
344			"\n" );
345			fflush( stdout );
346
347
348
349			// do calculations here.
350
351	mmeineke	43	if( calcGofR ){
352
353			fprintf( stdout,
354			"Calculating the g(r) between atoms \"%s\" and \"%s\"...",
355			gofR1, gofR2 );
356			fflush( stdout );
357
358			// gofr call
359			GofR( out_prefix, gofR1, gofR2, dumpArray, nFrames );
360
361			fprintf( stdout,
362			" done.\n"
363			"\n");
364			fflush(stdout);
365			}
366	mmeineke	38
367	mmeineke	43	if( calcRMSD ){
368
369			fprintf( stdout,
370			"Calculating the RMSD..." );
371			fflush( stdout );
372
373			// RMSD call
374	mmeineke	38
375	mmeineke	43
376			fprintf( stdout,
377			" done.\n"
378			"\n");
379			fflush(stdout);
380			}
381	mmeineke	38
382	mmeineke	43	if( calcMuCorr ){
383
384			fprintf( stdout,
385			"Calculating the mu correlation for \"%s\"...",
386			muCorr);
387			fflush( stdout );
388
389			// muCorr call
390	mmeineke	38
391	mmeineke	43
392			fprintf( stdout,
393			" done.\n"
394			"\n");
395			fflush(stdout);
396			}
397
398			if( calcCosCorr ){
399
400			fprintf( stdout,
401			"Calculating the cos correlation between \"%s\" and \"%s\"...",
402			cosCorr1, cosCorr2 );
403			fflush( stdout );
404
405			// cosCorr call
406
407
408			fprintf( stdout,
409			" done.\n"
410			"\n");
411			fflush(stdout);
412			}
413	mmeineke	38
414			return 0;
415
416			}
417
418
419
420			/***************************************************************************
421			* prints out the usage for the command line arguments, then exits.
422			***************************************************************************/
423
424			void usage(){
425	mmeineke	43	(void)fprintf(stdout,
426			"The proper usage is: %s [options] <xyz_file>\n"
427			"\n"
428			"Options:\n"
429			"\n"
430			" short:\n"
431			" ------\n"
432			" -h Display this message\n"
433			" -o <prefix> The output prefix\n"
434			" -r Calculate the RMSD\n"
435			" -g Calculate all to all g(r)\n"
436
437			"\n"
438			" long:\n"
439			" -----\n"
440			" --GofR <atom1> <atom2> Calculates g(r) between atom1 and atom 2\n"
441			" -note: \"all\" will do all atoms\n"
442			" --MuCorr <atom> Calculate mu correlation of atom\n"
443			" --CosCorr <atom1> <atom2> Calculate the cos correlation between atom1 and atom2\n"
444
445
446			"\n"
447			"\n",
448	mmeineke	38	program_name);
449			exit(8);
450			}