utils/sysbuilder/randomBilayer.cpp

#include <iostream>
#include <vector>
#include <algorithm>

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

#include "simError.h"
#include "SimInfo.hpp"
#include "ReadWrite.hpp"
#include "SimSetup.hpp"

#include "MoLocator.hpp"
#include "latticeBuilder.hpp"

#define RAND_SEED 31337 // \/\/007!

#define VERSION_MAJOR 0
#define VERSION_MINOR 1

class SortCond{
  
public:
  bool operator()(const pair<int, double>& p1, const pair<int, double>& p2){
    return p1.second < p2.second;
  }
  
  
};


void buildMap( double &x, double &y, double &z,
               double boxX, double boxY, double boxZ );

int buildRandomBilayer( double waterCell,
                        double waterBuffer,
                        double lipidBuffer,
                        char* waterName,
                        char* lipidName );


char *programName; /*the name of the program */
void usage(void);
using namespace std;
SimInfo* mainInfo;

int main(int argC,char* argV[]){
  
  int i,j; // loop counters

  char* outPrefix; // the output prefix

  char* conversionCheck;
  bool conversionError;
  bool optionError;

  char currentFlag; // used in parsing the flags
  bool done = false; // multipurpose boolean
  bool havePrefix; // boolean for the output prefix  

  char* lipidName;
  char* waterName;
  bool haveWaterName, haveLipidName;

  double waterLattice, waterBuffer, lipidBuffer;
  
  char* inName;
  
  SimSetup* simInit;
  
  // first things first, all of the initializations

  fflush(stdout);
  srand48( 1337 );          // the random number generator.
  initSimError();           // the error handler

  outPrefix = NULL;
  inName = NULL;
  
  conversionError = false;
  optionError = false;
 
  havePrefix = false;
  
  waterBuffer = 5.0;
  lipidBuffer = 6.0;
  waterLattice = 4.929;

  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], "--version") ){
          
          printf("\n"
                 "randomBilayer version %d.%d\n"
                 "\n",
                 VERSION_MAJOR, VERSION_MINOR );
          exit(0);
          
        }

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

        else if (!strcmp( argV[i], "--lipidBuffer" )){
          
          i++;
          if( i>=argC ){
            sprintf( painCave.errMsg,
                     "\n"
                     "not enough arguments for -lipidBuffer\n");
            usage();
            painCave.isFatal = 1;
            simError();
          }       
          
          lipidBuffer = atof( argV[i] );
        }

        else if (!strcmp( argV[i], "--waterBuffer" )){
          
          i++;
          if( i>=argC ){
            sprintf( painCave.errMsg,
                     "\n"
                     "not enough arguments for --waterBuffer\n");
            usage();
            painCave.isFatal = 1;
            simError();
          }       
          
          waterBuffer = atof( argV[i] );
        }

        else if (!strcmp( argV[i], "--waterLattice" )){
          
          i++;
          if( i>=argC ){
            sprintf( painCave.errMsg,
                     "\n"
                     "not enough arguments for -waterLattice\n");
            usage();
            painCave.isFatal = 1;
            simError();
          }       
          
          waterLattice = atof( argV[i] );
        }
          
          
        // 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 = true;
            
            if( optionError ){
              sprintf( painCave.errMsg, 
                       "\n"
                       "The -o flag should end an option sequence.\n"
                       "   example: -r <outname> *NOT* -or <outname>\n" );
              usage();
              painCave.isFatal = 1;
              simError();
            }
              
            i++;
            if( i>=argC ){
              sprintf( painCave.errMsg, 
                       "\n"
                       "not enough arguments for -o\n");
              usage();
              painCave.isFatal = 1;
              simError();
            }     
            
            outPrefix = argV[i];
            if( outPrefix[0] == '-' ) optionError = true;
                
            if( optionError ){
              sprintf( painCave.errMsg, 
                       "\n"
                       "\"%s\" is not a valid out prefix/name.\n"
                       "Out prefix/name should not begin with a dash.\n",
                       outPrefix );
              usage();
              painCave.isFatal = 1;
              simError();
            }
            
            havePrefix = true;
            done = true;
            break;

          case 'l':
            // -l <lipidName> => the lipid name.

            j++;
            currentFlag = argV[i][j];
              
            if( currentFlag != '\0' ) optionError = true;
            
            if( optionError ){
              sprintf( painCave.errMsg, 
                       "\n"
                       "The -l flag should end an option sequence.\n"
                       "   example: -rl <lipidName> *NOT* -lr <lipidName>\n" );
              usage();
              painCave.isFatal = 1;
              simError();
            }
              
            i++;
            if( i>=argC ){
              sprintf( painCave.errMsg, 
                       "\n"
                       "not enough arguments for -l\n");
              usage();
              painCave.isFatal = 1;
              simError();
            }     
            
            lipidName = argV[i];
            if( lipidName[0] == '-' ) optionError = true;
                
            if( optionError ){
              sprintf( painCave.errMsg, 
                       "\n"
                       "\"%s\" is not a valid lipidName.\n"
                       "lipidName should not begin with a dash.\n",
                       lipidName );
              usage();
              painCave.isFatal = 1;
              simError();
            }
            
            haveLipidName = true;
            done = true;
            break;

          case 'w':
            // -w <waterName> => the water name.

            j++;
            currentFlag = argV[i][j];
              
            if( currentFlag != '\0' ) optionError = true;
            
            if( optionError ){
              sprintf( painCave.errMsg, 
                       "\n"
                       "The -w flag should end an option sequence.\n"
                       "   example: -rw <waterName> *NOT* -lw <waterName>\n" );
              usage();
              painCave.isFatal = 1;
              simError();
            }
              
            i++;
            if( i>=argC ){
              sprintf( painCave.errMsg, 
                       "\n"
                       "not enough arguments for -w\n");
              usage();
              painCave.isFatal = 1;
              simError();
            }     
            
            waterName = argV[i];
            if( waterName[0] == '-' ) optionError = true;
                
            if( optionError ){
              sprintf( painCave.errMsg, 
                       "\n"
                       "\"%s\" is not a valid waterName.\n"
                       "waterName should not begin with a dash.\n",
                       waterName );
              usage();
              painCave.isFatal = 1;
              simError();
            }
            
            haveWaterName = true;
            done = true;
            break;

          default:

            sprintf(painCave.errMsg, 
                    "\n"
                    "Bad option \"-%c\"\n", currentFlag);
            usage();
            painCave.isFatal = 1;
            simError();
          }
          j++;
          currentFlag = argV[i][j];
        }
      }
    }

    else{
      
      if( inName != NULL ){
        sprintf( painCave.errMsg,
                 "Error at \"%s\", program does not currently support\n"
                 "more than one input bass file.\n"
                 "\n",
                 argV[i]);
        usage();
        painCave.isFatal = 1;
        simError();
      }
      
      inName = argV[i];
      
    }
  }  
  
  if( inName == NULL ){
    sprintf( painCave.errMsg,
             "Error, bass file is needed to run.\n" );
    usage();
    painCave.isFatal = 1;
    simError();
  }

  // if no output prefix is given default to "donkey".

  if( !havePrefix ){
    outPrefix = strdup( "donkey" );
  }

  if( !haveWaterName ){
    sprintf( painCave.errMsg,
             "Error, the water name is needed to run.\n"
             );
    usage();
    painCave.isFatal = 1;
    simError();
  }  
  
  if( !haveLipidName ){
    sprintf( painCave.errMsg,
             "Error, the lipid name is needed to run.\n"
             );
    usage();
    painCave.isFatal = 1;
    simError();
  }
  
  
  // create and initialize the info object

  mainInfo = new SimInfo();
  simInit = new SimSetup();
  simInit->setSimInfo( mainInfo );
  simInit->suspendInit();
  simInit->parseFile( inName );
  simInit->createSim();

  delete simInit;

  sprintf( mainInfo->statusName, "%s.stat", outPrefix );
  sprintf( mainInfo->sampleName, "%s.dump", outPrefix );
  sprintf( mainInfo->finalName, "%s.init", outPrefix );

  buildRandomBilayer( waterLattice, waterBuffer, lipidBuffer, 
                      waterName, lipidName );

  return 0;  
}

