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* rmsdName;
  char* pair1;
  char* pair2;
  int scdCorr;
  double startTime;
  double avgXY;
  double maxLength;

  int directorHead, directorWhole, doRMSD, doGofz, doAvgXY;
  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;
  doAvgXY = 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);
          }       
          rmsdName = argV[i];

          if( !strcmp(rmsdName, "HEAD") )    rmsdType = HEAD;
          else if( !strcmp(rmsdName, "CH") ) rmsdType = CH;
          else if( !strcmp(rmsdName, "CH2") )rmsdType = CH2;
          else if( !strcmp(rmsdName, "CH3") )rmsdType = CH3;
          else if( !strcmp(rmsdName, "SSD") )rmsdType = SSD;
          else if( !strcmp(rmsdName, "COM") )rmsdType = COM;
          else{
            fprintf( stderr,
                     "Unrecognized rmsd atom type \"%s\"\n",
                     rmsdName );
            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;

          case 'v':
            // -v turn on average XY

            doAvgXY = 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, rmsdName );
  }

  if(doGofz){

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

  if(doAvgXY){

    fprintf ( stdout,
              "Calculating the average XY\n" );
    fflush( stdout );
    
    avgXY = calcAverageXY( startTime );
    
    fprintf ( stdout,
              "Done, average XY = %6G\n", avgXY );
    fflush( stdout );
    
  }
  

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