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

Comparing trunk/src/rnemd/RNEMD.cpp (file contents):
Revision 1946 by gezelter, Tue Nov 12 02:18:35 2013 UTC vs.
Revision 1980 by gezelter, Sat Apr 5 21:17:12 2014 UTC

# Line 623 | Line 623 | namespace OpenMD {
623      StuntDouble* sd;
624  
625      RealType min_val;
626 <    bool min_found = false;  
626 >    int min_found = 0;  
627      StuntDouble* min_sd;
628  
629      RealType max_val;
630 <    bool max_found = false;
630 >    int max_found = 0;
631      StuntDouble* max_sd;
632  
633      for (sd = seleManA_.beginSelected(selei); sd != NULL;
# Line 682 | Line 682 | namespace OpenMD {
682        if (!max_found) {
683          max_val = value;
684          max_sd = sd;
685 <        max_found = true;
685 >        max_found = 1;
686        } else {
687          if (max_val < value) {
688            max_val = value;
# Line 744 | Line 744 | namespace OpenMD {
744        if (!min_found) {
745          min_val = value;
746          min_sd = sd;
747 <        min_found = true;
747 >        min_found = 1;
748        } else {
749          if (min_val > value) {
750            min_val = value;
# Line 754 | Line 754 | namespace OpenMD {
754      }
755      
756   #ifdef IS_MPI    
757 <    int worldRank = MPI::COMM_WORLD.Get_rank();
758 <    
759 <    bool my_min_found = min_found;
760 <    bool my_max_found = max_found;
757 >    int worldRank;
758 >    MPI_Comm_rank( MPI_COMM_WORLD, &worldRank);
759 >        
760 >    int my_min_found = min_found;
761 >    int my_max_found = max_found;
762  
763      // Even if we didn't find a minimum, did someone else?
764 <    MPI::COMM_WORLD.Allreduce(&my_min_found, &min_found, 1, MPI::BOOL, MPI::LOR);
764 >    MPI_Allreduce(&my_min_found, &min_found, 1, MPI_INT, MPI_LOR,
765 >                  MPI_COMM_WORLD);
766      // Even if we didn't find a maximum, did someone else?
767 <    MPI::COMM_WORLD.Allreduce(&my_max_found, &max_found, 1, MPI::BOOL, MPI::LOR);
767 >    MPI_Allreduce(&my_max_found, &max_found, 1, MPI_INT, MPI_LOR,
768 >                  MPI_COMM_WORLD);
769   #endif
770  
771      if (max_found && min_found) {
# Line 781 | Line 784 | namespace OpenMD {
784        min_vals.rank = worldRank;    
785        
786        // Who had the minimum?
787 <      MPI::COMM_WORLD.Allreduce(&min_vals, &min_vals,
788 <                                1, MPI::REALTYPE_INT, MPI::MINLOC);
787 >      MPI_Allreduce(&min_vals, &min_vals,
788 >                    1, MPI_REALTYPE_INT, MPI_MINLOC, MPI_COMM_WORLD);
789        min_val = min_vals.val;
790        
791        if (my_max_found) {
# Line 793 | Line 796 | namespace OpenMD {
796        max_vals.rank = worldRank;    
797        
798        // Who had the maximum?
799 <      MPI::COMM_WORLD.Allreduce(&max_vals, &max_vals,
800 <                                1, MPI::REALTYPE_INT, MPI::MAXLOC);
799 >      MPI_Allreduce(&max_vals, &max_vals,
800 >                    1, MPI_REALTYPE_INT, MPI_MAXLOC, MPI_COMM_WORLD);
801        max_val = max_vals.val;
802   #endif
803        
# Line 854 | Line 857 | namespace OpenMD {
857            
858            Vector3d min_vel;
859            Vector3d max_vel = max_sd->getVel();
860 <          MPI::Status status;
860 >          MPI_Status status;
861  
862            // point-to-point swap of the velocity vector
863 <          MPI::COMM_WORLD.Sendrecv(max_vel.getArrayPointer(), 3, MPI::REALTYPE,
864 <                                   min_vals.rank, 0,
865 <                                   min_vel.getArrayPointer(), 3, MPI::REALTYPE,
866 <                                   min_vals.rank, 0, status);
863 >          MPI_Sendrecv(max_vel.getArrayPointer(), 3, MPI_REALTYPE,
864 >                       min_vals.rank, 0,
865 >                       min_vel.getArrayPointer(), 3, MPI_REALTYPE,
866 >                       min_vals.rank, 0, MPI_COMM_WORLD, &status);
867            
868            switch(rnemdFluxType_) {
869            case rnemdKE :
# Line 871 | Line 874 | namespace OpenMD {
874                Vector3d max_angMom = max_sd->getJ();
875                
876                // point-to-point swap of the angular momentum vector
877 <              MPI::COMM_WORLD.Sendrecv(max_angMom.getArrayPointer(), 3,
878 <                                       MPI::REALTYPE, min_vals.rank, 1,
879 <                                       min_angMom.getArrayPointer(), 3,
880 <                                       MPI::REALTYPE, min_vals.rank, 1,
881 <                                       status);
877 >              MPI_Sendrecv(max_angMom.getArrayPointer(), 3,
878 >                           MPI_REALTYPE, min_vals.rank, 1,
879 >                           min_angMom.getArrayPointer(), 3,
880 >                           MPI_REALTYPE, min_vals.rank, 1,
881 >                           MPI_COMM_WORLD, &status);
882                
883                max_sd->setJ(min_angMom);
884              }
# Line 900 | Line 903 | namespace OpenMD {
903            
904            Vector3d max_vel;
905            Vector3d min_vel = min_sd->getVel();
906 <          MPI::Status status;
906 >          MPI_Status status;
907            
908            // point-to-point swap of the velocity vector
909 <          MPI::COMM_WORLD.Sendrecv(min_vel.getArrayPointer(), 3, MPI::REALTYPE,
910 <                                   max_vals.rank, 0,
911 <                                   max_vel.getArrayPointer(), 3, MPI::REALTYPE,
912 <                                   max_vals.rank, 0, status);
909 >          MPI_Sendrecv(min_vel.getArrayPointer(), 3, MPI_REALTYPE,
910 >                       max_vals.rank, 0,
911 >                       max_vel.getArrayPointer(), 3, MPI_REALTYPE,
912 >                       max_vals.rank, 0, MPI_COMM_WORLD, &status);
913            
914            switch(rnemdFluxType_) {
915            case rnemdKE :
# Line 917 | Line 920 | namespace OpenMD {
920                Vector3d max_angMom;
921                
922                // point-to-point swap of the angular momentum vector
923 <              MPI::COMM_WORLD.Sendrecv(min_angMom.getArrayPointer(), 3,
924 <                                       MPI::REALTYPE, max_vals.rank, 1,
925 <                                       max_angMom.getArrayPointer(), 3,
926 <                                       MPI::REALTYPE, max_vals.rank, 1,
927 <                                       status);
923 >              MPI_Sendrecv(min_angMom.getArrayPointer(), 3,
924 >                           MPI_REALTYPE, max_vals.rank, 1,
925 >                           max_angMom.getArrayPointer(), 3,
926 >                           MPI_REALTYPE, max_vals.rank, 1,
927 >                           MPI_COMM_WORLD, &status);
928                
929                min_sd->setJ(max_angMom);
930              }
# Line 1090 | Line 1093 | namespace OpenMD {
1093      Kcw *= 0.5;
1094  
1095   #ifdef IS_MPI
1096 <    MPI::COMM_WORLD.Allreduce(MPI::IN_PLACE, &Phx, 1, MPI::REALTYPE, MPI::SUM);
1097 <    MPI::COMM_WORLD.Allreduce(MPI::IN_PLACE, &Phy, 1, MPI::REALTYPE, MPI::SUM);
1098 <    MPI::COMM_WORLD.Allreduce(MPI::IN_PLACE, &Phz, 1, MPI::REALTYPE, MPI::SUM);
1099 <    MPI::COMM_WORLD.Allreduce(MPI::IN_PLACE, &Pcx, 1, MPI::REALTYPE, MPI::SUM);
1100 <    MPI::COMM_WORLD.Allreduce(MPI::IN_PLACE, &Pcy, 1, MPI::REALTYPE, MPI::SUM);
1101 <    MPI::COMM_WORLD.Allreduce(MPI::IN_PLACE, &Pcz, 1, MPI::REALTYPE, MPI::SUM);
1096 >    MPI_Allreduce(MPI_IN_PLACE, &Phx, 1, MPI_REALTYPE, MPI_SUM, MPI_COMM_WORLD);
1097 >    MPI_Allreduce(MPI_IN_PLACE, &Phy, 1, MPI_REALTYPE, MPI_SUM, MPI_COMM_WORLD);
1098 >    MPI_Allreduce(MPI_IN_PLACE, &Phz, 1, MPI_REALTYPE, MPI_SUM, MPI_COMM_WORLD);
1099 >    MPI_Allreduce(MPI_IN_PLACE, &Pcx, 1, MPI_REALTYPE, MPI_SUM, MPI_COMM_WORLD);
1100 >    MPI_Allreduce(MPI_IN_PLACE, &Pcy, 1, MPI_REALTYPE, MPI_SUM, MPI_COMM_WORLD);
1101 >    MPI_Allreduce(MPI_IN_PLACE, &Pcz, 1, MPI_REALTYPE, MPI_SUM, MPI_COMM_WORLD);
1102  
1103 <    MPI::COMM_WORLD.Allreduce(MPI::IN_PLACE, &Khx, 1, MPI::REALTYPE, MPI::SUM);
1104 <    MPI::COMM_WORLD.Allreduce(MPI::IN_PLACE, &Khy, 1, MPI::REALTYPE, MPI::SUM);
1105 <    MPI::COMM_WORLD.Allreduce(MPI::IN_PLACE, &Khz, 1, MPI::REALTYPE, MPI::SUM);
1106 <    MPI::COMM_WORLD.Allreduce(MPI::IN_PLACE, &Khw, 1, MPI::REALTYPE, MPI::SUM);
1103 >    MPI_Allreduce(MPI_IN_PLACE, &Khx, 1, MPI_REALTYPE, MPI_SUM, MPI_COMM_WORLD);
1104 >    MPI_Allreduce(MPI_IN_PLACE, &Khy, 1, MPI_REALTYPE, MPI_SUM, MPI_COMM_WORLD);
1105 >    MPI_Allreduce(MPI_IN_PLACE, &Khz, 1, MPI_REALTYPE, MPI_SUM, MPI_COMM_WORLD);
1106 >    MPI_Allreduce(MPI_IN_PLACE, &Khw, 1, MPI_REALTYPE, MPI_SUM, MPI_COMM_WORLD);
1107  
1108 <    MPI::COMM_WORLD.Allreduce(MPI::IN_PLACE, &Kcx, 1, MPI::REALTYPE, MPI::SUM);
1109 <    MPI::COMM_WORLD.Allreduce(MPI::IN_PLACE, &Kcy, 1, MPI::REALTYPE, MPI::SUM);
1110 <    MPI::COMM_WORLD.Allreduce(MPI::IN_PLACE, &Kcz, 1, MPI::REALTYPE, MPI::SUM);
1111 <    MPI::COMM_WORLD.Allreduce(MPI::IN_PLACE, &Kcw, 1, MPI::REALTYPE, MPI::SUM);
1108 >    MPI_Allreduce(MPI_IN_PLACE, &Kcx, 1, MPI_REALTYPE, MPI_SUM, MPI_COMM_WORLD);
1109 >    MPI_Allreduce(MPI_IN_PLACE, &Kcy, 1, MPI_REALTYPE, MPI_SUM, MPI_COMM_WORLD);
1110 >    MPI_Allreduce(MPI_IN_PLACE, &Kcz, 1, MPI_REALTYPE, MPI_SUM, MPI_COMM_WORLD);
1111 >    MPI_Allreduce(MPI_IN_PLACE, &Kcw, 1, MPI_REALTYPE, MPI_SUM, MPI_COMM_WORLD);
1112   #endif
1113  
1114      //solve coldBin coeff's first
# Line 1582 | Line 1585 | namespace OpenMD {
1585      Kc *= 0.5;
1586      
1587   #ifdef IS_MPI
1588 <    MPI::COMM_WORLD.Allreduce(MPI::IN_PLACE, &Ph[0], 3, MPI::REALTYPE, MPI::SUM);
1589 <    MPI::COMM_WORLD.Allreduce(MPI::IN_PLACE, &Pc[0], 3, MPI::REALTYPE, MPI::SUM);
1590 <    MPI::COMM_WORLD.Allreduce(MPI::IN_PLACE, &Lh[0], 3, MPI::REALTYPE, MPI::SUM);
1591 <    MPI::COMM_WORLD.Allreduce(MPI::IN_PLACE, &Lc[0], 3, MPI::REALTYPE, MPI::SUM);
1592 <    MPI::COMM_WORLD.Allreduce(MPI::IN_PLACE, &Mh, 1, MPI::REALTYPE, MPI::SUM);
1593 <    MPI::COMM_WORLD.Allreduce(MPI::IN_PLACE, &Kh, 1, MPI::REALTYPE, MPI::SUM);
1594 <    MPI::COMM_WORLD.Allreduce(MPI::IN_PLACE, &Mc, 1, MPI::REALTYPE, MPI::SUM);
1595 <    MPI::COMM_WORLD.Allreduce(MPI::IN_PLACE, &Kc, 1, MPI::REALTYPE, MPI::SUM);
1596 <    MPI::COMM_WORLD.Allreduce(MPI::IN_PLACE, Ih.getArrayPointer(), 9,
1597 <                              MPI::REALTYPE, MPI::SUM);
1598 <    MPI::COMM_WORLD.Allreduce(MPI::IN_PLACE, Ic.getArrayPointer(), 9,
1599 <                              MPI::REALTYPE, MPI::SUM);
1588 >    MPI_Allreduce(MPI_IN_PLACE, &Ph[0], 3, MPI_REALTYPE, MPI_SUM,
1589 >                  MPI_COMM_WORLD);
1590 >    MPI_Allreduce(MPI_IN_PLACE, &Pc[0], 3, MPI_REALTYPE, MPI_SUM,
1591 >                  MPI_COMM_WORLD);
1592 >    MPI_Allreduce(MPI_IN_PLACE, &Lh[0], 3, MPI_REALTYPE, MPI_SUM,
1593 >                  MPI_COMM_WORLD);
1594 >    MPI_Allreduce(MPI_IN_PLACE, &Lc[0], 3, MPI_REALTYPE, MPI_SUM,
1595 >                  MPI_COMM_WORLD);
1596 >    MPI_Allreduce(MPI_IN_PLACE, &Mh, 1, MPI_REALTYPE, MPI_SUM, MPI_COMM_WORLD);
1597 >    MPI_Allreduce(MPI_IN_PLACE, &Kh, 1, MPI_REALTYPE, MPI_SUM, MPI_COMM_WORLD);
1598 >    MPI_Allreduce(MPI_IN_PLACE, &Mc, 1, MPI_REALTYPE, MPI_SUM, MPI_COMM_WORLD);
1599 >    MPI_Allreduce(MPI_IN_PLACE, &Kc, 1, MPI_REALTYPE, MPI_SUM, MPI_COMM_WORLD);
1600 >    MPI_Allreduce(MPI_IN_PLACE, Ih.getArrayPointer(), 9,
1601 >                  MPI_REALTYPE, MPI_SUM, MPI_COMM_WORLD);
1602 >    MPI_Allreduce(MPI_IN_PLACE, Ic.getArrayPointer(), 9,
1603 >                  MPI_REALTYPE, MPI_SUM, MPI_COMM_WORLD);
1604   #endif
1605      
1606  
# Line 1987 | Line 1994 | namespace OpenMD {
1994   #ifdef IS_MPI
1995  
1996      for (int i = 0; i < nBins_; i++) {
1997 <
1998 <      MPI::COMM_WORLD.Allreduce(MPI::IN_PLACE, &binCount[i],
1999 <                                1, MPI::INT, MPI::SUM);
2000 <      MPI::COMM_WORLD.Allreduce(MPI::IN_PLACE, &binMass[i],
2001 <                                1, MPI::REALTYPE, MPI::SUM);
2002 <      MPI::COMM_WORLD.Allreduce(MPI::IN_PLACE, &binP[i],
2003 <                                3, MPI::REALTYPE, MPI::SUM);
2004 <      MPI::COMM_WORLD.Allreduce(MPI::IN_PLACE, &binL[i],
2005 <                                3, MPI::REALTYPE, MPI::SUM);
2006 <      MPI::COMM_WORLD.Allreduce(MPI::IN_PLACE, &binI[i],
2007 <                                9, MPI::REALTYPE, MPI::SUM);
2008 <      MPI::COMM_WORLD.Allreduce(MPI::IN_PLACE, &binKE[i],
2009 <                                1, MPI::REALTYPE, MPI::SUM);
2010 <      MPI::COMM_WORLD.Allreduce(MPI::IN_PLACE, &binDOF[i],
2011 <                                1, MPI::INT, MPI::SUM);
2012 <      //MPI::COMM_WORLD.Allreduce(MPI::IN_PLACE, &binOmega[i],
2013 <      //                          1, MPI::REALTYPE, MPI::SUM);
1997 >      
1998 >      MPI_Allreduce(MPI_IN_PLACE, &binCount[i],
1999 >                    1, MPI_INT, MPI_SUM, MPI_COMM_WORLD);
2000 >      MPI_Allreduce(MPI_IN_PLACE, &binMass[i],
2001 >                    1, MPI_REALTYPE, MPI_SUM, MPI_COMM_WORLD);
2002 >      MPI_Allreduce(MPI_IN_PLACE, binP[i].getArrayPointer(),
2003 >                    3, MPI_REALTYPE, MPI_SUM, MPI_COMM_WORLD);
2004 >      MPI_Allreduce(MPI_IN_PLACE, binL[i].getArrayPointer(),
2005 >                    3, MPI_REALTYPE, MPI_SUM, MPI_COMM_WORLD);
2006 >      MPI_Allreduce(MPI_IN_PLACE, binI[i].getArrayPointer(),
2007 >                    9, MPI_REALTYPE, MPI_SUM, MPI_COMM_WORLD);
2008 >      MPI_Allreduce(MPI_IN_PLACE, &binKE[i],
2009 >                    1, MPI_REALTYPE, MPI_SUM, MPI_COMM_WORLD);
2010 >      MPI_Allreduce(MPI_IN_PLACE, &binDOF[i],
2011 >                    1, MPI_INT, MPI_SUM, MPI_COMM_WORLD);
2012 >      //MPI_Allreduce(MPI_IN_PLACE, &binOmega[i],
2013 >      //                          1, MPI_REALTYPE, MPI_SUM, MPI_COMM_WORLD);
2014      }
2015      
2016   #endif
# Line 2099 | Line 2106 | namespace OpenMD {
2106      
2107   #ifdef IS_MPI
2108      // If we're the root node, should we print out the results
2109 <    int worldRank = MPI::COMM_WORLD.Get_rank();
2109 >    int worldRank;
2110 >    MPI_Comm_rank( MPI_COMM_WORLD, &worldRank);
2111 >
2112      if (worldRank == 0) {
2113   #endif
2114        rnemdFile_.open(rnemdFileName_.c_str(), std::ios::out | std::ios::trunc );
# Line 2230 | Line 2239 | namespace OpenMD {
2239        }        
2240  
2241        rnemdFile_ << "#######################################################\n";
2242 <      rnemdFile_ << "# Standard Deviations in those quantities follow:\n";
2242 >      rnemdFile_ << "# 95% confidence intervals in those quantities follow:\n";
2243        rnemdFile_ << "#######################################################\n";
2244  
2245  
# Line 2239 | Line 2248 | namespace OpenMD {
2248          for (unsigned int i = 0; i < outputMask_.size(); ++i) {
2249            if (outputMask_[i]) {
2250              if (data_[i].dataType == "RealType")
2251 <              writeRealStdDev(i,j);
2251 >              writeRealErrorBars(i,j);
2252              else if (data_[i].dataType == "Vector3d")
2253 <              writeVectorStdDev(i,j);
2253 >              writeVectorErrorBars(i,j);
2254              else {
2255                sprintf( painCave.errMsg,
2256                         "RNEMD found an unknown data type for: %s ",
# Line 2312 | Line 2321 | namespace OpenMD {
2321      }
2322    }  
2323  
2324 <  void RNEMD::writeRealStdDev(int index, unsigned int bin) {
2324 >  void RNEMD::writeRealErrorBars(int index, unsigned int bin) {
2325      if (!doRNEMD_) return;
2326      assert(index >=0 && index < ENDINDEX);
2327      assert(int(bin) < nBins_);
# Line 2322 | Line 2331 | namespace OpenMD {
2331      count = data_[index].accumulator[bin]->count();
2332      if (count == 0) return;
2333      
2334 <    dynamic_cast<Accumulator *>(data_[index].accumulator[bin])->getStdDev(s);
2334 >    dynamic_cast<Accumulator *>(data_[index].accumulator[bin])->get95percentConfidenceInterval(s);
2335      
2336      if (! isinf(s) && ! isnan(s)) {
2337        rnemdFile_ << "\t" << s;
# Line 2335 | Line 2344 | namespace OpenMD {
2344      }    
2345    }
2346    
2347 <  void RNEMD::writeVectorStdDev(int index, unsigned int bin) {
2347 >  void RNEMD::writeVectorErrorBars(int index, unsigned int bin) {
2348      if (!doRNEMD_) return;
2349      assert(index >=0 && index < ENDINDEX);
2350      assert(int(bin) < nBins_);
# Line 2345 | Line 2354 | namespace OpenMD {
2354      count = data_[index].accumulator[bin]->count();
2355      if (count == 0) return;
2356  
2357 <    dynamic_cast<VectorAccumulator*>(data_[index].accumulator[bin])->getStdDev(s);
2357 >    dynamic_cast<VectorAccumulator*>(data_[index].accumulator[bin])->get95percentConfidenceInterval(s);
2358      if (isinf(s[0]) || isnan(s[0]) ||
2359          isinf(s[1]) || isnan(s[1]) ||
2360          isinf(s[2]) || isnan(s[2]) ) {      

Diff Legend

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