ViewVC Help

View File | Revision Log | Show Annotations | View Changeset | Root Listing

root/OpenMD/trunk/src/constraints/ZconstraintForceManager.cpp

Comparing trunk/src/constraints/ZconstraintForceManager.cpp (file contents):
Revision 770 by tim, Fri Dec 2 15:38:03 2005 UTC vs.
Revision 1938 by gezelter, Thu Oct 31 15:32:17 2013 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, 234107 (2008).
39	+	* [4]  Kuang & Gezelter,  J. Chem. Phys. 133, 164101 (2010).
40	+	* [5]  Vardeman, Stocker & Gezelter, J. Chem. Theory Comput. 7, 834 (2011).
41		*/
42
43	+	#ifdef IS_MPI
44	+	#include <mpi.h>
45	+	#endif
46		#include <cmath>
47		#include "constraints/ZconstraintForceManager.hpp"
48		#include "integrators/Integrator.hpp"
49		#include "utils/simError.h"
50	<	#include "utils/OOPSEConstant.hpp"
50	>	#include "utils/PhysicalConstants.hpp"
51		#include "utils/StringUtils.hpp"
52	<	namespace oopse {
52	>
53	>	namespace OpenMD {
54		ZconstraintForceManager::ZconstraintForceManager(SimInfo* info): ForceManager(info), infiniteTime(1e31) {
55		currSnapshot_ = info_->getSnapshotManager()->getCurrentSnapshot();
56		Globals* simParam = info_->getSimParams();
#	Line 77 | Line 82 | namespace oopse {
82		zconsTol_ = 0.01;
83		sprintf(painCave.errMsg,
84		"ZConstraint Warning: Tolerance for z-constraint method is not specified.\n"
85	<	"\tOOPSE will use a default value of %f.\n"
85	>	"\tOpenMD will use a default value of %f.\n"
86		"\tTo set the tolerance, use the zconsTol variable.\n",
87		zconsTol_);
88		painCave.isFatal = 0;
#	Line 111 | Line 116 | namespace oopse {
116
117		//estimate the force constant of harmonical potential
118		Mat3x3d hmat = currSnapshot_->getHmat();
119	<	double halfOfLargestBox = std::max(hmat(0, 0), std::max(hmat(1, 1), hmat(2, 2))) /2;
120	<	double targetTemp;
119	>	RealType halfOfLargestBox = std::max(hmat(0, 0), std::max(hmat(1, 1), hmat(2, 2))) /2;
120	>	RealType targetTemp;
121		if (simParam->haveTargetTemp()) {
122		targetTemp = simParam->getTargetTemp();
123		} else {
124		targetTemp = 298.0;
125		}
126	<	double zforceConstant = OOPSEConstant::kb * targetTemp / (halfOfLargestBox * halfOfLargestBox);
126	>	RealType zforceConstant = PhysicalConstants::kb * targetTemp / (halfOfLargestBox * halfOfLargestBox);
127
128		int nZconstraints = simParam->getNZconsStamps();
129		std::vector<ZConsStamp*> stamp = simParam->getZconsStamps();
#	Line 148 | Line 153 | namespace oopse {
153		update();
154
155		//calculate masss of unconstraint molecules in the whole system (never change during the simulation)
156	<	double totMassUnconsMols_local = 0.0;
156	>	RealType totMassUnconsMols_local = 0.0;
157		std::vector<Molecule*>::iterator j;
158		for ( j = unzconsMols_.begin(); j !=  unzconsMols_.end(); ++j) {
159		totMassUnconsMols_local += (*j)->getMass();
#	Line 156 | Line 161 | namespace oopse {
161		#ifndef IS_MPI
162		totMassUnconsMols_ = totMassUnconsMols_local;
163		#else
164	<	MPI_Allreduce(&totMassUnconsMols_local, &totMassUnconsMols_, 1, MPI_DOUBLE,
165	<	MPI_SUM, MPI_COMM_WORLD);
164	>	MPI::COMM_WORLD.Allreduce(&totMassUnconsMols_local, &totMassUnconsMols_, 1,
165	>	MPI::REALTYPE, MPI::SUM);
166		#endif
167
168		// creat zconsWriter
#	Line 194 | Line 199 | namespace oopse {
199		zmol.param = i->second;
200		zmol.cantPos = zmol.param.zTargetPos; /**@todo fixed me when zmol migrate, it is incorrect*/
201		Vector3d com = zmol.mol->getCom();
202	<	double diff = fabs(zmol.param.zTargetPos - com[whichDirection]);
202	>	RealType diff = fabs(zmol.param.zTargetPos - com[whichDirection]);
203		if (diff < zconsTol_) {
204		fixedZMols_.push_back(zmol);
205		} else {
#	Line 240 | Line 245 | namespace oopse {
245		currZconsTime_ = currSnapshot_->getTime();
246		}
247
248	<	void ZconstraintForceManager::calcForces(bool needPotential, bool needStress){
249	<	ForceManager::calcForces(needPotential, needStress);
248	>	void ZconstraintForceManager::calcForces(){
249	>	ForceManager::calcForces();
250
251		if (usingZconsGap_){
252		updateZPos();
#	Line 282 | Line 287 | namespace oopse {
287		Vector3d vel;
288		std::list<ZconstraintMol>::iterator i;
289		Molecule* mol;
290	<	StuntDouble* integrableObject;
290	>	StuntDouble* sd;
291		Molecule::IntegrableObjectIterator ii;
292
293		//zero out the velocities of center of mass of fixed z-constrained molecules
294		for(i = fixedZMols_.begin(); i != fixedZMols_.end(); ++i) {
295	+
296		mol = i->mol;
297		comVel = mol->getComVel();
298	<	for(integrableObject = mol->beginIntegrableObject(ii); integrableObject != NULL;
299	<	integrableObject = mol->nextIntegrableObject(ii)) {
300	<	vel = integrableObject->getVel();
298	>
299	>	for(sd = mol->beginIntegrableObject(ii); sd != NULL;
300	>	sd = mol->nextIntegrableObject(ii)) {
301	>
302	>	vel = sd->getVel();
303		vel[whichDirection] -= comVel[whichDirection];
304	<	integrableObject->setVel(vel);
304	>	sd->setVel(vel);
305		}
306		}
307
308		// calculate the vz of center of mass of moving molecules(include unconstrained molecules
309		// and moving z-constrained molecules)
310	<	double pzMovingMols_local = 0.0;
311	<	double pzMovingMols;
310	>	RealType pzMovingMols_local = 0.0;
311	>	RealType pzMovingMols;
312
313		for ( i = movingZMols_.begin(); i !=  movingZMols_.end(); ++i) {
314		mol = i->mol;
#	Line 318 | Line 326 | namespace oopse {
326		#ifndef IS_MPI
327		pzMovingMols = pzMovingMols_local;
328		#else
329	<	MPI_Allreduce(&pzMovingMols_local, &pzMovingMols, 1, MPI_DOUBLE,
330	<	MPI_SUM, MPI_COMM_WORLD);
329	>	MPI::COMM_WORLD.Allreduce(&pzMovingMols_local, &pzMovingMols, 1,
330	>	MPI::REALTYPE, MPI::SUM);
331		#endif
332
333	<	double vzMovingMols = pzMovingMols / (totMassMovingZMols_ + totMassUnconsMols_);
333	>	RealType vzMovingMols = pzMovingMols / (totMassMovingZMols_ + totMassUnconsMols_);
334
335		//modify the velocities of moving z-constrained molecuels
336		for ( i = movingZMols_.begin(); i !=  movingZMols_.end(); ++i) {
337	+
338		mol = i->mol;
330	–	for(integrableObject = mol->beginIntegrableObject(ii); integrableObject != NULL;
331	–	integrableObject = mol->nextIntegrableObject(ii)) {
339
340	<	vel = integrableObject->getVel();
340	>	for(sd = mol->beginIntegrableObject(ii); sd != NULL;
341	>	sd = mol->nextIntegrableObject(ii)) {
342	>
343	>	vel = sd->getVel();
344		vel[whichDirection] -= vzMovingMols;
345	<	integrableObject->setVel(vel);
345	>	sd->setVel(vel);
346		}
347		}
348
349		//modify the velocites of unconstrained molecules
350		for ( j = unzconsMols_.begin(); j !=  unzconsMols_.end(); ++j) {
351	+
352		mol =*j;
342	–	for(integrableObject = mol->beginIntegrableObject(ii); integrableObject != NULL;
343	–	integrableObject = mol->nextIntegrableObject(ii)) {
353
354	<	vel = integrableObject->getVel();
354	>	for(sd = mol->beginIntegrableObject(ii); sd != NULL;
355	>	sd = mol->nextIntegrableObject(ii)) {
356	>
357	>	vel = sd->getVel();
358		vel[whichDirection] -= vzMovingMols;
359	<	integrableObject->setVel(vel);
359	>	sd->setVel(vel);
360		}
361		}
362
#	Line 352 | Line 364 | namespace oopse {
364
365
366		void ZconstraintForceManager::doZconstraintForce(){
367	<	double totalFZ;
368	<	double totalFZ_local;
367	>	RealType totalFZ;
368	>	RealType totalFZ_local;
369		Vector3d com;
370		Vector3d force(0.0);
371
#	Line 366 | Line 378 | namespace oopse {
378		//calculate the total z-contrained force of fixed z-contrained molecules
379		std::list<ZconstraintMol>::iterator i;
380		Molecule* mol;
381	<	StuntDouble* integrableObject;
381	>	StuntDouble* sd;
382		Molecule::IntegrableObjectIterator ii;
383
384		for ( i = fixedZMols_.begin(); i !=  fixedZMols_.end(); ++i) {
385	+
386		mol = i->mol;
387		i->fz = 0.0;
375	–	for(integrableObject = mol->beginIntegrableObject(ii); integrableObject != NULL;
376	–	integrableObject = mol->nextIntegrableObject(ii)) {
388
389	<	force = integrableObject->getFrc();
389	>	for( sd = mol->beginIntegrableObject(ii); sd != NULL;
390	>	sd = mol->nextIntegrableObject(ii)) {
391	>
392	>	force = sd->getFrc();
393		i->fz += force[whichDirection];
394		}
395		totalFZ_local += i->fz;
#	Line 383 | Line 397 | namespace oopse {
397
398		//calculate total z-constraint force
399		#ifdef IS_MPI
400	<	MPI_Allreduce(&totalFZ_local, &totalFZ, 1, MPI_DOUBLE, MPI_SUM, MPI_COMM_WORLD);
400	>	MPI::COMM_WORLD.Allreduce(&totalFZ_local, &totalFZ, 1,
401	>	MPI::REALTYPE, MPI::SUM);
402		#else
403		totalFZ = totalFZ_local;
404		#endif
#	Line 391 | Line 406 | namespace oopse {
406
407		// apply negative to fixed z-constrained molecues;
408		for ( i = fixedZMols_.begin(); i !=  fixedZMols_.end(); ++i) {
409	+
410		mol = i->mol;
395	–	for(integrableObject = mol->beginIntegrableObject(ii); integrableObject != NULL;
396	–	integrableObject = mol->nextIntegrableObject(ii)) {
411
412	<	force[whichDirection] = -getZFOfFixedZMols(mol, integrableObject, i->fz);
413	<	integrableObject->addFrc(force);
412	>	for(sd = mol->beginIntegrableObject(ii); sd != NULL;
413	>	sd = mol->nextIntegrableObject(ii)) {
414	>
415	>	force[whichDirection] = -getZFOfFixedZMols(mol, sd, i->fz);
416	>	sd->addFrc(force);
417		}
418		}
419
420		//modify the forces of moving z-constrained molecules
421		for ( i = movingZMols_.begin(); i !=  movingZMols_.end(); ++i) {
422	+
423		mol = i->mol;
406	–	for(integrableObject = mol->beginIntegrableObject(ii); integrableObject != NULL;
407	–	integrableObject = mol->nextIntegrableObject(ii)) {
424
425	+	for(sd = mol->beginIntegrableObject(ii); sd != NULL;
426	+	sd = mol->nextIntegrableObject(ii)) {
427	+
428		force[whichDirection] = -getZFOfMovingMols(mol,totalFZ);
429	<	integrableObject->addFrc(force);
429	>	sd->addFrc(force);
430		}
431		}
432
433		//modify the forces of unconstrained molecules
434		std::vector<Molecule*>::iterator j;
435		for ( j = unzconsMols_.begin(); j !=  unzconsMols_.end(); ++j) {
436	+
437		mol =*j;
418	–	for(integrableObject = mol->beginIntegrableObject(ii); integrableObject != NULL;
419	–	integrableObject = mol->nextIntegrableObject(ii)) {
438
439	+	for(sd = mol->beginIntegrableObject(ii); sd != NULL;
440	+	sd = mol->nextIntegrableObject(ii)) {
441	+
442		force[whichDirection] = -getZFOfMovingMols(mol, totalFZ);
443	<	integrableObject->addFrc(force);
443	>	sd->addFrc(force);
444		}
445		}
446
#	Line 427 | Line 448 | namespace oopse {
448
449
450		void ZconstraintForceManager::doHarmonic(){
451	<	double totalFZ;
451	>	RealType totalFZ;
452		Vector3d force(0.0);
453		Vector3d com;
454	<	double totalFZ_local = 0;
454	>	RealType totalFZ_local = 0;
455	>	RealType lrPot;
456		std::list<ZconstraintMol>::iterator i;
457	<	StuntDouble* integrableObject;
457	>	StuntDouble* sd;
458		Molecule::IntegrableObjectIterator ii;
459		Molecule* mol;
460		for ( i = movingZMols_.begin(); i !=  movingZMols_.end(); ++i) {
461		mol = i->mol;
462		com = mol->getCom();
463	<	double resPos = usingSMD_? i->cantPos : i->param.zTargetPos;
464	<	double diff = com[whichDirection] - resPos;
465	<	double harmonicU = 0.5 * i->param.kz * diff * diff;
466	<	currSnapshot_->statData[Stats::LONG_RANGE_POTENTIAL] += harmonicU;
467	<	double harmonicF = -i->param.kz * diff;
463	>	RealType resPos = usingSMD_? i->cantPos : i->param.zTargetPos;
464	>	RealType diff = com[whichDirection] - resPos;
465	>	RealType harmonicU = 0.5 * i->param.kz * diff * diff;
466	>	lrPot = currSnapshot_->getLongRangePotential();
467	>	lrPot += harmonicU;
468	>	currSnapshot_->setLongRangePotential(lrPot);
469	>	RealType harmonicF = -i->param.kz * diff;
470		totalFZ_local += harmonicF;
471
472		//adjust force
473	<	for(integrableObject = mol->beginIntegrableObject(ii); integrableObject != NULL;
474	<	integrableObject = mol->nextIntegrableObject(ii)) {
473	>	for(sd = mol->beginIntegrableObject(ii); sd != NULL;
474	>	sd = mol->nextIntegrableObject(ii)) {
475
476	<	force[whichDirection] = getHFOfFixedZMols(mol, integrableObject, harmonicF);
477	<	integrableObject->addFrc(force);
476	>	force[whichDirection] = getHFOfFixedZMols(mol, sd, harmonicF);
477	>	sd->addFrc(force);
478		}
479		}
480
481		#ifndef IS_MPI
482		totalFZ = totalFZ_local;
483		#else
484	<	MPI_Allreduce(&totalFZ_local, &totalFZ, 1, MPI_DOUBLE, MPI_SUM, MPI_COMM_WORLD);
484	>	MPI::COMM_WORLD.Allreduce(&totalFZ_local, &totalFZ, 1, MPI::REALTYPE,
485	>	MPI::SUM);
486		#endif
487
488		//modify the forces of unconstrained molecules
489		std::vector<Molecule*>::iterator j;
490		for ( j = unzconsMols_.begin(); j !=  unzconsMols_.end(); ++j) {
491	+
492		mol = *j;
467	–	for(integrableObject = mol->beginIntegrableObject(ii); integrableObject != NULL;
468	–	integrableObject = mol->nextIntegrableObject(ii)) {
493
494	+	for(sd = mol->beginIntegrableObject(ii); sd != NULL;
495	+	sd = mol->nextIntegrableObject(ii)) {
496	+
497		force[whichDirection] = getHFOfUnconsMols(mol, totalFZ);
498	<	integrableObject->addFrc(force);
498	>	sd->addFrc(force);
499		}
500		}
501
#	Line 476 | Line 503 | namespace oopse {
503
504		bool ZconstraintForceManager::checkZConsState(){
505		Vector3d com;
506	<	double diff;
506	>	RealType diff;
507		int changed_local = 0;
508
509		std::list<ZconstraintMol>::iterator i;
#	Line 527 | Line 554 | namespace oopse {
554		#ifndef IS_MPI
555		changed = changed_local;
556		#else
557	<	MPI_Allreduce(&changed_local, &changed, 1, MPI_INT, MPI_SUM, MPI_COMM_WORLD);
557	>	MPI::COMM_WORLD.Allreduce(&changed_local, &changed, 1, MPI::INT, MPI::SUM);
558		#endif
559
560		return (changed > 0);
#	Line 540 | Line 567 | namespace oopse {
567		#ifndef IS_MPI
568		havingFixed = havingFixed_local;
569		#else
570	<	MPI_Allreduce(&havingFixed_local, &havingFixed, 1, MPI_INT, MPI_SUM,
571	<	MPI_COMM_WORLD);
570	>	MPI::COMM_WORLD.Allreduce(&havingFixed_local, &havingFixed, 1,
571	>	MPI::INT, MPI::SUM);
572		#endif
573
574		return havingFixed > 0;
#	Line 557 | Line 584 | namespace oopse {
584		#ifndef IS_MPI
585		havingMoving = havingMoving_local;
586		#else
587	<	MPI_Allreduce(&havingMoving_local, &havingMoving, 1, MPI_INT, MPI_SUM,
588	<	MPI_COMM_WORLD);
587	>	MPI::COMM_WORLD.Allreduce(&havingMoving_local, &havingMoving, 1,
588	>	MPI::INT, MPI::SUM);
589		#endif
590
591		return havingMoving > 0;
#	Line 566 | Line 593 | namespace oopse {
593
594		void ZconstraintForceManager::calcTotalMassMovingZMols(){
595
596	<	double totMassMovingZMols_local = 0.0;
596	>	RealType totMassMovingZMols_local = 0.0;
597		std::list<ZconstraintMol>::iterator i;
598		for ( i = movingZMols_.begin(); i !=  movingZMols_.end(); ++i) {
599		totMassMovingZMols_local += i->mol->getMass();
600		}
601
602		#ifdef IS_MPI
603	<	MPI_Allreduce(&totMassMovingZMols_local, &totMassMovingZMols_, 1, MPI_DOUBLE,
604	<	MPI_SUM, MPI_COMM_WORLD);
603	>	MPI::COMM_WORLD.Allreduce(&totMassMovingZMols_local, &totMassMovingZMols_,
604	>	1, MPI::REALTYPE, MPI::SUM);
605		#else
606		totMassMovingZMols_ = totMassMovingZMols_local;
607		#endif
608
609		}
610
611	<	double ZconstraintForceManager::getZFOfFixedZMols(Molecule* mol, StuntDouble* sd, double totalForce){
611	>	RealType ZconstraintForceManager::getZFOfFixedZMols(Molecule* mol, StuntDouble* sd, RealType totalForce){
612		return totalForce * sd->getMass() / mol->getMass();
613		}
614
615	<	double ZconstraintForceManager::getZFOfMovingMols(Molecule* mol, double totalForce){
615	>	RealType ZconstraintForceManager::getZFOfMovingMols(Molecule* mol, RealType totalForce){
616		return totalForce * mol->getMass() / (totMassUnconsMols_ + totMassMovingZMols_);
617		}
618
619	<	double ZconstraintForceManager::getHFOfFixedZMols(Molecule* mol, StuntDouble*sd, double totalForce){
619	>	RealType ZconstraintForceManager::getHFOfFixedZMols(Molecule* mol, StuntDouble*sd, RealType totalForce){
620		return totalForce * sd->getMass() / mol->getMass();
621		}
622
623	<	double ZconstraintForceManager::getHFOfUnconsMols(Molecule* mol, double totalForce){
623	>	RealType ZconstraintForceManager::getHFOfUnconsMols(Molecule* mol, RealType totalForce){
624		return totalForce * mol->getMass() / totMassUnconsMols_;
625		}
626
627		void ZconstraintForceManager::updateZPos(){
628	<	double curTime = currSnapshot_->getTime();
628	>	RealType curTime = currSnapshot_->getTime();
629		std::list<ZconstraintMol>::iterator i;
630		for ( i = fixedZMols_.begin(); i !=  fixedZMols_.end(); ++i) {
631		i->param.zTargetPos += zconsGap_;
#	Line 612 | Line 639 | namespace oopse {
639		}
640		}
641
642	<	double ZconstraintForceManager::getZTargetPos(int index){
643	<	double zTargetPos;
642	>	RealType ZconstraintForceManager::getZTargetPos(int index){
643	>	RealType zTargetPos;
644		#ifndef IS_MPI
645		Molecule* mol = info_->getMoleculeByGlobalIndex(index);
646		assert(mol);
#	Line 621 | Line 648 | namespace oopse {
648		zTargetPos = com[whichDirection];
649		#else
650		int whicProc = info_->getMolToProc(index);
651	<	MPI_Bcast(&zTargetPos, 1, MPI_DOUBLE, whicProc, MPI_COMM_WORLD);
651	>	MPI::COMM_WORLD.Bcast(&zTargetPos, 1, MPI::REALTYPE, whicProc);
652		#endif
653		return zTargetPos;
654		}

Comparing trunk/src/constraints/ZconstraintForceManager.cpp (property svn:keywords):
Revision 770 by tim, Fri Dec 2 15:38:03 2005 UTC vs.
Revision 1938 by gezelter, Thu Oct 31 15:32:17 2013 UTC

#	Line 0 | Line 1
1	+	Author Id Revision Date

Diff Legend

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