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

Comparing trunk/src/visitors/OtherVisitor.cpp (property svn:keywords):
Revision 2 by gezelter, Fri Sep 24 04:16:43 2004 UTC vs.
Revision 1456 by gezelter, Fri Jun 25 17:40:24 2010 UTC

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

Diff Legend

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