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

Comparing branches/development/src/brains/SimInfo.cpp (file contents):
Revision 1750 by gezelter, Thu Jun 7 12:53:46 2012 UTC vs.
Revision 1798 by gezelter, Thu Sep 13 14:10:11 2012 UTC

#	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 265 \| Line 268 \| namespace OpenMD {
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 280 \| 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 312 \| 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 335 \| 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 348 \| 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 384 \| 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;
391	<	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 402 \| 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 537 \| 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;
544	<	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 555 \| 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 780 \| Line 784 \| namespace OpenMD {
784
785		void SimInfo::setupSimVariables() {
786		useAtomicVirial_ = simParams_->getUseAtomicVirial();
787	<	// we only call setAccumulateBoxDipole if the accumulateBoxDipole parameter is true
787	>	// we only call setAccumulateBoxDipole if the accumulateBoxDipole
788	>	// parameter is true
789		calcBoxDipole_ = false;
790		if ( simParams_->haveAccumulateBoxDipole() )
791		if ( simParams_->getAccumulateBoxDipole() ) {
#	Line 790 \| Line 795 \| namespace OpenMD {
795		set<AtomType*>::iterator i;
796		set<AtomType*> atomTypes;
797		atomTypes = getSimulatedAtomTypes();
798	<	int usesElectrostatic = 0;
799	<	int usesMetallic = 0;
800	<	int usesDirectional = 0;
801	<	int usesFluctuatingCharges = 0;
798	>	bool usesElectrostatic = false;
799	>	bool usesMetallic = false;
800	>	bool usesDirectional = false;
801	>	bool usesFluctuatingCharges = false;
802		//loop over all of the atom types
803		for (i = atomTypes.begin(); i != atomTypes.end(); ++i) {
804		usesElectrostatic \|= (*i)->isElectrostatic();
#	Line 801 \| Line 806 \| namespace OpenMD {
806		usesDirectional \|= (*i)->isDirectional();
807		usesFluctuatingCharges \|= (*i)->isFluctuatingCharge();
808		}
809	<
810	<	#ifdef IS_MPI
811	<	int temp;
809	>
810	>	#ifdef IS_MPI
811	>	bool temp;
812		temp = usesDirectional;
813	<	MPI_Allreduce(&temp, &usesDirectionalAtoms_, 1, MPI_INT, MPI_LOR, MPI_COMM_WORLD);
814	<
813	>	MPI::COMM_WORLD.Allreduce(&temp, &usesDirectionalAtoms_, 1, MPI::BOOL,
814	>	MPI::LOR);
815	>
816		temp = usesMetallic;
817	<	MPI_Allreduce(&temp, &usesMetallicAtoms_, 1, MPI_INT, MPI_LOR, MPI_COMM_WORLD);
817	>	MPI::COMM_WORLD.Allreduce(&temp, &usesMetallicAtoms_, 1, MPI::BOOL,
818	>	MPI::LOR);
819
820		temp = usesElectrostatic;
821	<	MPI_Allreduce(&temp, &usesElectrostaticAtoms_, 1, MPI_INT, MPI_LOR, MPI_COMM_WORLD);
821	>	MPI::COMM_WORLD.Allreduce(&temp, &usesElectrostaticAtoms_, 1, MPI::BOOL,
822	>	MPI::LOR);
823
824		temp = usesFluctuatingCharges;
825	<	MPI_Allreduce(&temp, &usesFluctuatingCharges_, 1, MPI_INT, MPI_LOR, MPI_COMM_WORLD);
825	>	MPI::COMM_WORLD.Allreduce(&temp, &usesFluctuatingCharges_, 1, MPI::BOOL,
826	>	MPI::LOR);
827		#else
828
829		usesDirectionalAtoms_ = usesDirectional;
#	Line 974 \| Line 983 \| namespace OpenMD {
983
984		for (mol = beginMolecule(mi); mol != NULL; mol = nextMolecule(mi)) {
985
986	<	for (atom = mol->beginAtom(atomIter); atom != NULL; atom = mol->nextAtom(atomIter)) {
986	>	for (atom = mol->beginAtom(atomIter); atom != NULL;
987	>	atom = mol->nextAtom(atomIter)) {
988		atom->setSnapshotManager(sman_);
989		}
990
991	<	for (rb = mol->beginRigidBody(rbIter); rb != NULL; rb = mol->nextRigidBody(rbIter)) {
991	>	for (rb = mol->beginRigidBody(rbIter); rb != NULL;
992	>	rb = mol->nextRigidBody(rbIter)) {
993		rb->setSnapshotManager(sman_);
994		}
995
996	<	for (cg = mol->beginCutoffGroup(cgIter); cg != NULL; cg = mol->nextCutoffGroup(cgIter)) {
996	>	for (cg = mol->beginCutoffGroup(cgIter); cg != NULL;
997	>	cg = mol->nextCutoffGroup(cgIter)) {
998		cg->setSnapshotManager(sman_);
999		}
1000		}
1001
1002		}
1003
992	–	Vector3d SimInfo::getComVel(){
993	–	SimInfo::MoleculeIterator i;
994	–	Molecule* mol;
1004
996	–	Vector3d comVel(0.0);
997	–	RealType totalMass = 0.0;
998	–
999	–
1000	–	for (mol = beginMolecule(i); mol != NULL; mol = nextMolecule(i)) {
1001	–	RealType mass = mol->getMass();
1002	–	totalMass += mass;
1003	–	comVel += mass * mol->getComVel();
1004	–	}
1005	–
1006	–	#ifdef IS_MPI
1007	–	RealType tmpMass = totalMass;
1008	–	Vector3d tmpComVel(comVel);
1009	–	MPI_Allreduce(&tmpMass,&totalMass,1,MPI_REALTYPE,MPI_SUM, MPI_COMM_WORLD);
1010	–	MPI_Allreduce(tmpComVel.getArrayPointer(), comVel.getArrayPointer(),3,MPI_REALTYPE,MPI_SUM, MPI_COMM_WORLD);
1011	–	#endif
1012	–
1013	–	comVel /= totalMass;
1014	–
1015	–	return comVel;
1016	–	}
1017	–
1018	–	Vector3d SimInfo::getCom(){
1019	–	SimInfo::MoleculeIterator i;
1020	–	Molecule* mol;
1021	–
1022	–	Vector3d com(0.0);
1023	–	RealType totalMass = 0.0;
1024	–
1025	–	for (mol = beginMolecule(i); mol != NULL; mol = nextMolecule(i)) {
1026	–	RealType mass = mol->getMass();
1027	–	totalMass += mass;
1028	–	com += mass * mol->getCom();
1029	–	}
1030	–
1031	–	#ifdef IS_MPI
1032	–	RealType tmpMass = totalMass;
1033	–	Vector3d tmpCom(com);
1034	–	MPI_Allreduce(&tmpMass,&totalMass,1,MPI_REALTYPE,MPI_SUM, MPI_COMM_WORLD);
1035	–	MPI_Allreduce(tmpCom.getArrayPointer(), com.getArrayPointer(),3,MPI_REALTYPE,MPI_SUM, MPI_COMM_WORLD);
1036	–	#endif
1037	–
1038	–	com /= totalMass;
1039	–
1040	–	return com;
1041	–
1042	–	}
1043	–
1005		ostream& operator <<(ostream& o, SimInfo& info) {
1006
1007		return o;
1008		}
1009
1010	<
1050	<	/*
1051	<	Returns center of mass and center of mass velocity in one function call.
1052	<	*/
1053	<
1054	<	void SimInfo::getComAll(Vector3d &com, Vector3d &comVel){
1055	<	SimInfo::MoleculeIterator i;
1056	<	Molecule* mol;
1057	<
1058	<
1059	<	RealType totalMass = 0.0;
1060	<
1061	<
1062	<	for (mol = beginMolecule(i); mol != NULL; mol = nextMolecule(i)) {
1063	<	RealType mass = mol->getMass();
1064	<	totalMass += mass;
1065	<	com += mass * mol->getCom();
1066	<	comVel += mass * mol->getComVel();
1067	<	}
1068	<
1069	<	#ifdef IS_MPI
1070	<	RealType tmpMass = totalMass;
1071	<	Vector3d tmpCom(com);
1072	<	Vector3d tmpComVel(comVel);
1073	<	MPI_Allreduce(&tmpMass,&totalMass,1,MPI_REALTYPE,MPI_SUM, MPI_COMM_WORLD);
1074	<	MPI_Allreduce(tmpCom.getArrayPointer(), com.getArrayPointer(),3,MPI_REALTYPE,MPI_SUM, MPI_COMM_WORLD);
1075	<	MPI_Allreduce(tmpComVel.getArrayPointer(), comVel.getArrayPointer(),3,MPI_REALTYPE,MPI_SUM, MPI_COMM_WORLD);
1076	<	#endif
1077	<
1078	<	com /= totalMass;
1079	<	comVel /= totalMass;
1080	<	}
1081	<
1082	<	/*
1083	<	Return intertia tensor for entire system and angular momentum Vector.
1084	<
1085	<
1086	<	[ Ixx -Ixy -Ixz ]
1087	<	J =\| -Iyx Iyy -Iyz \|
1088	<	[ -Izx -Iyz Izz ]
1089	<	*/
1090	<
1091	<	void SimInfo::getInertiaTensor(Mat3x3d &inertiaTensor, Vector3d &angularMomentum){
1092	<
1093	<
1094	<	RealType xx = 0.0;
1095	<	RealType yy = 0.0;
1096	<	RealType zz = 0.0;
1097	<	RealType xy = 0.0;
1098	<	RealType xz = 0.0;
1099	<	RealType yz = 0.0;
1100	<	Vector3d com(0.0);
1101	<	Vector3d comVel(0.0);
1102	<
1103	<	getComAll(com, comVel);
1104	<
1105	<	SimInfo::MoleculeIterator i;
1106	<	Molecule* mol;
1107	<
1108	<	Vector3d thisq(0.0);
1109	<	Vector3d thisv(0.0);
1110	<
1111	<	RealType thisMass = 0.0;
1112	<
1113	<
1114	<
1115	<
1116	<	for (mol = beginMolecule(i); mol != NULL; mol = nextMolecule(i)) {
1117	<
1118	<	thisq = mol->getCom()-com;
1119	<	thisv = mol->getComVel()-comVel;
1120	<	thisMass = mol->getMass();
1121	<	// Compute moment of intertia coefficients.
1122	<	xx += thisq[0]thisq[0]thisMass;
1123	<	yy += thisq[1]thisq[1]thisMass;
1124	<	zz += thisq[2]thisq[2]thisMass;
1125	<
1126	<	// compute products of intertia
1127	<	xy += thisq[0]thisq[1]thisMass;
1128	<	xz += thisq[0]thisq[2]thisMass;
1129	<	yz += thisq[1]thisq[2]thisMass;
1130	<
1131	<	angularMomentum += cross( thisq, thisv ) * thisMass;
1132	<
1133	<	}
1134	<
1135	<
1136	<	inertiaTensor(0,0) = yy + zz;
1137	<	inertiaTensor(0,1) = -xy;
1138	<	inertiaTensor(0,2) = -xz;
1139	<	inertiaTensor(1,0) = -xy;
1140	<	inertiaTensor(1,1) = xx + zz;
1141	<	inertiaTensor(1,2) = -yz;
1142	<	inertiaTensor(2,0) = -xz;
1143	<	inertiaTensor(2,1) = -yz;
1144	<	inertiaTensor(2,2) = xx + yy;
1145	<
1146	<	#ifdef IS_MPI
1147	<	Mat3x3d tmpI(inertiaTensor);
1148	<	Vector3d tmpAngMom;
1149	<	MPI_Allreduce(tmpI.getArrayPointer(), inertiaTensor.getArrayPointer(),9,MPI_REALTYPE,MPI_SUM, MPI_COMM_WORLD);
1150	<	MPI_Allreduce(tmpAngMom.getArrayPointer(), angularMomentum.getArrayPointer(),3,MPI_REALTYPE,MPI_SUM, MPI_COMM_WORLD);
1151	<	#endif
1152	<
1153	<	return;
1154	<	}
1155	<
1156	<	//Returns the angular momentum of the system
1157	<	Vector3d SimInfo::getAngularMomentum(){
1158	<
1159	<	Vector3d com(0.0);
1160	<	Vector3d comVel(0.0);
1161	<	Vector3d angularMomentum(0.0);
1162	<
1163	<	getComAll(com,comVel);
1164	<
1165	<	SimInfo::MoleculeIterator i;
1166	<	Molecule* mol;
1167	<
1168	<	Vector3d thisr(0.0);
1169	<	Vector3d thisp(0.0);
1170	<
1171	<	RealType thisMass;
1172	<
1173	<	for (mol = beginMolecule(i); mol != NULL; mol = nextMolecule(i)) {
1174	<	thisMass = mol->getMass();
1175	<	thisr = mol->getCom()-com;
1176	<	thisp = (mol->getComVel()-comVel)*thisMass;
1177	<
1178	<	angularMomentum += cross( thisr, thisp );
1179	<
1180	<	}
1181	<
1182	<	#ifdef IS_MPI
1183	<	Vector3d tmpAngMom;
1184	<	MPI_Allreduce(tmpAngMom.getArrayPointer(), angularMomentum.getArrayPointer(),3,MPI_REALTYPE,MPI_SUM, MPI_COMM_WORLD);
1185	<	#endif
1186	<
1187	<	return angularMomentum;
1188	<	}
1189	<
1010	>
1011		StuntDouble* SimInfo::getIOIndexToIntegrableObject(int index) {
1012	<	return IOIndexToIntegrableObject.at(index);
1012	>	if (index >= IOIndexToIntegrableObject.size()) {
1013	>	sprintf(painCave.errMsg,
1014	>	"SimInfo::getIOIndexToIntegrableObject Error: Integrable Object\n"
1015	>	"\tindex exceeds number of known objects!\n");
1016	>	painCave.isFatal = 1;
1017	>	simError();
1018	>	return NULL;
1019	>	} else
1020	>	return IOIndexToIntegrableObject.at(index);
1021		}
1022
1023		void SimInfo::setIOIndexToIntegrableObject(const vector<StuntDouble*>& v) {
1024		IOIndexToIntegrableObject= v;
1025		}
1026
1198	–	/* Returns the Volume of the simulation based on a ellipsoid with semi-axes
1199	–	based on the radius of gyration V=4/3PiR_1R_2R_3
1200	–	where R_i are related to the principle inertia moments R_i = sqrt(C*I_i/N), this reduces to
1201	–	V = 4/3Pi(C/N)^3/2*sqrt(det(I)). See S.E. Baltazar et. al. Comp. Mat. Sci. 37 (2006) 526-536.
1202	–	*/
1203	–	void SimInfo::getGyrationalVolume(RealType &volume){
1204	–	Mat3x3d intTensor;
1205	–	RealType det;
1206	–	Vector3d dummyAngMom;
1207	–	RealType sysconstants;
1208	–	RealType geomCnst;
1209	–
1210	–	geomCnst = 3.0/2.0;
1211	–	/* Get the inertial tensor and angular momentum for free*/
1212	–	getInertiaTensor(intTensor,dummyAngMom);
1213	–
1214	–	det = intTensor.determinant();
1215	–	sysconstants = geomCnst/(RealType)nGlobalIntegrableObjects_;
1216	–	volume = 4.0/3.0NumericConstant::PIpow(sysconstants,geomCnst)*sqrt(det);
1217	–	return;
1218	–	}
1219	–
1220	–	void SimInfo::getGyrationalVolume(RealType &volume, RealType &detI){
1221	–	Mat3x3d intTensor;
1222	–	Vector3d dummyAngMom;
1223	–	RealType sysconstants;
1224	–	RealType geomCnst;
1225	–
1226	–	geomCnst = 3.0/2.0;
1227	–	/* Get the inertial tensor and angular momentum for free*/
1228	–	getInertiaTensor(intTensor,dummyAngMom);
1229	–
1230	–	detI = intTensor.determinant();
1231	–	sysconstants = geomCnst/(RealType)nGlobalIntegrableObjects_;
1232	–	volume = 4.0/3.0NumericConstant::PIpow(sysconstants,geomCnst)*sqrt(detI);
1233	–	return;
1234	–	}
1235	–	/*
1236	–	void SimInfo::setStuntDoubleFromGlobalIndex(vector<StuntDouble*> v) {
1237	–	assert( v.size() == nAtoms_ + nRigidBodies_);
1238	–	sdByGlobalIndex_ = v;
1239	–	}
1240	–
1241	–	StuntDouble* SimInfo::getStuntDoubleFromGlobalIndex(int index) {
1242	–	//assert(index < nAtoms_ + nRigidBodies_);
1243	–	return sdByGlobalIndex_.at(index);
1244	–	}
1245	–	*/
1027		int SimInfo::getNGlobalConstraints() {
1028		int nGlobalConstraints;
1029		#ifdef IS_MPI
1030	<	MPI_Allreduce(&nConstraints_, &nGlobalConstraints, 1, MPI_INT, MPI_SUM,
1031	<	MPI_COMM_WORLD);
1030	>	MPI::COMM_WORLD.Allreduce(&nConstraints_, &nGlobalConstraints, 1,
1031	>	MPI::INT, MPI::SUM);
1032		#else
1033		nGlobalConstraints = nConstraints_;
1034		#endif

Diff Legend

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

Comparing branches/development/src/brains/SimInfo.cpp (file contents): Revision 1750 by gezelter, Thu Jun 7 12:53:46 2012 UTC vs. Revision 1798 by gezelter, Thu Sep 13 14:10:11 2012 UTC

Diff Legend

Comparing branches/development/src/brains/SimInfo.cpp (file contents):
Revision 1750 by gezelter, Thu Jun 7 12:53:46 2012 UTC vs.
Revision 1798 by gezelter, Thu Sep 13 14:10:11 2012 UTC