[ViewVC] Diff of: OpenMD/branches/development/src/brains/SimInfo.cpp

Comparing branches/development/src/brains/SimInfo.cpp (file contents):
Revision 1744 by gezelter, Tue Jun 5 18:07:08 2012 UTC vs.
Revision 1874 by gezelter, Wed May 15 15:09:35 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] Kuang & Gezelter, J. Chem. Phys. 133, 164101 (2010).
40		* [5] Vardeman, Stocker & Gezelter, J. Chem. Theory Comput. 7, 834 (2011).
41		*/
#	Line 88 \| Line 88 \| namespace OpenMD {
88
89		vector<Component*> components = simParams->getComponents();
90
91	<	for (vector<Component*>::iterator i = components.begin(); i !=components.end(); ++i) {
91	>	for (vector<Component*>::iterator i = components.begin();
92	>	i !=components.end(); ++i) {
93		molStamp = (*i)->getMoleculeStamp();
94		nMolWithSameStamp = (*i)->getNMol();
95
#	Line 231 \| Line 232 \| namespace OpenMD {
232		vector<Atom*>::iterator k;
233
234		Molecule* mol;
235	<	StuntDouble* integrableObject;
235	>	StuntDouble* sd;
236		Atom* atom;
237
238		ndf_local = 0;
239		nfq_local = 0;
240
241		for (mol = beginMolecule(i); mol != NULL; mol = nextMolecule(i)) {
241	–	for (integrableObject = mol->beginIntegrableObject(j); integrableObject != NULL;
242	–	integrableObject = mol->nextIntegrableObject(j)) {
242
243	+	for (sd = mol->beginIntegrableObject(j); sd != NULL;
244	+	sd = mol->nextIntegrableObject(j)) {
245	+
246		ndf_local += 3;
247
248	<	if (integrableObject->isDirectional()) {
249	<	if (integrableObject->isLinear()) {
248	>	if (sd->isDirectional()) {
249	>	if (sd->isLinear()) {
250		ndf_local += 2;
251		} else {
252		ndf_local += 3;
253		}
254		}
255		}
256	+
257		for (atom = mol->beginFluctuatingCharge(k); atom != NULL;
258		atom = mol->nextFluctuatingCharge(k)) {
259		if (atom->isFluctuatingCharge()) {
#	Line 260 \| Line 263 \| namespace OpenMD {
263		}
264
265		ndfLocal_ = ndf_local;
263	–	cerr << "ndfLocal_ = " << ndfLocal_ << "\n";
266
267		// n_constraints is local, so subtract them on each processor
268		ndf_local -= nConstraints_;
269
270		#ifdef IS_MPI
271	<	MPI_Allreduce(&ndf_local,&ndf_,1,MPI_INT,MPI_SUM, MPI_COMM_WORLD);
272	<	MPI_Allreduce(&nfq_local,&nGlobalFluctuatingCharges_,1, MPI_INT, MPI_SUM, MPI_COMM_WORLD);
271	>	MPI::COMM_WORLD.Allreduce(&ndf_local, &ndf_, 1, MPI::INT,MPI::SUM);
272	>	MPI::COMM_WORLD.Allreduce(&nfq_local, &nGlobalFluctuatingCharges_, 1,
273	>	MPI::INT, MPI::SUM);
274		#else
275		ndf_ = ndf_local;
276		nGlobalFluctuatingCharges_ = nfq_local;
#	Line 281 \| Line 284 \| namespace OpenMD {
284
285		int SimInfo::getFdf() {
286		#ifdef IS_MPI
287	<	MPI_Allreduce(&fdf_local,&fdf_,1,MPI_INT,MPI_SUM, MPI_COMM_WORLD);
287	>	MPI::COMM_WORLD.Allreduce(&fdf_local, &fdf_, 1, MPI::INT, MPI::SUM);
288		#else
289		fdf_ = fdf_local;
290		#endif
#	Line 313 \| Line 316 \| namespace OpenMD {
316		MoleculeIterator i;
317		vector<StuntDouble*>::iterator j;
318		Molecule* mol;
319	<	StuntDouble* integrableObject;
319	>	StuntDouble* sd;
320
321		// Raw degrees of freedom that we have to set
322		ndfRaw_local = 0;
323
324		for (mol = beginMolecule(i); mol != NULL; mol = nextMolecule(i)) {
325	<	for (integrableObject = mol->beginIntegrableObject(j); integrableObject != NULL;
326	<	integrableObject = mol->nextIntegrableObject(j)) {
325	>
326	>	for (sd = mol->beginIntegrableObject(j); sd != NULL;
327	>	sd = mol->nextIntegrableObject(j)) {
328
329		ndfRaw_local += 3;
330
331	<	if (integrableObject->isDirectional()) {
332	<	if (integrableObject->isLinear()) {
331	>	if (sd->isDirectional()) {
332	>	if (sd->isLinear()) {
333		ndfRaw_local += 2;
334		} else {
335		ndfRaw_local += 3;
#	Line 336 \| Line 340 \| namespace OpenMD {
340		}
341
342		#ifdef IS_MPI
343	<	MPI_Allreduce(&ndfRaw_local,&ndfRaw_,1,MPI_INT,MPI_SUM, MPI_COMM_WORLD);
343	>	MPI::COMM_WORLD.Allreduce(&ndfRaw_local, &ndfRaw_, 1, MPI::INT, MPI::SUM);
344		#else
345		ndfRaw_ = ndfRaw_local;
346		#endif
#	Line 349 \| Line 353 \| namespace OpenMD {
353
354
355		#ifdef IS_MPI
356	<	MPI_Allreduce(&ndfTrans_local,&ndfTrans_,1,MPI_INT,MPI_SUM, MPI_COMM_WORLD);
356	>	MPI::COMM_WORLD.Allreduce(&ndfTrans_local, &ndfTrans_, 1,
357	>	MPI::INT, MPI::SUM);
358		#else
359		ndfTrans_ = ndfTrans_local;
360		#endif
#	Line 385 \| Line 390 \| namespace OpenMD {
390		Molecule::RigidBodyIterator rbIter;
391		RigidBody* rb;
392		Molecule::IntegrableObjectIterator ii;
393	<	StuntDouble* integrableObject;
393	>	StuntDouble* sd;
394
395	<	for (integrableObject = mol->beginIntegrableObject(ii);
396	<	integrableObject != NULL;
392	<	integrableObject = mol->nextIntegrableObject(ii)) {
395	>	for (sd = mol->beginIntegrableObject(ii); sd != NULL;
396	>	sd = mol->nextIntegrableObject(ii)) {
397
398	<	if (integrableObject->isRigidBody()) {
399	<	rb = static_cast<RigidBody*>(integrableObject);
398	>	if (sd->isRigidBody()) {
399	>	rb = static_cast<RigidBody*>(sd);
400		vector<Atom*> atoms = rb->getAtoms();
401		set<int> rigidAtoms;
402		for (int i = 0; i < static_cast<int>(atoms.size()); ++i) {
#	Line 403 \| Line 407 \| namespace OpenMD {
407		}
408		} else {
409		set<int> oneAtomSet;
410	<	oneAtomSet.insert(integrableObject->getGlobalIndex());
411	<	atomGroups.insert(map<int, set<int> >::value_type(integrableObject->getGlobalIndex(), oneAtomSet));
410	>	oneAtomSet.insert(sd->getGlobalIndex());
411	>	atomGroups.insert(map<int, set<int> >::value_type(sd->getGlobalIndex(), oneAtomSet));
412		}
413		}
414
#	Line 538 \| Line 542 \| namespace OpenMD {
542		Molecule::RigidBodyIterator rbIter;
543		RigidBody* rb;
544		Molecule::IntegrableObjectIterator ii;
545	<	StuntDouble* integrableObject;
545	>	StuntDouble* sd;
546
547	<	for (integrableObject = mol->beginIntegrableObject(ii);
548	<	integrableObject != NULL;
545	<	integrableObject = mol->nextIntegrableObject(ii)) {
547	>	for (sd = mol->beginIntegrableObject(ii); sd != NULL;
548	>	sd = mol->nextIntegrableObject(ii)) {
549
550	<	if (integrableObject->isRigidBody()) {
551	<	rb = static_cast<RigidBody*>(integrableObject);
550	>	if (sd->isRigidBody()) {
551	>	rb = static_cast<RigidBody*>(sd);
552		vector<Atom*> atoms = rb->getAtoms();
553		set<int> rigidAtoms;
554		for (int i = 0; i < static_cast<int>(atoms.size()); ++i) {
#	Line 556 \| Line 559 \| namespace OpenMD {
559		}
560		} else {
561		set<int> oneAtomSet;
562	<	oneAtomSet.insert(integrableObject->getGlobalIndex());
563	<	atomGroups.insert(map<int, set<int> >::value_type(integrableObject->getGlobalIndex(), oneAtomSet));
562	>	oneAtomSet.insert(sd->getGlobalIndex());
563	>	atomGroups.insert(map<int, set<int> >::value_type(sd->getGlobalIndex(), oneAtomSet));
564		}
565		}
566
#	Line 777 \| Line 780 \| namespace OpenMD {
780		#endif
781
782		return atomTypes;
783	+	}
784	+
785	+
786	+	int getGlobalCountOfType(AtomType* atype) {
787	+	/*
788	+	set<AtomType*> atypes = getSimulatedAtomTypes();
789	+	map<AtomType*, int> counts_;
790	+
791	+	for(mol = beginMolecule(mi); mol != NULL; mol = nextMolecule(mi)) {
792	+	for(atom = mol->beginAtom(ai); atom != NULL;
793	+	atom = mol->nextAtom(ai)) {
794	+	atom->getAtomType();
795	+	}
796	+	}
797	+	*/
798	+	return 0;
799		}
800
801		void SimInfo::setupSimVariables() {
802		useAtomicVirial_ = simParams_->getUseAtomicVirial();
803	<	// we only call setAccumulateBoxDipole if the accumulateBoxDipole parameter is true
803	>	// we only call setAccumulateBoxDipole if the accumulateBoxDipole
804	>	// parameter is true
805		calcBoxDipole_ = false;
806		if ( simParams_->haveAccumulateBoxDipole() )
807		if ( simParams_->getAccumulateBoxDipole() ) {
#	Line 791 \| Line 811 \| namespace OpenMD {
811		set<AtomType*>::iterator i;
812		set<AtomType*> atomTypes;
813		atomTypes = getSimulatedAtomTypes();
814	<	int usesElectrostatic = 0;
815	<	int usesMetallic = 0;
816	<	int usesDirectional = 0;
817	<	int usesFluctuatingCharges = 0;
814	>	bool usesElectrostatic = false;
815	>	bool usesMetallic = false;
816	>	bool usesDirectional = false;
817	>	bool usesFluctuatingCharges = false;
818		//loop over all of the atom types
819		for (i = atomTypes.begin(); i != atomTypes.end(); ++i) {
820		usesElectrostatic \|= (*i)->isElectrostatic();
#	Line 802 \| Line 822 \| namespace OpenMD {
822		usesDirectional \|= (*i)->isDirectional();
823		usesFluctuatingCharges \|= (*i)->isFluctuatingCharge();
824		}
825	<
826	<	#ifdef IS_MPI
827	<	int temp;
825	>
826	>	#ifdef IS_MPI
827	>	bool temp;
828		temp = usesDirectional;
829	<	MPI_Allreduce(&temp, &usesDirectionalAtoms_, 1, MPI_INT, MPI_LOR, MPI_COMM_WORLD);
830	<
829	>	MPI::COMM_WORLD.Allreduce(&temp, &usesDirectionalAtoms_, 1, MPI::BOOL,
830	>	MPI::LOR);
831	>
832		temp = usesMetallic;
833	<	MPI_Allreduce(&temp, &usesMetallicAtoms_, 1, MPI_INT, MPI_LOR, MPI_COMM_WORLD);
833	>	MPI::COMM_WORLD.Allreduce(&temp, &usesMetallicAtoms_, 1, MPI::BOOL,
834	>	MPI::LOR);
835
836		temp = usesElectrostatic;
837	<	MPI_Allreduce(&temp, &usesElectrostaticAtoms_, 1, MPI_INT, MPI_LOR, MPI_COMM_WORLD);
837	>	MPI::COMM_WORLD.Allreduce(&temp, &usesElectrostaticAtoms_, 1, MPI::BOOL,
838	>	MPI::LOR);
839
840		temp = usesFluctuatingCharges;
841	<	MPI_Allreduce(&temp, &usesFluctuatingCharges_, 1, MPI_INT, MPI_LOR, MPI_COMM_WORLD);
841	>	MPI::COMM_WORLD.Allreduce(&temp, &usesFluctuatingCharges_, 1, MPI::BOOL,
842	>	MPI::LOR);
843		#else
844
845		usesDirectionalAtoms_ = usesDirectional;
#	Line 871 \| Line 895 \| namespace OpenMD {
895
896
897		void SimInfo::prepareTopology() {
874	–	int nExclude, nOneTwo, nOneThree, nOneFour;
898
899		//calculate mass ratio of cutoff group
900		SimInfo::MoleculeIterator mi;
#	Line 918 \| Line 941 \| namespace OpenMD {
941		}
942		}
943
921	–	//scan topology
922	–
923	–	nExclude = excludedInteractions_.getSize();
924	–	nOneTwo = oneTwoInteractions_.getSize();
925	–	nOneThree = oneThreeInteractions_.getSize();
926	–	nOneFour = oneFourInteractions_.getSize();
927	–
928	–	int* excludeList = excludedInteractions_.getPairList();
929	–	int* oneTwoList = oneTwoInteractions_.getPairList();
930	–	int* oneThreeList = oneThreeInteractions_.getPairList();
931	–	int* oneFourList = oneFourInteractions_.getPairList();
932	–
944		topologyDone_ = true;
945		}
946
#	Line 975 \| Line 986 \| namespace OpenMD {
986
987		for (mol = beginMolecule(mi); mol != NULL; mol = nextMolecule(mi)) {
988
989	<	for (atom = mol->beginAtom(atomIter); atom != NULL; atom = mol->nextAtom(atomIter)) {
989	>	for (atom = mol->beginAtom(atomIter); atom != NULL;
990	>	atom = mol->nextAtom(atomIter)) {
991		atom->setSnapshotManager(sman_);
992		}
993
994	<	for (rb = mol->beginRigidBody(rbIter); rb != NULL; rb = mol->nextRigidBody(rbIter)) {
994	>	for (rb = mol->beginRigidBody(rbIter); rb != NULL;
995	>	rb = mol->nextRigidBody(rbIter)) {
996		rb->setSnapshotManager(sman_);
997		}
998
999	<	for (cg = mol->beginCutoffGroup(cgIter); cg != NULL; cg = mol->nextCutoffGroup(cgIter)) {
999	>	for (cg = mol->beginCutoffGroup(cgIter); cg != NULL;
1000	>	cg = mol->nextCutoffGroup(cgIter)) {
1001		cg->setSnapshotManager(sman_);
1002		}
1003		}
1004
1005		}
1006
993	–	Vector3d SimInfo::getComVel(){
994	–	SimInfo::MoleculeIterator i;
995	–	Molecule* mol;
1007
997	–	Vector3d comVel(0.0);
998	–	RealType totalMass = 0.0;
999	–
1000	–
1001	–	for (mol = beginMolecule(i); mol != NULL; mol = nextMolecule(i)) {
1002	–	RealType mass = mol->getMass();
1003	–	totalMass += mass;
1004	–	comVel += mass * mol->getComVel();
1005	–	}
1006	–
1007	–	#ifdef IS_MPI
1008	–	RealType tmpMass = totalMass;
1009	–	Vector3d tmpComVel(comVel);
1010	–	MPI_Allreduce(&tmpMass,&totalMass,1,MPI_REALTYPE,MPI_SUM, MPI_COMM_WORLD);
1011	–	MPI_Allreduce(tmpComVel.getArrayPointer(), comVel.getArrayPointer(),3,MPI_REALTYPE,MPI_SUM, MPI_COMM_WORLD);
1012	–	#endif
1013	–
1014	–	comVel /= totalMass;
1015	–
1016	–	return comVel;
1017	–	}
1018	–
1019	–	Vector3d SimInfo::getCom(){
1020	–	SimInfo::MoleculeIterator i;
1021	–	Molecule* mol;
1022	–
1023	–	Vector3d com(0.0);
1024	–	RealType totalMass = 0.0;
1025	–
1026	–	for (mol = beginMolecule(i); mol != NULL; mol = nextMolecule(i)) {
1027	–	RealType mass = mol->getMass();
1028	–	totalMass += mass;
1029	–	com += mass * mol->getCom();
1030	–	}
1031	–
1032	–	#ifdef IS_MPI
1033	–	RealType tmpMass = totalMass;
1034	–	Vector3d tmpCom(com);
1035	–	MPI_Allreduce(&tmpMass,&totalMass,1,MPI_REALTYPE,MPI_SUM, MPI_COMM_WORLD);
1036	–	MPI_Allreduce(tmpCom.getArrayPointer(), com.getArrayPointer(),3,MPI_REALTYPE,MPI_SUM, MPI_COMM_WORLD);
1037	–	#endif
1038	–
1039	–	com /= totalMass;
1040	–
1041	–	return com;
1042	–
1043	–	}
1044	–
1008		ostream& operator <<(ostream& o, SimInfo& info) {
1009
1010		return o;
1011		}
1012
1013	<
1051	<	/*
1052	<	Returns center of mass and center of mass velocity in one function call.
1053	<	*/
1054	<
1055	<	void SimInfo::getComAll(Vector3d &com, Vector3d &comVel){
1056	<	SimInfo::MoleculeIterator i;
1057	<	Molecule* mol;
1058	<
1059	<
1060	<	RealType totalMass = 0.0;
1061	<
1062	<
1063	<	for (mol = beginMolecule(i); mol != NULL; mol = nextMolecule(i)) {
1064	<	RealType mass = mol->getMass();
1065	<	totalMass += mass;
1066	<	com += mass * mol->getCom();
1067	<	comVel += mass * mol->getComVel();
1068	<	}
1069	<
1070	<	#ifdef IS_MPI
1071	<	RealType tmpMass = totalMass;
1072	<	Vector3d tmpCom(com);
1073	<	Vector3d tmpComVel(comVel);
1074	<	MPI_Allreduce(&tmpMass,&totalMass,1,MPI_REALTYPE,MPI_SUM, MPI_COMM_WORLD);
1075	<	MPI_Allreduce(tmpCom.getArrayPointer(), com.getArrayPointer(),3,MPI_REALTYPE,MPI_SUM, MPI_COMM_WORLD);
1076	<	MPI_Allreduce(tmpComVel.getArrayPointer(), comVel.getArrayPointer(),3,MPI_REALTYPE,MPI_SUM, MPI_COMM_WORLD);
1077	<	#endif
1078	<
1079	<	com /= totalMass;
1080	<	comVel /= totalMass;
1081	<	}
1082	<
1083	<	/*
1084	<	Return intertia tensor for entire system and angular momentum Vector.
1085	<
1086	<
1087	<	[ Ixx -Ixy -Ixz ]
1088	<	J =\| -Iyx Iyy -Iyz \|
1089	<	[ -Izx -Iyz Izz ]
1090	<	*/
1091	<
1092	<	void SimInfo::getInertiaTensor(Mat3x3d &inertiaTensor, Vector3d &angularMomentum){
1093	<
1094	<
1095	<	RealType xx = 0.0;
1096	<	RealType yy = 0.0;
1097	<	RealType zz = 0.0;
1098	<	RealType xy = 0.0;
1099	<	RealType xz = 0.0;
1100	<	RealType yz = 0.0;
1101	<	Vector3d com(0.0);
1102	<	Vector3d comVel(0.0);
1103	<
1104	<	getComAll(com, comVel);
1105	<
1106	<	SimInfo::MoleculeIterator i;
1107	<	Molecule* mol;
1108	<
1109	<	Vector3d thisq(0.0);
1110	<	Vector3d thisv(0.0);
1111	<
1112	<	RealType thisMass = 0.0;
1113	<
1114	<
1115	<
1116	<
1117	<	for (mol = beginMolecule(i); mol != NULL; mol = nextMolecule(i)) {
1118	<
1119	<	thisq = mol->getCom()-com;
1120	<	thisv = mol->getComVel()-comVel;
1121	<	thisMass = mol->getMass();
1122	<	// Compute moment of intertia coefficients.
1123	<	xx += thisq[0]thisq[0]thisMass;
1124	<	yy += thisq[1]thisq[1]thisMass;
1125	<	zz += thisq[2]thisq[2]thisMass;
1126	<
1127	<	// compute products of intertia
1128	<	xy += thisq[0]thisq[1]thisMass;
1129	<	xz += thisq[0]thisq[2]thisMass;
1130	<	yz += thisq[1]thisq[2]thisMass;
1131	<
1132	<	angularMomentum += cross( thisq, thisv ) * thisMass;
1133	<
1134	<	}
1135	<
1136	<
1137	<	inertiaTensor(0,0) = yy + zz;
1138	<	inertiaTensor(0,1) = -xy;
1139	<	inertiaTensor(0,2) = -xz;
1140	<	inertiaTensor(1,0) = -xy;
1141	<	inertiaTensor(1,1) = xx + zz;
1142	<	inertiaTensor(1,2) = -yz;
1143	<	inertiaTensor(2,0) = -xz;
1144	<	inertiaTensor(2,1) = -yz;
1145	<	inertiaTensor(2,2) = xx + yy;
1146	<
1147	<	#ifdef IS_MPI
1148	<	Mat3x3d tmpI(inertiaTensor);
1149	<	Vector3d tmpAngMom;
1150	<	MPI_Allreduce(tmpI.getArrayPointer(), inertiaTensor.getArrayPointer(),9,MPI_REALTYPE,MPI_SUM, MPI_COMM_WORLD);
1151	<	MPI_Allreduce(tmpAngMom.getArrayPointer(), angularMomentum.getArrayPointer(),3,MPI_REALTYPE,MPI_SUM, MPI_COMM_WORLD);
1152	<	#endif
1153	<
1154	<	return;
1155	<	}
1156	<
1157	<	//Returns the angular momentum of the system
1158	<	Vector3d SimInfo::getAngularMomentum(){
1159	<
1160	<	Vector3d com(0.0);
1161	<	Vector3d comVel(0.0);
1162	<	Vector3d angularMomentum(0.0);
1163	<
1164	<	getComAll(com,comVel);
1165	<
1166	<	SimInfo::MoleculeIterator i;
1167	<	Molecule* mol;
1168	<
1169	<	Vector3d thisr(0.0);
1170	<	Vector3d thisp(0.0);
1171	<
1172	<	RealType thisMass;
1173	<
1174	<	for (mol = beginMolecule(i); mol != NULL; mol = nextMolecule(i)) {
1175	<	thisMass = mol->getMass();
1176	<	thisr = mol->getCom()-com;
1177	<	thisp = (mol->getComVel()-comVel)*thisMass;
1178	<
1179	<	angularMomentum += cross( thisr, thisp );
1180	<
1181	<	}
1182	<
1183	<	#ifdef IS_MPI
1184	<	Vector3d tmpAngMom;
1185	<	MPI_Allreduce(tmpAngMom.getArrayPointer(), angularMomentum.getArrayPointer(),3,MPI_REALTYPE,MPI_SUM, MPI_COMM_WORLD);
1186	<	#endif
1187	<
1188	<	return angularMomentum;
1189	<	}
1190	<
1013	>
1014		StuntDouble* SimInfo::getIOIndexToIntegrableObject(int index) {
1015	<	return IOIndexToIntegrableObject.at(index);
1015	>	if (index >= int(IOIndexToIntegrableObject.size())) {
1016	>	sprintf(painCave.errMsg,
1017	>	"SimInfo::getIOIndexToIntegrableObject Error: Integrable Object\n"
1018	>	"\tindex exceeds number of known objects!\n");
1019	>	painCave.isFatal = 1;
1020	>	simError();
1021	>	return NULL;
1022	>	} else
1023	>	return IOIndexToIntegrableObject.at(index);
1024		}
1025
1026		void SimInfo::setIOIndexToIntegrableObject(const vector<StuntDouble*>& v) {
1027		IOIndexToIntegrableObject= v;
1028		}
1029
1199	–	/* Returns the Volume of the simulation based on a ellipsoid with semi-axes
1200	–	based on the radius of gyration V=4/3PiR_1R_2R_3
1201	–	where R_i are related to the principle inertia moments R_i = sqrt(C*I_i/N), this reduces to
1202	–	V = 4/3Pi(C/N)^3/2*sqrt(det(I)). See S.E. Baltazar et. al. Comp. Mat. Sci. 37 (2006) 526-536.
1203	–	*/
1204	–	void SimInfo::getGyrationalVolume(RealType &volume){
1205	–	Mat3x3d intTensor;
1206	–	RealType det;
1207	–	Vector3d dummyAngMom;
1208	–	RealType sysconstants;
1209	–	RealType geomCnst;
1210	–
1211	–	geomCnst = 3.0/2.0;
1212	–	/* Get the inertial tensor and angular momentum for free*/
1213	–	getInertiaTensor(intTensor,dummyAngMom);
1214	–
1215	–	det = intTensor.determinant();
1216	–	sysconstants = geomCnst/(RealType)nGlobalIntegrableObjects_;
1217	–	volume = 4.0/3.0NumericConstant::PIpow(sysconstants,geomCnst)*sqrt(det);
1218	–	return;
1219	–	}
1220	–
1221	–	void SimInfo::getGyrationalVolume(RealType &volume, RealType &detI){
1222	–	Mat3x3d intTensor;
1223	–	Vector3d dummyAngMom;
1224	–	RealType sysconstants;
1225	–	RealType geomCnst;
1226	–
1227	–	geomCnst = 3.0/2.0;
1228	–	/* Get the inertial tensor and angular momentum for free*/
1229	–	getInertiaTensor(intTensor,dummyAngMom);
1230	–
1231	–	detI = intTensor.determinant();
1232	–	sysconstants = geomCnst/(RealType)nGlobalIntegrableObjects_;
1233	–	volume = 4.0/3.0NumericConstant::PIpow(sysconstants,geomCnst)*sqrt(detI);
1234	–	return;
1235	–	}
1236	–	/*
1237	–	void SimInfo::setStuntDoubleFromGlobalIndex(vector<StuntDouble*> v) {
1238	–	assert( v.size() == nAtoms_ + nRigidBodies_);
1239	–	sdByGlobalIndex_ = v;
1240	–	}
1241	–
1242	–	StuntDouble* SimInfo::getStuntDoubleFromGlobalIndex(int index) {
1243	–	//assert(index < nAtoms_ + nRigidBodies_);
1244	–	return sdByGlobalIndex_.at(index);
1245	–	}
1246	–	*/
1030		int SimInfo::getNGlobalConstraints() {
1031		int nGlobalConstraints;
1032		#ifdef IS_MPI
1033	<	MPI_Allreduce(&nConstraints_, &nGlobalConstraints, 1, MPI_INT, MPI_SUM,
1034	<	MPI_COMM_WORLD);
1033	>	MPI::COMM_WORLD.Allreduce(&nConstraints_, &nGlobalConstraints, 1,
1034	>	MPI::INT, MPI::SUM);
1035		#else
1036		nGlobalConstraints = nConstraints_;
1037		#endif

Diff Legend

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

Comparing branches/development/src/brains/SimInfo.cpp (file contents): Revision 1744 by gezelter, Tue Jun 5 18:07:08 2012 UTC vs. Revision 1874 by gezelter, Wed May 15 15:09:35 2013 UTC

Diff Legend

Comparing branches/development/src/brains/SimInfo.cpp (file contents):
Revision 1744 by gezelter, Tue Jun 5 18:07:08 2012 UTC vs.
Revision 1874 by gezelter, Wed May 15 15:09:35 2013 UTC