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

Comparing trunk/src/brains/BlockSnapshotManager.cpp (file contents):
Revision 1037 by gezelter, Fri Sep 8 16:13:21 2006 UTC vs.
Revision 1390 by gezelter, Wed Nov 25 20:02:06 2009 UTC

# Line 6 | Line 6
6   * redistribute this software in source and binary code form, provided
7   * that the following conditions are met:
8   *
9 < * 1. Acknowledgement of the program authors must be made in any
10 < *    publication of scientific results based in part on use of the
11 < *    program.  An acceptable form of acknowledgement is citation of
12 < *    the article in which the program was described (Matthew
13 < *    A. Meineke, Charles F. Vardeman II, Teng Lin, Christopher
14 < *    J. Fennell and J. Daniel Gezelter, "OOPSE: An Object-Oriented
15 < *    Parallel Simulation Engine for Molecular Dynamics,"
16 < *    J. Comput. Chem. 26, pp. 252-271 (2005))
17 < *
18 < * 2. Redistributions of source code must retain the above copyright
9 > * 1. Redistributions of source code must retain the above copyright
10   *    notice, this list of conditions and the following disclaimer.
11   *
12 < * 3. Redistributions in binary form must reproduce the above copyright
12 > * 2. Redistributions in binary form must reproduce the above copyright
13   *    notice, this list of conditions and the following disclaimer in the
14   *    documentation and/or other materials provided with the
15   *    distribution.
# Line 37 | Line 28
28   * arising out of the use of or inability to use software, even if the
29   * University of Notre Dame has been advised of the possibility of
30   * such damages.
31 + *
32 + * SUPPORT OPEN SCIENCE!  If you use OpenMD or its source code in your
33 + * research, please cite the appropriate papers when you publish your
34 + * work.  Good starting points are:
35 + *                                                                      
36 + * [1]  Meineke, et al., J. Comp. Chem. 26, 252-271 (2005).            
37 + * [2]  Fennell & Gezelter, J. Chem. Phys. 124, 234104 (2006).          
38 + * [3]  Sun, Lin & Gezelter, J. Chem. Phys. 128, 24107 (2008).          
39 + * [4]  Vardeman & Gezelter, in progress (2009).                        
40   */
41   #include <algorithm>
42   #include "brains/BlockSnapshotManager.hpp"
# Line 46 | Line 46
46   #include "brains/SimInfo.hpp"
47   #include "io/DumpReader.hpp"
48  
49 < namespace oopse {
49 > namespace OpenMD {
50    BlockSnapshotManager::BlockSnapshotManager(SimInfo* info, const std::string& filename,
51                                               int storageLayout, int blockCapacity)
52      : SnapshotManager(storageLayout), info_(info), blockCapacity_(blockCapacity),
# Line 58 | Line 58 | namespace oopse {
58        RealType physMem = physmem_total();
59        RealType rssMem = residentMem();
60        RealType avaliablePhysMem = physMem - rssMem;
61 +
62      
63        int bytesPerStuntDouble = DataStorage::getBytesPerStuntDouble(storageLayout);
64  
65        int bytesPerFrame = (nRigidBodies_ + nAtoms_) * bytesPerStuntDouble;
66  
67 <      int frameCapacity = int (avaliablePhysMem / bytesPerFrame);
68 <    
69 <      nSnapshotPerBlock_ = frameCapacity /blockCapacity_ ;
67 >      // total number of frames that can fit in memory
68 >      RealType frameCapacity = avaliablePhysMem / bytesPerFrame;
69 >
70 >      // number of frames in each block given the need to hold multiple blocks
71 >      // in memory at the same time:
72 >      nSnapshotPerBlock_ = int(frameCapacity) / blockCapacity_;
73        reader_ = new DumpReader(info, filename);
74        nframes_ = reader_->getNFrames();
71 –
75        int nblocks = nframes_ / nSnapshotPerBlock_;
76 <      if (nframes_ % nSnapshotPerBlock_ != 0) {
76 >      if (nframes_ % int(nSnapshotPerBlock_) != 0) {
77          ++nblocks;
78        }  
79      
# Line 82 | Line 85 | namespace oopse {
85  
86        snapshots_.insert(snapshots_.begin(), nframes_, static_cast<Snapshot*>(NULL));  
87  
88 <      // std::cout << "physmem = " << int(physMem) << "\trssMem =  "<< int(rssMem) << "\t availablePhysMem = " << int(avaliablePhysMem) <<std::endl;
89 <      // std::cout << "nSnapshotPerBlock = " << nSnapshotPerBlock_ << "\t total block = " << nblocks << std::endl;
88 >      std::cout << "-----------------------------------------------------"<<std::endl;
89 >      std::cout << "BlockSnapshotManager memory report:" << std::endl;
90 >      std::cout << "\n";
91 >      std::cout << "  Physical Memory available:\t" << (unsigned long)physMem <<  " bytes" <<std::endl;
92 >      std::cout << "     Resident Memory in use:\t" << (unsigned long)rssMem << " bytes" <<std::endl;
93 >      std::cout << "Memory available for OpenMD:\t" << (unsigned long)avaliablePhysMem << " bytes" <<std::endl;
94 >      std::cout << "      Bytes per StuntDouble:\t" << (unsigned long)bytesPerStuntDouble <<std::endl;
95 >      std::cout << "            Bytes per Frame:\t" << (unsigned long)bytesPerFrame <<std::endl;
96 >      std::cout << "             Frame Capacity:\t" << (unsigned long)frameCapacity <<std::endl;
97 >      std::cout << "       Frames in trajectory:\t" << (unsigned long)nframes_ <<std::endl;
98 >      std::cout << "        Snapshots per Block:\t" << (unsigned long)nSnapshotPerBlock_ <<std::endl;
99 >      std::cout << "     Total number of Blocks:\t" << (unsigned long)nblocks << std::endl;
100 >      std::cout << "-----------------------------------------------------"<<std::endl;
101      
102      }
103  
# Line 102 | Line 116 | namespace oopse {
116      }
117    }
118  
119 +   Snapshot* BlockSnapshotManager::getSnapshot(int id) {
120 +    currentSnapshot_ = snapshots_[id];
121 +    return snapshots_[id];
122 +  }
123 +
124    int BlockSnapshotManager::getNActiveBlocks() {
125   #ifdef __RWSTD  
126      int count = 0;
# Line 193 | Line 212 | namespace oopse {
212  
213    std::vector<int> BlockSnapshotManager::getActiveBlocks() {
214      std::vector<int> result;
215 <    oopse::copy_if(activeBlocks_.begin(), activeBlocks_.end(), std::back_inserter(result),
215 >    OpenMD::copy_if(activeBlocks_.begin(), activeBlocks_.end(), std::back_inserter(result),
216                     std::bind2nd(std::not_equal_to<int>(), -1));
217      return result;    
218    }
# Line 206 | Line 225 | namespace oopse {
225      Snapshot* oldSnapshot = currentSnapshot_;
226      currentSnapshot_ = snapshot;  
227      reader_->readFrame(frame);
228 <    currentSnapshot_ = oldSnapshot;
228 >
229 >    // What was this for?  It doesn't make sense!
230 >    //currentSnapshot_ = oldSnapshot;
231 >
232      return snapshot;
233    }
234  
# Line 214 | Line 236 | namespace oopse {
236      return reader_->getNFrames();
237    }
238  
239 +  void BlockSnapshotManager::needCOMprops(bool ncp) {
240 +    reader_->setNeedCOMprops(ncp);
241 +  }
242 +
243   }

Diff Legend

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