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 1871 by gezelter, Fri May 10 14:59:13 2013 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, 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"
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;
167	>	if (atomData == NULL) {
168	>	return;
169	>	}
170	>	} else {
171	>	return;
172	>	}
173
174	<	sprintf(buffer ,"Visitor Description: wrapping atoms back to periodic box\n");
175	<	result += buffer;
130	<
131	<	sprintf(buffer,"------------------------------------------------------------------\n");
132	<	result += buffer;
174	>	Snapshot* currSnapshot = info->getSnapshotManager()->getCurrentSnapshot();
175	>	Mat3x3d box = currSnapshot->getHmat();
176
177	<	return result;
135	<	}
177	>	std::vector<AtomInfo *> atomInfoList = atomData->getData();
178
179	<	//----------------------------------------------------------------------------//
179	>	replicate(atomInfoList, atomData, box);
180	>	}
181
182	<	ReplicateVisitor::ReplicateVisitor(SimInfo* info, IntVec3 opt) : BaseVisitor(){
183	<	this->info = info;
184	<	visitorName = "ReplicateVisitor";
185	<	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	<	}
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	<	void ReplicateVisitor::visit(RigidBody* rb){
188	<	internalVisit(rb);
189	<	}
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	<	void ReplicateVisitor::internalVisit(StuntDouble* sd){
193	<	GenericData* data;
194	<	AtomData* atomData;
195	<	AtomInfo* atomInfo;
196	<	double box[3][3];
197	<	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)
178	<	return;
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	>	}
197	>	} // end for(dirIter)
198		}
180	–	else
181	–	return;
199
200	<
201	<	info->getBoxM(box);
200	>	const std::string ReplicateVisitor::toString() {
201	>	char                            buffer[65535];
202	>	std::string                     result;
203	>	std::set<std::string>::iterator i;
204
205	<	atomInfoList = atomData->getData();
206	<
207	<	replicate(atomInfoList, atomData, box);
205	>	sprintf(buffer,
206	>	"------------------------------------------------------------------\n");
207	>	result += buffer;
208
209	<	}
209	>	sprintf(buffer, "Visitor name: %s\n", visitorName.c_str());
210	>	result += buffer;
211
212	<	void ReplicateVisitor::replicate(vector<AtomInfo*>& infoList, AtomData* data, double boxM[3][3]){
213	<	AtomInfo * newAtomInfo;
214	<	vector<IntVec3>::iterator dirIter;
195	<	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);
212	>	sprintf(buffer,
213	>	"Visitor Description: replicate the atoms in different direction\n");
214	>	result += buffer;
215
216	<	for(int j = 0; j < 3; j++)
217	<	newAtomInfo->pos[j] +=   (*dirIter)[0] * boxM[j][0] + (*dirIter)[1]* boxM[j][1] + (*dirIter)[2] * boxM[j][2];
216	>	//print the replicate direction
217	>	sprintf(buffer, "repeatX = %d:\n", replicateOpt[0]);
218	>	result += buffer;
219
220	<	data->addAtomInfo(newAtomInfo);
221	<	}
207	<	}// end for(dirIter)
208	<	}
220	>	sprintf(buffer, "repeatY = %d:\n", replicateOpt[1]);
221	>	result += buffer;
222
223	<	const string ReplicateVisitor::toString(){
224	<	char buffer[65535];
212	<	string result;
213	<	set<string>::iterator i;
214	<
215	<	sprintf(buffer ,"------------------------------------------------------------------\n");
216	<	result += buffer;
223	>	sprintf(buffer, "repeatZ = %d:\n", replicateOpt[2]);
224	>	result += buffer;
225
226	<	sprintf(buffer ,"Visitor name: %s\n", visitorName.c_str());
227	<	result += buffer;
226	>	sprintf(buffer,
227	>	"------------------------------------------------------------------\n");
228	>	result += buffer;
229
230	<	sprintf(buffer ,"Visitor Description: replicate the atoms in different direction\n");
231	<	result += buffer;
223	<
224	<	//print the replicate direction
225	<	sprintf(buffer , "repeatX = %d:\n", replicateOpt[0]);
226	<	result += buffer;
230	>	return result;
231	>	}
232
233	<	sprintf(buffer , "repeatY = %d:\n", replicateOpt[1]);
229	<	result += buffer;
233	>	//------------------------------------------------------------------------//
234
235	<	sprintf(buffer , "repeatZ = %d:\n", replicateOpt[2]);
236	<	result += buffer;
237	<
238	<
239	<	sprintf(buffer,"------------------------------------------------------------------\n");
240	<	result += buffer;
241	<
242	<	return result;
243	<	}
244	<
245	<	//----------------------------------------------------------------------------//
246	<
247	<	XYZVisitor::XYZVisitor(SimInfo* info,  bool printDipole) : BaseVisitor(){
248	<	this->info = info;
245	<	visitorName = "XYZVisitor";
246	<	this->printDipole = printDipole;
247	<	}
248	<
249	<	void XYZVisitor::visit(Atom* atom){
250	<	if(!isIgnore(atom))
251	<	internalVisit(atom);
252	<	}
253	<
254	<	void XYZVisitor::visit(DirectionalAtom* datom){
255	<	if(!isIgnore(datom))
256	<	internalVisit(datom);
257	<	}
258	<
259	<	void XYZVisitor::visit(RigidBody* rb){
260	<	if(!isIgnore(rb))
261	<	internalVisit(rb);
262	<
263	<	}
264	<
265	<	void XYZVisitor::internalVisit(StuntDouble* sd){
266	<	GenericData* data;
267	<	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	>	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	<	sprintf(buffer ,"Visitor Description: assemble the atom data and output xyz file\n");
346	<	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");
345	>	bool XYZVisitor::isSelected(StuntDouble *sd) {
346	>	return seleMan.isSelected(sd);
347		}
348
349	<	//remove atomdata
350	<	data = atom->getProperty("ATOMDATA");
351	<	if(data != NULL){
352	<	atomData = dynamic_cast<AtomData*>(data);
353	<	if(atomData != NULL)
354	<	atom->removeProperty("ATOMDATA");
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	>
356	>	//total number of atoms
357	>	outStream << frame.size() << std::endl;
358	>
359	>	//write comment line
360	>	Snapshot* currSnapshot = info->getSnapshotManager()->getCurrentSnapshot();
361	>	Mat3x3d box = currSnapshot->getHmat();
362	>
363	>	sprintf(buffer,
364	>	"%15.8f;%15.8f%15.8f%15.8f;%15.8f%15.8f%15.8f;%15.8f%15.8f%15.8f",
365	>	currSnapshot->getTime(),
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	>
370	>	outStream << buffer << std::endl;
371	>
372	>	for( i = frame.begin(); i != frame.end(); ++i )
373	>	outStream << *i << std::endl;
374		}
375
376	<	}
377	<
378	<	void PrepareVisitor::internalVisit(RigidBody * rb){
380	<	GenericData* data;
381	<	AtomData* atomData;
382	<	vector<Atom*> myAtoms;
383	<	vector<Atom*>::iterator atomIter;
376	>	std::string XYZVisitor::trimmedName(const std::string&atomTypeName) {
377	>	return atomTypeName.substr(0, atomTypeName.find('-'));
378	>	}
379
380	<	//if visited property is  existed, remove it
381	<	data = rb->getProperty("VISITED");
382	<	if(data != NULL){
383	<	rb->removeProperty("VISITED");
380	>	const std::string XYZVisitor::toString() {
381	>	char        buffer[65535];
382	>	std::string result;
383	>
384	>	sprintf(buffer,
385	>	"------------------------------------------------------------------\n");
386	>	result += buffer;
387	>
388	>	sprintf(buffer, "Visitor name: %s\n", visitorName.c_str());
389	>	result += buffer;
390	>
391	>	sprintf(buffer,
392	>	"Visitor Description: assemble the atom data and output xyz file\n");
393	>	result += buffer;
394	>
395	>	sprintf(buffer,
396	>	"------------------------------------------------------------------\n");
397	>	result += buffer;
398	>
399	>	return result;
400		}
401	+
402	+	//----------------------------------------------------------------------------//
403	+
404	+	void PrepareVisitor::internalVisit(Atom *atom) {
405	+	GenericData *data;
406	+	AtomData *   atomData;
407	+
408	+	//if visited property is  existed, remove it
409	+	data = atom->getPropertyByName("VISITED");
410	+
411	+	if (data != NULL) {
412	+	atom->removeProperty("VISITED");
413	+	}
414	+
415	+	//remove atomdata
416	+	data = atom->getPropertyByName("ATOMDATA");
417
418	<	//remove atomdata
419	<	data = rb->getProperty("ATOMDATA");
420	<	if(data != NULL){
421	<	atomData = dynamic_cast<AtomData*>(data);
422	<	if(atomData != NULL)
423	<	rb->removeProperty("ATOMDATA");
418	>	if (data != NULL) {
419	>	atomData = dynamic_cast<AtomData *>(data);
420	>
421	>	if (atomData != NULL)
422	>	atom->removeProperty("ATOMDATA");
423	>	}
424		}
425
426	<	myAtoms = rb->getAtoms();
427	<
428	<	for(atomIter = myAtoms.begin(); atomIter != myAtoms.end(); ++atomIter)
429	<	internalVisit (*atomIter);
430	<	}
426	>	void PrepareVisitor::internalVisit(RigidBody *rb) {
427	>	GenericData* data;
428	>	AtomData* atomData;
429	>	std::vector<Atom *> myAtoms;
430	>	std::vector<Atom *>::iterator atomIter;
431
432	<	const string PrepareVisitor::toString(){
433	<	char buffer[65535];
407	<	string result;
408	<
409	<	sprintf(buffer ,"------------------------------------------------------------------\n");
410	<	result += buffer;
432	>	//if visited property is  existed, remove it
433	>	data = rb->getPropertyByName("VISITED");
434
435	<	sprintf(buffer ,"Visitor name: %s", visitorName.c_str());
436	<	result += buffer;
435	>	if (data != NULL) {
436	>	rb->removeProperty("VISITED");
437	>	}
438
439	<	sprintf(buffer ,"Visitor Description: prepare for operation of other vistors\n");
440	<	result += buffer;
439	>	//remove atomdata
440	>	data = rb->getPropertyByName("ATOMDATA");
441
442	<	sprintf(buffer ,"------------------------------------------------------------------\n");
443	<	result += buffer;
442	>	if (data != NULL) {
443	>	atomData = dynamic_cast<AtomData *>(data);
444
445	<	return result;
446	<	}
445	>	if (atomData != NULL)
446	>	rb->removeProperty("ATOMDATA");
447	>	}
448
449	<	//----------------------------------------------------------------------------//
449	>	myAtoms = rb->getAtoms();
450
451	<	WaterTypeVisitor:: WaterTypeVisitor(){
452	<	visitorName = "WaterTypeVisitor";
453	<	waterTypeList.insert("TIP3P_RB_0");
429	<	waterTypeList.insert("TIP4P_RB_0");
430	<	waterTypeList.insert("TIP5P_RB_0");
431	<	waterTypeList.insert("SPCE_RB_0");
432	<	}
451	>	for( atomIter = myAtoms.begin(); atomIter != myAtoms.end(); ++atomIter )
452	>	internalVisit(*atomIter);
453	>	}
454
455	+	const std::string PrepareVisitor::toString() {
456	+	char buffer[65535];
457	+	std::string result;
458	+
459	+	sprintf(buffer,
460	+	"------------------------------------------------------------------\n");
461	+	result += buffer;
462	+
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;
469	+
470	+	sprintf(buffer,
471	+	"------------------------------------------------------------------\n");
472	+	result += buffer;
473	+
474	+	return result;
475	+	}
476
477	<	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();
477	>	//----------------------------------------------------------------------------//
478
479	<	if(waterTypeList.find(rbName) != waterTypeList.end()){
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	>	waterTypeList.insert("SPC_RB_0");
488	>	}
489
490	<	myAtoms = rb->getAtoms();
491	<	for(atomIter = myAtoms.begin(); atomIter != myAtoms.end(); ++atomIter){
490	>	void WaterTypeVisitor::visit(RigidBody *rb) {
491	>	std::string rbName;
492	>	std::vector<Atom *> myAtoms;
493	>	std::vector<Atom *>::iterator atomIter;
494	>	GenericData* data;
495	>	AtomData* atomData;
496	>	AtomInfo* atomInfo;
497	>	std::vector<AtomInfo *>::iterator i;
498
499	<	data = (*atomIter)->getProperty("ATOMDATA");
500	<	if(data != NULL){
501	<	atomData = dynamic_cast<AtomData*>(data);
502	<	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)
499	>	rbName = rb->getType();
500	>
501	>	if (waterTypeList.find(rbName) != waterTypeList.end()) {
502	>	myAtoms = rb->getAtoms();
503
504	<	}//end for(atomIter)
505	<
506	<	}//end if (waterTypeList.find(rbName) != waterTypeList.end())
507	<
508	<	}
504	>	for( atomIter = myAtoms.begin(); atomIter != myAtoms.end();
505	>	++atomIter ) {
506	>	data = (*atomIter)->getPropertyByName("ATOMDATA");
507	>
508	>	if (data != NULL) {
509	>	atomData = dynamic_cast<AtomData *>(data);
510	>
511	>	if (atomData == NULL)
512	>	continue;
513	>	} else
514	>	continue;
515	>
516	>	for( atomInfo = atomData->beginAtomInfo(i); atomInfo;
517	>	atomInfo = atomData->nextAtomInfo(i) ) {
518	>	atomInfo->atomTypeName = trimmedName(atomInfo->atomTypeName);
519	>	} //end for(atomInfo)
520	>	}     //end for(atomIter)
521	>	}         //end if (waterTypeList.find(rbName) != waterTypeList.end())
522	>	}
523
524	<	void WaterTypeVisitor:: replaceType(string& atomType){
525	<	atomType = atomType.substr(0, atomType.find('_'));
526	<	}
524	>	std::string WaterTypeVisitor::trimmedName(const std::string&atomTypeName) {
525	>	return atomTypeName.substr(0, atomTypeName.find('_'));
526	>	}
527
528	<	const string WaterTypeVisitor:: toString(){
529	<	char buffer[65535];
530	<	string result;
477	<
478	<	sprintf(buffer ,"------------------------------------------------------------------\n");
479	<	result += buffer;
528	>	const std::string WaterTypeVisitor::toString() {
529	>	char buffer[65535];
530	>	std::string result;
531
532	<	sprintf(buffer ,"Visitor name: %s\n", visitorName.c_str());
533	<	result += buffer;
532	>	sprintf(buffer,
533	>	"------------------------------------------------------------------\n");
534	>	result += buffer;
535
536	<	sprintf(buffer ,"Visitor Description: Replace the atom type in water model\n");
537	<	result += buffer;
536	>	sprintf(buffer, "Visitor name: %s\n", visitorName.c_str());
537	>	result += buffer;
538
539	<	sprintf(buffer ,"------------------------------------------------------------------\n");
540	<	result += buffer;
539	>	sprintf(buffer,
540	>	"Visitor Description: Replace the atom type in water model\n");
541	>	result += buffer;
542
543	<	return result;
544	<	}
543	>	sprintf(buffer,
544	>	"------------------------------------------------------------------\n");
545	>	result += buffer;
546
547	+	return result;
548	+	}
549	+
550	+	} //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 1871 by gezelter, Fri May 10 14:59:13 2013 UTC

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

Diff Legend

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