int buildRandomBilayer( double waterCell,
                        double water_padding,
                        double lipid_spaceing,
                        char* waterName,
                        char* lipidName ){

  typedef struct{
    double rot[3][3];
    double pos[3];
  } coord;

  Lattice myFCC( FCC_LATTICE_TYPE, waterCell );
  double *posX, *posY, *posZ;
  double pos[3], posA[3], posB[3];

  int i,j,k, l, m;
  int nAtoms, atomIndex, molIndex, molID;
  int* molSeq;
  int* molMap;
  int* molStart;
  int* cardDeck;
  int deckSize;
  int rSite, rCard;
  double cell;
  int nCells, nSites, siteIndex;
  
  coord testSite;

  Atom** atoms;
  SimInfo* simnfo;
  SimState* theConfig;
  DumpWriter* writer;

  MoleculeStamp* lipidStamp;
  MoleculeStamp* waterStamp;  
  MoLocator *lipidLocate;
  MoLocator *waterLocate;
  int foundLipid, foundWater;
  int nLipids, lipidNatoms, nWaters, waterNatoms;
  double testBox, maxLength;

  double waterRho, waterVol;

  
  srand48( RAND_SEED );

  // calculate the water parameters
  
  waterVol = waterCell * waterCell * waterCell;
  waterRho = 4.0 / waterVol;

  // set the the lipidStamp

  foundLipid = 0;
  foundWater = 0;
  for(i=0; i<mainInfo->nComponents; i++){
    
    if( !strcmp( mainInfo->compStamps[i]->getID(), lipidName ) ){
          
      foundLipid = 1;
      lipidStamp = mainInfo->compStamps[i];
      nLipids = mainInfo->componentsNmol[i];
    }
    if( !strcmp( mainInfo->compStamps[i]->getID(), waterName ) ){
          
      foundWater = 1;
          
      waterStamp = mainInfo->compStamps[i];
      nWaters = mainInfo->componentsNmol[i];
    }
  }
  if( !foundLipid ){
    sprintf(painCave.errMsg,
            "randomBilayer error: Could not find lipid \"%s\" in the bass file.\n",
            lipidName );
    painCave.isFatal = 1;
    simError();
  }
  if( !foundWater ){
    sprintf(painCave.errMsg,
            "randomBilayer error: Could not find solvent \"%s\" in the bass file.\n",
            waterName );
    painCave.isFatal = 1;
    simError();
  }
  
  //create the temp Molocator and atom Arrays
  
  lipidLocate = new MoLocator( lipidStamp );
  lipidNatoms = lipidStamp->getNAtoms();
  maxLength = lipidLocate->getMaxLength();

  waterLocate = new MoLocator( waterStamp );
  waterNatoms = waterStamp->getNAtoms();
  
  // create a test box

  SimInfo* testInfo;

  testInfo = new SimInfo();
  testInfo->n_atoms = lipidNatoms;
  theConfig = testInfo->getConfiguration();
  theConfig->createArrays( lipidNatoms );
  testInfo->atoms = new Atom*[lipidNatoms];
  for (i=0; i < lipidNatoms; i++) {
          testInfo->atoms[i] = new Atom(i, theConfig);
          testInfo->atoms[i]->setCoords();
  }
  atoms = testInfo->atoms;

  // create the test box for initial water displacement

  testBox = maxLength + waterCell * 10.0; // pad with 4 cells
  nCells = (int)( testBox / waterCell + 1.0 );
  int testWaters = 4 * nCells * nCells * nCells;
  
  double* waterX = new double[testWaters];
  double* waterY = new double[testWaters];
  double* waterZ = new double[testWaters];
  
  double x0 = 0.0 - ( testBox * 0.5 );
  double y0 = 0.0 - ( testBox * 0.5 );
  double z0 = 0.0 - ( testBox * 0.5 );


  // create an fcc lattice in the water box.

  int ndx = 0;
  for( i=0; i < nCells; i++ ){
    for( j=0; j < nCells; j++ ){
      for( k=0; k < nCells; k++ ){

        myFCC.getLatticePoints(&posX, &posY, &posZ, i, j, k);
        for(l=0; l<4; l++){
          waterX[ndx]=posX[l];
          waterY[ndx]=posY[l];
          waterZ[ndx]=posZ[l];
          ndx++;
        }
      }
    }
  }

  // calculate the number of water's displaced by our lipid.

  testSite.rot[0][0] = 1.0;
  testSite.rot[0][1] = 0.0;
  testSite.rot[0][2] = 0.0;

  testSite.rot[1][0] = 0.0;
  testSite.rot[1][1] = 1.0;
  testSite.rot[1][2] = 0.0;

  testSite.rot[2][0] = 0.0;
  testSite.rot[2][1] = 0.0;
  testSite.rot[2][2] = 1.0;
  
  testSite.pos[0] = 0.0;
  testSite.pos[1] = 0.0;
  testSite.pos[2] = 0.0;

  lipidLocate->placeMol( testSite.pos, testSite.rot, atoms, 0, theConfig );

  int *isActive = new int[testWaters];
  for(i=0; i<testWaters; i++) isActive[i] = 1;
  
  int n_deleted = 0;
  double dx, dy, dz;
  double dx2, dy2, dz2, dSqr;
  double rCutSqr = water_padding * water_padding;
  
  for(i=0; ( (i<testWaters) && isActive[i] ); i++){
    for(j=0; ( (j<lipidNatoms) && isActive[i] ); j++){
      
      atoms[j]->getPos( pos );

      dx = waterX[i] - pos[0];
      dy = waterY[i] - pos[1];
      dz = waterZ[i] - pos[2];

      buildMap( dx, dy, dz, testBox, testBox, testBox );

      dx2 = dx * dx;
      dy2 = dy * dy;
      dz2 = dz * dz;
          
      dSqr = dx2 + dy2 + dz2;
      if( dSqr < rCutSqr ){
        isActive[i] = 0;
        n_deleted++;
      }
    }
  }
  
  int targetWaters = nWaters + n_deleted * nLipids;

  targetWaters = (int) ( targetWaters * 1.2 );

  // find the best box size for the sim

  int nCellsX, nCellsY, nCellsZ;

  const double boxTargetX = 66.22752;
  const double boxTargetY = 60.53088;

//   nCellsX = (int)ceil(boxTargetX / waterCell);
//   nCellsY = (int)ceil(boxTargetY / waterCell);
  
  int testTot;
  int done = 0;
  nCellsX = 0;
  nCellsY = 0;
  nCellsZ = 0;
  while( !done ){
        
    nCellsX++;
    nCellsY++;
    nCellsZ++;
    testTot = 4 * nCellsX * nCellsY * nCellsZ;
        
    if( testTot >= targetWaters ) done = 1;
  }

  // create the new water box to the new specifications
  
  int newWaters = nCellsX * nCellsY * nCellsZ * 4;
  
  delete[] waterX;
  delete[] waterY;
  delete[] waterZ;
  
  coord* waterSites = new coord[newWaters];
  
  double box_x = waterCell * nCellsX;
  double box_y = waterCell * nCellsY;
  double box_z = waterCell * nCellsZ;
         
  // create an fcc lattice in the water box.
  
  ndx = 0;
  for( i=0; i < nCellsX; i++ ){
    for( j=0; j < nCellsY; j++ ){
      for( k=0; k < nCellsZ; k++ ){

        myFCC.getLatticePoints(&posX, &posY, &posZ, i, j, k);
        for(l=0; l<4; l++){
          waterSites[ndx].pos[0] = posX[l];
          waterSites[ndx].pos[1] = posY[l];
          waterSites[ndx].pos[2] = posZ[l];
          ndx++;
        }
      }
    }
  }  

  coord* lipidSites = new coord[nLipids];

  // start a 3D RSA for the for the lipid placements
  
  
  int reject;
  int testDX, acceptedDX;
  SimInfo* testInfo2;

  nAtoms = nLipids * lipidNatoms;
  testInfo2 = new SimInfo();
  testInfo2->n_atoms = nAtoms;
  theConfig = testInfo2->getConfiguration();
  theConfig->createArrays( nAtoms );
  testInfo2->atoms = new Atom*[nAtoms];
  for (i=0; i < nAtoms; i++) {
          testInfo2->atoms[i] = new Atom(i, theConfig);
          testInfo2->atoms[i]->setCoords();
  }
  atoms = testInfo2->atoms;

  rCutSqr = lipid_spaceing * lipid_spaceing;

  for(i=0; i<nLipids; i++ ){
    done = 0;
    while( !done ){
          
      lipidSites[i].pos[0] = drand48() * box_x;
      lipidSites[i].pos[1] = drand48() * box_y;
      lipidSites[i].pos[2] = drand48() * box_z;
          
      getRandomRot( lipidSites[i].rot );
          
      ndx = i * lipidNatoms;

      lipidLocate->placeMol( lipidSites[i].pos, lipidSites[i].rot, atoms, 
                             ndx, theConfig );
          
      reject = 0;
      for( j=0; !reject && j<i; j++){
        for(k=0; !reject && k<lipidNatoms; k++){
          
          acceptedDX = j*lipidNatoms + k;
          for(l=0; !reject && l<lipidNatoms; l++){
                
            testDX = ndx + l;

            atoms[testDX]->getPos( posA );
            atoms[acceptedDX]->getPos( posB );
            
            dx = posA[0] - posB[0];
            dy = posA[1] - posB[1];
            dz = posA[2] - posB[2];
                
            buildMap( dx, dy, dz, box_x, box_y, box_z );
                
            dx2 = dx * dx;
            dy2 = dy * dy;
            dz2 = dz * dz;
                
            dSqr = dx2 + dy2 + dz2;
            if( dSqr < rCutSqr ) reject = 1;
          }
        }
      }

      if( reject ){

        for(j=0; j< lipidNatoms; j++) delete atoms[ndx+j];
      }
      else{
        done = 1;
        std::cout << (i+1) << " has been accepted\n";
        std::cout.flush();
      }
    }
  }
        

//   // zSort of the lipid positions


//   vector< pair<int,double> >zSortArray;
//   for(i=0;i<nLipids;i++) 
//     zSortArray.push_back( make_pair(i, lipidSites[i].pos[2]) );

//   sort(zSortArray.begin(),zSortArray.end(),SortCond());

//   ofstream outFile( "./zipper.bass", ios::app);

//   for(i=0; i<nLipids; i++){
//     outFile << "zConstraint[" << i << "]{\n"
//          << "  molIndex = " << zSortArray[i].first <<  ";\n"
//          << "  zPos = ";

//     if(i<32) outFile << "60.0;\n";
//     else outFile << "100.0;\n";

//     outFile << "  kRatio = 0.5;\n"
//          << "}\n";
//   }
  
//   outFile.close();


  // cut out the waters that overlap with the lipids.
  

  delete[] isActive;
  isActive = new int[newWaters];
  for(i=0; i<newWaters; i++) isActive[i] = 1;
  int n_active = newWaters;
  rCutSqr = water_padding * water_padding;
  
  for(i=0; ( (i<newWaters) && isActive[i] ); i++){
    for(j=0; ( (j<nAtoms) && isActive[i] ); j++){

      atoms[j]->getPos( pos );

      dx = waterSites[i].pos[0] - pos[0];
      dy = waterSites[i].pos[1] - pos[1];
      dz = waterSites[i].pos[2] - pos[2];

      buildMap( dx, dy, dz, box_x, box_y, box_z );

      dx2 = dx * dx;
      dy2 = dy * dy;
      dz2 = dz * dz;
          
      dSqr = dx2 + dy2 + dz2;
      if( dSqr < rCutSqr ){
        isActive[i] = 0;
        n_active--;


      }
    }
  }


  if( n_active < nWaters ){
        
    sprintf( painCave.errMsg,
             "Too many waters were removed, edit code and try again.\n" );
        
    painCave.isFatal = 1;
    simError();
  }

  int quickKill;
  while( n_active > nWaters ){

    quickKill = (int)(drand48()*newWaters);

    if( isActive[quickKill] ){
      isActive[quickKill] = 0;
      n_active--;

    }
  }

  if( n_active != nWaters ){
        
    sprintf( painCave.errMsg,
             "QuickKill didn't work right. n_active = %d, and nWaters = %d\n",
             n_active, nWaters );
    painCave.isFatal = 1;
    simError();
  }

  // clean up our messes before building the final system.

  testInfo->getConfiguration()->destroyArrays();
  testInfo2->getConfiguration()->destroyArrays();

  // create the real Atom arrays
  
  nAtoms = 0;
  molIndex = 0;
  molStart = new int[nLipids + nWaters];  
  
  for(j=0; j<nLipids; j++){
    molStart[molIndex] = nAtoms;
    molIndex++;
    nAtoms += lipidNatoms;
  }

  for(j=0; j<nWaters; j++){
    molStart[molIndex] = nAtoms;
    molIndex++;
    nAtoms += waterNatoms;
  }
  
  std::cerr << "Flag-1\n";
  theConfig = mainInfo->getConfiguration();
  mainInfo->n_atoms = nAtoms;
  theConfig->createArrays( nAtoms );
  mainInfo->atoms = new Atom*[nAtoms];
  for (i=0; i < nAtoms; i++) {
          mainInfo->atoms[i] = new Atom(i, theConfig);
          mainInfo->atoms[i]->setCoords();
  }
  atoms = mainInfo->atoms;
  std::cerr << "Flag0\n";
  
  // set up the SimInfo object
  
  double Hmat[3][3];

  Hmat[0][0] = box_x;
  Hmat[0][1] = 0.0;
  Hmat[0][2] = 0.0;

  Hmat[1][0] = 0.0;
  Hmat[1][1] = box_y;
  Hmat[1][2] = 0.0;

  Hmat[2][0] = 0.0;
  Hmat[2][1] = 0.0;
  Hmat[2][2] = box_z;
    
  mainInfo->setBoxM( Hmat );

  // center the system on (0,0,0)

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

    mainInfo->wrapVector( lipidSites[j].pos );
  }

  for(j=0;j<newWaters;j++){

    mainInfo->wrapVector( waterSites[j].pos );
  }
  
  // initialize lipid positions
  
  std::cerr << "Flag1\n";
  
  molIndex = 0;
  for(i=0; i<nLipids; i++ ){
    lipidLocate->placeMol( lipidSites[i].pos, lipidSites[i].rot, atoms,
                           molStart[molIndex], theConfig );
    molIndex++;
  }

  // initialize the water positions
  std::cerr << "Flag2\n";

  for(i=0; i<newWaters; i++){
        
    if( isActive[i] ){
          
      getRandomRot( waterSites[i].rot );
      waterLocate->placeMol( waterSites[i].pos, waterSites[i].rot, atoms,
                             molStart[molIndex], theConfig );
      molIndex++;
    }
  }  

  std::cerr << "Flag3\n";


  // set up the writer and write out
  
  writer = new DumpWriter( mainInfo );
  std::cerr << "Flag4\n";
  writer->writeFinal( 0.0 );
  std::cerr << "Flag5\n";
        
  return 1;
}

