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 1790 by gezelter, Thu Aug 30 17:18:22 2012 UTC vs.
Revision 1810 by gezelter, Thu Nov 8 14:23:43 2012 UTC

# Line 1 | Line 1
1   /*
2 < * Copyright (c) 2005 The University of Notre Dame. All Rights Reserved.
2 > * copyright (c) 2005 The University of Notre Dame. All Rights Reserved.
3   *
4   * The University of Notre Dame grants you ("Licensee") a
5   * non-exclusive, royalty free, license to use, modify and
# Line 100 | Line 100 | namespace OpenMD {
100   #ifdef IS_MPI            
101        int streamSize;
102        const int masterNode = 0;
103 <      int commStatus;
103 >
104        if (worldRank == masterNode) {
105 <        commStatus = MPI_Bcast(&mdFileVersion, 1, MPI_INT, masterNode, MPI_COMM_WORLD);
105 >        MPI::COMM_WORLD.Bcast(&mdFileVersion, 1, MPI::INT, masterNode);
106   #endif                
107          SimplePreprocessor preprocessor;
108 <        preprocessor.preprocess(rawMetaDataStream, filename, startOfMetaDataBlock, ppStream);
108 >        preprocessor.preprocess(rawMetaDataStream, filename, startOfMetaDataBlock,
109 >                                ppStream);
110                  
111   #ifdef IS_MPI            
112          //brocasting the stream size
113          streamSize = ppStream.str().size() +1;
114 <        commStatus = MPI_Bcast(&streamSize, 1, MPI_LONG, masterNode, MPI_COMM_WORLD);                  
115 <
116 <        commStatus = MPI_Bcast(static_cast<void*>(const_cast<char*>(ppStream.str().c_str())), streamSize, MPI_CHAR, masterNode, MPI_COMM_WORLD);
116 <            
114 >        MPI::COMM_WORLD.Bcast(&streamSize, 1, MPI::LONG, masterNode);
115 >        MPI::COMM_WORLD.Bcast(static_cast<void*>(const_cast<char*>(ppStream.str().c_str())),
116 >                              streamSize, MPI::CHAR, masterNode);
117                  
118        } else {
119  
120 <        commStatus = MPI_Bcast(&mdFileVersion, 1, MPI_INT, masterNode, MPI_COMM_WORLD);
120 >        MPI::COMM_WORLD.Bcast(&mdFileVersion, 1, MPI::INT, masterNode);
121  
122          //get stream size
123 <        commStatus = MPI_Bcast(&streamSize, 1, MPI_LONG, masterNode, MPI_COMM_WORLD);  
123 >        MPI::COMM_WORLD.Bcast(&streamSize, 1, MPI::LONG, masterNode);
124  
125          char* buf = new char[streamSize];
126          assert(buf);
127                  
128          //receive file content
129 <        commStatus = MPI_Bcast(buf, streamSize, MPI_CHAR, masterNode, MPI_COMM_WORLD);
129 >        MPI::COMM_WORLD.Bcast(buf, streamSize, MPI::CHAR, masterNode);
130                  
131          ppStream.str(buf);
132          delete [] buf;
# Line 255 | Line 255 | namespace OpenMD {
255      std::string mdRawData;
256      int metaDataBlockStart = -1;
257      int metaDataBlockEnd = -1;
258 <    int i;
258 >    int i, j;
259      streamoff mdOffset(0);
260      int mdFileVersion;
261  
262 +    // Create a string for embedding the version information in the MetaData
263 +    std::string version;
264 +    version.assign("## Last run using OpenMD Version: ");
265 +    version.append(OPENMD_VERSION_MAJOR);
266 +    version.append(".");
267 +    version.append(OPENMD_VERSION_MINOR);
268  
269 +    std::string svnrev;
270 +    //convert a macro from compiler to a string in c++
271 +    STR_DEFINE(svnrev, SVN_REV );
272 +    version.append(" Revision: ");
273 +    // If there's no SVN revision, just call this the RELEASE revision.
274 +    if (!svnrev.empty()) {
275 +      version.append(svnrev);
276 +    } else {
277 +      version.append("RELEASE");
278 +    }
279 +  
280   #ifdef IS_MPI            
281      const int masterNode = 0;
282      if (worldRank == masterNode) {
# Line 354 | Line 371 | namespace OpenMD {
371  
372        mdRawData.clear();
373  
374 +      bool foundVersion = false;
375 +
376        for (int i = 0; i < metaDataBlockEnd - metaDataBlockStart - 1; ++i) {
377          mdFile_.getline(buffer, bufferSize);
378 <        mdRawData += buffer;
378 >        std::string line = trimLeftCopy(buffer);
379 >        j = CaseInsensitiveFind(line, "## Last run using OpenMD Version");
380 >        if (static_cast<size_t>(j) != string::npos) {
381 >          foundVersion = true;
382 >          mdRawData += version;
383 >        } else {
384 >          mdRawData += buffer;
385 >        }
386          mdRawData += "\n";
387        }
388 <
388 >      
389 >      if (!foundVersion) mdRawData += version + "\n";
390 >      
391        mdFile_.close();
392  
393   #ifdef IS_MPI
# Line 499 | Line 527 | namespace OpenMD {
527      int nTarget;
528      int done;
529      int i;
502 –    int j;
530      int loops;
531      int which_proc;
532      int nProcessors;
# Line 507 | Line 534 | namespace OpenMD {
534      int nGlobalMols = info->getNGlobalMolecules();
535      std::vector<int> molToProcMap(nGlobalMols, -1); // default to an error condition:
536      
537 <    MPI_Comm_size(MPI_COMM_WORLD, &nProcessors);
537 >    nProcessors = MPI::COMM_WORLD.Get_size();
538      
539      if (nProcessors > nGlobalMols) {
540        sprintf(painCave.errMsg,
# Line 545 | Line 572 | namespace OpenMD {
572        nTarget = (int)(precast + 0.5);
573        
574        for(i = 0; i < nGlobalMols; i++) {
575 +
576          done = 0;
577          loops = 0;
578          
# Line 569 | Line 597 | namespace OpenMD {
597            // and be done with it.
598            
599            if (loops > 100) {
600 +
601              sprintf(painCave.errMsg,
602 <                    "I've tried 100 times to assign molecule %d to a "
603 <                    " processor, but can't find a good spot.\n"
604 <                    "I'm assigning it at random to processor %d.\n",
602 >                    "There have been 100 attempts to assign molecule %d to an\n"
603 >                    "\tunderworked processor, but there's no good place to\n"
604 >                    "\tleave it.  OpenMD is assigning it at random to processor %d.\n",
605                      i, which_proc);
606 <            
606 >          
607              painCave.isFatal = 0;
608 +            painCave.severity = OPENMD_INFO;
609              simError();
610              
611              molToProcMap[i] = which_proc;
# Line 620 | Line 650 | namespace OpenMD {
650        }
651        
652        delete myRandom;
653 <      
653 >
654        // Spray out this nonsense to all other processors:
655 <      
626 <      MPI_Bcast(&molToProcMap[0], nGlobalMols, MPI_INT, 0, MPI_COMM_WORLD);
655 >      MPI::COMM_WORLD.Bcast(&molToProcMap[0], nGlobalMols, MPI::INT, 0);
656      } else {
657        
658        // Listen to your marching orders from processor 0:
659 <      
660 <      MPI_Bcast(&molToProcMap[0], nGlobalMols, MPI_INT, 0, MPI_COMM_WORLD);
659 >      MPI::COMM_WORLD.Bcast(&molToProcMap[0], nGlobalMols, MPI::INT, 0);
660 >
661      }
662      
663      info->setMolToProcMap(molToProcMap);
# Line 786 | Line 815 | namespace OpenMD {
815      int beginRigidBodyIndex;
816      int beginCutoffGroupIndex;
817      int nGlobalAtoms = info->getNGlobalAtoms();
818 +    int nGlobalRigidBodies = info->getNGlobalRigidBodies();
819      
820      beginAtomIndex = 0;
821      //rigidbody's index begins right after atom's
# Line 852 | Line 882 | namespace OpenMD {
882      // This would be prettier if we could use MPI_IN_PLACE like the MPI-2
883      // docs said we could.
884      std::vector<int> tmpGroupMembership(info->getNGlobalAtoms(), 0);
885 <    MPI_Allreduce(&globalGroupMembership[0], &tmpGroupMembership[0], nGlobalAtoms,
886 <                  MPI_INT, MPI_SUM, MPI_COMM_WORLD);
885 >    MPI::COMM_WORLD.Allreduce(&globalGroupMembership[0],
886 >                              &tmpGroupMembership[0], nGlobalAtoms,
887 >                              MPI::INT, MPI::SUM);
888      info->setGlobalGroupMembership(tmpGroupMembership);
889   #else
890      info->setGlobalGroupMembership(globalGroupMembership);
891   #endif
892      
893      //fill molMembership
894 <    std::vector<int> globalMolMembership(info->getNGlobalAtoms(), 0);
894 >    std::vector<int> globalMolMembership(info->getNGlobalAtoms() +
895 >                                         info->getNGlobalRigidBodies(), 0);
896      
897 <    for(mol = info->beginMolecule(mi); mol != NULL; mol = info->nextMolecule(mi)) {
897 >    for(mol = info->beginMolecule(mi); mol != NULL;
898 >        mol = info->nextMolecule(mi)) {
899        for(atom = mol->beginAtom(ai); atom != NULL; atom = mol->nextAtom(ai)) {
900          globalMolMembership[atom->getGlobalIndex()] = mol->getGlobalIndex();
901        }
902 +      for (rb = mol->beginRigidBody(ri); rb != NULL;
903 +           rb = mol->nextRigidBody(ri)) {
904 +        globalMolMembership[rb->getGlobalIndex()] = mol->getGlobalIndex();
905 +      }
906      }
907      
908   #ifdef IS_MPI
909 <    std::vector<int> tmpMolMembership(info->getNGlobalAtoms(), 0);
909 >    std::vector<int> tmpMolMembership(info->getNGlobalAtoms() +
910 >                                      info->getNGlobalRigidBodies(), 0);
911 >    MPI::COMM_WORLD.Allreduce(&globalMolMembership[0], &tmpMolMembership[0],
912 >                              nGlobalAtoms + nGlobalRigidBodies,
913 >                              MPI::INT, MPI::SUM);
914      
874 –    MPI_Allreduce(&globalMolMembership[0], &tmpMolMembership[0], nGlobalAtoms,
875 –                  MPI_INT, MPI_SUM, MPI_COMM_WORLD);
876 –    
915      info->setGlobalMolMembership(tmpMolMembership);
916   #else
917      info->setGlobalMolMembership(globalMolMembership);
# Line 883 | Line 921 | namespace OpenMD {
921      // here the molecules are listed by their global indices.
922  
923      std::vector<int> nIOPerMol(info->getNGlobalMolecules(), 0);
924 <    for (mol = info->beginMolecule(mi); mol != NULL; mol = info->nextMolecule(mi)) {
924 >    for (mol = info->beginMolecule(mi); mol != NULL;
925 >         mol = info->nextMolecule(mi)) {
926        nIOPerMol[mol->getGlobalIndex()] = mol->getNIntegrableObjects();      
927      }
928      
929   #ifdef IS_MPI
930      std::vector<int> numIntegrableObjectsPerMol(info->getNGlobalMolecules(), 0);
931 <    MPI_Allreduce(&nIOPerMol[0], &numIntegrableObjectsPerMol[0],
932 <                  info->getNGlobalMolecules(), MPI_INT, MPI_SUM, MPI_COMM_WORLD);
931 >    MPI::COMM_WORLD.Allreduce(&nIOPerMol[0], &numIntegrableObjectsPerMol[0],
932 >                              info->getNGlobalMolecules(), MPI::INT, MPI::SUM);
933   #else
934      std::vector<int> numIntegrableObjectsPerMol = nIOPerMol;
935   #endif    
# Line 904 | Line 943 | namespace OpenMD {
943      }
944      
945      std::vector<StuntDouble*> IOIndexToIntegrableObject(info->getNGlobalIntegrableObjects(), (StuntDouble*)NULL);
946 <    for (mol = info->beginMolecule(mi); mol != NULL; mol = info->nextMolecule(mi)) {
946 >    for (mol = info->beginMolecule(mi); mol != NULL;
947 >         mol = info->nextMolecule(mi)) {
948        int myGlobalIndex = mol->getGlobalIndex();
949        int globalIO = startingIOIndexForMol[myGlobalIndex];
950        for (StuntDouble* sd = mol->beginIntegrableObject(ioi); sd != NULL;
# Line 920 | Line 960 | namespace OpenMD {
960    }
961    
962    void SimCreator::loadCoordinates(SimInfo* info, const std::string& mdFileName) {
923 –    Globals* simParams;
963  
925 –    simParams = info->getSimParams();
926 –    
964      DumpReader reader(info, mdFileName);
965      int nframes = reader.getNFrames();
966  

Diff Legend

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