ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/group/trunk/OOPSE/utils/bilayerSys.cpp
(Generate patch)

Comparing trunk/OOPSE/utils/bilayerSys.cpp (file contents):
Revision 501 by mmeineke, Tue Apr 15 21:20:35 2003 UTC vs.
Revision 504 by mmeineke, Thu Apr 17 21:54:18 2003 UTC

# Line 1 | Line 1
1 + #include <iostream>
2 +
3   #include <cstdlib>
4   #include <cstring>
5   #include <cmath>
# Line 34 | Line 36 | int buildRandomBilayer( void ){
36   int buildRandomBilayer( void ){
37  
38    int i,j,k;
39 <  int nAtoms, atomIndex;
39 >  int nAtoms, atomIndex, molIndex, molID;
40    int* molSeq;
41    int* molMap;
42 +  int* molStart;
43    int* cardDeck;
44    int deckSize;
45    int rSite, rCard;
# Line 54 | Line 57 | int buildRandomBilayer( void ){
57    
58    srand48( RAND_SEED );
59    molSeq = NULL;
60 +  molStart = NULL;
61    molMap = NULL;
62    cardDeck = NULL;
63    atoms = NULL;
# Line 67 | Line 71 | int buildRandomBilayer( void ){
71    nSites = 0;
72    while( nSites < bsInfo.totNmol ){
73      nCells++;
74 <    nSites = 4 * pow( nCells, 3 );
74 >    nSites = 4.0 * pow( (double)nCells, 3.0 );
75    }
76  
77  
# Line 102 | Line 106 | int buildRandomBilayer( void ){
106    molIndex = 0;
107    locate = new MoLocator*[bsInfo.nComponents];
108    molSeq = new int[bsInfo.totNmol];
109 +  molStart = new int[bsInfo.totNmol];  
110    for(i=0; i<bsInfo.nComponents; i++){
111      locate[i] = new MoLocator( bsInfo.compStamps[i] );
112      for(j=0; j<bsInfo.componentsNmol[i]; j++){
113        molSeq[molIndex] = i;
114 +      molStart[molIndex] = nAtoms;
115        molIndex++;
116 <      nAtoms += bsInfo.compStamp[i]->getNAtoms();
116 >      nAtoms += bsInfo.compStamps[i]->getNAtoms();
117      }
118    }
119    
# Line 121 | Line 127 | int buildRandomBilayer( void ){
127    for(i=0; i<bsInfo.nComponents; i++){
128      if(cell < locate[i]->getMaxLength() ) cell = locate[i]->getMaxLength();
129    }
130 <  cell *= M_SQRT_2;
130 >  cell *= M_SQRT2;
131  
132    siteIndex = 0;
127 –  atomIndex = 0;
133    for(i=0; i<nCells; i++){
134      for(j=0; j<nCells; j++){
135        for(k=0; k<nCells; k++){
# Line 136 | Line 141 | int buildRandomBilayer( void ){
141            
142            getRandomRot( rot );
143            molID = molSeq[molMap[siteIndex]];
144 <          locate[molID]->placeMol( pos, rot, &atoms[atomIndex] );
145 <          
141 <          atomIndex += bsInfo.compStamps[molID]->getNatoms();
144 >          atomIndex = molStart[ molMap[siteIndex] ];
145 >          locate[molID]->placeMol( pos, rot, atoms, atomIndex );
146          }
147          siteIndex++;
148  
# Line 146 | Line 150 | int buildRandomBilayer( void ){
150            pos[0] = i * cell + (0.5 * cell);
151            pos[1] = j * cell;
152            pos[2] = k * cell + (0.5 * cell);
153 <          
153 >
154            getRandomRot( rot );
155            molID = molSeq[molMap[siteIndex]];
156 <          locate[molID]->placeMol( pos, rot, &atoms[atomIndex] );
157 <          
154 <          atomIndex += bsInfo.compStamps[molID]->getNatoms();
156 >          atomIndex = molStart[ molMap[siteIndex] ];
157 >          locate[molID]->placeMol( pos, rot, atoms, atomIndex );
158          }
159          siteIndex++;
160  
# Line 162 | Line 165 | int buildRandomBilayer( void ){
165            
166            getRandomRot( rot );
167            molID = molSeq[molMap[siteIndex]];
168 <          locate[molID]->placeMol( pos, rot, &atoms[atomIndex] );
169 <          
167 <          atomIndex += bsInfo.compStamps[molID]->getNatoms();
168 >          atomIndex = molStart[ molMap[siteIndex] ];
169 >          locate[molID]->placeMol( pos, rot, atoms, atomIndex );
170          }
171          siteIndex++;
172  
# Line 172 | Line 174 | int buildRandomBilayer( void ){
174            pos[0] = i * cell;
175            pos[1] = j * cell + (0.5 * cell);
176            pos[2] = k * cell + (0.5 * cell);
177 <          
177 >
178            getRandomRot( rot );
179            molID = molSeq[molMap[siteIndex]];
180 <          locate[molID]->placeMol( pos, rot, &atoms[atomIndex] );
181 <          
180 <          atomIndex += bsInfo.compStamps[molID]->getNatoms();
180 >          atomIndex = molStart[ molMap[siteIndex] ];
181 >          locate[molID]->placeMol( pos, rot, atoms, atomIndex );
182          }
183          siteIndex++;
184        }
# Line 191 | Line 192 | int buildRandomBilayer( void ){
192    bsInfo.boxZ = nCells * cell;
193    
194    simnfo = new SimInfo();
195 <  simnfo.n_atoms = nAtoms;
196 <  simnfo.box_x = bsInfo.boxX;
197 <  simnfo.box_y = bsInfo.boxY;
198 <  simnfo.box_z = bsInfo.boxZ;
195 >  simnfo->n_atoms = nAtoms;
196 >  simnfo->box_x = bsInfo.boxX;
197 >  simnfo->box_y = bsInfo.boxY;
198 >  simnfo->box_z = bsInfo.boxZ;
199    
200 <  sprintf( simnfo.statusName, "%s.dump", bsInfo.outPrefix );
201 <  sprintf( simnfo.finalName, "%s.init", bsInfo.outPrefix );
200 >  sprintf( simnfo->sampleName, "%s.dump", bsInfo.outPrefix );
201 >  sprintf( simnfo->finalName, "%s.init", bsInfo.outPrefix );
202 >
203 >  simnfo->atoms = atoms;
204    
202 –  simnfo.atoms = atoms;
203 –  
205    // set up the writer and write out
206    
207 <  writer = new DumpWriter( &simnfo );
207 >  writer = new DumpWriter( simnfo );
208    writer->writeFinal();
209      
210    // clean up the memory
# Line 246 | Line 247 | void getRandomRot( double rot[3][3] ){
247  
248    rot[0][0] = (cos(phi) * cos(psi)) - (sin(phi) * cos(theta) * sin(psi));
249    rot[0][1] = (sin(phi) * cos(psi)) + (cos(phi) * cos(theta) * sin(psi));
250 <  rot[0][2[ = sin(theta) * sin(psi);
250 >  rot[0][2] = sin(theta) * sin(psi);
251    
252    rot[1][0] = -(cos(phi) * sin(psi)) - (sin(phi) * cos(theta) * cos(psi));
253    rot[1][1] = -(sin(phi) * sin(psi)) + (cos(phi) * cos(theta) * cos(psi));

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines