ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/group/trunk/OOPSE-4/src/applications/nanoparticleBuilder/nanoparticleBuilder.cpp
(Generate patch)

Comparing trunk/OOPSE-4/src/applications/nanoparticleBuilder/nanoparticleBuilder.cpp (file contents):
Revision 2352 by chuckv, Tue Oct 11 21:57:22 2005 UTC vs.
Revision 2679 by chuckv, Thu Mar 30 19:37:48 2006 UTC

# Line 47 | Line 47
47   #include <string>
48   #include <map>
49   #include <fstream>
50 + #include <algorithm>
51  
52   #include "config.h"
53 <
53 > #include "shapedLatticeSpherical.hpp"
54   #include "nanoparticleBuilderCmd.h"
54 – #include "sphericalNanoparticle.hpp"
55   #include "lattice/LatticeFactory.hpp"
56   #include "utils/MoLocator.hpp"
57   #include "lattice/Lattice.hpp"
# Line 67 | Line 67 | void createMdFile(const std::string&oldMdFileName,
67   using namespace oopse;
68   void createMdFile(const std::string&oldMdFileName,
69                    const std::string&newMdFileName,
70 <                  int numMol);
70 >                  int components,int* numMol);
71  
72   int main(int argc, char *argv []) {
73    
# Line 85 | Line 85 | int main(int argc, char *argv []) {
85    
86    
87    Lattice *simpleLat;
88 <  int numMol;
88 >  MoLocator* locator;
89 >  int* numMol;
90 >  int nComponents;
91    double latticeConstant;
92    std::vector<double> lc;
93    double mass;
94    const double rhoConvertConst = 1.661;
95    double density;
96 +  double particleRadius;
97    
98    
99  
100    Mat3x3d hmat;
98 –  MoLocator *locator;
99 –  sphericalNanoparticle *nanoparticle;
101    std::vector<Vector3d> latticePos;
102    std::vector<Vector3d> latticeOrt;
103    int numMolPerCell;
# Line 105 | Line 106 | int main(int argc, char *argv []) {
106    
107    DumpWriter *writer;
108    
109 <  // parse command line arguments
109 >  // Parse Command Line Arguments
110    if (cmdline_parser(argc, argv, &args_info) != 0)
111      exit(1);
112    
# Line 127 | Line 128 | int main(int argc, char *argv []) {
128    SimCreator oldCreator;
129    SimInfo* oldInfo = oldCreator.createSim(inputFileName, false);
130    
130 –  nShells = 0;
131 –  if (args_info.coreShellRadius_given){
132 –    nShells = args_info.coreShellRadius_given;
133 –  }
131    
135 –  nComponents = oldInfo->getNMoleculeStamp();
136 –  
137 –  /* Check to see if we have enough components to build that many shells. */
138 –  if (nShells){
139 –    if (oldInfo->getNMoleculeStamp() != nShells) {
140 –      std::cerr << "Not enough components present in MD file to build specified number of shells"
141 –      << std::endl;
142 –      exit(1);
143 –    }
144 –  }
145 –  
146 –  
147 –  //creat lattice
148 –  simpleLat = LatticeFactory::getInstance()->createLattice(latticeType);
149 –  
150 –  if (simpleLat == NULL) {
151 –    std::cerr << "Error in creating lattice" << std::endl;
152 –    exit(1);
153 –  }
154 –  
155 –  numMolPerCell = simpleLat->getNumSitesPerCell();
156 –  
132    /*calculate lattice constant (in Angstrom)
133    latticeConstant = pow(rhoConvertConst * numMolPerCell * mass / density,
134                          1.0 / 3.0);*/
135    
136    latticeConstant = args_info.latticeCnst_arg;
137    particleRadius = args_info.radius_arg;
138 <  particleDiameter = 2.0 * particleRadius;
138 >  Globals* simParams = oldInfo->getSimParams();
139    
140 <  /* set lattice constant */
141 <  lc.push_back(latticeConstant);
167 <  simpleLat->setLatticeConstant(lc);
140 >  /* Find out how many different components in this simualtion */
141 >  nComponents =simParams->getNComponents();
142    
169 –  
143    /*determine the output file names*/
144 <  if (args_info.output_given)
144 >  if (args_info.output_given){
145      outInitFileName = args_info.output_arg;
146 <  else
146 >  }else{
147      outInitFileName = getPrefix(inputFileName.c_str()) + ".in";
148 +  }
149 +  
150 +  std::cout <<"Before build shaped lattice. "<<std::endl;
151    
176 –  
177 –        
178 –  
179 –  
180 –  
152    /* create Molocators */
153    locator = new MoLocator(oldInfo->getMoleculeStamp(0), oldInfo->getForceField());
154    
155 <  /* create a new spherical nanoparticle */
156 <  nanoparticle = new sphericalNanoparticle(particleRadius,latticeConstant);
186 <  /* Build a nanoparticle to see how many sites are there */
187 <  numSites = new int[nComponents]
188 <  nanoparticle.getNMol(numSites);
155 >  /* Create nanoparticle */
156 >  shapedLatticeSpherical nanoParticle(latticeConstant,latticeType,particleRadius);
157    
158 +  std::cout <<"Before build getPoints. "<<std::endl;
159 +  /* Build a lattice and get lattice points for this lattice constant */
160 +  vector<Vector3d> nanoParticleSites = nanoParticle.getPoints();
161 +  
162 +  /* Get number of lattice sites */
163 +  numSites = nanoParticleSites.size();
164 +
165 + //std::cout <<"numSites are %d "<<numSites<<std::endl;
166 + // std::cout <<"nComponents are %d "<<nComponents<<std::endl;
167    numMol = new int[nComponents];
168 +
169 +  
170    /* Random particle is the default case*/
171    if (!args_info.ShellRadius_given){
172      std::cout << "Creating a random nanoparticle" << std::endl;
173      /* Check to see if we have enough components */
174 <    if (nComponents != args_info.molFraction_given + 1){
174 >    if (nComponents != args_info.molFraction_given && nComponents != 1){
175        std::cerr << "Number of components does not equal molFraction occurances." << std::endl;
176 <      exit 1;
176 >      exit(1);
177      }
178 +    /* Build the mole fractions and number of molecules of each type */  
179      int totComponents = 0;
180 <    for (int i = 0;i<nComponents-2;i++){ /* Figure out Percent for each component */
180 >    for (int i = 0;i<nComponents-1;i++){ /* Figure out Percent for each component */
181        numMol[i] = int((double)numSites * args_info.molFraction_arg[i]);
182 +      std::cout<<numMol[i]<<std::endl;
183        totComponents += numMol[i];
184      }
185      numMol[nComponents-1] = numSites - totComponents;
186 <
186 >  
187 >        /* do the iPod thing, Shuffle da vector */
188 >        std::random_shuffle(nanoParticleSites.begin(), nanoParticleSites.end());
189    } else{ /*Handle core-shell with multiple components.*/
190      std::cout << "Creating a core-shell nanoparticle." << std::endl;
191      if (nComponents != args_info.ShellRadius_given + 1){
192        std::cerr << "Number of components does not equal ShellRadius occurances." << std::endl;
193 <      exit 1;
194 <    }
193 >      exit(1);
194 >    }  
195      
213 –    
214 –    
196    }
197  
198 +
199     //get the orientation of the cell sites
200    //for the same type of molecule in same lattice, it will not change
201 <   latticeOrt = simpleLat->getLatticePointsOrt();
201 >   latticeOrt = nanoParticle.getPointsOrt();
202 > std::cout<<"Orientational vector Size: "<< std::endl;
203 > std::cout<<latticeOrt.size()<< std::endl;
204 >
205    
206 <  
222 <  
206 >
207    // needed for writing out new md file.
208    
209      outPrefix = getPrefix(inputFileName.c_str()) + "_" + latticeType;
210      outMdFileName = outPrefix + ".md";
211    
212      //creat new .md file on fly which corrects the number of molecule    
213 <    createMdFile(inputFileName, outMdFileName, numcomponents,numMol);
213 >    createMdFile(inputFileName, outMdFileName, nComponents,numMol);
214    
215    if (oldInfo != NULL)
216      delete oldInfo;
# Line 235 | Line 219 | int main(int argc, char *argv []) {
219    // We need to read in new siminfo object.    
220    //parse md file and set up the system
221    //SimCreator NewCreator;
222 +   SimCreator newCreator;
223 +  SimInfo* NewInfo = newCreator.createSim(outMdFileName, false);
224    
239 –  SimInfo* NewInfo = oldCreator.createSim(outMdFileName, false);
225    
226 <  // This was so much fun the first time, lets do it again.
242 <  
226 >  // Place molecules
227    Molecule* mol;
228    SimInfo::MoleculeIterator mi;
229    mol = NewInfo->beginMolecule(mi);
230 + int l = 0;
231 + for (mol = NewInfo->beginMolecule(mi); mol != NULL; mol = NewInfo->nextMolecule(mi)) {
232 +        locator->placeMol(nanoParticleSites[l], latticeOrt[l], mol);
233 +        l++;
234 +  }
235 +
236  
237  
248 –  for(int i = -nx; i < nx; i++) {
249 –     for(int j = -ny; j < ny; j++) {
250 –        for(int k = -nz; k < nz; k++) {
251 –          
252 –           //get the position of the cell sites
253 –           simpleLat->getLatticePointsPos(latticePos, i, j, k);
254 –          
255 –           for(int l = 0; l < numMolPerCell; l++) {
256 – #ifdef HAVE_CGAL              
257 –              if (myGeometry->isInsidePolyhedron(latticePos[l][0],latticePos[l][1],latticePos[l][2])){
258 – #endif                              
259 –                 if (mol != NULL) {
260 –                    locator->placeMol(latticePos[l], latticeOrt[l], mol);
261 –                 } else {
262 –                    std::cerr<<"Error in placing molecule " << std::endl;                    
263 –                 }
264 –                 mol = NewInfo->nextMolecule(mi);
265 – #ifdef HAVE_CGAL                
266 –              }
267 – #endif              
268 –           }
269 –        }
270 –     }
271 –  }
238    
273 –
274 –  
239    //fill Hmat
240 <  hmat(0, 0)= nx * latticeConstant;
240 >  hmat(0, 0)=  latticeConstant;
241    hmat(0, 1) = 0.0;
242    hmat(0, 2) = 0.0;
243    
244    hmat(1, 0) = 0.0;
245 <  hmat(1, 1) = ny * latticeConstant;
245 >  hmat(1, 1) =  latticeConstant;
246    hmat(1, 2) = 0.0;
247    
248    hmat(2, 0) = 0.0;
249    hmat(2, 1) = 0.0;
250 <  hmat(2, 2) = nz * latticeConstant;
250 >  hmat(2, 2) =  latticeConstant;
251    
252    //set Hmat
253    NewInfo->getSnapshotManager()->getCurrentSnapshot()->setHmat(hmat);
# Line 310 | Line 274 | int main(int argc, char *argv []) {
274      delete NewInfo;
275    
276    if (writer != NULL)
277 <    delete writer;
314 <  delete simpleLat;    
277 >    delete writer;      
278    cmdline_parser_free(&args_info);
279    return 0;
280   }
281  
282   void createMdFile(const std::string&oldMdFileName, const std::string&newMdFileName,
283 <                  int components,int &nummol) {
283 >                  int components,int* numMol) {
284    ifstream oldMdFile;
285    ofstream newMdFile;
286    const int MAXLEN = 65535;
# Line 328 | Line 291 | void createMdFile(const std::string&oldMdFileName, con
291    newMdFile.open(newMdFileName.c_str());
292    
293    oldMdFile.getline(buffer, MAXLEN);
294 <  
294 >
295 >  int i = 0;
296    while (!oldMdFile.eof()) {
297      
298      //correct molecule number
299      if (strstr(buffer, "nMol") != NULL) {
300 <      sprintf(buffer, "\tnMol = %i;", numMol);                          
300 >        if(i<components){
301 >      sprintf(buffer, "\tnMol = %i;", numMol[i]);                              
302        newMdFile << buffer << std::endl;
303 +      i++;
304 +        }
305      } else
306        newMdFile << buffer << std::endl;
307      

Diff Legend

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