ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/OpenMD/trunk/src/brains/SimCreator.cpp
(Generate patch)

Comparing trunk/src/brains/SimCreator.cpp (file contents):
Revision 436 by tim, Fri Mar 11 17:50:11 2005 UTC vs.
Revision 963 by tim, Wed May 17 21:51:42 2006 UTC

# Line 46 | Line 46
46   * @time 13:51am
47   * @version 1.0
48   */
49 + #include <exception>
50 + #include <iostream>
51 + #include <sstream>
52 + #include <string>
53  
54   #include "brains/MoleculeCreator.hpp"
55   #include "brains/SimCreator.hpp"
56   #include "brains/SimSnapshotManager.hpp"
57   #include "io/DumpReader.hpp"
54 – #include "io/parse_me.h"
58   #include "UseTheForce/ForceFieldFactory.hpp"
59   #include "utils/simError.h"
60   #include "utils/StringUtils.hpp"
61   #include "math/SeqRandNumGen.hpp"
62 + #include "mdParser/MDLexer.hpp"
63 + #include "mdParser/MDParser.hpp"
64 + #include "mdParser/MDTreeParser.hpp"
65 + #include "mdParser/SimplePreprocessor.hpp"
66 + #include "antlr/ANTLRException.hpp"
67 + #include "antlr/TokenStreamRecognitionException.hpp"
68 + #include "antlr/TokenStreamIOException.hpp"
69 + #include "antlr/TokenStreamException.hpp"
70 + #include "antlr/RecognitionException.hpp"
71 + #include "antlr/CharStreamException.hpp"
72 +
73 + #include "antlr/MismatchedCharException.hpp"
74 + #include "antlr/MismatchedTokenException.hpp"
75 + #include "antlr/NoViableAltForCharException.hpp"
76 + #include "antlr/NoViableAltException.hpp"
77 +
78   #ifdef IS_MPI
60 – #include "io/mpiBASS.h"
79   #include "math/ParallelRandNumGen.hpp"
80   #endif
81  
82   namespace oopse {
83    
84 <  void SimCreator::parseFile(const std::string mdFileName,  MakeStamps* stamps,
85 <                             Globals* simParams){
84 > Globals* SimCreator::parseFile(const std::string mdFileName){
85 >        Globals* simParams = NULL;
86 >        try {
87 >
88 >            // Create a preprocessor that preprocesses md file into an ostringstream
89 >            std::stringstream ppStream;
90 > #ifdef IS_MPI            
91 >            int streamSize;
92 >            const int masterNode = 0;
93 >            int commStatus;
94 >            if (worldRank == masterNode) {
95 > #endif
96 >                
97 >                SimplePreprocessor preprocessor;
98 >                preprocessor.preprocess(mdFileName, ppStream);
99 >                
100 > #ifdef IS_MPI            
101 >                //brocasting the stream size
102 >                streamSize = ppStream.str().size() +1;
103 >                commStatus = MPI_Bcast(&streamSize, 1, MPI_LONG, masterNode, MPI_COMM_WORLD);                  
104 >
105 >                commStatus = MPI_Bcast(static_cast<void*>(const_cast<char*>(ppStream.str().c_str())), streamSize, MPI_CHAR, masterNode, MPI_COMM_WORLD);
106 >            
107 >                
108 >            } else {
109 >                //get stream size
110 >                commStatus = MPI_Bcast(&streamSize, 1, MPI_LONG, masterNode, MPI_COMM_WORLD);  
111 >                
112 >                  char* buf = new char[streamSize];
113 >                  assert(buf);
114 >                
115 >                  //receive file content
116 >                  commStatus = MPI_Bcast(buf, streamSize, MPI_CHAR, masterNode, MPI_COMM_WORLD);
117 >                
118 >                  ppStream.str(buf);
119 >                  delete buf;
120 >
121 >            }
122 > #endif            
123 >            // Create a scanner that reads from the input stream
124 >            MDLexer lexer(ppStream);
125 >            lexer.setFilename(mdFileName);
126 >            lexer.initDeferredLineCount();
127      
128 < #ifdef IS_MPI
128 >            // Create a parser that reads from the scanner
129 >            MDParser parser(lexer);
130 >            parser.setFilename(mdFileName);
131 >
132 >            // Create an observer that synchorizes file name change
133 >            FilenameObserver observer;
134 >            observer.setLexer(&lexer);
135 >            observer.setParser(&parser);
136 >            lexer.setObserver(&observer);
137      
138 <    if (worldRank == 0) {
139 < #endif // is_mpi
138 >            antlr::ASTFactory factory;
139 >            parser.initializeASTFactory(factory);
140 >            parser.setASTFactory(&factory);
141 >            parser.mdfile();
142 >
143 >            // Create a tree parser that reads information into Globals
144 >            MDTreeParser treeParser;
145 >            treeParser.initializeASTFactory(factory);
146 >            treeParser.setASTFactory(&factory);
147 >             simParams = treeParser.walkTree(parser.getAST());
148 >
149 >        }
150 >
151        
152 <      simParams->initalize();
153 <      set_interface_stamps(stamps, simParams);
152 >      catch(antlr::MismatchedCharException& e) {
153 >          sprintf(painCave.errMsg,
154 >                  "parser exception: %s %s:%d:%d\n",
155 >                  e.getMessage().c_str(),e.getFilename().c_str(), e.getLine(), e.getColumn());
156 >          painCave.isFatal = 1;
157 >          simError();          
158 >      }
159 >      catch(antlr::MismatchedTokenException &e) {
160 >          sprintf(painCave.errMsg,
161 >                  "parser exception: %s %s:%d:%d\n",
162 >                  e.getMessage().c_str(),e.getFilename().c_str(), e.getLine(), e.getColumn());
163 >          painCave.isFatal = 1;
164 >          simError();  
165 >      }
166 >      catch(antlr::NoViableAltForCharException &e) {
167 >          sprintf(painCave.errMsg,
168 >                  "parser exception: %s %s:%d:%d\n",
169 >                  e.getMessage().c_str(),e.getFilename().c_str(), e.getLine(), e.getColumn());
170 >          painCave.isFatal = 1;
171 >          simError();  
172 >      }
173 >      catch(antlr::NoViableAltException &e) {
174 >          sprintf(painCave.errMsg,
175 >                  "parser exception: %s %s:%d:%d\n",
176 >                  e.getMessage().c_str(),e.getFilename().c_str(), e.getLine(), e.getColumn());
177 >          painCave.isFatal = 1;
178 >          simError();  
179 >      }
180        
181 < #ifdef IS_MPI
182 <      
183 <      mpiEventInit();
184 <      
185 < #endif
186 <      
187 <      yacc_BASS(mdFileName.c_str());
188 <      
189 < #ifdef IS_MPI
190 <      
191 <      throwMPIEvent(NULL);
192 <    } else {
193 <      set_interface_stamps(stamps, simParams);
194 <      mpiEventInit();
195 <      MPIcheckPoint();
196 <      mpiEventLoop();
197 <    }
198 <    
199 < #endif
200 <    
181 >        catch(antlr::TokenStreamRecognitionException& e) {
182 >          sprintf(painCave.errMsg,
183 >                  "parser exception: %s %s:%d:%d\n",
184 >                  e.getMessage().c_str(),e.getFilename().c_str(), e.getLine(), e.getColumn());
185 >          painCave.isFatal = 1;
186 >          simError();  
187 >        }
188 >        
189 >        catch(antlr::TokenStreamIOException& e) {
190 >          sprintf(painCave.errMsg,
191 >                  "parser exception: %s\n",
192 >                  e.getMessage().c_str());
193 >          painCave.isFatal = 1;
194 >          simError();
195 >        }
196 >        
197 >        catch(antlr::TokenStreamException& e) {
198 >          sprintf(painCave.errMsg,
199 >                  "parser exception: %s\n",
200 >                  e.getMessage().c_str());
201 >          painCave.isFatal = 1;
202 >          simError();
203 >        }        
204 >       catch (antlr::RecognitionException& e) {
205 >          sprintf(painCave.errMsg,
206 >                  "parser exception: %s %s:%d:%d\n",
207 >                  e.getMessage().c_str(),e.getFilename().c_str(), e.getLine(), e.getColumn());
208 >          painCave.isFatal = 1;
209 >          simError();          
210 >       }
211 >       catch (antlr::CharStreamException& e) {
212 >          sprintf(painCave.errMsg,
213 >                  "parser exception: %s\n",
214 >                  e.getMessage().c_str());
215 >          painCave.isFatal = 1;
216 >          simError();        
217 >       }
218 >       catch (OOPSEException& e) {
219 >          sprintf(painCave.errMsg,
220 >                  "%s\n",
221 >                  e.getMessage().c_str());
222 >          painCave.isFatal = 1;
223 >          simError();
224 >       }
225 >       catch (std::exception& e) {
226 >          sprintf(painCave.errMsg,
227 >                  "parser exception: %s\n",
228 >                  e.what());
229 >          painCave.isFatal = 1;
230 >          simError();
231 >       }
232 >
233 >        return simParams;
234    }
235    
236 <  SimInfo*  SimCreator::createSim(const std::string & mdFileName, bool loadInitCoords) {
237 <    
238 <    MakeStamps * stamps = new MakeStamps();
102 <    
103 <    Globals * simParams = new Globals();
104 <    
236 >  SimInfo*  SimCreator::createSim(const std::string & mdFileName,
237 >                                  bool loadInitCoords) {
238 >
239      //parse meta-data file
240 <    parseFile(mdFileName, stamps, simParams);
240 >    Globals* simParams = parseFile(mdFileName);
241      
242      //create the force field
243 <    ForceField * ff = ForceFieldFactory::getInstance()->createForceField(
244 <                                                                         simParams->getForceField());
243 >    ForceField * ff = ForceFieldFactory::getInstance()
244 >      ->createForceField(simParams->getForceField());
245      
246      if (ff == NULL) {
247 <      sprintf(painCave.errMsg, "ForceField Factory can not create %s force field\n",
248 <              simParams->getForceField());
247 >      sprintf(painCave.errMsg,
248 >              "ForceField Factory can not create %s force field\n",
249 >              simParams->getForceField().c_str());
250        painCave.isFatal = 1;
251        simError();
252      }
# Line 140 | Line 275 | namespace oopse {
275      }
276      
277      ff->parse(forcefieldFileName);
278 <    
144 <    //extract the molecule stamps
145 <    std::vector < std::pair<MoleculeStamp *, int> > moleculeStampPairs;
146 <    compList(stamps, simParams, moleculeStampPairs);
147 <    
278 >    ff->setFortranForceOptions();
279      //create SimInfo
280 <    SimInfo * info = new SimInfo(moleculeStampPairs, ff, simParams);
281 <    
282 <    //gather parameters (SimCreator only retrieves part of the parameters)
280 >    SimInfo * info = new SimInfo(ff, simParams);
281 >    
282 >    //gather parameters (SimCreator only retrieves part of the
283 >    //parameters)
284      gatherParameters(info, mdFileName);
285      
286      //divide the molecules and determine the global index of molecules
# Line 160 | Line 292 | namespace oopse {
292      createMolecules(info);
293      
294      
295 <    //allocate memory for DataStorage(circular reference, need to break it)
295 >    //allocate memory for DataStorage(circular reference, need to
296 >    //break it)
297      info->setSnapshotManager(new SimSnapshotManager(info));
298      
299 <    //set the global index of atoms, rigidbodies and cutoffgroups (only need to be set once, the
300 <    //global index will never change again). Local indices of atoms and rigidbodies are already set by
301 <    //MoleculeCreator class which actually delegates the responsibility to LocalIndexManager.
299 >    //set the global index of atoms, rigidbodies and cutoffgroups
300 >    //(only need to be set once, the global index will never change
301 >    //again). Local indices of atoms and rigidbodies are already set
302 >    //by MoleculeCreator class which actually delegates the
303 >    //responsibility to LocalIndexManager.
304      setGlobalIndex(info);
305      
306 <    //Alought addExculdePairs is called inside SimInfo's addMolecule method, at that point
307 <    //atoms don't have the global index yet  (their global index are all initialized to -1).
308 <    //Therefore we have to call addExcludePairs explicitly here. A way to work around is that
309 <    //we can determine the beginning global indices of atoms before they get created.
306 >    //Although addExcludePairs is called inside SimInfo's addMolecule
307 >    //method, at that point atoms don't have the global index yet
308 >    //(their global index are all initialized to -1).  Therefore we
309 >    //have to call addExcludePairs explicitly here. A way to work
310 >    //around is that we can determine the beginning global indices of
311 >    //atoms before they get created.
312      SimInfo::MoleculeIterator mi;
313      Molecule* mol;
314      for (mol= info->beginMolecule(mi); mol != NULL; mol = info->nextMolecule(mi)) {
# Line 186 | Line 323 | namespace oopse {
323    
324    void SimCreator::gatherParameters(SimInfo *info, const std::string& mdfile) {
325      
326 <    //figure out the ouput file names
326 >    //figure out the output file names
327      std::string prefix;
328      
329   #ifdef IS_MPI
# Line 215 | Line 352 | namespace oopse {
352    
353   #ifdef IS_MPI
354    void SimCreator::divideMolecules(SimInfo *info) {
355 <    double numerator;
356 <    double denominator;
357 <    double precast;
358 <    double x;
359 <    double y;
360 <    double a;
355 >    RealType numerator;
356 >    RealType denominator;
357 >    RealType precast;
358 >    RealType x;
359 >    RealType y;
360 >    RealType a;
361      int old_atoms;
362      int add_atoms;
363      int new_atoms;
# Line 332 | Line 469 | namespace oopse {
469            //           Pacc(x) = exp(- a * x)
470            // where a = penalty / (average atoms per molecule)
471            
472 <          x = (double)(new_atoms - nTarget);
472 >          x = (RealType)(new_atoms - nTarget);
473            y = myRandom->rand();
474            
475            if (y < exp(- a * x)) {
# Line 392 | Line 529 | namespace oopse {
529        
530      } //end for(int i=0)  
531    }
395 –  
396 –  void SimCreator::compList(MakeStamps *stamps, Globals* simParams,
397 –                            std::vector < std::pair<MoleculeStamp *, int> > &moleculeStampPairs) {
398 –    int i;
399 –    char * id;
400 –    LinkedMolStamp* extractedStamp = NULL;
401 –    MoleculeStamp * currentStamp;
402 –    Component** the_components = simParams->getComponents();
403 –    int n_components = simParams->getNComponents();
404 –    
405 –    if (!simParams->haveNMol()) {
406 –      // we don't have the total number of molecules, so we assume it is
407 –      // given in each component
408 –      
409 –      for(i = 0; i < n_components; i++) {
410 –        if (!the_components[i]->haveNMol()) {
411 –          // we have a problem
412 –          sprintf(painCave.errMsg,
413 –                  "SimCreator Error. No global NMol or component NMol given.\n"
414 –                  "\tCannot calculate the number of atoms.\n");
415 –          
416 –          painCave.isFatal = 1;
417 –          simError();
418 –        }
419 –        
420 –        id = the_components[i]->getType();
421 –        
422 –        extractedStamp = stamps->extractMolStamp(id);
423 –        if (extractedStamp == NULL) {
424 –          sprintf(painCave.errMsg,
425 –                  "SimCreator error: Component \"%s\" was not found in the "
426 –                  "list of declared molecules\n", id);
427 –          
428 –          painCave.isFatal = 1;
429 –          simError();
430 –        }
431 –        
432 –        currentStamp = extractedStamp->getStamp();
433 –        
434 –        
435 –        moleculeStampPairs.push_back(
436 –                                     std::make_pair(currentStamp, the_components[i]->getNMol()));
437 –      } //end for (i = 0; i < n_components; i++)
438 –    } else {
439 –      sprintf(painCave.errMsg, "SimSetup error.\n"
440 –              "\tSorry, the ability to specify total"
441 –              " nMols and then give molfractions in the components\n"
442 –              "\tis not currently supported."
443 –              " Please give nMol in the components.\n");
444 –      
445 –      painCave.isFatal = 1;
446 –      simError();
447 –    }
532      
449 – #ifdef IS_MPI
450 –    
451 –    strcpy(checkPointMsg, "Component stamps successfully extracted\n");
452 –    MPIcheckPoint();
453 –    
454 – #endif // is_mpi
455 –    
456 –  }
457 –  
533    void SimCreator::setGlobalIndex(SimInfo *info) {
534      SimInfo::MoleculeIterator mi;
535      Molecule::AtomIterator ai;
# Line 606 | Line 681 | namespace oopse {
681        //invalid initial coordinate file
682        sprintf(painCave.errMsg,
683                "Initial configuration file %s should at least contain one frame\n",
684 <              simParams->getInitialConfig());
684 >              simParams->getInitialConfig().c_str());
685        painCave.isFatal = 1;
686        simError();
687      }

Diff Legend

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