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 1442 by gezelter, Mon May 10 17:28:26 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;
228	>	XYZVisitor::XYZVisitor(SimInfo *info) :
229	>	BaseVisitor(), seleMan(info), evaluator(info){
230	>	this->info = info;
231	>	visitorName = "XYZVisitor";
232
233	+	evaluator.loadScriptString("select all");
234
235	<	sprintf(buffer,"------------------------------------------------------------------\n");
236	<	result += buffer;
235	>	if (!evaluator.isDynamic()) {
236	>	seleMan.setSelectionSet(evaluator.evaluate());
237	>	}
238	>	posOnly_ = false;
239	>	}
240
241	<	return result;
242	<	}
241	>	XYZVisitor::XYZVisitor(SimInfo *info, const std::string& script) :
242	>	BaseVisitor(), seleMan(info), evaluator(info) {
243	>	this->info = info;
244	>	visitorName = "XYZVisitor";
245
246	<	//----------------------------------------------------------------------------//
246	>	evaluator.loadScriptString(script);
247
248	<	XYZVisitor::XYZVisitor(SimInfo* info,  bool printDipole) : BaseVisitor(){
249	<	this->info = info;
250	<	visitorName = "XYZVisitor";
251	<	this->printDipole = printDipole;
252	<	}
248	>	if (!evaluator.isDynamic()) {
249	>	seleMan.setSelectionSet(evaluator.evaluate());
250	>	}
251	>	posOnly_ = false;
252	>	}
253	>
254	>	void XYZVisitor::visit(Atom *atom) {
255	>	if (isSelected(atom))
256	>	internalVisit(atom);
257	>	}
258
259	<	void XYZVisitor::visit(Atom* atom){
260	<	if(!isIgnore(atom))
261	<	internalVisit(atom);
262	<	}
259	>	void XYZVisitor::visit(DirectionalAtom *datom) {
260	>	if (isSelected(datom))
261	>	internalVisit(datom);
262	>	}
263
264	<	void XYZVisitor::visit(DirectionalAtom* datom){
265	<	if(!isIgnore(datom))
266	<	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];
271	<
272	<	//if there is not atom data, just skip it
273	<	data = sd->getProperty("ATOMDATA");
274	<	if(data != NULL){
275	<	atomData = dynamic_cast<AtomData*>(data);
276	<	if(atomData == NULL)
277	<	return;
264	>	void XYZVisitor::visit(RigidBody *rb) {
265	>	if (isSelected(rb))
266	>	internalVisit(rb);
267		}
279	–	else
280	–	return;
268
269	<	for(atomInfo = atomData->beginAtomInfo(i); atomInfo; atomInfo = atomData->nextAtomInfo(i)){
270	<
271	<	if(printDipole)
272	<	sprintf(buffer, "%s%15.8f%15.8f%15.8f%15.8f%15.8f%15.8f",
273	<	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	<
269	>	void XYZVisitor::update() {
270	>	//if dynamic, we need to re-evaluate the selection
271	>	if (evaluator.isDynamic()) {
272	>	seleMan.setSelectionSet(evaluator.evaluate());
273	>	}
274		}
275
276	<	}
276	>	void XYZVisitor::internalVisit(StuntDouble *sd) {
277	>	GenericData *                     data;
278	>	AtomData *                        atomData;
279	>	AtomInfo *                        atomInfo;
280	>	std::vector<AtomInfo *>::iterator i;
281	>	char                              buffer[1024];
282
283	<	bool XYZVisitor::isIgnore(StuntDouble* sd){
284	<	GenericData* data;
308	<
309	<	data = sd->getProperty("IGNORE");
310	<	return data ==NULL ? false : true;
311	<	}
283	>	//if there is not atom data, just skip it
284	>	data = sd->getPropertyByName("ATOMDATA");
285
286	<	void XYZVisitor::writeFrame(ostream& outStream){
287	<	vector<string>::iterator i;
315	<	double box[3][3];
316	<	char buffer[1024];
286	>	if (data != NULL) {
287	>	atomData = dynamic_cast<AtomData *>(data);
288
289	<	if(frame.size() == 0)
290	<	cerr << "Current Frame does not contain any atoms" << endl;
289	>	if (atomData == NULL)
290	>	return;
291	>	} else
292	>	return;
293
294	<	//total number of atoms
295	<	outStream << frame.size() << endl;
294	>	AtomType* at = dynamic_cast<Atom *>(sd)->getAtomType();
295	>	std::string bn = baseTypeName(at);
296
297	<	//write comment line
298	<	info->getBoxM(box);
299	<	sprintf(buffer,"%15.8f;%15.8f%15.8f%15.8f;%15.8f%15.8f%15.8f;%15.8f%15.8f%15.8f",
300	<	info->getTime(),
301	<	box[0][0], box[0][1], box[0][2],
302	<	box[1][0], box[1][1], box[1][2],
303	<	box[2][0], box[2][1], box[2][2]);
297	>	if (posOnly_){
298	>	for( atomInfo = atomData->beginAtomInfo(i); atomInfo;
299	>	atomInfo = atomData->nextAtomInfo(i) ) {
300	>	if (atomInfo->hasCharge) {
301	>	sprintf(buffer,
302	>	"%s%15.8f%15.8f%15.8f%15.8f",
303	>	bn.c_str(),
304	>	atomInfo->pos[0],
305	>	atomInfo->pos[1],
306	>	atomInfo->pos[2],
307	>	atomInfo->charge);
308	>	} else {
309	>	sprintf(buffer,
310	>	"%s%15.8f%15.8f%15.8f",
311	>	bn.c_str(),
312	>	atomInfo->pos[0],
313	>	atomInfo->pos[1],
314	>	atomInfo->pos[2]);
315	>	}
316	>	frame.push_back(buffer);
317	>	}
318	>	}else{
319	>	for( atomInfo = atomData->beginAtomInfo(i); atomInfo;
320	>	atomInfo = atomData->nextAtomInfo(i) ) {
321	>	if (atomInfo->hasCharge) {
322	>	sprintf(buffer,
323	>	"%s%15.8f%15.8f%15.8f%15.8f%15.8f%15.8f%15.8f",
324	>	bn.c_str(),
325	>	atomInfo->pos[0],
326	>	atomInfo->pos[1],
327	>	atomInfo->pos[2],
328	>	atomInfo->charge,
329	>	atomInfo->dipole[0],
330	>	atomInfo->dipole[1],
331	>	atomInfo->dipole[2]);
332	>	} else {
333	>	sprintf(buffer,
334	>	"%s%15.8f%15.8f%15.8f%15.8f%15.8f%15.8f",
335	>	bn.c_str(),
336	>	atomInfo->pos[0],
337	>	atomInfo->pos[1],
338	>	atomInfo->pos[2],
339	>	atomInfo->dipole[0],
340	>	atomInfo->dipole[1],
341	>	atomInfo->dipole[2]);
342	>	}
343	>	frame.push_back(buffer);
344	>	}
345	>	}
346	>	}
347
348	<	outStream << buffer << endl;
348	>	bool XYZVisitor::isSelected(StuntDouble *sd) {
349	>	return seleMan.isSelected(sd);
350	>	}
351
352	<	for(i = frame.begin(); i != frame.end(); ++i)
353	<	outStream << *i << endl;
354	<	}
352	>	void XYZVisitor::writeFrame(std::ostream &outStream) {
353	>	std::vector<std::string>::iterator i;
354	>	char buffer[1024];
355
356	<	const string XYZVisitor::toString(){
357	<	char buffer[65535];
340	<	string result;
341	<
342	<	sprintf(buffer ,"------------------------------------------------------------------\n");
343	<	result += buffer;
356	>	if (frame.size() == 0)
357	>	std::cerr << "Current Frame does not contain any atoms" << std::endl;
358
359	<	sprintf(buffer ,"Visitor name: %s\n", visitorName.c_str());
360	<	result += buffer;
359	>	//total number of atoms
360	>	outStream << frame.size() << std::endl;
361
362	<	sprintf(buffer ,"Visitor Description: assemble the atom data and output xyz file\n");
363	<	result += buffer;
364	<
365	<	sprintf(buffer,"------------------------------------------------------------------\n");
366	<	result += buffer;
362	>	//write comment line
363	>	Snapshot* currSnapshot = info->getSnapshotManager()->getCurrentSnapshot();
364	>	Mat3x3d box = currSnapshot->getHmat();
365	>
366	>	sprintf(buffer,
367	>	"%15.8f;%15.8f%15.8f%15.8f;%15.8f%15.8f%15.8f;%15.8f%15.8f%15.8f",
368	>	currSnapshot->getTime(),
369	>	box(0, 0), box(0, 1), box(0, 2),
370	>	box(1, 0), box(1, 1), box(1, 2),
371	>	box(2, 0), box(2, 1), box(2, 2));
372
373	<	return result;
355	<	}
373	>	outStream << buffer << std::endl;
374
375	<	//----------------------------------------------------------------------------//
375	>	for( i = frame.begin(); i != frame.end(); ++i )
376	>	outStream << *i << std::endl;
377	>	}
378
379	<	void PrepareVisitor::internalVisit(Atom * atom){
380	<	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");
379	>	std::string XYZVisitor::trimmedName(const std::string&atomTypeName) {
380	>	return atomTypeName.substr(0, atomTypeName.find('-'));
381		}
382
383	<	//remove atomdata
384	<	data = atom->getProperty("ATOMDATA");
385	<	if(data != NULL){
372	<	atomData = dynamic_cast<AtomData*>(data);
373	<	if(atomData != NULL)
374	<	atom->removeProperty("ATOMDATA");
383	>	std::string XYZVisitor::baseTypeName(AtomType* at) {
384	>	std::vector<AtomType*> ayb = at->allYourBase();
385	>	return ayb[ayb.size()-1]->getName();
386		}
376	–
377	–	}
387
388	<	void PrepareVisitor::internalVisit(RigidBody * rb){
389	<	GenericData* data;
390	<	AtomData* atomData;
391	<	vector<Atom*> myAtoms;
392	<	vector<Atom*>::iterator atomIter;
393	<
394	<	//if visited property is  existed, remove it
395	<	data = rb->getProperty("VISITED");
396	<	if(data != NULL){
397	<	rb->removeProperty("VISITED");
388	>	const std::string XYZVisitor::toString() {
389	>	char        buffer[65535];
390	>	std::string result;
391	>
392	>	sprintf(buffer,
393	>	"------------------------------------------------------------------\n");
394	>	result += buffer;
395	>
396	>	sprintf(buffer, "Visitor name: %s\n", visitorName.c_str());
397	>	result += buffer;
398	>
399	>	sprintf(buffer,
400	>	"Visitor Description: assemble the atom data and output xyz file\n");
401	>	result += buffer;
402	>
403	>	sprintf(buffer,
404	>	"------------------------------------------------------------------\n");
405	>	result += buffer;
406	>
407	>	return result;
408		}
409
410	<	//remove atomdata
411	<	data = rb->getProperty("ATOMDATA");
412	<	if(data != NULL){
413	<	atomData = dynamic_cast<AtomData*>(data);
414	<	if(atomData != NULL)
415	<	rb->removeProperty("ATOMDATA");
410	>	//----------------------------------------------------------------------------//
411	>
412	>	void PrepareVisitor::internalVisit(Atom *atom) {
413	>	GenericData *data;
414	>	AtomData *   atomData;
415	>
416	>	//if visited property is  existed, remove it
417	>	data = atom->getPropertyByName("VISITED");
418	>
419	>	if (data != NULL) {
420	>	atom->removeProperty("VISITED");
421	>	}
422	>
423	>	//remove atomdata
424	>	data = atom->getPropertyByName("ATOMDATA");
425	>
426	>	if (data != NULL) {
427	>	atomData = dynamic_cast<AtomData *>(data);
428	>
429	>	if (atomData != NULL)
430	>	atom->removeProperty("ATOMDATA");
431	>	}
432		}
433
434	<	myAtoms = rb->getAtoms();
435	<
436	<	for(atomIter = myAtoms.begin(); atomIter != myAtoms.end(); ++atomIter)
437	<	internalVisit (*atomIter);
438	<	}
434	>	void PrepareVisitor::internalVisit(RigidBody *rb) {
435	>	GenericData* data;
436	>	AtomData* atomData;
437	>	std::vector<Atom *> myAtoms;
438	>	std::vector<Atom *>::iterator atomIter;
439
440	<	const string PrepareVisitor::toString(){
441	<	char buffer[65535];
407	<	string result;
408	<
409	<	sprintf(buffer ,"------------------------------------------------------------------\n");
410	<	result += buffer;
440	>	//if visited property is  existed, remove it
441	>	data = rb->getPropertyByName("VISITED");
442
443	<	sprintf(buffer ,"Visitor name: %s", visitorName.c_str());
444	<	result += buffer;
443	>	if (data != NULL) {
444	>	rb->removeProperty("VISITED");
445	>	}
446
447	<	sprintf(buffer ,"Visitor Description: prepare for operation of other vistors\n");
448	<	result += buffer;
447	>	//remove atomdata
448	>	data = rb->getPropertyByName("ATOMDATA");
449
450	<	sprintf(buffer ,"------------------------------------------------------------------\n");
451	<	result += buffer;
450	>	if (data != NULL) {
451	>	atomData = dynamic_cast<AtomData *>(data);
452
453	<	return result;
454	<	}
453	>	if (atomData != NULL)
454	>	rb->removeProperty("ATOMDATA");
455	>	}
456
457	<	//----------------------------------------------------------------------------//
457	>	myAtoms = rb->getAtoms();
458
459	<	WaterTypeVisitor:: WaterTypeVisitor(){
460	<	visitorName = "WaterTypeVisitor";
461	<	waterTypeList.insert("TIP3P_RB_0");
429	<	waterTypeList.insert("TIP4P_RB_0");
430	<	waterTypeList.insert("TIP5P_RB_0");
431	<	waterTypeList.insert("SPCE_RB_0");
432	<	}
459	>	for( atomIter = myAtoms.begin(); atomIter != myAtoms.end(); ++atomIter )
460	>	internalVisit(*atomIter);
461	>	}
462
463	+	const std::string PrepareVisitor::toString() {
464	+	char buffer[65535];
465	+	std::string result;
466	+
467	+	sprintf(buffer,
468	+	"------------------------------------------------------------------\n");
469	+	result += buffer;
470	+
471	+	sprintf(buffer, "Visitor name: %s", visitorName.c_str());
472	+	result += buffer;
473	+
474	+	sprintf(buffer,
475	+	"Visitor Description: prepare for operation of other vistors\n");
476	+	result += buffer;
477	+
478	+	sprintf(buffer,
479	+	"------------------------------------------------------------------\n");
480	+	result += buffer;
481	+
482	+	return result;
483	+	}
484
485	<	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();
485	>	//----------------------------------------------------------------------------//
486
487	<	if(waterTypeList.find(rbName) != waterTypeList.end()){
487	>	WaterTypeVisitor::WaterTypeVisitor() {
488	>	visitorName = "WaterTypeVisitor";
489	>	waterTypeList.insert("TIP3P_RB_0");
490	>	waterTypeList.insert("TIP4P_RB_0");
491	>	waterTypeList.insert("TIP5P_RB_0");
492	>	waterTypeList.insert("SPCE_RB_0");
493	>	}
494
495	<	myAtoms = rb->getAtoms();
496	<	for(atomIter = myAtoms.begin(); atomIter != myAtoms.end(); ++atomIter){
495	>	void WaterTypeVisitor::visit(RigidBody *rb) {
496	>	std::string rbName;
497	>	std::vector<Atom *> myAtoms;
498	>	std::vector<Atom *>::iterator atomIter;
499	>	GenericData* data;
500	>	AtomData* atomData;
501	>	AtomInfo* atomInfo;
502	>	std::vector<AtomInfo *>::iterator i;
503
504	<	data = (*atomIter)->getProperty("ATOMDATA");
452	<	if(data != NULL){
453	<	atomData = dynamic_cast<AtomData*>(data);
454	<	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)
504	>	rbName = rb->getType();
505
506	<	}//end for(atomIter)
507	<
466	<	}//end if (waterTypeList.find(rbName) != waterTypeList.end())
467	<
468	<	}
506	>	if (waterTypeList.find(rbName) != waterTypeList.end()) {
507	>	myAtoms = rb->getAtoms();
508
509	<	void WaterTypeVisitor:: replaceType(string& atomType){
510	<	atomType = atomType.substr(0, atomType.find('_'));
511	<	}
509	>	for( atomIter = myAtoms.begin(); atomIter != myAtoms.end();
510	>	++atomIter ) {
511	>	data = (*atomIter)->getPropertyByName("ATOMDATA");
512
513	<	const string WaterTypeVisitor:: toString(){
514	<	char buffer[65535];
476	<	string result;
477	<
478	<	sprintf(buffer ,"------------------------------------------------------------------\n");
479	<	result += buffer;
513	>	if (data != NULL) {
514	>	atomData = dynamic_cast<AtomData *>(data);
515
516	<	sprintf(buffer ,"Visitor name: %s\n", visitorName.c_str());
517	<	result += buffer;
516	>	if (atomData == NULL)
517	>	continue;
518	>	} else
519	>	continue;
520
521	<	sprintf(buffer ,"Visitor Description: Replace the atom type in water model\n");
522	<	result += buffer;
521	>	for( atomInfo = atomData->beginAtomInfo(i); atomInfo;
522	>	atomInfo = atomData->nextAtomInfo(i) ) {
523	>	atomInfo->atomTypeName = trimmedName(atomInfo->atomTypeName);
524	>	} //end for(atomInfo)
525	>	}     //end for(atomIter)
526	>	}         //end if (waterTypeList.find(rbName) != waterTypeList.end())
527	>	}
528
529	<	sprintf(buffer ,"------------------------------------------------------------------\n");
530	<	result += buffer;
529	>	std::string WaterTypeVisitor::trimmedName(const std::string&atomTypeName) {
530	>	return atomTypeName.substr(0, atomTypeName.find('_'));
531	>	}
532
533	<	return result;
534	<	}
533	>	const std::string WaterTypeVisitor::toString() {
534	>	char buffer[65535];
535	>	std::string result;
536
537	+	sprintf(buffer,
538	+	"------------------------------------------------------------------\n");
539	+	result += buffer;
540	+
541	+	sprintf(buffer, "Visitor name: %s\n", visitorName.c_str());
542	+	result += buffer;
543	+
544	+	sprintf(buffer,
545	+	"Visitor Description: Replace the atom type in water model\n");
546	+	result += buffer;
547	+
548	+	sprintf(buffer,
549	+	"------------------------------------------------------------------\n");
550	+	result += buffer;
551	+
552	+	return result;
553	+	}
554	+
555	+	} //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 1442 by gezelter, Mon May 10 17:28:26 2010 UTC

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

Diff Legend

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