void buildMap( double &x, double &y, double &z, 
               double boxX, double boxY, double boxZ ){ 
  
  if(x < 0) x -= boxX * (double)( (int)( (x / boxX)  - 0.5 ) );
  else x -= boxX * (double)( (int)( (x / boxX ) + 0.5));

  if(y < 0) y -= boxY * (double)( (int)( (y / boxY)  - 0.5 ) );
  else y -= boxY * (double)( (int)( (y / boxY ) + 0.5));
  
  if(z < 0) z -= boxZ * (double)( (int)( (z / boxZ)  - 0.5 ) );
  else z -= boxZ * (double)( (int)( (z / boxZ ) + 0.5));
}

/***************************************************************************
 * 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"
                "   -l <lipidName>  The name of the lipid molecule specified in the BASS file.\n"
                "   -w <waterName>  The name of the water molecule specified in the BASS file.\n"

                "\n"
                "   long:\n"
                "   -----\n"

                "   --version          displays the version number\n"
                "   --help             displays this help message.\n"
                "   --waterBuffer <#>  sets the distance of closest approach of the water around the lipid\n"
                "                        defaults to 5.0\n"
                "   --lipidBuffer <#>  sets the distance of closest approach between two lipids\n"
                "                        defaults to 6.0\n"
                "   --waterLattice <#> sets the water lattice spacing\n"
                "                        defaults to 4.929 ( 1 g/cm^3 )\n"
                "\n"
                "\n",
                programName);
}
Revision:	1417
Committed:	Tue Jul 27 15:41:17 2004 UTC (19 years, 11 months ago) by tim
File size:	21405 byte(s)
Log Message:	BASS eradication project (part 1)