ViewVC Help

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

root/OpenMD/branches/development/src/visitors/OtherVisitor.cpp

Comparing:
trunk/src/visitors/OtherVisitor.cpp (file contents), Revision 413 by tim, Wed Mar 9 17:30:29 2005 UTC vs.
branches/development/src/visitors/OtherVisitor.cpp (file contents), Revision 1875 by gezelter, Fri May 17 14:41:42 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		#include "selection/SelectionManager.hpp"
43		#include "visitors/OtherVisitor.hpp"
#	Line 44 | Line 45
45		#include "primitives/RigidBody.hpp"
46		#include "primitives/Molecule.hpp"
47		#include "brains/SimInfo.hpp"
48	<	namespace oopse {
48	>	#include "brains/Thermo.hpp"
49
50	<	void WrappingVisitor::visit(Atom *atom) {
50	<	internalVisit(atom);
51	<	}
50	>	namespace OpenMD {
51
52	<	void WrappingVisitor::visit(DirectionalAtom *datom) {
53	<	internalVisit(datom);
54	<	}
52	>	void WrappingVisitor::visit(Atom *atom) {
53	>	internalVisit(atom);
54	>	}
55
56	<	void WrappingVisitor::visit(RigidBody *rb) {
57	<	internalVisit(rb);
58	<	}
56	>	void WrappingVisitor::visit(DirectionalAtom *datom) {
57	>	internalVisit(datom);
58	>	}
59
60	<	void WrappingVisitor::internalVisit(StuntDouble *sd) {
60	>	void WrappingVisitor::visit(RigidBody *rb) {
61	>	internalVisit(rb);
62	>	}
63	>
64	>	void WrappingVisitor::internalVisit(StuntDouble *sd) {
65		GenericData *                     data;
66		AtomData *                        atomData;
67		AtomInfo *                        atomInfo;
#	Line 67 | Line 70 | void WrappingVisitor::internalVisit(StuntDouble *sd) {
70		data = sd->getPropertyByName("ATOMDATA");
71
72		if (data != NULL) {
73	<	atomData = dynamic_cast<AtomData *>(data);
73	>	atomData = dynamic_cast<AtomData *>(data);
74
75	<	if (atomData == NULL)
76	<	return;
75	>	if (atomData == NULL)
76	>	return;
77		} else
78	<	return;
78	>	return;
79
80		Snapshot* currSnapshot = info->getSnapshotManager()->getCurrentSnapshot();
81
82	<	for( atomInfo = atomData->beginAtomInfo(i); atomInfo; atomInfo = atomData->nextAtomInfo(i) ) {
83	<	currSnapshot->wrapVector(atomInfo->pos);
82	>	for( atomInfo = atomData->beginAtomInfo(i); atomInfo;
83	>	atomInfo = atomData->nextAtomInfo(i) ) {
84	>
85	>	Vector3d newPos = atomInfo->pos - origin_;
86	>	currSnapshot->wrapVector(newPos);
87	>	atomInfo->pos = newPos;
88	>
89		}
90	<	}
90	>	}
91
92	<	const std::string WrappingVisitor::toString() {
92	>	void WrappingVisitor::update() {
93	>	if (useCom_){
94	>	Thermo thermo(info);
95	>	origin_ = thermo.getCom();
96	>	}
97	>	}
98	>
99	>	const std::string WrappingVisitor::toString() {
100		char        buffer[65535];
101		std::string result;
102
#	Line 101 | Line 116 | const std::string WrappingVisitor::toString() {
116		result += buffer;
117
118		return result;
119	<	}
119	>	}
120
121	<	//----------------------------------------------------------------------------//
121	>	//----------------------------------------------------------------------------//
122
123	<	ReplicateVisitor::ReplicateVisitor(SimInfo *info, Vector3i opt) :
124	<	BaseVisitor() {
125	<	this->info = info;
126	<	visitorName = "ReplicateVisitor";
112	<	this->replicateOpt = opt;
123	>	ReplicateVisitor::ReplicateVisitor(SimInfo *info, Vector3i opt) :
124	>	BaseVisitor(), replicateOpt(opt) {
125	>	this->info = info;
126	>	visitorName = "ReplicateVisitor";
127
128	<	//generate the replicate directions
129	<	for( int i = 0; i <= replicateOpt[0]; i++ ) {
128	>	//generate the replicate directions
129	>	for( int i = 0; i <= replicateOpt[0]; i++ ) {
130		for( int j = 0; j <= replicateOpt[1]; j++ ) {
131	<	for( int k = 0; k <= replicateOpt[2]; k++ ) {
132	<	//skip original frame
133	<	if (i == 0 && j == 0 && k == 0) {
134	<	continue;
135	<	} else {
136	<	dir.push_back(Vector3i(i, j, k));
137	<	}
138	<	}
131	>	for( int k = 0; k <= replicateOpt[2]; k++ ) {
132	>	//skip original frame
133	>	if (i == 0 && j == 0 && k == 0) {
134	>	continue;
135	>	} else {
136	>	dir.push_back(Vector3i(i, j, k));
137	>	}
138	>	}
139		}
140	<	}
140	>	}
141
142	<	}
142	>	}
143
144	<	void ReplicateVisitor::visit(Atom *atom) {
145	<	internalVisit(atom);
146	<	}
144	>	void ReplicateVisitor::visit(Atom *atom) {
145	>	internalVisit(atom);
146	>	}
147
148	<	void ReplicateVisitor::visit(DirectionalAtom *datom) {
149	<	internalVisit(datom);
150	<	}
148	>	void ReplicateVisitor::visit(DirectionalAtom *datom) {
149	>	internalVisit(datom);
150	>	}
151
152	<	void ReplicateVisitor::visit(RigidBody *rb) {
153	<	internalVisit(rb);
154	<	}
152	>	void ReplicateVisitor::visit(RigidBody *rb) {
153	>	internalVisit(rb);
154	>	}
155
156	<	void ReplicateVisitor::internalVisit(StuntDouble *sd) {
156	>	void ReplicateVisitor::internalVisit(StuntDouble *sd) {
157		GenericData *          data;
158		AtomData *             atomData;
159
#	Line 147 | Line 161 | void ReplicateVisitor::internalVisit(StuntDouble *sd)
161		data = sd->getPropertyByName("ATOMDATA");
162
163		if (data != NULL) {
164	<	atomData = dynamic_cast<AtomData *>(data);
164	>	atomData = dynamic_cast<AtomData *>(data);
165
166	<	if (atomData == NULL) {
167	<	return;
168	<	}
166	>	if (atomData == NULL) {
167	>	return;
168	>	}
169		} else {
170	<	return;
170	>	return;
171		}
172
173		Snapshot* currSnapshot = info->getSnapshotManager()->getCurrentSnapshot();
#	Line 162 | Line 176 | void ReplicateVisitor::internalVisit(StuntDouble *sd)
176		std::vector<AtomInfo *> atomInfoList = atomData->getData();
177
178		replicate(atomInfoList, atomData, box);
179	<	}
179	>	}
180
181	<	void ReplicateVisitor::replicate(std::vector<AtomInfo *>&infoList, AtomData *data, const Mat3x3d& box) {
181	>	void ReplicateVisitor::replicate(std::vector<AtomInfo *>&infoList, AtomData *data, const Mat3x3d& box) {
182		AtomInfo* newAtomInfo;
183		std::vector<Vector3i>::iterator dirIter;
184		std::vector<AtomInfo *>::iterator i;
185
186		for( dirIter = dir.begin(); dirIter != dir.end(); ++dirIter ) {
187	<	for( i = infoList.begin(); i != infoList.end(); i++ ) {
188	<	newAtomInfo = new AtomInfo();
189	<	*newAtomInfo = *(*i);
176	<
177	<	for( int j = 0; j < 3; j++ )
178	<	newAtomInfo->pos[j] += (*dirIter)[0]*box(j, 0) + (*dirIter)[1]*box(j, 1) + (*dirIter)[2]*box(j, 2);
187	>	for( i = infoList.begin(); i != infoList.end(); ++i ) {
188	>	newAtomInfo = new AtomInfo();
189	>	*newAtomInfo = *(*i);
190
191	<	data->addAtomInfo(newAtomInfo);
192	<	}
191	>	for( int j = 0; j < 3; j++ )
192	>	newAtomInfo->pos[j] += (*dirIter)[0]*box(j, 0) + (*dirIter)[1]*box(j, 1) + (*dirIter)[2]*box(j, 2);
193	>
194	>	data->addAtomInfo(newAtomInfo);
195	>	}
196		} // end for(dirIter)
197	<	}
197	>	}
198
199	<	const std::string ReplicateVisitor::toString() {
199	>	const std::string ReplicateVisitor::toString() {
200		char                            buffer[65535];
201		std::string                     result;
188	–	std::set<std::string>::iterator i;
202
203	+
204		sprintf(buffer,
205	<	"------------------------------------------------------------------\n");
205	>	"--------------------------------------------------------------\n");
206		result += buffer;
207
208		sprintf(buffer, "Visitor name: %s\n", visitorName.c_str());
#	Line 209 | Line 223 | const std::string ReplicateVisitor::toString() {
223		result += buffer;
224
225		sprintf(buffer,
226	<	"------------------------------------------------------------------\n");
226	>	"--------------------------------------------------------------\n");
227		result += buffer;
228
229		return result;
230	<	}
230	>	}
231
232	<	//----------------------------------------------------------------------------//
232	>	//------------------------------------------------------------------------//
233
234	<	XYZVisitor::XYZVisitor(SimInfo *info) :
235	<	BaseVisitor(), seleMan(info), evaluator(info){
234	>	XYZVisitor::XYZVisitor(SimInfo *info) : BaseVisitor(), seleMan(info),
235	>	evaluator(info), doPositions_(true),
236	>	doVelocities_(false),
237	>	doForces_(false), doVectors_(false),
238	>	doCharges_(false),
239	>	doElectricFields_(false) {
240		this->info = info;
241		visitorName = "XYZVisitor";
242	<
242	>
243		evaluator.loadScriptString("select all");
244	<
244	>
245		if (!evaluator.isDynamic()) {
246	<	seleMan.setSelectionSet(evaluator.evaluate());
246	>	seleMan.setSelectionSet(evaluator.evaluate());
247		}
248	<
249	<	}
250	<
251	<	XYZVisitor::XYZVisitor(SimInfo *info, const std::string& script) :
252	<	BaseVisitor(), seleMan(info), evaluator(info) {
248	>	}
249	>
250	>	XYZVisitor::XYZVisitor(SimInfo *info, const std::string& script) :
251	>	BaseVisitor(), seleMan(info), evaluator(info), doPositions_(true),
252	>	doVelocities_(false), doForces_(false), doVectors_(false),
253	>	doCharges_(false), doElectricFields_(false) {
254	>
255		this->info = info;
256		visitorName = "XYZVisitor";
257	<
257	>
258		evaluator.loadScriptString(script);
259	<
259	>
260		if (!evaluator.isDynamic()) {
261	<	seleMan.setSelectionSet(evaluator.evaluate());
261	>	seleMan.setSelectionSet(evaluator.evaluate());
262		}
263	<
244	<	}
263	>	}
264
265	<	void XYZVisitor::visit(Atom *atom) {
265	>	void XYZVisitor::visit(Atom *atom) {
266		if (isSelected(atom))
267	<	internalVisit(atom);
268	<	}
267	>	internalVisit(atom);
268	>	}
269
270	<	void XYZVisitor::visit(DirectionalAtom *datom) {
270	>	void XYZVisitor::visit(DirectionalAtom *datom) {
271		if (isSelected(datom))
272	<	internalVisit(datom);
273	<	}
274	<
275	<	void XYZVisitor::visit(RigidBody *rb) {
272	>	internalVisit(datom);
273	>	}
274	>
275	>	void XYZVisitor::visit(RigidBody *rb) {
276		if (isSelected(rb))
277	<	internalVisit(rb);
278	<	}
279	<
280	<	void XYZVisitor::update() {
277	>	internalVisit(rb);
278	>	}
279	>
280	>	void XYZVisitor::update() {
281		//if dynamic, we need to re-evaluate the selection
282		if (evaluator.isDynamic()) {
283	<	seleMan.setSelectionSet(evaluator.evaluate());
283	>	seleMan.setSelectionSet(evaluator.evaluate());
284		}
285	<	}
286	<
287	<	void XYZVisitor::internalVisit(StuntDouble *sd) {
285	>	}
286	>
287	>	void XYZVisitor::internalVisit(StuntDouble *sd) {
288		GenericData *                     data;
289		AtomData *                        atomData;
290		AtomInfo *                        atomInfo;
291		std::vector<AtomInfo *>::iterator i;
292		char                              buffer[1024];
293	<
293	>
294		//if there is not atom data, just skip it
295		data = sd->getPropertyByName("ATOMDATA");
296	<
296	>
297		if (data != NULL) {
298	<	atomData = dynamic_cast<AtomData *>(data);
299	<
300	<	if (atomData == NULL)
301	<	return;
298	>	atomData = dynamic_cast<AtomData *>(data);
299	>
300	>	if (atomData == NULL)
301	>	return;
302		} else
303	<	return;
303	>	return;
304
305		for( atomInfo = atomData->beginAtomInfo(i); atomInfo;
306	<	atomInfo = atomData->nextAtomInfo(i) ) {
307	<	sprintf(buffer,
308	<	"%s%15.8f%15.8f%15.8f%15.8f%15.8f%15.8f",
309	<	atomInfo->atomTypeName.c_str(),
310	<	atomInfo->pos[0],
311	<	atomInfo->pos[1],
312	<	atomInfo->pos[2],
313	<	atomInfo->dipole[0],
314	<	atomInfo->dipole[1],
315	<	atomInfo->dipole[2]);
316	<	frame.push_back(buffer);
317	<	}
318	<	}
306	>	atomInfo = atomData->nextAtomInfo(i) ) {
307	>
308	>	std::string line;
309	>	sprintf(buffer, "%s", atomInfo->atomTypeName.c_str());
310	>	line += buffer;
311	>
312	>	if (doPositions_){
313	>	sprintf(buffer, "%15.8f%15.8f%15.8f", atomInfo->pos[0],
314	>	atomInfo->pos[1], atomInfo->pos[2]);
315	>	line += buffer;
316	>	}
317	>	if (doCharges_ && atomInfo->hasCharge) {
318	>	sprintf(buffer, "%15.8f", atomInfo->charge);
319	>	line += buffer;
320	>	}
321	>	if (doVectors_ && atomInfo->hasVector) {
322	>	sprintf(buffer, "%15.8f%15.8f%15.8f", atomInfo->vec[0],
323	>	atomInfo->vec[1], atomInfo->vec[2]);
324	>	line += buffer;
325	>	}
326	>	if (doVelocities_ && atomInfo->hasVelocity) {
327	>	sprintf(buffer, "%15.8f%15.8f%15.8f", atomInfo->vel[0],
328	>	atomInfo->vel[1], atomInfo->vel[2]);
329	>	line += buffer;
330	>	}
331	>	if (doForces_ && atomInfo->hasForce) {
332	>	sprintf(buffer, "%15.8f%15.8f%15.8f", atomInfo->frc[0],
333	>	atomInfo->frc[1], atomInfo->frc[2]);
334	>	line += buffer;
335	>	}
336	>	if (doElectricFields_ && atomInfo->hasElectricField) {
337	>	sprintf(buffer, "%15.8f%15.8f%15.8f", atomInfo->eField[0],
338	>	atomInfo->eField[1], atomInfo->eField[2]);
339	>	line += buffer;
340	>	}
341	>	frame.push_back(line);
342	>	}
343	>	}
344
345	<	bool XYZVisitor::isSelected(StuntDouble *sd) {
345	>	bool XYZVisitor::isSelected(StuntDouble *sd) {
346		return seleMan.isSelected(sd);
347	<	}
347	>	}
348
349	<	void XYZVisitor::writeFrame(std::ostream &outStream) {
349	>	void XYZVisitor::writeFrame(std::ostream &outStream) {
350		std::vector<std::string>::iterator i;
351		char buffer[1024];
352	<
353	<	if (frame.size() == 0)
354	<	std::cerr << "Current Frame does not contain any atoms" << std::endl;
355	<
352	>
353	>	if (frame.empty())
354	>	std::cerr << "Current Frame does not contain any atoms" << std::endl;
355	>
356		//total number of atoms
357		outStream << frame.size() << std::endl;
358	<
358	>
359		//write comment line
360		Snapshot* currSnapshot = info->getSnapshotManager()->getCurrentSnapshot();
361		Mat3x3d box = currSnapshot->getHmat();
#	Line 322 | Line 366 | void XYZVisitor::writeFrame(std::ostream &outStream) {
366		box(0, 0), box(0, 1), box(0, 2),
367		box(1, 0), box(1, 1), box(1, 2),
368		box(2, 0), box(2, 1), box(2, 2));
369	<
369	>
370		outStream << buffer << std::endl;
371	<
371	>
372		for( i = frame.begin(); i != frame.end(); ++i )
373	<	outStream << *i << std::endl;
374	<	}
375	<
376	<	const std::string XYZVisitor::toString() {
373	>	outStream << *i << std::endl;
374	>	}
375	>
376	>	std::string XYZVisitor::trimmedName(const std::string&atomTypeName) {
377	>	return atomTypeName.substr(0, atomTypeName.find('-'));
378	>	}
379	>
380	>	const std::string XYZVisitor::toString() {
381		char        buffer[65535];
382		std::string result;
383	<
383	>
384		sprintf(buffer,
385		"------------------------------------------------------------------\n");
386		result += buffer;
387	<
387	>
388		sprintf(buffer, "Visitor name: %s\n", visitorName.c_str());
389		result += buffer;
390	<
390	>
391		sprintf(buffer,
392		"Visitor Description: assemble the atom data and output xyz file\n");
393		result += buffer;
#	Line 347 | Line 395 | const std::string XYZVisitor::toString() {
395		sprintf(buffer,
396		"------------------------------------------------------------------\n");
397		result += buffer;
398	<
398	>
399		return result;
400	<	}
401	<
402	<	//----------------------------------------------------------------------------//
403	<
404	<	void PrepareVisitor::internalVisit(Atom *atom) {
400	>	}
401	>
402	>	//----------------------------------------------------------------------------//
403	>
404	>	void PrepareVisitor::internalVisit(Atom *atom) {
405		GenericData *data;
406	<	AtomData *   atomData;
359	<
406	>
407		//if visited property is  existed, remove it
408		data = atom->getPropertyByName("VISITED");
409	<
409	>
410		if (data != NULL) {
411	<	atom->removeProperty("VISITED");
411	>	atom->removeProperty("VISITED");
412		}
413	<
413	>
414		//remove atomdata
415		data = atom->getPropertyByName("ATOMDATA");
416
417		if (data != NULL) {
418	<	atomData = dynamic_cast<AtomData *>(data);
418	>	AtomData* atomData = dynamic_cast<AtomData *>(data);
419
420	<	if (atomData != NULL)
421	<	atom->removeProperty("ATOMDATA");
420	>	if (atomData != NULL)
421	>	atom->removeProperty("ATOMDATA");
422		}
423	<	}
423	>	}
424
425	<	void PrepareVisitor::internalVisit(RigidBody *rb) {
425	>	void PrepareVisitor::internalVisit(RigidBody *rb) {
426		GenericData* data;
427		AtomData* atomData;
428		std::vector<Atom *> myAtoms;
#	Line 385 | Line 432 | void PrepareVisitor::internalVisit(RigidBody *rb) {
432		data = rb->getPropertyByName("VISITED");
433
434		if (data != NULL) {
435	<	rb->removeProperty("VISITED");
435	>	rb->removeProperty("VISITED");
436		}
437
438		//remove atomdata
439		data = rb->getPropertyByName("ATOMDATA");
440
441		if (data != NULL) {
442	<	atomData = dynamic_cast<AtomData *>(data);
442	>	atomData = dynamic_cast<AtomData *>(data);
443
444	<	if (atomData != NULL)
445	<	rb->removeProperty("ATOMDATA");
444	>	if (atomData != NULL)
445	>	rb->removeProperty("ATOMDATA");
446		}
447
448		myAtoms = rb->getAtoms();
449
450		for( atomIter = myAtoms.begin(); atomIter != myAtoms.end(); ++atomIter )
451	<	internalVisit(*atomIter);
452	<	}
451	>	internalVisit(*atomIter);
452	>	}
453
454	<	const std::string PrepareVisitor::toString() {
455	<	char buffer[65535];
456	<	std::string result;
454	>	const std::string PrepareVisitor::toString() {
455	>	char buffer[65535];
456	>	std::string result;
457
458	<	sprintf(buffer,
459	<	"------------------------------------------------------------------\n");
460	<	result += buffer;
458	>	sprintf(buffer,
459	>	"------------------------------------------------------------------\n");
460	>	result += buffer;
461
462	<	sprintf(buffer, "Visitor name: %s", visitorName.c_str());
463	<	result += buffer;
462	>	sprintf(buffer, "Visitor name: %s", visitorName.c_str());
463	>	result += buffer;
464
465	<	sprintf(buffer,
466	<	"Visitor Description: prepare for operation of other vistors\n");
467	<	result += buffer;
465	>	sprintf(buffer,
466	>	"Visitor Description: prepare for operation of other vistors\n");
467	>	result += buffer;
468
469	<	sprintf(buffer,
470	<	"------------------------------------------------------------------\n");
471	<	result += buffer;
469	>	sprintf(buffer,
470	>	"------------------------------------------------------------------\n");
471	>	result += buffer;
472
473	<	return result;
474	<	}
473	>	return result;
474	>	}
475
476	<	//----------------------------------------------------------------------------//
476	>	//----------------------------------------------------------------------------//
477
478	<	WaterTypeVisitor::WaterTypeVisitor() {
478	>	WaterTypeVisitor::WaterTypeVisitor() {
479		visitorName = "WaterTypeVisitor";
480		waterTypeList.insert("TIP3P_RB_0");
481		waterTypeList.insert("TIP4P_RB_0");
482	+	waterTypeList.insert("TIP4P-Ew_RB_0");
483		waterTypeList.insert("TIP5P_RB_0");
484	+	waterTypeList.insert("TIP5P-E_RB_0");
485		waterTypeList.insert("SPCE_RB_0");
486	<	}
486	>	waterTypeList.insert("SPC_RB_0");
487	>	}
488
489	<	void WaterTypeVisitor::visit(RigidBody *rb) {
489	>	void WaterTypeVisitor::visit(RigidBody *rb) {
490		std::string rbName;
491		std::vector<Atom *> myAtoms;
492		std::vector<Atom *>::iterator atomIter;
443	–	GenericData* data;
444	–	AtomData* atomData;
445	–	AtomInfo* atomInfo;
493		std::vector<AtomInfo *>::iterator i;
494	+	AtomData* atomData;
495
496		rbName = rb->getType();
497	<
497	>
498		if (waterTypeList.find(rbName) != waterTypeList.end()) {
499	<	myAtoms = rb->getAtoms();
499	>	myAtoms = rb->getAtoms();
500	>
501	>	for( atomIter = myAtoms.begin(); atomIter != myAtoms.end();
502	>	++atomIter ) {
503	>	GenericData* data = (*atomIter)->getPropertyByName("ATOMDATA");
504	>
505	>	if (data != NULL) {
506	>	atomData = dynamic_cast<AtomData *>(data);
507	>
508	>	if (atomData == NULL)
509	>	continue;
510	>	} else
511	>	continue;
512	>
513	>	for( AtomInfo* atomInfo = atomData->beginAtomInfo(i); atomInfo;
514	>	atomInfo = atomData->nextAtomInfo(i) ) {
515	>	atomInfo->atomTypeName = trimmedName(atomInfo->atomTypeName);
516	>	}
517	>	}
518	>	}
519	>	}
520
453	–	for( atomIter = myAtoms.begin(); atomIter != myAtoms.end();
454	–	++atomIter ) {
455	–	data = (*atomIter)->getPropertyByName("ATOMDATA");
456	–
457	–	if (data != NULL) {
458	–	atomData = dynamic_cast<AtomData *>(data);
459	–
460	–	if (atomData == NULL)
461	–	continue;
462	–	} else
463	–	continue;
464	–
465	–	for( atomInfo = atomData->beginAtomInfo(i); atomInfo;
466	–	atomInfo = atomData->nextAtomInfo(i) ) {
467	–	atomInfo->atomTypeName = trimmedName(atomInfo->atomTypeName);
468	–	} //end for(atomInfo)
469	–	}     //end for(atomIter)
470	–	}         //end if (waterTypeList.find(rbName) != waterTypeList.end())
471	–	}
472	–
521		std::string WaterTypeVisitor::trimmedName(const std::string&atomTypeName) {
522		return atomTypeName.substr(0, atomTypeName.find('_'));
523		}
524
525	<	const std::string WaterTypeVisitor::toString() {
525	>	const std::string WaterTypeVisitor::toString() {
526		char buffer[65535];
527		std::string result;
528
#	Line 494 | Line 542 | const std::string WaterTypeVisitor::toString() {
542		result += buffer;
543
544		return result;
545	<	}
545	>	}
546
547	<	} //namespace oopse
547	>	} //namespace OpenMD

Comparing:
trunk/src/visitors/OtherVisitor.cpp (property svn:keywords), Revision 413 by tim, Wed Mar 9 17:30:29 2005 UTC vs.
branches/development/src/visitors/OtherVisitor.cpp (property svn:keywords), Revision 1875 by gezelter, Fri May 17 14:41:42 2013 UTC

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

Diff Legend

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