trunk/tcProps/tcProps.c

#define _FILE_OFFSET_BITS 64

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


#include "params.h"
#include "tcProps.h"
#include "readWrite.h"
#include "scdCorr.h"
#include "directorHead.h"
#include "directorWhole.h"
#include "rmsd.h"
#include "gofz.h"


#define VERSION_MAJOR 0
#define VERSION_MINOR 1

char *programName; /*the name of the program */
void usage(void);

int main( int argC, char *argV[] ){

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

  // different needed variables
  
  struct atomCoord atoms[nAtoms];
  int i,j,k;
  
  char* outPrefix; // the output prefix
  char currentFlag; // used in parsing the flags
  int done = 0; // multipurpose boolean
  int havePrefix; // boolean for the output prefix  
  int haveMaxLength;
  char* conversionCheck;
  int conversionError;
  int optionError;
  char* pair1;
  char* pair2;
  int scdCorr;
  double startTime;
  double maxLength;
  int directorHead, directorWhole, doRMSD, doGofz;
  enum atomNames rmsdType;

  // system initialization
  
  isScanned = 0;
  fileOpen = 0;
  nFrames = 0;
  frameTimes = NULL;

  outPrefix = NULL;
  inName = NULL;
  
  haveMaxLength = 0;
  conversionError = 0;
  optionError = 0;
  havePrefix = 0;
  scdCorr = 0;
  startTime = 0.0;
  directorHead = 0;
  directorWhole = 0;
  doRMSD = 0;
  doGofz = 0;
  

  // parse the command line

  programName = 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], "--rmsd" ) ){

          doRMSD = 1;
          i++;
          if( i>=argC ){
            fprintf( stderr,
                     "\n"
                     "not enough arguments for --rmsd\n");
            usage();
            exit(0);
          }       
          pair1 = argV[i];

          if( !strcmp(pair1, "HEAD") )    rmsdType = HEAD;
          else if( !strcmp(pair1, "CH") ) rmsdType = CH;
          else if( !strcmp(pair1, "CH2") )rmsdType = CH2;
          else if( !strcmp(pair1, "CH3") )rmsdType = CH3;
          else if( !strcmp(pair1, "SSD") )rmsdType = SSD;
          else if( !strcmp(pair1, "COM") )rmsdType = COM;
          else{
            fprintf( stderr,
                     "Unrecognized rmsd atom type \"%s\"\n",
                     pair1 );
            exit(0);
          }

        }

        else if( !strcmp( argV[i], "--gofrTheta" ) ){
          
          i++;
          if( i>=argC ){
            fprintf( stderr,
                     "\n"
                     "not enough arguments for --gofrTheta\n");
            usage();
            exit(0);
          }       
          pair1 = argV[i];

          i++;
          if( i>=argC ){
            fprintf( stderr,
                     "\n"
                     "not enough arguments for --gofrTheta\n");
            usage();
            exit(0);
          }       
          pair2 = argV[i];

        }

        else if( !strcmp( argV[i], "--gofrOmega" ) ){
          
          i++;
          if( i>=argC ){
            fprintf( stderr,
                     "\n"
                     "not enough arguments for --gofrOmega\n");
            usage();
            exit(0);
          }       
          pair1 = argV[i];

          i++;
          if( i>=argC ){
            fprintf( stderr,
                     "\n"
                     "not enough arguments for --gofrOmega\n");
            usage();
            exit(0);
          }       
          pair2 = argV[i];

        }

        else if( !strcmp( argV[i], "--version") ){
          
          printf("\n"
                 "tcProps version %d.%d\n"
                 "\n",
                 VERSION_MAJOR, VERSION_MINOR );
          exit(0);
          
        }

        else if( !strcmp( argV[i], "--help") ){
          
          usage();
          exit(0);
        }
        
        // anything else is an error

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

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

            j++;
            currentFlag = argV[i][j];
              
            if( currentFlag != '\0' ) optionError = 1;
            
            if( optionError ){
              fprintf( stderr, 
                       "\n"
                       "The -o flag should end an option sequence.\n"
                       "   example: -r <outname> *NOT* -or <outname>\n" );
              usage();
              exit(0);
            }
              
            i++;
            if( i>=argC ){
              fprintf( stderr, 
                       "\n"
                       "not enough arguments for -o\n");
              usage();
              exit(0);
            }     
            
            outPrefix = argV[i];
            if( outPrefix[0] == '-' ) optionError = 1;
                
            if( optionError ){
              fprintf( stderr, 
                       "\n"
                       "\"%s\" is not a valid out prefix/name.\n"
                       "Out prefix/name should not begin with a dash.\n",
                       outPrefix );
              usage();
              exit(0);
            }
            
            havePrefix = 1;
            done = 1;
            break;

          case 'l':
            // -l <double>    set <double> to the maxLength

            haveMaxLength = 1;
            j++;
            currentFlag = argV[i][j];
              
            if( currentFlag != '\0' ) optionError = 1;
            
            if( optionError ){
              fprintf( stderr,
                       "\n"
                       "The -l flag should end an option sequence.\n"
                       "   example: -sl <double> *NOT* -ls <double>\n" );
              usage();
              exit(0);
            }

            i++;
            if( i>=argC ){
              fprintf( stderr,
                       "\n"
                       "not enough arguments for -l\n");
              usage();
              exit(0);
            }     

            maxLength = atof( argV[i] );
            
            done = 1;

            break;

          case 't':
            // -t <double>    set <double> to the startTime

            j++;
            currentFlag = argV[i][j];
              
            if( currentFlag != '\0' ) optionError = 1;
            
            if( optionError ){
              fprintf( stderr,
                       "\n"
                       "The -t flag should end an option sequence.\n"
                       "   example: -st <double> *NOT* -ts <double>\n" );
              usage();
              exit(0);
            }

            i++;
            if( i>=argC ){
              fprintf( stderr,
                       "\n"
                       "not enough arguments for -t\n");
              usage();
              exit(0);
            }     

            startTime = atof( argV[i] );
            done = 1;
            break;

          case 's':
            // -s turn on Scd corr

            scdCorr = 1;
            break;

          case 'h':
            // -h turn on director head

            directorHead = 1;
            break;

          case 'w':
            // -w turn on director head

            directorWhole = 1;
            break;

          case 'g':
            // -g turn on gofZ

            doGofz = 1;
            break;


          default:

            fprintf( stderr, 
                    "\n"
                    "Bad option \"-%c\"\n", currentFlag);
            usage();
            exit(0);
          }
          j++;
          currentFlag = argV[i][j];
        }
      }
    }

    else{
      
      if( inName != NULL ){
        fprintf( stderr,
                 "Error at \"%s\", program does not currently support\n"
                 "more than one input dump file.\n"
                 "\n",
                 argV[i]);
        usage();
        exit(0);
      }
      
      inName = argV[i];
      
    }
  }  
  
  if( inName == NULL ){
    fprintf( stderr,
             "Error, dump file is needed to run.\n" );
    usage();
    exit(0);
  }

  if( outPrefix == NULL )
    outPrefix = inName;


  // initialize the arrays

  for(i=0;i<nLipids;i++){

    atoms[nLipAtoms*i+0].type = HEAD;
    atoms[nLipAtoms*i+0].mass = 72;
    atoms[nLipAtoms*i+0].u[0] = 0.0;
    atoms[nLipAtoms*i+0].u[1] = 0.0;
    atoms[nLipAtoms*i+0].u[2] = 1.0;
    
    
    atoms[nLipAtoms*i+1].type = CH2;
    atoms[nLipAtoms*i+1].mass = 14.03;

    atoms[nLipAtoms*i+2].type = CH;
    atoms[nLipAtoms*i+2].mass = 13.02;

    atoms[nLipAtoms*i+3].type = CH2;
    atoms[nLipAtoms*i+3].mass = 14.03;

    atoms[nLipAtoms*i+4].type = CH2;
    atoms[nLipAtoms*i+4].mass = 14.03;

    atoms[nLipAtoms*i+5].type = CH2;
    atoms[nLipAtoms*i+5].mass = 14.03;

    atoms[nLipAtoms*i+6].type = CH2;
    atoms[nLipAtoms*i+6].mass = 14.03;

    atoms[nLipAtoms*i+7].type = CH2;
    atoms[nLipAtoms*i+7].mass = 14.03;

    atoms[nLipAtoms*i+8].type = CH2;
    atoms[nLipAtoms*i+8].mass = 14.03;

    atoms[nLipAtoms*i+9].type = CH2;
    atoms[nLipAtoms*i+9].mass = 14.03;

    atoms[nLipAtoms*i+10].type = CH3;
    atoms[nLipAtoms*i+10].mass = 15.04;

    atoms[nLipAtoms*i+11].type = CH2;
    atoms[nLipAtoms*i+11].mass = 14.03;

    atoms[nLipAtoms*i+12].type = CH2;
    atoms[nLipAtoms*i+12].mass = 14.03;

    atoms[nLipAtoms*i+13].type = CH2;    
    atoms[nLipAtoms*i+13].mass = 14.03;

    atoms[nLipAtoms*i+14].type = CH2;
    atoms[nLipAtoms*i+14].mass = 14.03;
  
    atoms[nLipAtoms*i+15].type = CH2;
    atoms[nLipAtoms*i+15].mass = 14.03;
  
    atoms[nLipAtoms*i+16].type = CH2;
    atoms[nLipAtoms*i+16].mass = 14.03;
  
    atoms[nLipAtoms*i+17].type = CH2;
    atoms[nLipAtoms*i+17].mass = 14.03;
  
    atoms[nLipAtoms*i+18].type = CH3;
    atoms[nLipAtoms*i+18].mass = 15.04;
  }
  
  for(i=(nLipAtoms*nLipids);i<nAtoms;i++){
    atoms[i].type = SSD;
    atoms[i].mass = 18.03;
    atoms[i].u[0] = 0.0;
    atoms[i].u[1] = 0.0;
    atoms[i].u[2] = 1.0;
  }

  // read and set the frames
  
  openFile();

  fprintf( stdout,
           "\n"
           "Counting the number of frames in \"%s\"...",
           inName );
  fflush(stdout);

  setFrames();
  
  fprintf( stdout,
           "done.\n"
           "nFrames = %d.\n",
           nFrames );
  fflush(stdout);

  if(scdCorr){

    fprintf ( stdout,
              "Calculating the Scd correlation\n" );
    fflush( stdout );
    
    calcScdCorr( startTime, atoms, outPrefix );
  }

  if(directorHead){

    fprintf ( stdout,
              "Calculating the Head director\n" );
    fflush( stdout );
    
    calcDirHeadCorr( startTime, atoms, outPrefix );
  }

  if(directorWhole){

    fprintf ( stdout,
              "Calculating the bilayer director\n" );
    fflush( stdout );
    
    calcDirWholeCorr( startTime, atoms, outPrefix );
  }

  if(doRMSD){

    fprintf ( stdout,
              "Calculating the RMSD\n" );
    fflush( stdout );
    
    rmsd( rmsdType, startTime, outPrefix );
  }

  if(doGofz){

    fprintf ( stdout,
              "Calculating the gofZ\n" );
    fflush( stdout );
    
    calcGofz( startTime, atoms, outPrefix );
  }
  

  closeFile();

}


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

