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.
Revision 1455 by gezelter, Thu Jun 24 20:44:18 2010 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, 24107 (2008).
39	+	* [4]  Vardeman & Gezelter, in progress (2009).
40		*/
41		#include "selection/SelectionManager.hpp"
42		#include "visitors/OtherVisitor.hpp"
#	Line 44 | Line 44
44		#include "primitives/RigidBody.hpp"
45		#include "primitives/Molecule.hpp"
46		#include "brains/SimInfo.hpp"
47	<	namespace oopse {
47	>	namespace OpenMD {
48
49	<	void WrappingVisitor::visit(Atom *atom) {
50	<	internalVisit(atom);
51	<	}
49	>	void WrappingVisitor::visit(Atom *atom) {
50	>	internalVisit(atom);
51	>	}
52
53	<	void WrappingVisitor::visit(DirectionalAtom *datom) {
54	<	internalVisit(datom);
55	<	}
53	>	void WrappingVisitor::visit(DirectionalAtom *datom) {
54	>	internalVisit(datom);
55	>	}
56
57	<	void WrappingVisitor::visit(RigidBody *rb) {
58	<	internalVisit(rb);
59	<	}
57	>	void WrappingVisitor::visit(RigidBody *rb) {
58	>	internalVisit(rb);
59	>	}
60
61	<	void WrappingVisitor::internalVisit(StuntDouble *sd) {
61	>	void WrappingVisitor::internalVisit(StuntDouble *sd) {
62		GenericData *                     data;
63		AtomData *                        atomData;
64		AtomInfo *                        atomInfo;
#	Line 67 | Line 67 | void WrappingVisitor::internalVisit(StuntDouble *sd) {
67		data = sd->getPropertyByName("ATOMDATA");
68
69		if (data != NULL) {
70	<	atomData = dynamic_cast<AtomData *>(data);
70	>	atomData = dynamic_cast<AtomData *>(data);
71
72	<	if (atomData == NULL)
73	<	return;
72	>	if (atomData == NULL)
73	>	return;
74		} else
75	<	return;
75	>	return;
76
77		Snapshot* currSnapshot = info->getSnapshotManager()->getCurrentSnapshot();
78
79		for( atomInfo = atomData->beginAtomInfo(i); atomInfo; atomInfo = atomData->nextAtomInfo(i) ) {
80	<	currSnapshot->wrapVector(atomInfo->pos);
80	>	Vector3d newPos = atomInfo->pos - origin_;
81	>	currSnapshot->wrapVector(newPos);
82	>	atomInfo->pos = newPos;
83		}
84	<	}
84	>	}
85
86	<	const std::string WrappingVisitor::toString() {
86	>	void WrappingVisitor::update() {
87	>	if (useCom_){
88	>	origin_ = info->getCom();
89	>	}
90	>	}
91	>
92	>	const std::string WrappingVisitor::toString() {
93		char        buffer[65535];
94		std::string result;
95
#	Line 101 | Line 109 | const std::string WrappingVisitor::toString() {
109		result += buffer;
110
111		return result;
112	<	}
112	>	}
113
114	<	//----------------------------------------------------------------------------//
114	>	//----------------------------------------------------------------------------//
115
116	<	ReplicateVisitor::ReplicateVisitor(SimInfo *info, Vector3i opt) :
116	>	ReplicateVisitor::ReplicateVisitor(SimInfo *info, Vector3i opt) :
117		BaseVisitor() {
118	<	this->info = info;
119	<	visitorName = "ReplicateVisitor";
120	<	this->replicateOpt = opt;
118	>	this->info = info;
119	>	visitorName = "ReplicateVisitor";
120	>	this->replicateOpt = opt;
121
122	<	//generate the replicate directions
123	<	for( int i = 0; i <= replicateOpt[0]; i++ ) {
122	>	//generate the replicate directions
123	>	for( int i = 0; i <= replicateOpt[0]; i++ ) {
124		for( int j = 0; j <= replicateOpt[1]; j++ ) {
125	<	for( int k = 0; k <= replicateOpt[2]; k++ ) {
126	<	//skip original frame
127	<	if (i == 0 && j == 0 && k == 0) {
128	<	continue;
129	<	} else {
130	<	dir.push_back(Vector3i(i, j, k));
131	<	}
132	<	}
125	>	for( int k = 0; k <= replicateOpt[2]; k++ ) {
126	>	//skip original frame
127	>	if (i == 0 && j == 0 && k == 0) {
128	>	continue;
129	>	} else {
130	>	dir.push_back(Vector3i(i, j, k));
131	>	}
132	>	}
133		}
134	<	}
134	>	}
135
136	<	}
136	>	}
137
138	<	void ReplicateVisitor::visit(Atom *atom) {
139	<	internalVisit(atom);
140	<	}
138	>	void ReplicateVisitor::visit(Atom *atom) {
139	>	internalVisit(atom);
140	>	}
141
142	<	void ReplicateVisitor::visit(DirectionalAtom *datom) {
143	<	internalVisit(datom);
144	<	}
142	>	void ReplicateVisitor::visit(DirectionalAtom *datom) {
143	>	internalVisit(datom);
144	>	}
145
146	<	void ReplicateVisitor::visit(RigidBody *rb) {
147	<	internalVisit(rb);
148	<	}
146	>	void ReplicateVisitor::visit(RigidBody *rb) {
147	>	internalVisit(rb);
148	>	}
149
150	<	void ReplicateVisitor::internalVisit(StuntDouble *sd) {
150	>	void ReplicateVisitor::internalVisit(StuntDouble *sd) {
151		GenericData *          data;
152		AtomData *             atomData;
153
#	Line 147 | Line 155 | void ReplicateVisitor::internalVisit(StuntDouble *sd)
155		data = sd->getPropertyByName("ATOMDATA");
156
157		if (data != NULL) {
158	<	atomData = dynamic_cast<AtomData *>(data);
158	>	atomData = dynamic_cast<AtomData *>(data);
159
160	<	if (atomData == NULL) {
161	<	return;
162	<	}
160	>	if (atomData == NULL) {
161	>	return;
162	>	}
163		} else {
164	<	return;
164	>	return;
165		}
166
167		Snapshot* currSnapshot = info->getSnapshotManager()->getCurrentSnapshot();
#	Line 162 | Line 170 | void ReplicateVisitor::internalVisit(StuntDouble *sd)
170		std::vector<AtomInfo *> atomInfoList = atomData->getData();
171
172		replicate(atomInfoList, atomData, box);
173	<	}
173	>	}
174
175	<	void ReplicateVisitor::replicate(std::vector<AtomInfo *>&infoList, AtomData *data, const Mat3x3d& box) {
175	>	void ReplicateVisitor::replicate(std::vector<AtomInfo *>&infoList, AtomData *data, const Mat3x3d& box) {
176		AtomInfo* newAtomInfo;
177		std::vector<Vector3i>::iterator dirIter;
178		std::vector<AtomInfo *>::iterator i;
179
180		for( dirIter = dir.begin(); dirIter != dir.end(); ++dirIter ) {
181	<	for( i = infoList.begin(); i != infoList.end(); i++ ) {
182	<	newAtomInfo = new AtomInfo();
183	<	*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);
181	>	for( i = infoList.begin(); i != infoList.end(); i++ ) {
182	>	newAtomInfo = new AtomInfo();
183	>	*newAtomInfo = *(*i);
184
185	<	data->addAtomInfo(newAtomInfo);
186	<	}
185	>	for( int j = 0; j < 3; j++ )
186	>	newAtomInfo->pos[j] += (*dirIter)[0]*box(j, 0) + (*dirIter)[1]*box(j, 1) + (*dirIter)[2]*box(j, 2);
187	>
188	>	data->addAtomInfo(newAtomInfo);
189	>	}
190		} // end for(dirIter)
191	<	}
191	>	}
192
193	<	const std::string ReplicateVisitor::toString() {
193	>	const std::string ReplicateVisitor::toString() {
194		char                            buffer[65535];
195		std::string                     result;
196		std::set<std::string>::iterator i;
#	Line 213 | Line 221 | const std::string ReplicateVisitor::toString() {
221		result += buffer;
222
223		return result;
224	<	}
224	>	}
225
226	<	//----------------------------------------------------------------------------//
226	>	//----------------------------------------------------------------------------//
227
228	<	XYZVisitor::XYZVisitor(SimInfo *info) :
228	>	XYZVisitor::XYZVisitor(SimInfo *info) :
229		BaseVisitor(), seleMan(info), evaluator(info){
230	<	this->info = info;
231	<	visitorName = "XYZVisitor";
230	>	this->info = info;
231	>	visitorName = "XYZVisitor";
232
233	<	evaluator.loadScriptString("select all");
233	>	evaluator.loadScriptString("select all");
234
235	<	if (!evaluator.isDynamic()) {
235	>	if (!evaluator.isDynamic()) {
236		seleMan.setSelectionSet(evaluator.evaluate());
237	+	}
238	+	posOnly_ = false;
239		}
240
241	<	}
232	<
233	<	XYZVisitor::XYZVisitor(SimInfo *info, const std::string& script) :
241	>	XYZVisitor::XYZVisitor(SimInfo *info, const std::string& script) :
242		BaseVisitor(), seleMan(info), evaluator(info) {
243	<	this->info = info;
244	<	visitorName = "XYZVisitor";
243	>	this->info = info;
244	>	visitorName = "XYZVisitor";
245
246	<	evaluator.loadScriptString(script);
246	>	evaluator.loadScriptString(script);
247
248	<	if (!evaluator.isDynamic()) {
248	>	if (!evaluator.isDynamic()) {
249		seleMan.setSelectionSet(evaluator.evaluate());
250	+	}
251	+	posOnly_ = false;
252		}
243	–
244	–	}
253
254	<	void XYZVisitor::visit(Atom *atom) {
254	>	void XYZVisitor::visit(Atom *atom) {
255		if (isSelected(atom))
256	<	internalVisit(atom);
257	<	}
256	>	internalVisit(atom);
257	>	}
258
259	<	void XYZVisitor::visit(DirectionalAtom *datom) {
259	>	void XYZVisitor::visit(DirectionalAtom *datom) {
260		if (isSelected(datom))
261	<	internalVisit(datom);
262	<	}
261	>	internalVisit(datom);
262	>	}
263
264	<	void XYZVisitor::visit(RigidBody *rb) {
264	>	void XYZVisitor::visit(RigidBody *rb) {
265		if (isSelected(rb))
266	<	internalVisit(rb);
267	<	}
266	>	internalVisit(rb);
267	>	}
268
269	<	void XYZVisitor::update() {
269	>	void XYZVisitor::update() {
270		//if dynamic, we need to re-evaluate the selection
271		if (evaluator.isDynamic()) {
272	<	seleMan.setSelectionSet(evaluator.evaluate());
272	>	seleMan.setSelectionSet(evaluator.evaluate());
273		}
274	<	}
274	>	}
275
276	<	void XYZVisitor::internalVisit(StuntDouble *sd) {
276	>	void XYZVisitor::internalVisit(StuntDouble *sd) {
277		GenericData *                     data;
278		AtomData *                        atomData;
279		AtomInfo *                        atomInfo;
#	Line 276 | Line 284 | void XYZVisitor::internalVisit(StuntDouble *sd) {
284		data = sd->getPropertyByName("ATOMDATA");
285
286		if (data != NULL) {
287	<	atomData = dynamic_cast<AtomData *>(data);
287	>	atomData = dynamic_cast<AtomData *>(data);
288
289	<	if (atomData == NULL)
290	<	return;
289	>	if (atomData == NULL)
290	>	return;
291		} else
292	<	return;
292	>	return;
293
294	<	for( atomInfo = atomData->beginAtomInfo(i); atomInfo;
295	<	atomInfo = atomData->nextAtomInfo(i) ) {
296	<	sprintf(buffer,
297	<	"%s%15.8f%15.8f%15.8f%15.8f%15.8f%15.8f",
298	<	atomInfo->atomTypeName.c_str(),
299	<	atomInfo->pos[0],
300	<	atomInfo->pos[1],
301	<	atomInfo->pos[2],
302	<	atomInfo->dipole[0],
303	<	atomInfo->dipole[1],
304	<	atomInfo->dipole[2]);
305	<	frame.push_back(buffer);
294	>	if (posOnly_){
295	>	for( atomInfo = atomData->beginAtomInfo(i); atomInfo;
296	>	atomInfo = atomData->nextAtomInfo(i) ) {
297	>	if (atomInfo->hasCharge) {
298	>	sprintf(buffer,
299	>	"%s%15.8f%15.8f%15.8f%15.8f",
300	>	atomInfo->atomTypeName.c_str(),
301	>	atomInfo->pos[0],
302	>	atomInfo->pos[1],
303	>	atomInfo->pos[2],
304	>	atomInfo->charge);
305	>	} else {
306	>	sprintf(buffer,
307	>	"%s%15.8f%15.8f%15.8f",
308	>	atomInfo->atomTypeName.c_str(),
309	>	atomInfo->pos[0],
310	>	atomInfo->pos[1],
311	>	atomInfo->pos[2]);
312	>	}
313	>	frame.push_back(buffer);
314	>	}
315	>	}else{
316	>	for( atomInfo = atomData->beginAtomInfo(i); atomInfo;
317	>	atomInfo = atomData->nextAtomInfo(i) ) {
318	>	if (atomInfo->hasCharge) {
319	>	sprintf(buffer,
320	>	"%s%15.8f%15.8f%15.8f%15.8f%15.8f%15.8f%15.8f",
321	>	atomInfo->atomTypeName.c_str(),
322	>	atomInfo->pos[0],
323	>	atomInfo->pos[1],
324	>	atomInfo->pos[2],
325	>	atomInfo->charge,
326	>	atomInfo->dipole[0],
327	>	atomInfo->dipole[1],
328	>	atomInfo->dipole[2]);
329	>	} else {
330	>	sprintf(buffer,
331	>	"%s%15.8f%15.8f%15.8f%15.8f%15.8f%15.8f",
332	>	atomInfo->atomTypeName.c_str(),
333	>	atomInfo->pos[0],
334	>	atomInfo->pos[1],
335	>	atomInfo->pos[2],
336	>	atomInfo->dipole[0],
337	>	atomInfo->dipole[1],
338	>	atomInfo->dipole[2]);
339	>	}
340	>	frame.push_back(buffer);
341	>	}
342		}
343	<	}
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;
354	>	std::cerr << "Current Frame does not contain any atoms" << std::endl;
355
356		//total number of atoms
357		outStream << frame.size() << std::endl;
#	Line 326 | Line 370 | void XYZVisitor::writeFrame(std::ostream &outStream) {
370		outStream << buffer << std::endl;
371
372		for( i = frame.begin(); i != frame.end(); ++i )
373	<	outStream << *i << std::endl;
374	<	}
373	>	outStream << *i << std::endl;
374	>	}
375
376	<	const std::string XYZVisitor::toString() {
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
#	Line 349 | Line 397 | const std::string XYZVisitor::toString() {
397		result += buffer;
398
399		return result;
400	<	}
400	>	}
401
402	<	//----------------------------------------------------------------------------//
402	>	//----------------------------------------------------------------------------//
403
404	<	void PrepareVisitor::internalVisit(Atom *atom) {
404	>	void PrepareVisitor::internalVisit(Atom *atom) {
405		GenericData *data;
406		AtomData *   atomData;
407
#	Line 361 | Line 409 | void PrepareVisitor::internalVisit(Atom *atom) {
409		data = atom->getPropertyByName("VISITED");
410
411		if (data != NULL) {
412	<	atom->removeProperty("VISITED");
412	>	atom->removeProperty("VISITED");
413		}
414
415		//remove atomdata
416		data = atom->getPropertyByName("ATOMDATA");
417
418		if (data != NULL) {
419	<	atomData = dynamic_cast<AtomData *>(data);
419	>	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 385 | 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("TIP5P_RB_0");
484		waterTypeList.insert("SPCE_RB_0");
485	<	}
485	>	}
486
487	<	void WaterTypeVisitor::visit(RigidBody *rb) {
487	>	void WaterTypeVisitor::visit(RigidBody *rb) {
488		std::string rbName;
489		std::vector<Atom *> myAtoms;
490		std::vector<Atom *>::iterator atomIter;
#	Line 448 | Line 496 | void WaterTypeVisitor::visit(RigidBody *rb) {
496		rbName = rb->getType();
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	<	data = (*atomIter)->getPropertyByName("ATOMDATA");
501	>	for( atomIter = myAtoms.begin(); atomIter != myAtoms.end();
502	>	++atomIter ) {
503	>	data = (*atomIter)->getPropertyByName("ATOMDATA");
504
505	<	if (data != NULL) {
506	<	atomData = dynamic_cast<AtomData *>(data);
505	>	if (data != NULL) {
506	>	atomData = dynamic_cast<AtomData *>(data);
507
508	<	if (atomData == NULL)
509	<	continue;
510	<	} else
511	<	continue;
508	>	if (atomData == NULL)
509	>	continue;
510	>	} else
511	>	continue;
512
513	<	for( atomInfo = atomData->beginAtomInfo(i); atomInfo;
514	<	atomInfo = atomData->nextAtomInfo(i) ) {
515	<	atomInfo->atomTypeName = trimmedName(atomInfo->atomTypeName);
516	<	} //end for(atomInfo)
517	<	}     //end for(atomIter)
513	>	for( atomInfo = atomData->beginAtomInfo(i); atomInfo;
514	>	atomInfo = atomData->nextAtomInfo(i) ) {
515	>	atomInfo->atomTypeName = trimmedName(atomInfo->atomTypeName);
516	>	} //end for(atomInfo)
517	>	}     //end for(atomIter)
518		}         //end if (waterTypeList.find(rbName) != waterTypeList.end())
519	<	}
519	>	}
520
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.
Revision 1455 by gezelter, Thu Jun 24 20:44:18 2010 UTC

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

Diff Legend

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