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 2 by gezelter, Fri Sep 24 04:16:43 2004 UTC vs.
branches/development/src/visitors/OtherVisitor.cpp (file contents), Revision 1764 by gezelter, Tue Jul 3 18:32:27 2012 UTC

#	Line 1 | Line 1
1	<	#include "OtherVisitor.hpp"
2	<	#include "DirectionalAtom.hpp"
3	<	#include "RigidBody.hpp"
4	<	#include "Molecule.hpp"
5	<	#include "SimInfo.hpp"
6	<	//----------------------------------------------------------------------------//
7	<	void IgnoreVisitor::visit(Atom* atom){
8	<	if(isIgnoreType(atom->getType()))
1	>	/*
2	>	* Copyright (c) 2005 The University of Notre Dame. All Rights Reserved.
3	>	*
4	>	* The University of Notre Dame grants you ("Licensee") a
5	>	* non-exclusive, royalty free, license to use, modify and
6	>	* redistribute this software in source and binary code form, provided
7	>	* that the following conditions are met:
8	>	*
9	>	* 1. Redistributions of source code must retain the above copyright
10	>	*    notice, this list of conditions and the following disclaimer.
11	>	*
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.
16	>	*
17	>	* This software is provided "AS IS," without a warranty of any
18	>	* kind. All express or implied conditions, representations and
19	>	* warranties, including any implied warranty of merchantability,
20	>	* fitness for a particular purpose or non-infringement, are hereby
21	>	* excluded.  The University of Notre Dame and its licensors shall not
22	>	* be liable for any damages suffered by licensee as a result of
23	>	* using, modifying or distributing the software or its
24	>	* derivatives. In no event will the University of Notre Dame or its
25	>	* licensors be liable for any lost revenue, profit or data, or for
26	>	* direct, indirect, special, consequential, incidental or punitive
27	>	* damages, however caused and regardless of the theory of liability,
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]  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"
44	>	#include "primitives/DirectionalAtom.hpp"
45	>	#include "primitives/RigidBody.hpp"
46	>	#include "primitives/Molecule.hpp"
47	>	#include "brains/SimInfo.hpp"
48	>	#include "brains/Thermo.hpp"
49	>
50	>	namespace OpenMD {
51	>
52	>	void WrappingVisitor::visit(Atom *atom) {
53		internalVisit(atom);
54	<	}
54	>	}
55
56	<	void IgnoreVisitor::visit(DirectionalAtom* datom){
13	<	if(isIgnoreType(datom->getType()))
56	>	void WrappingVisitor::visit(DirectionalAtom *datom) {
57		internalVisit(datom);
58	<	}
58	>	}
59
60	<	void IgnoreVisitor::visit(RigidBody* rb){
18	<	vector<Atom*> myAtoms;
19	<	vector<Atom*>::iterator atomIter;
20	<	AtomInfo* atomInfo;
21	<
22	<	if(isIgnoreType(rb->getType())){
23	<
60	>	void WrappingVisitor::visit(RigidBody *rb) {
61		internalVisit(rb);
62	+	}
63
64	<	myAtoms = rb->getAtoms();
65	<
66	<	for(atomIter = myAtoms.begin(); atomIter != myAtoms.end(); ++atomIter)
67	<	internalVisit(*atomIter);
64	>	void WrappingVisitor::internalVisit(StuntDouble *sd) {
65	>	GenericData *                     data;
66	>	AtomData *                        atomData;
67	>	AtomInfo *                        atomInfo;
68	>	std::vector<AtomInfo *>::iterator i;
69
70	<	}
32	<
33	<	}
70	>	data = sd->getPropertyByName("ATOMDATA");
71
72	<	bool IgnoreVisitor::isIgnoreType(const string& name){
73	<	return itList.find(name) != itList.end() ? true : false;
37	<	}
72	>	if (data != NULL) {
73	>	atomData = dynamic_cast<AtomData *>(data);
74
75	<	void IgnoreVisitor::internalVisit(StuntDouble* sd){
76	<	GenericData* data;
77	<	data = sd->getProperty("IGNORE");
75	>	if (atomData == NULL)
76	>	return;
77	>	} else
78	>	return;
79
80	<	//if this stuntdoulbe is already marked as ignore just skip it
44	<	if (data == NULL){
45	<	data = new GenericData;
46	<	data->setID("IGNORE");
47	<	sd->addProperty(data);
48	<	}
80	>	Snapshot* currSnapshot = info->getSnapshotManager()->getCurrentSnapshot();
81
82	<	}
82	>	for( atomInfo = atomData->beginAtomInfo(i); atomInfo;
83	>	atomInfo = atomData->nextAtomInfo(i) ) {
84
85	<	const string IgnoreVisitor::toString(){
86	<	char buffer[65535];
87	<	string result;
88	<	set<string>::iterator i;
85	>	Vector3d newPos = atomInfo->pos - origin_;
86	>	currSnapshot->wrapVector(newPos);
87	>	atomInfo->pos = newPos;
88	>
89	>	}
90	>	}
91	>
92	>	void WrappingVisitor::update() {
93	>	if (useCom_){
94	>	Thermo thermo(info);
95	>	origin_ = thermo.getCom();
96	>	}
97	>	}
98
99	<	sprintf(buffer ,"------------------------------------------------------------------\n");
100	<	result += buffer;
99	>	const std::string WrappingVisitor::toString() {
100	>	char        buffer[65535];
101	>	std::string result;
102
103	<	sprintf(buffer ,"Visitor name: %s\n", visitorName.c_str());
104	<	result += buffer;
103	>	sprintf(buffer,
104	>	"------------------------------------------------------------------\n");
105	>	result += buffer;
106
107	<	sprintf(buffer ,"Visitor Description: ignore  stuntdoubles\n");
108	<	result += buffer;
107	>	sprintf(buffer, "Visitor name: %s\n", visitorName.c_str());
108	>	result += buffer;
109
110	<	//print the ignore type list
111	<	sprintf(buffer , "Ignore type list contains below types:\n");
112	<	result += buffer;
110	>	sprintf(buffer,
111	>	"Visitor Description: wrapping atoms back to periodic box\n");
112	>	result += buffer;
113
114	<	for(i = itList.begin(); i != itList.end(); ++i){
115	<	sprintf(buffer ,"%s\t", i->c_str());
114	>	sprintf(buffer,
115	>	"------------------------------------------------------------------\n");
116		result += buffer;
117
118	+	return result;
119		}
75	–	sprintf(buffer ,"\n");
76	–	result += buffer;
120
121	<	sprintf(buffer ,"------------------------------------------------------------------\n");
79	<	result += buffer;
121	>	//----------------------------------------------------------------------------//
122
123	<	return result;
124	<	}
123	>	ReplicateVisitor::ReplicateVisitor(SimInfo *info, Vector3i opt) :
124	>	BaseVisitor() {
125	>	this->info = info;
126	>	visitorName = "ReplicateVisitor";
127	>	this->replicateOpt = opt;
128
129	<	//----------------------------------------------------------------------------//
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	>	}
140	>	}
141	>	}
142	>
143	>	}
144
145	<	void WrappingVisitor::visit(Atom* atom){
146	<	internalVisit(atom);
147	<	}
89	<	void WrappingVisitor::visit(DirectionalAtom* datom){
90	<	internalVisit(datom);
91	<	}
145	>	void ReplicateVisitor::visit(Atom *atom) {
146	>	internalVisit(atom);
147	>	}
148
149	<	void WrappingVisitor::visit(RigidBody* rb){
150	<	internalVisit(rb);
151	<	}
149	>	void ReplicateVisitor::visit(DirectionalAtom *datom) {
150	>	internalVisit(datom);
151	>	}
152
153	<	void WrappingVisitor::internalVisit(StuntDouble* sd){
154	<	GenericData* data;
99	<	AtomData* atomData;
100	<	AtomInfo* atomInfo;
101	<	vector<AtomInfo*>::iterator i;
102	<
103	<	data = sd->getProperty("ATOMDATA");
104	<	if(data != NULL){
105	<	atomData = dynamic_cast<AtomData*>(data);
106	<	if(atomData == NULL)
107	<	return;
153	>	void ReplicateVisitor::visit(RigidBody *rb) {
154	>	internalVisit(rb);
155		}
109	–	else
110	–	return;
156
157	<	for(atomInfo = atomData->beginAtomInfo(i); atomInfo; atomInfo = atomData->nextAtomInfo(i))
158	<	info->wrapVector(atomInfo->pos);
157	>	void ReplicateVisitor::internalVisit(StuntDouble *sd) {
158	>	GenericData *          data;
159	>	AtomData *             atomData;
160
161	<
162	<	}
161	>	//if there is not atom data, just skip it
162	>	data = sd->getPropertyByName("ATOMDATA");
163
164	<	const string WrappingVisitor::toString(){
165	<	char buffer[65535];
120	<	string result;
121	<
122	<	sprintf(buffer ,"------------------------------------------------------------------\n");
123	<	result += buffer;
164	>	if (data != NULL) {
165	>	atomData = dynamic_cast<AtomData *>(data);
166
167	<	sprintf(buffer ,"Visitor name: %s\n", visitorName.c_str());
168	<	result += buffer;
169	<
170	<	sprintf(buffer ,"Visitor Description: wrapping atoms back to periodic box\n");
129	<	result += buffer;
130	<
131	<	sprintf(buffer,"------------------------------------------------------------------\n");
132	<	result += buffer;
133	<
134	<	return result;
135	<	}
136	<
137	<	//----------------------------------------------------------------------------//
138	<
139	<	ReplicateVisitor::ReplicateVisitor(SimInfo* info, IntVec3 opt) : BaseVisitor(){
140	<	this->info = info;
141	<	visitorName = "ReplicateVisitor";
142	<	this->replicateOpt = opt;
143	<	//generate the replicate directions
144	<	for(int i = 0; i <= replicateOpt[0]; i ++)
145	<	for(int j = 0; j <= replicateOpt[1]; j ++)
146	<	for(int k = 0; k <= replicateOpt[2]; k ++)
147	<	//skip original frame
148	<	if(i == 0 && j ==0 && k ==0)
149	<	continue;
150	<	else
151	<	dir.push_back(IntVec3(i, j, k));
152	<
153	<	}
154	<	void ReplicateVisitor::visit(Atom* atom){
155	<	internalVisit(atom);
156	<	}
157	<	void ReplicateVisitor::visit(DirectionalAtom* datom){
158	<	internalVisit(datom);
159	<	}
160	<
161	<	void ReplicateVisitor::visit(RigidBody* rb){
162	<	internalVisit(rb);
163	<	}
164	<
165	<	void ReplicateVisitor::internalVisit(StuntDouble* sd){
166	<	GenericData* data;
167	<	AtomData* atomData;
168	<	AtomInfo* atomInfo;
169	<	double box[3][3];
170	<	vector<AtomInfo*> atomInfoList;
171	<	IntVec3 dir;
172	<
173	<	//if there is not atom data, just skip it
174	<	data = sd->getProperty("ATOMDATA");
175	<	if(data != NULL){
176	<	atomData = dynamic_cast<AtomData*>(data);
177	<	if(atomData == NULL)
167	>	if (atomData == NULL) {
168	>	return;
169	>	}
170	>	} else {
171		return;
172	<	}
180	<	else
181	<	return;
172	>	}
173
174	<
175	<	info->getBoxM(box);
174	>	Snapshot* currSnapshot = info->getSnapshotManager()->getCurrentSnapshot();
175	>	Mat3x3d box = currSnapshot->getHmat();
176
177	<	atomInfoList = atomData->getData();
187	<
188	<	replicate(atomInfoList, atomData, box);
177	>	std::vector<AtomInfo *> atomInfoList = atomData->getData();
178
179	<	}
179	>	replicate(atomInfoList, atomData, box);
180	>	}
181
182	<	void ReplicateVisitor::replicate(vector<AtomInfo*>& infoList, AtomData* data, double boxM[3][3]){
183	<	AtomInfo * newAtomInfo;
184	<	vector<IntVec3>::iterator dirIter;
185	<	vector<AtomInfo*>::iterator i;
196	<
197	<	for(dirIter = dir.begin(); dirIter != dir.end(); ++dirIter){
198	<	for(i = infoList.begin(); i != infoList.end(); i++){
199	<	newAtomInfo = new AtomInfo;
200	<	*newAtomInfo = *(*i);
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(int j = 0; j < 3; j++)
188	<	newAtomInfo->pos[j] +=   (*dirIter)[0] * boxM[j][0] + (*dirIter)[1]* boxM[j][1] + (*dirIter)[2] * boxM[j][2];
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);
191
192	<	data->addAtomInfo(newAtomInfo);
193	<	}
207	<	}// end for(dirIter)
208	<	}
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	<	const string ReplicateVisitor::toString(){
196	<	char buffer[65535];
197	<	string result;
198	<	set<string>::iterator i;
214	<
215	<	sprintf(buffer ,"------------------------------------------------------------------\n");
216	<	result += buffer;
195	>	data->addAtomInfo(newAtomInfo);
196	>	}
197	>	} // end for(dirIter)
198	>	}
199
200	<	sprintf(buffer ,"Visitor name: %s\n", visitorName.c_str());
201	<	result += buffer;
200	>	const std::string ReplicateVisitor::toString() {
201	>	char                            buffer[65535];
202	>	std::string                     result;
203	>	std::set<std::string>::iterator i;
204
205	<	sprintf(buffer ,"Visitor Description: replicate the atoms in different direction\n");
206	<	result += buffer;
207	<
224	<	//print the replicate direction
225	<	sprintf(buffer , "repeatX = %d:\n", replicateOpt[0]);
226	<	result += buffer;
205	>	sprintf(buffer,
206	>	"------------------------------------------------------------------\n");
207	>	result += buffer;
208
209	<	sprintf(buffer , "repeatY = %d:\n", replicateOpt[1]);
210	<	result += buffer;
209	>	sprintf(buffer, "Visitor name: %s\n", visitorName.c_str());
210	>	result += buffer;
211
212	<	sprintf(buffer , "repeatZ = %d:\n", replicateOpt[2]);
213	<	result += buffer;
212	>	sprintf(buffer,
213	>	"Visitor Description: replicate the atoms in different direction\n");
214	>	result += buffer;
215
216	+	//print the replicate direction
217	+	sprintf(buffer, "repeatX = %d:\n", replicateOpt[0]);
218	+	result += buffer;
219
220	<	sprintf(buffer,"------------------------------------------------------------------\n");
221	<	result += buffer;
220	>	sprintf(buffer, "repeatY = %d:\n", replicateOpt[1]);
221	>	result += buffer;
222
223	<	return result;
224	<	}
223	>	sprintf(buffer, "repeatZ = %d:\n", replicateOpt[2]);
224	>	result += buffer;
225
226	<	//----------------------------------------------------------------------------//
226	>	sprintf(buffer,
227	>	"------------------------------------------------------------------\n");
228	>	result += buffer;
229
230	<	XYZVisitor::XYZVisitor(SimInfo* info,  bool printDipole) : BaseVisitor(){
231	<	this->info = info;
245	<	visitorName = "XYZVisitor";
246	<	this->printDipole = printDipole;
247	<	}
230	>	return result;
231	>	}
232
233	<	void XYZVisitor::visit(Atom* atom){
250	<	if(!isIgnore(atom))
251	<	internalVisit(atom);
252	<	}
233	>	//------------------------------------------------------------------------//
234
235	<	void XYZVisitor::visit(DirectionalAtom* datom){
236	<	if(!isIgnore(datom))
237	<	internalVisit(datom);
238	<	}
239	<
240	<	void XYZVisitor::visit(RigidBody* rb){
241	<	if(!isIgnore(rb))
242	<	internalVisit(rb);
243	<
244	<	}
245	<
246	<	void XYZVisitor::internalVisit(StuntDouble* sd){
247	<	GenericData* data;
248	<	AtomData* atomData;
268	<	AtomInfo* atomInfo;
269	<	vector<AtomInfo*>::iterator i;
270	<	char buffer[1024];
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	>	this->info = info;
241	>	visitorName = "XYZVisitor";
242	>
243	>	evaluator.loadScriptString("select all");
244	>
245	>	if (!evaluator.isDynamic()) {
246	>	seleMan.setSelectionSet(evaluator.evaluate());
247	>	}
248	>	}
249
250	<	//if there is not atom data, just skip it
251	<	data = sd->getProperty("ATOMDATA");
252	<	if(data != NULL){
253	<	atomData = dynamic_cast<AtomData*>(data);
254	<	if(atomData == NULL)
255	<	return;
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) {
254	>
255	>	this->info = info;
256	>	visitorName = "XYZVisitor";
257	>
258	>	evaluator.loadScriptString(script);
259	>
260	>	if (!evaluator.isDynamic()) {
261	>	seleMan.setSelectionSet(evaluator.evaluate());
262	>	}
263		}
264	<	else
265	<	return;
264	>
265	>	void XYZVisitor::visit(Atom *atom) {
266	>	if (isSelected(atom))
267	>	internalVisit(atom);
268	>	}
269
270	<	for(atomInfo = atomData->beginAtomInfo(i); atomInfo; atomInfo = atomData->nextAtomInfo(i)){
271	<
272	<	if(printDipole)
285	<	sprintf(buffer, "%s%15.8f%15.8f%15.8f%15.8f%15.8f%15.8f",
286	<	atomInfo->AtomType.c_str(),
287	<	atomInfo->pos[0],
288	<	atomInfo->pos[1],
289	<	atomInfo->pos[2],
290	<	atomInfo->dipole[0],
291	<	atomInfo->dipole[1],
292	<	atomInfo->dipole[2]);
293	<	else
294	<	sprintf(buffer, "%s%15.8f%15.8f%15.8f",
295	<	atomInfo->AtomType.c_str(),
296	<	atomInfo->pos[0],
297	<	atomInfo->pos[1],
298	<	atomInfo->pos[2]);
299	<
300	<	frame.push_back(buffer);
301	<
270	>	void XYZVisitor::visit(DirectionalAtom *datom) {
271	>	if (isSelected(datom))
272	>	internalVisit(datom);
273		}
303	–
304	–	}
305	–
306	–	bool XYZVisitor::isIgnore(StuntDouble* sd){
307	–	GenericData* data;
274
275	<	data = sd->getProperty("IGNORE");
276	<	return data ==NULL ? false : true;
277	<	}
278	<
313	<	void XYZVisitor::writeFrame(ostream& outStream){
314	<	vector<string>::iterator i;
315	<	double box[3][3];
316	<	char buffer[1024];
317	<
318	<	if(frame.size() == 0)
319	<	cerr << "Current Frame does not contain any atoms" << endl;
320	<
321	<	//total number of atoms
322	<	outStream << frame.size() << endl;
323	<
324	<	//write comment line
325	<	info->getBoxM(box);
326	<	sprintf(buffer,"%15.8f;%15.8f%15.8f%15.8f;%15.8f%15.8f%15.8f;%15.8f%15.8f%15.8f",
327	<	info->getTime(),
328	<	box[0][0], box[0][1], box[0][2],
329	<	box[1][0], box[1][1], box[1][2],
330	<	box[2][0], box[2][1], box[2][2]);
331	<
332	<	outStream << buffer << endl;
333	<
334	<	for(i = frame.begin(); i != frame.end(); ++i)
335	<	outStream << *i << endl;
336	<	}
337	<
338	<	const string XYZVisitor::toString(){
339	<	char buffer[65535];
340	<	string result;
275	>	void XYZVisitor::visit(RigidBody *rb) {
276	>	if (isSelected(rb))
277	>	internalVisit(rb);
278	>	}
279
280	<	sprintf(buffer ,"------------------------------------------------------------------\n");
281	<	result += buffer;
280	>	void XYZVisitor::update() {
281	>	//if dynamic, we need to re-evaluate the selection
282	>	if (evaluator.isDynamic()) {
283	>	seleMan.setSelectionSet(evaluator.evaluate());
284	>	}
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	>
294	>	//if there is not atom data, just skip it
295	>	data = sd->getPropertyByName("ATOMDATA");
296	>
297	>	if (data != NULL) {
298	>	atomData = dynamic_cast<AtomData *>(data);
299	>
300	>	if (atomData == NULL)
301	>	return;
302	>	} else
303	>	return;
304
305	<	sprintf(buffer ,"Visitor name: %s\n", visitorName.c_str());
306	<	result += buffer;
305	>	for( atomInfo = atomData->beginAtomInfo(i); atomInfo;
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	>	frame.push_back(line);
337	>	}
338	>	}
339
340	<	sprintf(buffer ,"Visitor Description: assemble the atom data and output xyz file\n");
341	<	result += buffer;
350	<
351	<	sprintf(buffer,"------------------------------------------------------------------\n");
352	<	result += buffer;
353	<
354	<	return result;
355	<	}
356	<
357	<	//----------------------------------------------------------------------------//
358	<
359	<	void PrepareVisitor::internalVisit(Atom * atom){
360	<	GenericData* data;
361	<	AtomData* atomData;
362	<
363	<	//if visited property is  existed, remove it
364	<	data = atom->getProperty("VISITED");
365	<	if(data != NULL){
366	<	atom->removeProperty("VISITED");
340	>	bool XYZVisitor::isSelected(StuntDouble *sd) {
341	>	return seleMan.isSelected(sd);
342		}
343
344	<	//remove atomdata
345	<	data = atom->getProperty("ATOMDATA");
346	<	if(data != NULL){
347	<	atomData = dynamic_cast<AtomData*>(data);
348	<	if(atomData != NULL)
349	<	atom->removeProperty("ATOMDATA");
344	>	void XYZVisitor::writeFrame(std::ostream &outStream) {
345	>	std::vector<std::string>::iterator i;
346	>	char buffer[1024];
347	>
348	>	if (frame.size() == 0)
349	>	std::cerr << "Current Frame does not contain any atoms" << std::endl;
350	>
351	>	//total number of atoms
352	>	outStream << frame.size() << std::endl;
353	>
354	>	//write comment line
355	>	Snapshot* currSnapshot = info->getSnapshotManager()->getCurrentSnapshot();
356	>	Mat3x3d box = currSnapshot->getHmat();
357	>
358	>	sprintf(buffer,
359	>	"%15.8f;%15.8f%15.8f%15.8f;%15.8f%15.8f%15.8f;%15.8f%15.8f%15.8f",
360	>	currSnapshot->getTime(),
361	>	box(0, 0), box(0, 1), box(0, 2),
362	>	box(1, 0), box(1, 1), box(1, 2),
363	>	box(2, 0), box(2, 1), box(2, 2));
364	>
365	>	outStream << buffer << std::endl;
366	>
367	>	for( i = frame.begin(); i != frame.end(); ++i )
368	>	outStream << *i << std::endl;
369		}
370
371	<	}
372	<
373	<	void PrepareVisitor::internalVisit(RigidBody * rb){
380	<	GenericData* data;
381	<	AtomData* atomData;
382	<	vector<Atom*> myAtoms;
383	<	vector<Atom*>::iterator atomIter;
371	>	std::string XYZVisitor::trimmedName(const std::string&atomTypeName) {
372	>	return atomTypeName.substr(0, atomTypeName.find('-'));
373	>	}
374
375	<	//if visited property is  existed, remove it
376	<	data = rb->getProperty("VISITED");
377	<	if(data != NULL){
378	<	rb->removeProperty("VISITED");
375	>	const std::string XYZVisitor::toString() {
376	>	char        buffer[65535];
377	>	std::string result;
378	>
379	>	sprintf(buffer,
380	>	"------------------------------------------------------------------\n");
381	>	result += buffer;
382	>
383	>	sprintf(buffer, "Visitor name: %s\n", visitorName.c_str());
384	>	result += buffer;
385	>
386	>	sprintf(buffer,
387	>	"Visitor Description: assemble the atom data and output xyz file\n");
388	>	result += buffer;
389	>
390	>	sprintf(buffer,
391	>	"------------------------------------------------------------------\n");
392	>	result += buffer;
393	>
394	>	return result;
395		}
396	+
397	+	//----------------------------------------------------------------------------//
398	+
399	+	void PrepareVisitor::internalVisit(Atom *atom) {
400	+	GenericData *data;
401	+	AtomData *   atomData;
402	+
403	+	//if visited property is  existed, remove it
404	+	data = atom->getPropertyByName("VISITED");
405	+
406	+	if (data != NULL) {
407	+	atom->removeProperty("VISITED");
408	+	}
409	+
410	+	//remove atomdata
411	+	data = atom->getPropertyByName("ATOMDATA");
412
413	<	//remove atomdata
414	<	data = rb->getProperty("ATOMDATA");
415	<	if(data != NULL){
416	<	atomData = dynamic_cast<AtomData*>(data);
417	<	if(atomData != NULL)
418	<	rb->removeProperty("ATOMDATA");
413	>	if (data != NULL) {
414	>	atomData = dynamic_cast<AtomData *>(data);
415	>
416	>	if (atomData != NULL)
417	>	atom->removeProperty("ATOMDATA");
418	>	}
419		}
420
421	<	myAtoms = rb->getAtoms();
422	<
423	<	for(atomIter = myAtoms.begin(); atomIter != myAtoms.end(); ++atomIter)
424	<	internalVisit (*atomIter);
425	<	}
421	>	void PrepareVisitor::internalVisit(RigidBody *rb) {
422	>	GenericData* data;
423	>	AtomData* atomData;
424	>	std::vector<Atom *> myAtoms;
425	>	std::vector<Atom *>::iterator atomIter;
426
427	<	const string PrepareVisitor::toString(){
428	<	char buffer[65535];
407	<	string result;
408	<
409	<	sprintf(buffer ,"------------------------------------------------------------------\n");
410	<	result += buffer;
427	>	//if visited property is  existed, remove it
428	>	data = rb->getPropertyByName("VISITED");
429
430	<	sprintf(buffer ,"Visitor name: %s", visitorName.c_str());
431	<	result += buffer;
430	>	if (data != NULL) {
431	>	rb->removeProperty("VISITED");
432	>	}
433
434	<	sprintf(buffer ,"Visitor Description: prepare for operation of other vistors\n");
435	<	result += buffer;
434	>	//remove atomdata
435	>	data = rb->getPropertyByName("ATOMDATA");
436
437	<	sprintf(buffer ,"------------------------------------------------------------------\n");
438	<	result += buffer;
437	>	if (data != NULL) {
438	>	atomData = dynamic_cast<AtomData *>(data);
439
440	<	return result;
441	<	}
440	>	if (atomData != NULL)
441	>	rb->removeProperty("ATOMDATA");
442	>	}
443
444	<	//----------------------------------------------------------------------------//
444	>	myAtoms = rb->getAtoms();
445
446	<	WaterTypeVisitor:: WaterTypeVisitor(){
447	<	visitorName = "WaterTypeVisitor";
448	<	waterTypeList.insert("TIP3P_RB_0");
429	<	waterTypeList.insert("TIP4P_RB_0");
430	<	waterTypeList.insert("TIP5P_RB_0");
431	<	waterTypeList.insert("SPCE_RB_0");
432	<	}
446	>	for( atomIter = myAtoms.begin(); atomIter != myAtoms.end(); ++atomIter )
447	>	internalVisit(*atomIter);
448	>	}
449
450	+	const std::string PrepareVisitor::toString() {
451	+	char buffer[65535];
452	+	std::string result;
453	+
454	+	sprintf(buffer,
455	+	"------------------------------------------------------------------\n");
456	+	result += buffer;
457	+
458	+	sprintf(buffer, "Visitor name: %s", visitorName.c_str());
459	+	result += buffer;
460	+
461	+	sprintf(buffer,
462	+	"Visitor Description: prepare for operation of other vistors\n");
463	+	result += buffer;
464	+
465	+	sprintf(buffer,
466	+	"------------------------------------------------------------------\n");
467	+	result += buffer;
468	+
469	+	return result;
470	+	}
471
472	<	void WaterTypeVisitor:: visit(RigidBody* rb){
436	<	string rbName;
437	<	vector<Atom*> myAtoms;
438	<	vector<Atom*>::iterator atomIter;
439	<	GenericData* data;
440	<	AtomData* atomData;
441	<	AtomInfo* atomInfo;
442	<	vector<AtomInfo*>::iterator i;
443	<
444	<	rbName = rb->getType();
472	>	//----------------------------------------------------------------------------//
473
474	<	if(waterTypeList.find(rbName) != waterTypeList.end()){
474	>	WaterTypeVisitor::WaterTypeVisitor() {
475	>	visitorName = "WaterTypeVisitor";
476	>	waterTypeList.insert("TIP3P_RB_0");
477	>	waterTypeList.insert("TIP4P_RB_0");
478	>	waterTypeList.insert("TIP4P-Ew_RB_0");
479	>	waterTypeList.insert("TIP5P_RB_0");
480	>	waterTypeList.insert("TIP5P-E_RB_0");
481	>	waterTypeList.insert("SPCE_RB_0");
482	>	waterTypeList.insert("SPC_RB_0");
483	>	}
484
485	<	myAtoms = rb->getAtoms();
486	<	for(atomIter = myAtoms.begin(); atomIter != myAtoms.end(); ++atomIter){
485	>	void WaterTypeVisitor::visit(RigidBody *rb) {
486	>	std::string rbName;
487	>	std::vector<Atom *> myAtoms;
488	>	std::vector<Atom *>::iterator atomIter;
489	>	GenericData* data;
490	>	AtomData* atomData;
491	>	AtomInfo* atomInfo;
492	>	std::vector<AtomInfo *>::iterator i;
493
494	<	data = (*atomIter)->getProperty("ATOMDATA");
495	<	if(data != NULL){
496	<	atomData = dynamic_cast<AtomData*>(data);
497	<	if(atomData == NULL)
455	<	continue;
456	<	}
457	<	else
458	<	continue;
459	<
460	<	for(atomInfo = atomData->beginAtomInfo(i); atomInfo; atomInfo = atomData->nextAtomInfo(i)){
461	<	replaceType(atomInfo->AtomType);
462	<	}//end for(atomInfo)
494	>	rbName = rb->getType();
495	>
496	>	if (waterTypeList.find(rbName) != waterTypeList.end()) {
497	>	myAtoms = rb->getAtoms();
498
499	<	}//end for(atomIter)
500	<
501	<	}//end if (waterTypeList.find(rbName) != waterTypeList.end())
502	<
503	<	}
499	>	for( atomIter = myAtoms.begin(); atomIter != myAtoms.end();
500	>	++atomIter ) {
501	>	data = (*atomIter)->getPropertyByName("ATOMDATA");
502	>
503	>	if (data != NULL) {
504	>	atomData = dynamic_cast<AtomData *>(data);
505	>
506	>	if (atomData == NULL)
507	>	continue;
508	>	} else
509	>	continue;
510	>
511	>	for( atomInfo = atomData->beginAtomInfo(i); atomInfo;
512	>	atomInfo = atomData->nextAtomInfo(i) ) {
513	>	atomInfo->atomTypeName = trimmedName(atomInfo->atomTypeName);
514	>	} //end for(atomInfo)
515	>	}     //end for(atomIter)
516	>	}         //end if (waterTypeList.find(rbName) != waterTypeList.end())
517	>	}
518
519	<	void WaterTypeVisitor:: replaceType(string& atomType){
520	<	atomType = atomType.substr(0, atomType.find('_'));
521	<	}
519	>	std::string WaterTypeVisitor::trimmedName(const std::string&atomTypeName) {
520	>	return atomTypeName.substr(0, atomTypeName.find('_'));
521	>	}
522
523	<	const string WaterTypeVisitor:: toString(){
524	<	char buffer[65535];
525	<	string result;
477	<
478	<	sprintf(buffer ,"------------------------------------------------------------------\n");
479	<	result += buffer;
523	>	const std::string WaterTypeVisitor::toString() {
524	>	char buffer[65535];
525	>	std::string result;
526
527	<	sprintf(buffer ,"Visitor name: %s\n", visitorName.c_str());
528	<	result += buffer;
527	>	sprintf(buffer,
528	>	"------------------------------------------------------------------\n");
529	>	result += buffer;
530
531	<	sprintf(buffer ,"Visitor Description: Replace the atom type in water model\n");
532	<	result += buffer;
531	>	sprintf(buffer, "Visitor name: %s\n", visitorName.c_str());
532	>	result += buffer;
533
534	<	sprintf(buffer ,"------------------------------------------------------------------\n");
535	<	result += buffer;
534	>	sprintf(buffer,
535	>	"Visitor Description: Replace the atom type in water model\n");
536	>	result += buffer;
537
538	<	return result;
539	<	}
538	>	sprintf(buffer,
539	>	"------------------------------------------------------------------\n");
540	>	result += buffer;
541
542	+	return result;
543	+	}
544	+
545	+	} //namespace OpenMD

Comparing:
trunk/src/visitors/OtherVisitor.cpp (property svn:keywords), Revision 2 by gezelter, Fri Sep 24 04:16:43 2004 UTC vs.
branches/development/src/visitors/OtherVisitor.cpp (property svn:keywords), Revision 1764 by gezelter, Tue Jul 3 18:32:27 2012 UTC

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

Diff Legend

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