void usage(){
  (void)fprintf(stdout, 
                "\n"
                "The proper usage is: %s [options] <input_file>\n"
                "\n"
                "Options:\n"
                "\n"
                "   short:\n"
                "   ------\n"
                "   -o <name>       The output prefix\n"
                "   -t <time>       Set the start time for correlations\n"
                "   -l <maxLength>  set the maximum value of r\n"
                "                     *Defaults to 1/2 smallest length of first frame.\n"
                "   -s              Calculate the Scd chain correlation.\n"
                "   -h              Calculate the directors for the head groups\n"
                "   -w              Calculate the director from the bilayers\n"
                "   -g              Calculate the gofz profile\n"
                "\n"
                "   long:\n"
                "   -----\n"
                "   --rmsd <atom1>                 rmsd for atom1\n"
                "   --gofrTheta <atom1> <atom2>    g(r, theta) for atom1 and atom2\n"
                "   --gofrOmega <atom1> <atom2>    g(r, omega) for atom1 and atom2\n"
                "   --version                      displays the version number\n"
                "   --help                         displays this help message.\n"
                
                "\n"
                "\n",
                programName);
}
Revision:	1080
Committed:	Wed Mar 3 15:16:15 2004 UTC (20 years, 4 months ago) by mmeineke
Content type:	text/plain
File size:	11001 byte(s)
Log Message:	added gofz code
#	User	Rev	Content
1	mmeineke	1052	#define _FILE_OFFSET_BITS 64
2
3	mmeineke	1049	#include <stdio.h>
4			#include <stdlib.h>
5	mmeineke	1060	#include <string.h>
6	mmeineke	1049
7
8			#include "params.h"
9			#include "tcProps.h"
10	mmeineke	1052	#include "readWrite.h"
11	mmeineke	1058	#include "scdCorr.h"
12	mmeineke	1060	#include "directorHead.h"
13	mmeineke	1067	#include "directorWhole.h"
14	mmeineke	1073	#include "rmsd.h"
15	mmeineke	1080	#include "gofz.h"
16	mmeineke	1049
17
18	mmeineke	1058	#define VERSION_MAJOR 0
19			#define VERSION_MINOR 1
20
21			char programName; /the name of the program */
22			void usage(void);
23
24	mmeineke	1049	int main( int argC, char *argV[] ){
25
26			// list of 'a priori' constants
27
28	mmeineke	1056	const int nLipAtoms = NL_ATOMS;
29			const int nBonds = NBONDS;
30			const int nLipids = NLIPIDS;
31			const int nSSD = NSSD;
32			const int nAtoms = nLipAtoms * nLipids + nSSD;
33	mmeineke	1052
34			// different needed variables
35	mmeineke	1049
36			struct atomCoord atoms[nAtoms];
37	mmeineke	1052	int i,j,k;
38	mmeineke	1058
39			char* outPrefix; // the output prefix
40			char currentFlag; // used in parsing the flags
41			int done = 0; // multipurpose boolean
42			int havePrefix; // boolean for the output prefix
43	mmeineke	1060	int haveMaxLength;
44	mmeineke	1058	char* conversionCheck;
45			int conversionError;
46			int optionError;
47			char* pair1;
48			char* pair2;
49			int scdCorr;
50			double startTime;
51	mmeineke	1060	double maxLength;
52	mmeineke	1080	int directorHead, directorWhole, doRMSD, doGofz;
53	mmeineke	1073	enum atomNames rmsdType;
54	mmeineke	1049
55	mmeineke	1052	// system initialization
56	mmeineke	1049
57	mmeineke	1052	isScanned = 0;
58	mmeineke	1056	fileOpen = 0;
59			nFrames = 0;
60			frameTimes = NULL;
61	mmeineke	1049
62	mmeineke	1058	outPrefix = NULL;
63			inName = NULL;
64
65	mmeineke	1060	haveMaxLength = 0;
66	mmeineke	1058	conversionError = 0;
67			optionError = 0;
68			havePrefix = 0;
69			scdCorr = 0;
70			startTime = 0.0;
71	mmeineke	1060	directorHead = 0;
72	mmeineke	1062	directorWhole = 0;
73	mmeineke	1073	doRMSD = 0;
74	mmeineke	1080	doGofz = 0;
75	mmeineke	1058
76	mmeineke	1052
77	mmeineke	1058	// parse the command line
78
79			programName = argV[0]; /save the program name in case we need it/
80
81			for( i = 1; i < argC; i++){
82
83			if(argV[i][0] =='-'){
84
85			// parse the option
86
87			if(argV[i][1] == '-' ){
88
89			// parse long word options
90
91	mmeineke	1073	if( !strcmp( argV[i], "--rmsd" ) ){
92	mmeineke	1058
93	mmeineke	1073	doRMSD = 1;
94	mmeineke	1058	i++;
95			if( i>=argC ){
96			fprintf( stderr,
97			"\n"
98	mmeineke	1073	"not enough arguments for --rmsd\n");
99	mmeineke	1058	usage();
100			exit(0);
101			}
102			pair1 = argV[i];
103
104	mmeineke	1073	if( !strcmp(pair1, "HEAD") ) rmsdType = HEAD;
105			else if( !strcmp(pair1, "CH") ) rmsdType = CH;
106			else if( !strcmp(pair1, "CH2") )rmsdType = CH2;
107			else if( !strcmp(pair1, "CH3") )rmsdType = CH3;
108			else if( !strcmp(pair1, "SSD") )rmsdType = SSD;
109			else if( !strcmp(pair1, "COM") )rmsdType = COM;
110			else{
111	mmeineke	1058	fprintf( stderr,
112	mmeineke	1073	"Unrecognized rmsd atom type \"%s\"\n",
113			pair1 );
114	mmeineke	1058	exit(0);
115	mmeineke	1073	}
116	mmeineke	1058
117			}
118
119			else if( !strcmp( argV[i], "--gofrTheta" ) ){
120
121			i++;
122			if( i>=argC ){
123			fprintf( stderr,
124			"\n"
125			"not enough arguments for --gofrTheta\n");
126			usage();
127			exit(0);
128			}
129			pair1 = argV[i];
130
131			i++;
132			if( i>=argC ){
133			fprintf( stderr,
134			"\n"
135			"not enough arguments for --gofrTheta\n");
136			usage();
137			exit(0);
138			}
139			pair2 = argV[i];
140
141			}
142
143			else if( !strcmp( argV[i], "--gofrOmega" ) ){
144
145			i++;
146			if( i>=argC ){
147			fprintf( stderr,
148			"\n"
149			"not enough arguments for --gofrOmega\n");
150			usage();
151			exit(0);
152			}
153			pair1 = argV[i];
154
155			i++;
156			if( i>=argC ){
157			fprintf( stderr,
158			"\n"
159			"not enough arguments for --gofrOmega\n");
160			usage();
161			exit(0);
162			}
163			pair2 = argV[i];
164
165			}
166
167			else if( !strcmp( argV[i], "--version") ){
168
169			printf("\n"
170			"tcProps version %d.%d\n"
171			"\n",
172			VERSION_MAJOR, VERSION_MINOR );
173			exit(0);
174
175			}
176
177			else if( !strcmp( argV[i], "--help") ){
178
179			usage();
180			exit(0);
181			}
182
183			// anything else is an error
184
185			else{
186			fprintf( stderr,
187			"Invalid option \"%s\"\n", argV[i] );
188			usage();
189			exit(0);
190			}
191			}
192
193			else{
194
195			// parse single character options
196
197			done =0;
198			j = 1;
199			currentFlag = argV[i][j];
200			while( (currentFlag != '\0') && (!done) ){
201
202			switch(currentFlag){
203
204			case 'o':
205			// -o <prefix> => the output prefix.
206
207			j++;
208			currentFlag = argV[i][j];
209
210			if( currentFlag != '\0' ) optionError = 1;
211
212			if( optionError ){
213			fprintf( stderr,
214			"\n"
215			"The -o flag should end an option sequence.\n"
216			" example: -r <outname> NOT -or <outname>\n" );
217			usage();
218			exit(0);
219			}
220
221			i++;
222			if( i>=argC ){
223			fprintf( stderr,
224			"\n"
225			"not enough arguments for -o\n");
226			usage();
227			exit(0);
228			}
229
230			outPrefix = argV[i];
231			if( outPrefix[0] == '-' ) optionError = 1;
232
233			if( optionError ){
234			fprintf( stderr,
235			"\n"
236			"\"%s\" is not a valid out prefix/name.\n"
237			"Out prefix/name should not begin with a dash.\n",
238			outPrefix );
239			usage();
240			exit(0);
241			}
242
243			havePrefix = 1;
244			done = 1;
245			break;
246
247			case 'l':
248			// -l <double> set <double> to the maxLength
249
250	mmeineke	1060	haveMaxLength = 1;
251	mmeineke	1058	j++;
252			currentFlag = argV[i][j];
253
254			if( currentFlag != '\0' ) optionError = 1;
255
256			if( optionError ){
257			fprintf( stderr,
258			"\n"
259			"The -l flag should end an option sequence.\n"
260			" example: -sl <double> NOT -ls <double>\n" );
261			usage();
262			exit(0);
263			}
264
265			i++;
266			if( i>=argC ){
267			fprintf( stderr,
268			"\n"
269			"not enough arguments for -l\n");
270			usage();
271			exit(0);
272			}
273
274			maxLength = atof( argV[i] );
275
276			done = 1;
277
278			break;
279
280			case 't':
281			// -t <double> set <double> to the startTime
282
283			j++;
284			currentFlag = argV[i][j];
285
286			if( currentFlag != '\0' ) optionError = 1;
287
288			if( optionError ){
289			fprintf( stderr,
290			"\n"
291			"The -t flag should end an option sequence.\n"
292			" example: -st <double> NOT -ts <double>\n" );
293			usage();
294			exit(0);
295			}
296
297			i++;
298			if( i>=argC ){
299			fprintf( stderr,
300			"\n"
301			"not enough arguments for -t\n");
302			usage();
303			exit(0);
304			}
305
306			startTime = atof( argV[i] );
307			done = 1;
308			break;
309
310			case 's':
311	mmeineke	1060	// -s turn on Scd corr
312	mmeineke	1058
313			scdCorr = 1;
314			break;
315
316	mmeineke	1060	case 'h':
317			// -h turn on director head
318	mmeineke	1058
319	mmeineke	1060	directorHead = 1;
320			break;
321
322	mmeineke	1062	case 'w':
323	mmeineke	1080	// -w turn on director head
324	mmeineke	1060
325	mmeineke	1062	directorWhole = 1;
326			break;
327
328	mmeineke	1080	case 'g':
329			// -g turn on gofZ
330	mmeineke	1062
331	mmeineke	1080	doGofz = 1;
332			break;
333
334
335	mmeineke	1058	default:
336
337	mmeineke	1060	fprintf( stderr,
338	mmeineke	1058	"\n"
339			"Bad option \"-%c\"\n", currentFlag);
340			usage();
341			exit(0);
342			}
343			j++;
344			currentFlag = argV[i][j];
345			}
346			}
347			}
348
349			else{
350
351			if( inName != NULL ){
352			fprintf( stderr,
353			"Error at \"%s\", program does not currently support\n"
354			"more than one input dump file.\n"
355			"\n",
356			argV[i]);
357			usage();
358			exit(0);
359			}
360
361			inName = argV[i];
362
363			}
364			}
365
366			if( inName == NULL ){
367			fprintf( stderr,
368			"Error, dump file is needed to run.\n" );
369			usage();
370			exit(0);
371			}
372
373	mmeineke	1060	if( outPrefix == NULL )
374			outPrefix = inName;
375	mmeineke	1058
376	mmeineke	1060
377	mmeineke	1049	// initialize the arrays
378
379			for(i=0;i<nLipids;i++){
380
381			atoms[nLipAtoms*i+0].type = HEAD;
382	mmeineke	1062	atoms[nLipAtoms*i+0].mass = 72;
383	mmeineke	1052	atoms[nLipAtoms*i+0].u[0] = 0.0;
384			atoms[nLipAtoms*i+0].u[1] = 0.0;
385			atoms[nLipAtoms*i+0].u[2] = 1.0;
386
387	mmeineke	1062
388	mmeineke	1049
389			atoms[nLipAtoms*i+1].type = CH2;
390	mmeineke	1062	atoms[nLipAtoms*i+1].mass = 14.03;
391	mmeineke	1049
392			atoms[nLipAtoms*i+2].type = CH;
393	mmeineke	1062	atoms[nLipAtoms*i+2].mass = 13.02;
394	mmeineke	1049
395			atoms[nLipAtoms*i+3].type = CH2;
396	mmeineke	1062	atoms[nLipAtoms*i+3].mass = 14.03;
397	mmeineke	1049
398			atoms[nLipAtoms*i+4].type = CH2;
399	mmeineke	1062	atoms[nLipAtoms*i+4].mass = 14.03;
400	mmeineke	1049
401			atoms[nLipAtoms*i+5].type = CH2;
402	mmeineke	1062	atoms[nLipAtoms*i+5].mass = 14.03;
403	mmeineke	1049
404			atoms[nLipAtoms*i+6].type = CH2;
405	mmeineke	1062	atoms[nLipAtoms*i+6].mass = 14.03;
406	mmeineke	1049
407			atoms[nLipAtoms*i+7].type = CH2;
408	mmeineke	1062	atoms[nLipAtoms*i+7].mass = 14.03;
409	mmeineke	1049
410			atoms[nLipAtoms*i+8].type = CH2;
411	mmeineke	1062	atoms[nLipAtoms*i+8].mass = 14.03;
412	mmeineke	1049
413			atoms[nLipAtoms*i+9].type = CH2;
414	mmeineke	1062	atoms[nLipAtoms*i+9].mass = 14.03;
415	mmeineke	1049
416			atoms[nLipAtoms*i+10].type = CH3;
417	mmeineke	1062	atoms[nLipAtoms*i+10].mass = 15.04;
418	mmeineke	1049
419			atoms[nLipAtoms*i+11].type = CH2;
420	mmeineke	1062	atoms[nLipAtoms*i+11].mass = 14.03;
421	mmeineke	1049
422			atoms[nLipAtoms*i+12].type = CH2;
423	mmeineke	1062	atoms[nLipAtoms*i+12].mass = 14.03;
424	mmeineke	1049
425	mmeineke	1062	atoms[nLipAtoms*i+13].type = CH2;
426			atoms[nLipAtoms*i+13].mass = 14.03;
427	mmeineke	1049
428			atoms[nLipAtoms*i+14].type = CH2;
429	mmeineke	1062	atoms[nLipAtoms*i+14].mass = 14.03;
430	mmeineke	1049
431			atoms[nLipAtoms*i+15].type = CH2;
432	mmeineke	1062	atoms[nLipAtoms*i+15].mass = 14.03;
433	mmeineke	1049
434			atoms[nLipAtoms*i+16].type = CH2;
435	mmeineke	1062	atoms[nLipAtoms*i+16].mass = 14.03;
436	mmeineke	1049
437			atoms[nLipAtoms*i+17].type = CH2;
438	mmeineke	1062	atoms[nLipAtoms*i+17].mass = 14.03;
439	mmeineke	1049
440			atoms[nLipAtoms*i+18].type = CH3;
441	mmeineke	1062	atoms[nLipAtoms*i+18].mass = 15.04;
442	mmeineke	1049	}
443
444	mmeineke	1052	for(i=(nLipAtoms*nLipids);i<nAtoms;i++){
445	mmeineke	1049	atoms[i].type = SSD;
446	mmeineke	1062	atoms[i].mass = 18.03;
447	mmeineke	1052	atoms[i].u[0] = 0.0;
448			atoms[i].u[1] = 0.0;
449			atoms[i].u[2] = 1.0;
450	mmeineke	1049	}
451	mmeineke	1052
452			// read and set the frames
453
454	mmeineke	1060	openFile();
455	mmeineke	1058
456			fprintf( stdout,
457			"\n"
458			"Counting the number of frames in \"%s\"...",
459			inName );
460			fflush(stdout);
461
462	mmeineke	1060	setFrames();
463	mmeineke	1052
464	mmeineke	1058	fprintf( stdout,
465			"done.\n"
466	mmeineke	1060	"nFrames = %d.\n",
467	mmeineke	1058	nFrames );
468			fflush(stdout);
469
470			if(scdCorr){
471
472			fprintf ( stdout,
473			"Calculating the Scd correlation\n" );
474			fflush( stdout );
475
476	mmeineke	1060	calcScdCorr( startTime, atoms, outPrefix );
477	mmeineke	1058	}
478	mmeineke	1060
479			if(directorHead){
480
481			fprintf ( stdout,
482			"Calculating the Head director\n" );
483			fflush( stdout );
484
485			calcDirHeadCorr( startTime, atoms, outPrefix );
486			}
487	mmeineke	1062
488			if(directorWhole){
489
490			fprintf ( stdout,
491			"Calculating the bilayer director\n" );
492			fflush( stdout );
493
494			calcDirWholeCorr( startTime, atoms, outPrefix );
495			}
496	mmeineke	1073
497			if(doRMSD){
498
499			fprintf ( stdout,
500			"Calculating the RMSD\n" );
501			fflush( stdout );
502
503			rmsd( rmsdType, startTime, outPrefix );
504			}
505	mmeineke	1080
506			if(doGofz){
507
508			fprintf ( stdout,
509			"Calculating the gofZ\n" );
510			fflush( stdout );
511
512			calcGofz( startTime, atoms, outPrefix );
513			}
514	mmeineke	1058
515
516	mmeineke	1060	closeFile();
517
518	mmeineke	1058	}
519
520
521			/***************************************************************************
522			* prints out the usage for the command line arguments, then exits.
523			***************************************************************************/
524
525			void usage(){
526			(void)fprintf(stdout,
527			"\n"
528			"The proper usage is: %s [options] <input_file>\n"
529			"\n"
530			"Options:\n"
531			"\n"
532			" short:\n"
533			" ------\n"
534			" -o <name> The output prefix\n"
535			" -t <time> Set the start time for correlations\n"
536			" -l <maxLength> set the maximum value of r\n"
537			" *Defaults to 1/2 smallest length of first frame.\n"
538			" -s Calculate the Scd chain correlation.\n"
539	mmeineke	1062	" -h Calculate the directors for the head groups\n"
540	mmeineke	1080	" -w Calculate the director from the bilayers\n"
541			" -g Calculate the gofz profile\n"
542	mmeineke	1058	"\n"
543			" long:\n"
544			" -----\n"
545	mmeineke	1073	" --rmsd <atom1> rmsd for atom1\n"
546	mmeineke	1058	" --gofrTheta <atom1> <atom2> g(r, theta) for atom1 and atom2\n"
547			" --gofrOmega <atom1> <atom2> g(r, omega) for atom1 and atom2\n"
548			" --version displays the version number\n"
549			" --help displays this help message.\n"
550
551			"\n"
552			"\n",
553			programName);
554			}