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];

  int startFrame = 0;
  int haveStartFrame = 0;
  int endFrame = 0;
  int haveEndFrame = 0;

  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], "--CosCorr" ) ){
          calcCosCorr = 1;
          i++;
          strcpy( cosCorr1, argv[i] );
          i++;
          strcpy( cosCorr2, argv[i] );
        }

        else if( !strcmp( argv[i], "--MuCorr") ){
          calcMuCorr = 1;
          i++;
          strcpy( muCorr, argv[i] );
        }
        
        else if( !strcmp( argv[i], "--startFrame" ) ){
          haveStartFrame = 1;
          i++;
          startFrame = atoi(argv[i]);
          startFrame--;
        }

        else if( !strcmp( argv[i], "--endFrame" ) ){
          haveEndFrame = 1;
          i++;
          endFrame = atoi(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 );
  if( !haveEndFrame ) endFrame = nFrames;

  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));
    }

    //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, startFrame, endFrame );
    
    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( out_prefix, cosCorr1, cosCorr2, dumpArray, nFrames, startFrame, 
             endFrame );
    
    fprintf( stdout, 
             " done.\n"
             "\n");
    fflush(stdout);
  }
  
  return 0;
  
}


void map( double *x, double *y, double *z, 
          double boxX, double boxY, double boxZ ){ 
  
  *x -= boxX * copysign(1.0,*x) * floor( fabs( *x/boxX ) + 0.5  );
  *y -= boxY * copysign(1.0,*y) * floor( fabs( *y/boxY ) + 0.5  );
  *z -= boxZ * copysign(1.0,*z) * floor( fabs( *z/boxZ ) + 0.5  );

}


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