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

Comparing branches/development/src/rnemd/RNEMD.cpp (file contents):
Revision 1777 by gezelter, Thu Aug 9 18:35:09 2012 UTC vs.
Revision 1850 by gezelter, Wed Feb 20 15:39:39 2013 UTC

# Line 35 | Line 35
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).          
38 > * [3]  Sun, Lin & Gezelter, J. Chem. Phys. 128, 234107 (2008).          
39   * [4]  Vardeman & Gezelter, in progress (2009).                        
40   */
41  
# Line 51 | Line 51
51   #include "utils/Tuple.hpp"
52   #ifdef IS_MPI
53   #include <mpi.h>
54 + #endif
55 +
56 + #ifdef _MSC_VER
57 + #define isnan(x) _isnan((x))
58 + #define isinf(x) (!_finite(x) && !_isnan(x))
59   #endif
60  
61   #define HONKING_LARGE_VALUE 1.0e10
# Line 65 | Line 70 | namespace OpenMD {
70      failTrialCount_ = 0;
71      failRootCount_ = 0;
72  
68 –    int seedValue;
73      Globals * simParams = info->getSimParams();
74      RNEMDParameters* rnemdParams = simParams->getRNEMDParameters();
75  
# Line 277 | Line 281 | namespace OpenMD {
281      // do some sanity checking
282  
283      int selectionCount = seleMan_.getSelectionCount();
284 +
285      int nIntegrable = info->getNGlobalIntegrableObjects();
286  
287      if (selectionCount > nIntegrable) {
# Line 305 | Line 310 | namespace OpenMD {
310      z.title =  "Z";
311      z.dataType = "RealType";
312      z.accumulator.reserve(nBins_);
313 <    for (unsigned int i = 0; i < nBins_; i++)
313 >    for (int i = 0; i < nBins_; i++)
314        z.accumulator.push_back( new Accumulator() );
315      data_[Z] = z;
316      outputMap_["Z"] =  Z;
# Line 315 | Line 320 | namespace OpenMD {
320      temperature.title =  "Temperature";
321      temperature.dataType = "RealType";
322      temperature.accumulator.reserve(nBins_);
323 <    for (unsigned int i = 0; i < nBins_; i++)
323 >    for (int i = 0; i < nBins_; i++)
324        temperature.accumulator.push_back( new Accumulator() );
325      data_[TEMPERATURE] = temperature;
326      outputMap_["TEMPERATURE"] =  TEMPERATURE;
# Line 325 | Line 330 | namespace OpenMD {
330      velocity.title =  "Velocity";  
331      velocity.dataType = "Vector3d";
332      velocity.accumulator.reserve(nBins_);
333 <    for (unsigned int i = 0; i < nBins_; i++)
333 >    for (int i = 0; i < nBins_; i++)
334        velocity.accumulator.push_back( new VectorAccumulator() );
335      data_[VELOCITY] = velocity;
336      outputMap_["VELOCITY"] = VELOCITY;
# Line 335 | Line 340 | namespace OpenMD {
340      density.title =  "Density";
341      density.dataType = "RealType";
342      density.accumulator.reserve(nBins_);
343 <    for (unsigned int i = 0; i < nBins_; i++)
343 >    for (int i = 0; i < nBins_; i++)
344        density.accumulator.push_back( new Accumulator() );
345      data_[DENSITY] = density;
346      outputMap_["DENSITY"] =  DENSITY;
# Line 447 | Line 452 | namespace OpenMD {
452  
453      int selei;
454      StuntDouble* sd;
450 –    int idx;
455  
456      RealType min_val;
457      bool min_found = false;  
# Line 460 | Line 464 | namespace OpenMD {
464      for (sd = seleMan_.beginSelected(selei); sd != NULL;
465           sd = seleMan_.nextSelected(selei)) {
466  
463 –      idx = sd->getLocalIndex();
464 –
467        Vector3d pos = sd->getPos();
468  
469        // wrap the stuntdouble's position back into the box:
# Line 539 | Line 541 | namespace OpenMD {
541        }
542      }
543      
544 < #ifdef IS_MPI
545 <    int nProc, worldRank;
544 > #ifdef IS_MPI    
545 >    int worldRank = MPI::COMM_WORLD.Get_rank();
546      
545 –    nProc = MPI::COMM_WORLD.Get_size();
546 –    worldRank = MPI::COMM_WORLD.Get_rank();
547 –
547      bool my_min_found = min_found;
548      bool my_max_found = max_found;
549  
# Line 777 | Line 776 | namespace OpenMD {
776  
777      int selei;
778      StuntDouble* sd;
780 –    int idx;
779  
780      vector<StuntDouble*> hotBin, coldBin;
781  
# Line 799 | Line 797 | namespace OpenMD {
797      for (sd = seleMan_.beginSelected(selei); sd != NULL;
798           sd = seleMan_.nextSelected(selei)) {
799  
802 –      idx = sd->getLocalIndex();
803 –
800        Vector3d pos = sd->getPos();
801  
802        // wrap the stuntdouble's position back into the box:
# Line 913 | Line 909 | namespace OpenMD {
909  
910        if ((c > 0.81) && (c < 1.21)) {//restrict scaling coefficients
911          c = sqrt(c);
912 <        //std::cerr << "cold slab scaling coefficient: " << c << endl;
917 <        //now convert to hotBin coefficient
912 >
913          RealType w = 0.0;
914          if (rnemdFluxType_ ==  rnemdFullKE) {
915            x = 1.0 + px * (1.0 - c);
# Line 952 | Line 947 | namespace OpenMD {
947              }
948            }
949            w = sqrt(w);
955 –          // std::cerr << "xh= " << x << "\tyh= " << y << "\tzh= " << z
956 –          //           << "\twh= " << w << endl;
950            for (sdi = hotBin.begin(); sdi != hotBin.end(); sdi++) {
951              if (rnemdFluxType_ == rnemdFullKE) {
952                vel = (*sdi)->getVel();
# Line 1227 | Line 1220 | namespace OpenMD {
1220  
1221      int selei;
1222      StuntDouble* sd;
1230 –    int idx;
1223  
1224      vector<StuntDouble*> hotBin, coldBin;
1225  
# Line 1242 | Line 1234 | namespace OpenMD {
1234      for (sd = seleMan_.beginSelected(selei); sd != NULL;
1235           sd = seleMan_.nextSelected(selei)) {
1236  
1245 –      idx = sd->getLocalIndex();
1246 –
1237        Vector3d pos = sd->getPos();
1238  
1239        // wrap the stuntdouble's position back into the box:
# Line 1262 | Line 1252 | namespace OpenMD {
1252        
1253          if (inA) {
1254            hotBin.push_back(sd);
1265 –          //std::cerr << "before, velocity = " << vel << endl;
1255            Ph += mass * vel;
1267 –          //std::cerr << "after, velocity = " << vel << endl;
1256            Mh += mass;
1257            Kh += mass * vel.lengthSquare();
1258            if (rnemdFluxType_ == rnemdFullKE) {
# Line 1312 | Line 1300 | namespace OpenMD {
1300      
1301      Kh *= 0.5;
1302      Kc *= 0.5;
1315 –
1316 –    // std::cerr << "Mh= " << Mh << "\tKh= " << Kh << "\tMc= " << Mc
1317 –    //        << "\tKc= " << Kc << endl;
1318 –    // std::cerr << "Ph= " << Ph << "\tPc= " << Pc << endl;
1303      
1304   #ifdef IS_MPI
1305      MPI::COMM_WORLD.Allreduce(MPI::IN_PLACE, &Ph[0], 3, MPI::REALTYPE, MPI::SUM);
# Line 1347 | Line 1331 | namespace OpenMD {
1331                if (hDenominator > 0.0) {
1332                  RealType h = sqrt(hNumerator / hDenominator);
1333                  if ((h > 0.9) && (h < 1.1)) {
1334 <                  // std::cerr << "cold slab scaling coefficient: " << c << "\n";
1351 <                  // std::cerr << "hot slab scaling coefficient: " << h <<  "\n";
1334 >
1335                    vector<StuntDouble*>::iterator sdi;
1336                    Vector3d vel;
1337                    for (sdi = coldBin.begin(); sdi != coldBin.end(); sdi++) {
# Line 1423 | Line 1406 | namespace OpenMD {
1406  
1407      seleMan_.setSelectionSet(evaluator_.evaluate());
1408  
1409 <    int selei;
1409 >    int selei(0);
1410      StuntDouble* sd;
1428 –    int idx;
1411  
1412      vector<RealType> binMass(nBins_, 0.0);
1413      vector<RealType> binPx(nBins_, 0.0);
# Line 1449 | Line 1431 | namespace OpenMD {
1431               sd != NULL;
1432               sd = mol->nextIntegrableObject(iiter))
1433      */
1434 +
1435      for (sd = seleMan_.beginSelected(selei); sd != NULL;
1436 <         sd = seleMan_.nextSelected(selei)) {
1437 <      
1455 <      idx = sd->getLocalIndex();
1456 <      
1436 >         sd = seleMan_.nextSelected(selei)) {    
1437 >    
1438        Vector3d pos = sd->getPos();
1439  
1440        // wrap the stuntdouble's position back into the box:
# Line 1468 | Line 1449 | namespace OpenMD {
1449        // The modulo operator is used to wrap the case when we are
1450        // beyond the end of the bins back to the beginning.
1451        int binNo = int(nBins_ * (pos.z() / hmat(2,2) + 0.5)) % nBins_;
1452 <    
1452 >
1453        RealType mass = sd->getMass();
1454        Vector3d vel = sd->getVel();
1455  
# Line 1499 | Line 1480 | namespace OpenMD {
1480        }
1481      }
1482      
1502 –
1483   #ifdef IS_MPI
1484      MPI::COMM_WORLD.Allreduce(MPI::IN_PLACE, &binCount[0],
1485                                nBins_, MPI::INT, MPI::SUM);
# Line 1530 | Line 1510 | namespace OpenMD {
1510        den = binMass[i] * nBins_ * PhysicalConstants::densityConvert
1511          / currentSnap_->getVolume() ;
1512  
1513 <      temp = 2.0 * binKE[i] / (binDOF[i] * PhysicalConstants::kb *
1514 <                               PhysicalConstants::energyConvert);
1515 <
1516 <      for (unsigned int j = 0; j < outputMask_.size(); ++j) {
1517 <        if(outputMask_[j]) {
1518 <          switch(j) {
1519 <          case Z:
1520 <            (data_[j].accumulator[i])->add(z);
1521 <            break;
1522 <          case TEMPERATURE:
1523 <            data_[j].accumulator[i]->add(temp);
1524 <            break;
1525 <          case VELOCITY:
1526 <            dynamic_cast<VectorAccumulator *>(data_[j].accumulator[i])->add(vel);
1527 <            break;
1528 <          case DENSITY:
1529 <            data_[j].accumulator[i]->add(den);
1530 <            break;
1513 >      if (binCount[i] > 0) {
1514 >        // only add values if there are things to add
1515 >        temp = 2.0 * binKE[i] / (binDOF[i] * PhysicalConstants::kb *
1516 >                                 PhysicalConstants::energyConvert);
1517 >        
1518 >        for (unsigned int j = 0; j < outputMask_.size(); ++j) {
1519 >          if(outputMask_[j]) {
1520 >            switch(j) {
1521 >            case Z:
1522 >              dynamic_cast<Accumulator *>(data_[j].accumulator[i])->add(z);
1523 >              break;
1524 >            case TEMPERATURE:
1525 >              dynamic_cast<Accumulator *>(data_[j].accumulator[i])->add(temp);
1526 >              break;
1527 >            case VELOCITY:
1528 >              dynamic_cast<VectorAccumulator *>(data_[j].accumulator[i])->add(vel);
1529 >              break;
1530 >            case DENSITY:
1531 >              dynamic_cast<Accumulator *>(data_[j].accumulator[i])->add(den);
1532 >              break;
1533 >            }
1534            }
1535          }
1536        }
# Line 1681 | Line 1664 | namespace OpenMD {
1664        
1665        rnemdFile_.precision(8);
1666        
1667 <      for (unsigned int j = 0; j < nBins_; j++) {        
1667 >      for (int j = 0; j < nBins_; j++) {        
1668          
1669          for (unsigned int i = 0; i < outputMask_.size(); ++i) {
1670            if (outputMask_[i]) {
# Line 1707 | Line 1690 | namespace OpenMD {
1690        rnemdFile_ << "#######################################################\n";
1691  
1692  
1693 <      for (unsigned int j = 0; j < nBins_; j++) {        
1693 >      for (int j = 0; j < nBins_; j++) {        
1694          rnemdFile_ << "#";
1695          for (unsigned int i = 0; i < outputMask_.size(); ++i) {
1696            if (outputMask_[i]) {
# Line 1740 | Line 1723 | namespace OpenMD {
1723    void RNEMD::writeReal(int index, unsigned int bin) {
1724      if (!doRNEMD_) return;
1725      assert(index >=0 && index < ENDINDEX);
1726 <    assert(bin < nBins_);
1726 >    assert(int(bin) < nBins_);
1727      RealType s;
1728      
1729 <    data_[index].accumulator[bin]->getAverage(s);
1729 >    dynamic_cast<Accumulator *>(data_[index].accumulator[bin])->getAverage(s);
1730      
1731      if (! isinf(s) && ! isnan(s)) {
1732        rnemdFile_ << "\t" << s;
# Line 1759 | Line 1742 | namespace OpenMD {
1742    void RNEMD::writeVector(int index, unsigned int bin) {
1743      if (!doRNEMD_) return;
1744      assert(index >=0 && index < ENDINDEX);
1745 <    assert(bin < nBins_);
1745 >    assert(int(bin) < nBins_);
1746      Vector3d s;
1747      dynamic_cast<VectorAccumulator*>(data_[index].accumulator[bin])->getAverage(s);
1748      if (isinf(s[0]) || isnan(s[0]) ||
# Line 1778 | Line 1761 | namespace OpenMD {
1761    void RNEMD::writeRealStdDev(int index, unsigned int bin) {
1762      if (!doRNEMD_) return;
1763      assert(index >=0 && index < ENDINDEX);
1764 <    assert(bin < nBins_);
1764 >    assert(int(bin) < nBins_);
1765      RealType s;
1766      
1767 <    data_[index].accumulator[bin]->getStdDev(s);
1767 >    dynamic_cast<Accumulator *>(data_[index].accumulator[bin])->getStdDev(s);
1768      
1769      if (! isinf(s) && ! isnan(s)) {
1770        rnemdFile_ << "\t" << s;
# Line 1797 | Line 1780 | namespace OpenMD {
1780    void RNEMD::writeVectorStdDev(int index, unsigned int bin) {
1781      if (!doRNEMD_) return;
1782      assert(index >=0 && index < ENDINDEX);
1783 <    assert(bin < nBins_);
1783 >    assert(int(bin) < nBins_);
1784      Vector3d s;
1785      dynamic_cast<VectorAccumulator*>(data_[index].accumulator[bin])->getStdDev(s);
1786      if (isinf(s[0]) || isnan(s[0]) ||

Diff Legend

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