# | Line 1 | Line 1 | |
---|---|---|
1 | #include "Integrator.hpp" | |
2 | #include "simError.h" | |
3 | < | #include <cmath> |
3 | > | #include <math.h> |
4 | template<typename T> ZConstraint<T>::ZConstraint(SimInfo* theInfo, ForceFields* the_ff) | |
5 | < | : T(theInfo, the_ff), fz(NULL), curZPos(NULL), |
6 | < | indexOfZConsMols(NULL), forcePolicy(NULL), curZconsTime(0) |
5 | > | : T(theInfo, the_ff), indexOfZConsMols(NULL), fz(NULL), curZPos(NULL), |
6 | > | fzOut(NULL), curZconsTime(0), forcePolicy(NULL) |
7 | { | |
8 | ||
9 | //get properties from SimInfo | |
# | Line 27 | Line 27 | template<typename T> ZConstraint<T>::ZConstraint(SimIn | |
27 | double halfOfLargestBox = max(info->boxL[0], max(info->boxL[1], info->boxL[2])) /2; | |
28 | zForceConst = Kb * info->target_temp /(halfOfLargestBox * halfOfLargestBox); | |
29 | ||
30 | < | //creat force substraction policy |
30 | > | //creat force Subtraction policy |
31 | data = info->getProperty(ZCONSFORCEPOLICY_ID); | |
32 | if(!data){ | |
33 | sprintf( painCave.errMsg, | |
34 | < | "ZConstraint Warning: User does not set force substraction policy, " |
34 | > | "ZConstraint Warning: User does not set force Subtraction policy, " |
35 | "PolicyByMass is used\n"); | |
36 | painCave.isFatal = 0; | |
37 | simError(); | |
38 | ||
39 | < | forcePolicy = (ForceSubstractionPolicy*) new PolicyByMass(this); |
39 | > | forcePolicy = (ForceSubtractionPolicy*) new PolicyByMass(this); |
40 | } | |
41 | else{ | |
42 | policy = dynamic_cast<StringData*>(data); | |
# | Line 48 | Line 48 | template<typename T> ZConstraint<T>::ZConstraint(SimIn | |
48 | painCave.isFatal = 0; | |
49 | simError(); | |
50 | ||
51 | < | forcePolicy = (ForceSubstractionPolicy*) new PolicyByMass(this); |
51 | > | forcePolicy = (ForceSubtractionPolicy*) new PolicyByMass(this); |
52 | } | |
53 | else{ | |
54 | if(policy->getData() == "BYNUMBER") | |
55 | < | forcePolicy = (ForceSubstractionPolicy*) new PolicyByNumber(this); |
55 | > | forcePolicy = (ForceSubtractionPolicy*) new PolicyByNumber(this); |
56 | else if(policy->getData() == "BYMASS") | |
57 | < | forcePolicy = (ForceSubstractionPolicy*) new PolicyByMass(this); |
57 | > | forcePolicy = (ForceSubtractionPolicy*) new PolicyByMass(this); |
58 | else{ | |
59 | sprintf( painCave.errMsg, | |
60 | < | "ZConstraint Warning: unknown force substraction policy, " |
60 | > | "ZConstraint Warning: unknown force Subtraction policy, " |
61 | "PolicyByMass is used\n"); | |
62 | painCave.isFatal = 0; | |
63 | simError(); | |
64 | < | forcePolicy = (ForceSubstractionPolicy*) new PolicyByMass(this); |
64 | > | forcePolicy = (ForceSubtractionPolicy*) new PolicyByMass(this); |
65 | } | |
66 | } | |
67 | } | |
# | Line 213 | Line 213 | template<typename T> ZConstraint<T>::ZConstraint(SimIn | |
213 | ||
214 | //if user does not specify the zpos for the zconstraint molecule | |
215 | //its initial z coordinate will be used as default | |
216 | < | for(int i = 0; i < parameters->size(); i++){ |
216 | > | for(int i = 0; i < (int)(parameters->size()); i++){ |
217 | ||
218 | if(!(*parameters)[i].havingZPos){ | |
219 | #ifndef IS_MPI | |
# | Line 227 | Line 227 | template<typename T> ZConstraint<T>::ZConstraint(SimIn | |
227 | //query which processor current zconstraint molecule belongs to | |
228 | int *MolToProcMap; | |
229 | int whichNode; | |
230 | < | double initZPos; |
230 | > | |
231 | MolToProcMap = mpiSim->getMolToProcMap(); | |
232 | whichNode = MolToProcMap[(*parameters)[i].zconsIndex]; | |
233 | ||
# | Line 279 | Line 279 | template<typename T> ZConstraint<T>::ZConstraint(SimIn | |
279 | zPos.push_back((*parameters)[searchResult].zPos); | |
280 | // cout << "index: "<< (*parameters)[searchResult].zconsIndex | |
281 | // <<"\tzPos = " << (*parameters)[searchResult].zPos << endl; | |
282 | – | kz.push_back((*parameters)[searchResult]. kRatio * zForceConst); |
282 | ||
283 | + | kz.push_back((*parameters)[searchResult]. kRatio * zForceConst); |
284 | molecules[i].getCOM(COM); | |
285 | } | |
286 | else | |
# | Line 304 | Line 304 | template<typename T> ZConstraint<T>::ZConstraint(SimIn | |
304 | } | |
305 | ||
306 | //determine the states of z-constraint molecules | |
307 | < | for(int i = 0; i < zconsMols.size(); i++){ |
307 | > | for(int i = 0; i < (int)(zconsMols.size()); i++){ |
308 | indexOfZConsMols[i] = zconsMols[i]->getGlobalIndex(); | |
309 | ||
310 | zconsMols[i]->getCOM(COM); | |
# | Line 320 | Line 320 | template<typename T> ZConstraint<T>::ZConstraint(SimIn | |
320 | double totalMassOfUncons_local; | |
321 | totalMassOfUncons_local = 0; | |
322 | ||
323 | < | for(int i = 0; i < unconsMols.size(); i++) |
323 | > | for(int i = 0; i < (int)(unconsMols.size()); i++) |
324 | totalMassOfUncons_local += unconsMols[i]->getTotalMass(); | |
325 | ||
326 | #ifndef IS_MPI | |
# | Line 330 | Line 330 | template<typename T> ZConstraint<T>::ZConstraint(SimIn | |
330 | MPI_DOUBLE, MPI_SUM, MPI_COMM_WORLD); | |
331 | #endif | |
332 | ||
333 | – | |
333 | //get total number of unconstrained atoms | |
334 | int nUnconsAtoms_local; | |
335 | nUnconsAtoms_local = 0; | |
336 | < | for(int i = 0; i < unconsMols.size(); i++) |
336 | > | for(int i = 0; i < (int)(unconsMols.size()); i++) |
337 | nUnconsAtoms_local += unconsMols[i]->getNAtoms(); | |
338 | ||
339 | #ifndef IS_MPI | |
# | Line 344 | Line 343 | template<typename T> ZConstraint<T>::ZConstraint(SimIn | |
343 | MPI_INT,MPI_SUM, MPI_COMM_WORLD); | |
344 | #endif | |
345 | ||
347 | – | // creat zconsWriter |
348 | – | fzOut = new ZConsWriter(zconsOutput.c_str(), parameters); |
349 | – | |
350 | – | if(!fzOut){ |
351 | – | sprintf( painCave.errMsg, |
352 | – | "Memory allocation failure in class Zconstraint\n"); |
353 | – | painCave.isFatal = 1; |
354 | – | simError(); |
355 | – | } |
356 | – | |
346 | forcePolicy->update(); | |
347 | } | |
348 | ||
# | Line 405 | Line 394 | template<typename T> void ZConstraint<T>::update() | |
394 | zconsMols.push_back(&molecules[i]); | |
395 | zPos.push_back((*parameters)[index].zPos); | |
396 | kz.push_back((*parameters)[index].kRatio * zForceConst); | |
408 | – | |
397 | massOfZConsMols.push_back(molecules[i].getTotalMass()); | |
398 | ||
399 | molecules[i].getCOM(COM); | |
# | Line 420 | Line 408 | template<typename T> void ZConstraint<T>::update() | |
408 | } | |
409 | ||
410 | //determine the states of z-constraint molecules | |
411 | < | for(int i = 0; i < zconsMols.size(); i++){ |
411 | > | for(int i = 0; i < (int)(zconsMols.size()); i++){ |
412 | zconsMols[i]->getCOM(COM); | |
413 | if (fabs(zPos[i] - COM[whichDirection]) < zconsTol) | |
414 | states.push_back(zcsFixed); | |
# | Line 452 | Line 440 | template<typename T> void ZConstraint<T>::update() | |
440 | simError(); | |
441 | } | |
442 | ||
443 | < | for(int i = 0; i < zconsMols.size(); i++){ |
443 | > | for(int i = 0; i < (int)(zconsMols.size()); i++){ |
444 | indexOfZConsMols[i] = zconsMols[i]->getGlobalIndex(); | |
445 | } | |
446 | ||
# | Line 506 | Line 494 | template<typename T> void ZConstraint<T>::integrate(){ | |
494 | } | |
495 | ||
496 | template<typename T> void ZConstraint<T>::integrate(){ | |
497 | + | |
498 | + | // creat zconsWriter |
499 | + | fzOut = new ZConsWriter(zconsOutput.c_str(), parameters); |
500 | ||
501 | + | if(!fzOut){ |
502 | + | sprintf( painCave.errMsg, |
503 | + | "Memory allocation failure in class Zconstraint\n"); |
504 | + | painCave.isFatal = 1; |
505 | + | simError(); |
506 | + | } |
507 | + | |
508 | //zero out the velocities of center of mass of unconstrained molecules | |
509 | //and the velocities of center of mass of every single z-constrained molecueles | |
510 | zeroOutVel(); | |
# | Line 532 | Line 530 | template<typename T> void ZConstraint<T>::calcForce(in | |
530 | ||
531 | T::calcForce(calcPot, calcStress); | |
532 | ||
533 | < | if (checkZConsState()){ |
534 | < | |
537 | < | #ifdef IS_MPI |
538 | < | if(worldRank == 0){ |
539 | < | #endif |
540 | < | // std::cerr << "\n" |
541 | < | // << "*******************************************\n" |
542 | < | // << " about to call zeroOutVel()\n" |
543 | < | // << "*******************************************\n" |
544 | < | // << "\n"; |
545 | < | #ifdef IS_MPI |
546 | < | } |
547 | < | #endif |
548 | < | zeroOutVel(); |
549 | < | |
550 | < | #ifdef IS_MPI |
551 | < | if(worldRank == 0){ |
552 | < | #endif |
553 | < | // std::cerr << "\n" |
554 | < | // << "*******************************************\n" |
555 | < | // << " finished zeroOutVel()\n" |
556 | < | // << "*******************************************\n" |
557 | < | // << "\n"; |
558 | < | #ifdef IS_MPI |
559 | < | } |
560 | < | #endif |
561 | < | |
533 | > | if (checkZConsState()){ |
534 | > | zeroOutVel(); |
535 | forcePolicy->update(); | |
536 | } | |
537 | ||
# | Line 567 | Line 540 | template<typename T> void ZConstraint<T>::calcForce(in | |
540 | #ifdef IS_MPI | |
541 | if(worldRank == 0){ | |
542 | #endif | |
543 | < | // cout << "---------------------------------------------------------------------" <<endl; |
544 | < | // cout << "current time: " << info->getTime() << endl; |
545 | < | // cout << "center of mass at z: " << zsys << endl; |
546 | < | // cout << "before calcForce, the COMVel of system is " << zSysCOMVel <<endl; |
543 | > | //cout << "---------------------------------------------------------------------" <<endl; |
544 | > | //cout << "current time: " << info->getTime() << endl; |
545 | > | //cout << "center of mass at z: " << zsys << endl; |
546 | > | //cout << "before calcForce, the COMVel of system is " << zSysCOMVel <<endl; |
547 | ||
548 | #ifdef IS_MPI | |
549 | } | |
# | Line 586 | Line 559 | template<typename T> void ZConstraint<T>::calcForce(in | |
559 | ||
560 | //write out forces and current positions of z-constraint molecules | |
561 | if(info->getTime() >= curZconsTime){ | |
562 | < | for(int i = 0; i < zconsMols.size(); i++){ |
562 | > | for(int i = 0; i < (int)(zconsMols.size()); i++){ |
563 | zconsMols[i]->getCOM(COM); | |
564 | curZPos[i] = COM[whichDirection]; | |
565 | ||
# | Line 609 | Line 582 | template<typename T> void ZConstraint<T>::calcForce(in | |
582 | #ifdef IS_MPI | |
583 | if(worldRank == 0){ | |
584 | #endif | |
585 | < | // cout << "after calcForce, the COMVel of system is " << zSysCOMVel <<endl; |
585 | > | //cout << "after calcForce, the COMVel of system is " << zSysCOMVel <<endl; |
586 | #ifdef IS_MPI | |
587 | } | |
588 | #endif | |
# | Line 681 | Line 654 | template<typename T> void ZConstraint<T>::zeroOutVel() | |
654 | ||
655 | //zero out the velocities of center of mass of fixed z-constrained molecules | |
656 | ||
657 | < | for(int i = 0; i < zconsMols.size(); i++){ |
657 | > | for(int i = 0; i < (int)(zconsMols.size()); i++){ |
658 | ||
659 | if (states[i] == zcsFixed){ | |
660 | ||
661 | zconsMols[i]->getCOMvel(COMvel); | |
662 | < | //cout << "before resetting " << indexOfZConsMols[i] <<"'s vz is " << COMvel[whichDirection] << endl; |
662 | > | //cout << "before resetting " << indexOfZConsMols[i] <<"'s vz is " << COMvel[whichDirection] << endl; |
663 | ||
664 | fixedZAtoms = zconsMols[i]->getMyAtoms(); | |
665 | ||
# | Line 708 | Line 681 | template<typename T> void ZConstraint<T>::zeroOutVel() | |
681 | #ifdef IS_MPI | |
682 | if(worldRank == 0){ | |
683 | #endif | |
684 | < | // cout << "before resetting the COMVel of sytem is " << zSysCOMVel << endl; |
684 | > | //cout << "before resetting the COMVel of sytem is " << zSysCOMVel << endl; |
685 | #ifdef IS_MPI | |
686 | } | |
687 | #endif | |
# | Line 722 | Line 695 | template<typename T> void ZConstraint<T>::zeroOutVel() | |
695 | MVzOfMovingMols_local = 0; | |
696 | totalMassOfMovingZMols_local = 0; | |
697 | ||
698 | < | for(int i =0; i < unconsMols.size(); i++){ |
698 | > | for(int i =0; i < (int)(unconsMols.size()); i++){ |
699 | unconsMols[i]->getCOMvel(COMvel); | |
700 | MVzOfMovingMols_local += massOfUnconsMols[i] * COMvel[whichDirection]; | |
701 | } | |
702 | ||
703 | < | for(int i = 0; i < zconsMols.size(); i++){ |
703 | > | for(int i = 0; i < (int)(zconsMols.size()); i++){ |
704 | if (states[i] == zcsMoving){ | |
705 | zconsMols[i]->getCOMvel(COMvel); | |
706 | MVzOfMovingMols_local += massOfZConsMols[i] * COMvel[whichDirection]; | |
# | Line 749 | Line 722 | template<typename T> void ZConstraint<T>::zeroOutVel() | |
722 | ||
723 | //modify the velocites of unconstrained molecules | |
724 | Atom** unconsAtoms; | |
725 | < | for(int i = 0; i < unconsMols.size(); i++){ |
725 | > | for(int i = 0; i < (int)(unconsMols.size()); i++){ |
726 | ||
727 | unconsAtoms = unconsMols[i]->getMyAtoms(); | |
728 | for(int j = 0; j < unconsMols[i]->getNAtoms();j++){ | |
# | Line 762 | Line 735 | template<typename T> void ZConstraint<T>::zeroOutVel() | |
735 | ||
736 | //modify the velocities of moving z-constrained molecuels | |
737 | Atom** movingZAtoms; | |
738 | < | for(int i = 0; i < zconsMols.size(); i++){ |
738 | > | for(int i = 0; i < (int)(zconsMols.size()); i++){ |
739 | ||
740 | if (states[i] ==zcsMoving){ | |
741 | ||
# | Line 782 | Line 755 | template<typename T> void ZConstraint<T>::zeroOutVel() | |
755 | #ifdef IS_MPI | |
756 | if(worldRank == 0){ | |
757 | #endif | |
758 | < | // cout << "after resetting the COMVel of moving molecules is " << zSysCOMVel << endl; |
758 | > | //cout << "after resetting the COMVel of moving molecules is " << zSysCOMVel << endl; |
759 | #ifdef IS_MPI | |
760 | } | |
761 | #endif | |
# | Line 798 | Line 771 | template<typename T> void ZConstraint<T>::doZconstrain | |
771 | Atom** zconsAtoms; | |
772 | double totalFZ; | |
773 | double totalFZ_local; | |
801 | – | double COMvel[3]; |
774 | double COM[3]; | |
775 | double force[3]; | |
776 | ||
# | Line 808 | Line 780 | template<typename T> void ZConstraint<T>::doZconstrain | |
780 | totalFZ_local = 0; | |
781 | ||
782 | //calculate the total z-contrained force of fixed z-contrained molecules | |
783 | + | |
784 | + | //cout << "before zero out z-constraint force on fixed z-constraint molecuels " |
785 | + | // << "total force is " << calcTotalForce() << endl; |
786 | ||
787 | < | for(int i = 0; i < zconsMols.size(); i++){ |
787 | > | for(int i = 0; i < (int)(zconsMols.size()); i++){ |
788 | ||
789 | if (states[i] == zcsFixed){ | |
790 | ||
# | Line 825 | Line 800 | template<typename T> void ZConstraint<T>::doZconstrain | |
800 | ||
801 | //cout << "Fixed Molecule\tindex: " << indexOfZConsMols[i] | |
802 | // <<"\tcurrent zpos: " << COM[whichDirection] | |
803 | < | // << "\tcurrent fz: " <<fz[i] << endl; |
803 | > | // << "\tcurrent fz: " <<fz[i] << endl; |
804 | ||
805 | ||
806 | } | |
# | Line 845 | Line 820 | template<typename T> void ZConstraint<T>::doZconstrain | |
820 | force[1]= 0; | |
821 | force[2]= 0; | |
822 | ||
823 | < | for(int i = 0; i < zconsMols.size(); i++){ |
823 | > | for(int i = 0; i < (int)(zconsMols.size()); i++){ |
824 | ||
825 | if (states[i] == zcsFixed){ | |
826 | ||
# | Line 862 | Line 837 | template<typename T> void ZConstraint<T>::doZconstrain | |
837 | ||
838 | } | |
839 | ||
840 | < | // cout << "after zero out z-constraint force on fixed z-constraint molecuels " |
841 | < | // << "total force is " << calcTotalForce() << endl; |
840 | > | //cout << "after zero out z-constraint force on fixed z-constraint molecuels " |
841 | > | // << "total force is " << calcTotalForce() << endl; |
842 | > | |
843 | ||
844 | force[0]= 0; | |
845 | force[1]= 0; | |
846 | force[2]= 0; | |
847 | ||
848 | //modify the forces of unconstrained molecules | |
849 | < | for(int i = 0; i < unconsMols.size(); i++){ |
849 | > | for(int i = 0; i < (int)(unconsMols.size()); i++){ |
850 | ||
851 | Atom** unconsAtoms = unconsMols[i]->getMyAtoms(); | |
852 | ||
# | Line 883 | Line 859 | template<typename T> void ZConstraint<T>::doZconstrain | |
859 | } | |
860 | ||
861 | //modify the forces of moving z-constrained molecules | |
862 | < | for(int i = 0; i < zconsMols.size(); i++) { |
862 | > | for(int i = 0; i < (int)(zconsMols.size()); i++) { |
863 | if (states[i] == zcsMoving){ | |
864 | ||
865 | Atom** movingZAtoms = zconsMols[i]->getMyAtoms(); | |
# | Line 895 | Line 871 | template<typename T> void ZConstraint<T>::doZconstrain | |
871 | } | |
872 | } | |
873 | } | |
874 | + | // cout << "after substracting z-constraint force from moving molecuels " |
875 | + | // << "total force is " << calcTotalForce() << endl; |
876 | ||
899 | – | //cout << "after substracting z-constraint force from moving molecuels " |
900 | – | // << "total force is " << calcTotalForce() << endl; |
901 | – | |
877 | } | |
878 | ||
879 | /** | |
# | Line 921 | Line 896 | template<typename T> void ZConstraint<T>::doHarmonic() | |
896 | ||
897 | totalFZ_local = 0; | |
898 | ||
899 | < | for(int i = 0; i < zconsMols.size(); i++) { |
899 | > | for(int i = 0; i < (int)(zconsMols.size()); i++) { |
900 | ||
901 | if (states[i] == zcsMoving){ | |
902 | zconsMols[i]->getCOM(COM); | |
# | Line 955 | Line 930 | template<typename T> void ZConstraint<T>::doHarmonic() | |
930 | MPI_Allreduce(&totalFZ_local, &totalFZ, 1, MPI_DOUBLE,MPI_SUM, MPI_COMM_WORLD); | |
931 | #endif | |
932 | ||
933 | + | //cout << "before substracting harmonic force from moving molecuels " |
934 | + | // << "total force is " << calcTotalForce() << endl; |
935 | + | |
936 | force[0]= 0; | |
937 | force[1]= 0; | |
938 | force[2]= 0; | |
939 | ||
940 | //modify the forces of unconstrained molecules | |
941 | < | for(int i = 0; i < unconsMols.size(); i++){ |
941 | > | for(int i = 0; i < (int)(unconsMols.size()); i++){ |
942 | ||
943 | Atom** unconsAtoms = unconsMols[i]->getMyAtoms(); | |
944 | ||
# | Line 971 | Line 949 | template<typename T> void ZConstraint<T>::doHarmonic() | |
949 | } | |
950 | } | |
951 | ||
952 | + | //cout << "after substracting harmonic force from moving molecuels " |
953 | + | // << "total force is " << calcTotalForce() << endl; |
954 | + | |
955 | } | |
956 | ||
957 | /** | |
# | Line 986 | Line 967 | template<typename T> bool ZConstraint<T>::checkZConsSt | |
967 | ||
968 | changed_local = 0; | |
969 | ||
970 | < | for(int i =0; i < zconsMols.size(); i++){ |
970 | > | for(int i =0; i < (int)(zconsMols.size()); i++){ |
971 | ||
972 | zconsMols[i]->getCOM(COM); | |
973 | diff = fabs(COM[whichDirection] - zPos[i]); | |
# | Line 1018 | Line 999 | template<typename T> bool ZConstraint<T>::haveFixedZMo | |
999 | ||
1000 | havingFixed_local = 0; | |
1001 | ||
1002 | < | for(int i = 0; i < zconsMols.size(); i++) |
1002 | > | for(int i = 0; i < (int)(zconsMols.size()); i++) |
1003 | if (states[i] == zcsFixed){ | |
1004 | havingFixed_local = 1; | |
1005 | break; | |
# | Line 1044 | Line 1025 | template<typename T> bool ZConstraint<T>::haveMovingZM | |
1025 | ||
1026 | havingMoving_local = 0; | |
1027 | ||
1028 | < | for(int i = 0; i < zconsMols.size(); i++) |
1028 | > | for(int i = 0; i < (int)(zconsMols.size()); i++) |
1029 | if (states[i] == zcsMoving){ | |
1030 | havingMoving_local = 1; | |
1031 | break; | |
# | Line 1126 | Line 1107 | template<typename T> double ZConstraint<T>::calcSysCOM | |
1107 | ||
1108 | massOfZCons_local = 0; | |
1109 | ||
1110 | < | for(int i = 0; i < massOfZConsMols.size(); i++){ |
1110 | > | for(int i = 0; i < (int)(massOfZConsMols.size()); i++){ |
1111 | massOfZCons_local += massOfZConsMols[i]; | |
1112 | } | |
1113 | #ifndef IS_MPI | |
# | Line 1177 | Line 1158 | template<typename T> void ZConstraint<T>::PolicyByNumb | |
1158 | int nMovingZAtoms; | |
1159 | ||
1160 | nMovingZAtoms_local = 0; | |
1161 | < | for(int i = 0; i < (zconsIntegrator->zconsMols).size(); i++) |
1161 | > | for(int i = 0; i < (int)((zconsIntegrator->zconsMols).size()); i++) |
1162 | if((zconsIntegrator->states)[i] == (zconsIntegrator->zcsMoving)) | |
1163 | nMovingZAtoms_local += (zconsIntegrator->zconsMols)[i]->getNAtoms(); | |
1164 | ||
# | Line 1187 | Line 1168 | template<typename T> void ZConstraint<T>::PolicyByNumb | |
1168 | nMovingZAtoms = nMovingZAtoms_local; | |
1169 | #endif | |
1170 | totNumOfMovingAtoms = nMovingZAtoms + zconsIntegrator->totNumOfUnconsAtoms; | |
1190 | – | |
1191 | – | #ifdef IS_MPI |
1192 | – | if(worldRank == 0){ |
1193 | – | #endif |
1194 | – | // std::cerr << "\n" |
1195 | – | // << "*******************************************\n" |
1196 | – | // << " fiished Policy by numbr()\n" |
1197 | – | // << "*******************************************\n" |
1198 | – | // << "\n"; |
1199 | – | #ifdef IS_MPI |
1200 | – | } |
1201 | – | #endif |
1171 | } | |
1172 | ||
1173 | template<typename T>double ZConstraint<T>::PolicyByNumber::getZFOfFixedZMols(Molecule* mol, Atom* atom, double totalForce){ | |
# | Line 1227 | Line 1196 | template<typename T> void ZConstraint<T>::PolicyByMass | |
1196 | double massOfMovingZAtoms; | |
1197 | ||
1198 | massOfMovingZAtoms_local = 0; | |
1199 | < | for(int i = 0; i < (zconsIntegrator->zconsMols).size(); i++) |
1199 | > | for(int i = 0; i < (int)((zconsIntegrator->zconsMols).size()); i++) |
1200 | if((zconsIntegrator->states)[i] == (zconsIntegrator->zcsMoving)) | |
1201 | massOfMovingZAtoms_local += (zconsIntegrator->zconsMols)[i]->getTotalMass(); | |
1202 | ||
# | Line 1236 | Line 1205 | template<typename T> void ZConstraint<T>::PolicyByMass | |
1205 | #else | |
1206 | massOfMovingZAtoms = massOfMovingZAtoms_local; | |
1207 | #endif | |
1208 | < | totMassOfMovingAtoms = massOfMovingZAtoms_local + zconsIntegrator->totalMassOfUncons; |
1208 | > | totMassOfMovingAtoms = massOfMovingZAtoms + zconsIntegrator->totalMassOfUncons; |
1209 | } | |
1210 | ||
1211 | template<typename T> double ZConstraint<T>::PolicyByMass::getZFOfFixedZMols(Molecule* mol, Atom* atom, double totalForce){ |
– | Removed lines |
+ | Added lines |
< | Changed lines |
> | Changed lines |