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

Comparing:
trunk/src/visitors/OtherVisitor.cpp (property svn:keywords), Revision 407 by gezelter, Tue Mar 8 21:07:49 2005 UTC vs.
branches/development/src/visitors/OtherVisitor.cpp (property svn:keywords), Revision 1874 by gezelter, Wed May 15 15:09:35 2013 UTC

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

Diff Legend

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