ViewVC Help

View File | Revision Log | Show Annotations | View Changeset | Root Listing

root/OpenMD/trunk/src/applications/dump2Xyz/Dump2XYZ.cpp

Comparing trunk/src/applications/dump2Xyz/Dump2XYZ.cpp (file contents):
Revision 291 by tim, Fri Feb 4 22:43:54 2005 UTC vs.
Revision 1474 by gezelter, Wed Jul 21 14:29:14 2010 UTC

#	Line 1 | Line 1
1	<	/*
1	>	/*
2		* Copyright (c) 2005 The University of Notre Dame. All Rights Reserved.
3		*
4		* The University of Notre Dame grants you ("Licensee") a
#	Line 6 | Line 6
6		* redistribute this software in source and binary code form, provided
7		* that the following conditions are met:
8		*
9	<	* 1. Acknowledgement of the program authors must be made in any
10	<	*    publication of scientific results based in part on use of the
11	<	*    program.  An acceptable form of acknowledgement is citation of
12	<	*    the article in which the program was described (Matthew
13	<	*    A. Meineke, Charles F. Vardeman II, Teng Lin, Christopher
14	<	*    J. Fennell and J. Daniel Gezelter, "OOPSE: An Object-Oriented
15	<	*    Parallel Simulation Engine for Molecular Dynamics,"
16	<	*    J. Comput. Chem. 26, pp. 252-271 (2005))
17	<	*
18	<	* 2. Redistributions of source code must retain the above copyright
9	>	* 1. Redistributions of source code must retain the above copyright
10		*    notice, this list of conditions and the following disclaimer.
11		*
12	<	* 3. Redistributions in binary form must reproduce the above copyright
12	>	* 2. Redistributions in binary form must reproduce the above copyright
13		*    notice, this list of conditions and the following disclaimer in the
14		*    documentation and/or other materials provided with the
15		*    distribution.
#	Line 37 | Line 28
28		* arising out of the use of or inability to use software, even if the
29		* University of Notre Dame has been advised of the possibility of
30		* such damages.
31	+	*
32	+	* SUPPORT OPEN SCIENCE!  If you use OpenMD or its source code in your
33	+	* research, please cite the appropriate papers when you publish your
34	+	* work.  Good starting points are:
35	+	*
36	+	* [1]  Meineke, et al., J. Comp. Chem. 26, 252-271 (2005).
37	+	* [2]  Fennell & Gezelter, J. Chem. Phys. 124, 234104 (2006).
38	+	* [3]  Sun, Lin & Gezelter, J. Chem. Phys. 128, 24107 (2008).
39	+	* [4]  Vardeman & Gezelter, in progress (2009).
40		*/
41
42		#include <iostream>
#	Line 47 | Line 47
47		#include "brains/Register.hpp"
48		#include "brains/SimCreator.hpp"
49		#include "brains/SimInfo.hpp"
50	+	#include "brains/ForceManager.hpp"
51		#include "io/DumpReader.hpp"
52		#include "utils/simError.h"
53		#include "visitors/AtomVisitor.hpp"
54	+	#include "visitors/ReplacementVisitor.hpp"
55		#include "visitors/CompositeVisitor.hpp"
56		#include "visitors/RigidBodyVisitor.hpp"
57		#include "visitors/OtherVisitor.hpp"
58		#include "visitors/ZconsVisitor.hpp"
57	–	#include "visitors/SelectionVisitor.hpp"
59		#include "selection/SelectionEvaluator.hpp"
60	<	using namespace oopse;
60	>	#include "selection/SelectionManager.hpp"
61	>	#include "visitors/LipidTransVisitor.hpp"
62	>	#include "visitors/AtomNameVisitor.hpp"
63
64	+	using namespace OpenMD;
65	+
66		int main(int argc, char* argv[]){
67
68		//register force fields
#	Line 65 | Line 70 | int main(int argc, char* argv[]){
70
71		gengetopt_args_info args_info;
72		std::string dumpFileName;
68	–	std::string mdFileName;
73		std::string xyzFileName;
74	+	bool printVel;
75	+	bool printFrc;
76	+	bool printVec;
77	+	bool printChrg;
78
79		//parse the command line option
80		if (cmdline_parser (argc, argv, &args_info) != 0) {
#	Line 81 | Line 89 | int main(int argc, char* argv[]){
89		exit(1);
90		}
91
84	–	mdFileName = dumpFileName;
85	–	mdFileName = mdFileName.substr(0, mdFileName.rfind(".")) + ".md";
86	–
92		if (args_info.output_given){
93		xyzFileName = args_info.output_arg;
94		} else {
#	Line 93 | Line 98 | int main(int argc, char* argv[]){
98
99		//parse md file and set up the system
100		SimCreator creator;
101	<	SimInfo* info = creator.createSim(mdFileName, false);
101	>	SimInfo* info = creator.createSim(dumpFileName, false);
102	>	ForceManager* forceMan = new ForceManager(info);
103
104	<
99	<
100	<	//creat visitor list
104	>	//create visitor list
105		CompositeVisitor* compositeVisitor = new CompositeVisitor();
106
107	<	//creat ignore visitor
104	<	if(args_info.ignore_given ||args_info.water_flag){
105	<
106	<	IgnoreVisitor* ignoreVisitor = new IgnoreVisitor(info);
107	<
108	<	for(int i = 0; i < args_info.ignore_given; i++)
109	<	ignoreVisitor->addIgnoreType(args_info.ignore_arg[i]);
110	<
111	<	//ignore water
112	<	if(args_info.water_flag){
113	<	ignoreVisitor->addIgnoreType("SSD");
114	<	ignoreVisitor->addIgnoreType("SSD1");
115	<	ignoreVisitor->addIgnoreType("SSD_E");
116	<	ignoreVisitor->addIgnoreType("SSD_RF");
117	<	ignoreVisitor->addIgnoreType("TIP3P_RB_0");
118	<	ignoreVisitor->addIgnoreType("TIP4P_RB_0");
119	<	ignoreVisitor->addIgnoreType("TIP5P_RB_0");
120	<	ignoreVisitor->addIgnoreType("SPCE_RB_0");
121	<	ignoreVisitor->addIgnoreType("DPD_RB_0");
122	<	}
123	<
124	<	compositeVisitor->addVisitor(ignoreVisitor, 1000);
125	<	}
126	<
127	<	//creat RigidBody Visitor
107	>	//create RigidBody Visitor
108		if(args_info.rigidbody_flag){
109		RBCOMVisitor* rbCOMVisitor = new RBCOMVisitor(info);
110		compositeVisitor->addVisitor(rbCOMVisitor, 900);
111		}
112
113	<	//create selection visitor
134	<	//if (args_info.selection_given){
135	<	//  SelectionVisitor* selectionVisitor = new SelectionVisitor(info, args_info.selection_arg);
136	<	//  compositeVisitor->addVisitor(selectionVisitor, 850);
137	<	//}
138	<
139	<	SelectionEvaluator* evaluator = NULL;
140	<	if (args_info.selection_given) {
141	<	evaluator = new SelectionEvaluator(info);
142	<	assert(evaluator);
143	<	evaluator->loadScriptString( args_info.selection_arg);
144	<
145	<	}
146	<
147	<	//creat SSD atom visitor
113	>	//create SSD atom visitor
114		SSDAtomVisitor* ssdVisitor = new SSDAtomVisitor(info);
115		compositeVisitor->addVisitor(ssdVisitor, 800);
116	+
117	+	//create GBtail atom visitor
118	+	GBtailVisitor* gbtVisitor = new GBtailVisitor(info);
119	+	compositeVisitor->addVisitor(gbtVisitor, 790);
120	+
121	+	//create GBhead atom visitor
122	+	GBheadVisitor* gbhVisitor = new GBheadVisitor(info);
123	+	compositeVisitor->addVisitor(gbhVisitor, 789);
124
125	<	LinearAtomVisitor* linearVisitor = new LinearAtomVisitor(info);
152	<	compositeVisitor->addVisitor(linearVisitor, 750);
153	<
154	<	//creat default atom visitor
125	>	//create default atom visitor
126		DefaultAtomVisitor* defaultAtomVisitor = new DefaultAtomVisitor(info);
127		compositeVisitor->addVisitor(defaultAtomVisitor, 700);
128
129	<	//creat waterType visitor
130	<	if(args_info.watertype_flag){
131	<	WaterTypeVisitor* waterTypeVisitor = new WaterTypeVisitor;
132	<	compositeVisitor->addVisitor(waterTypeVisitor, 600);
129	>	// if we gave the -w option, we want to skip the waters:
130	>	if (!args_info.water_given) {
131	>	//create waterType visitor
132	>	if(args_info.watertype_flag){
133	>	WaterTypeVisitor* waterTypeVisitor = new WaterTypeVisitor;
134	>	compositeVisitor->addVisitor(waterTypeVisitor, 600);
135	>	}
136	>	}
137	>
138	>	if (args_info.basetype_flag) {
139	>	AtomNameVisitor* atomNameVisitor = new AtomNameVisitor(info);
140	>	compositeVisitor->addVisitor(atomNameVisitor, 550);
141	>	std::cout << compositeVisitor->toString();
142		}
143
144		//create ZconsVisitor
#	Line 173 | Line 153 | int main(int argc, char* argv[]){
153		}
154		}
155
156	<	//creat wrapping visitor
156	>	//create wrapping visitor
157
158	<	if(args_info.periodicBox_flag){
159	<	WrappingVisitor* wrappingVisitor = new WrappingVisitor(info);
160	<	compositeVisitor->addVisitor(wrappingVisitor, 400);
158	>	//if(args_info.periodicBox_flag){
159	>	//  WrappingVisitor* wrappingVisitor = new WrappingVisitor(info);
160	>	//  compositeVisitor->addVisitor(wrappingVisitor, 400);
161	>	//}
162	>
163	>	//create replicate visitor
164	>	if(args_info.repeatX_given > 0 ||
165	>	args_info.repeatY_given > 0 ||
166	>	args_info.repeatY_given > 0) {
167	>	Vector3i replicateOpt(args_info.repeatX_arg,
168	>	args_info.repeatY_arg,
169	>	args_info.repeatZ_arg);
170	>	ReplicateVisitor* replicateVisitor = new ReplicateVisitor(info,
171	>	replicateOpt);
172	>	compositeVisitor->addVisitor(replicateVisitor, 300);
173		}
174	+
175	+
176	+	//create rotation visitor
177	+	if (args_info.refsele_given&& args_info.originsele_given) {
178	+	compositeVisitor->addVisitor(new LipidTransVisitor(info,
179	+	args_info.originsele_arg,
180	+	args_info.refsele_arg),
181	+	250);
182	+	} else if (args_info.refsele_given || args_info.originsele_given) {
183	+	std::cerr << "Both of --refsele and --originsele should appear by pair"
184	+	<< std::endl;
185	+	exit(1);
186	+	}
187
188	<	//creat replicate visitor
189	<	if(args_info.repeatX_given > 0 || args_info.repeatY_given > 0 ||args_info.repeatY_given > 0){
190	<	Vector3i replicateOpt(args_info.repeatX_arg, args_info.repeatY_arg, args_info.repeatZ_arg);
191	<	ReplicateVisitor* replicateVisitor = new ReplicateVisitor(info, replicateOpt);
192	<	compositeVisitor->addVisitor(replicateVisitor, 300);
188	>	//create xyzVisitor
189	>	XYZVisitor* xyzVisitor;
190	>
191	>	if (args_info.selection_given) {
192	>	xyzVisitor = new XYZVisitor(info, args_info.selection_arg);
193	>	} else {
194	>	xyzVisitor = new XYZVisitor(info);
195		}
196	+
197	+	if(args_info.velocities_flag){
198	+	printVel = true;
199	+	xyzVisitor->doVelocities(printVel);
200	+	}
201	+	if(args_info.forces_flag){
202	+	printFrc = true;
203	+	xyzVisitor->doForces(printFrc);
204	+	}
205	+	if(args_info.vectors_flag){
206	+	printVec = true;
207	+	xyzVisitor->doVectors(printVec);
208	+	}
209	+	if(args_info.charges_flag){
210	+	printChrg = true;
211	+	xyzVisitor->doCharges(printChrg);
212	+	}
213
214	<	//creat xyzVisitor
191	<	XYZVisitor* xyzVisitor = new XYZVisitor(info);
192	<	compositeVisitor->addVisitor(xyzVisitor, 200);
214	>	compositeVisitor->addVisitor(xyzVisitor, 200);
215
216	<	std::cout << compositeVisitor->toString();
195	<
196	<	//creat prepareVisitor
216	>	//create prepareVisitor
217		PrepareVisitor* prepareVisitor = new PrepareVisitor();
218
219		//open dump file
220		DumpReader* dumpReader = new DumpReader(info, dumpFileName);
221		int nframes = dumpReader->getNFrames();
222
223	+	std::ofstream xyzStream(xyzFileName.c_str());
224
204	–	std::ofstream xyzStream;
205	–	xyzStream .open(xyzFileName.c_str());
206	–
207	–
225		SimInfo::MoleculeIterator miter;
226		Molecule::IntegrableObjectIterator  iiter;
227		Molecule::RigidBodyIterator rbIter;
228		Molecule* mol;
229		StuntDouble* integrableObject;
230		RigidBody* rb;
231	<
232	<	if (evaluator && !evaluator->isDynamic()) {
233	<	info->getSelectionManager()->setSelectionSet(evaluator->evaluate());
234	<	}
235	<
231	>	Vector3d molCom;
232	>	Vector3d newMolCom;
233	>	Vector3d displacement;
234	>	Mat3x3d hmat;
235	>	Snapshot* currentSnapshot;
236	>
237		for (int i = 0; i < nframes; i += args_info.frame_arg){
238		dumpReader->readFrame(i);
239
240	+	if (printFrc) forceMan->calcForces();
241	+
242	+	//wrapping the molecule
243	+	if(args_info.periodicBox_flag) {
244	+	currentSnapshot = info->getSnapshotManager()->getCurrentSnapshot();
245	+	for (mol = info->beginMolecule(miter); mol != NULL;
246	+	mol = info->nextMolecule(miter)) {
247	+	molCom = mol->getCom();
248	+	newMolCom = molCom;
249	+	currentSnapshot->wrapVector(newMolCom);
250	+	displacement = newMolCom - molCom;
251	+	for (integrableObject = mol->beginIntegrableObject(iiter);
252	+	integrableObject != NULL;
253	+	integrableObject = mol->nextIntegrableObject(iiter)) {
254	+	integrableObject->setPos(integrableObject->getPos() + displacement);
255	+	}
256	+	}
257	+	}
258		//update atoms of rigidbody
259	<	for (mol = info->beginMolecule(miter); mol != NULL; mol = info->nextMolecule(miter)) {
259	>	for (mol = info->beginMolecule(miter); mol != NULL;
260	>	mol = info->nextMolecule(miter)) {
261
262		//change the positions of atoms which belong to the rigidbodies
263	<	for (rb = mol->beginRigidBody(rbIter); rb != NULL; rb = mol->nextRigidBody(rbIter)) {
263	>	for (rb = mol->beginRigidBody(rbIter); rb != NULL;
264	>	rb = mol->nextRigidBody(rbIter)) {
265		rb->updateAtoms();
266	+	if (printVel) rb->updateAtomVel();
267		}
268		}
269
270		//prepare visit
271	<	for (mol = info->beginMolecule(miter); mol != NULL; mol = info->nextMolecule(miter)) {
272	<	for (integrableObject = mol->beginIntegrableObject(iiter); integrableObject != NULL;
271	>	for (mol = info->beginMolecule(miter); mol != NULL;
272	>	mol = info->nextMolecule(miter)) {
273	>	for (integrableObject = mol->beginIntegrableObject(iiter);
274	>	integrableObject != NULL;
275		integrableObject = mol->nextIntegrableObject(iiter)) {
276		integrableObject->accept(prepareVisitor);
277		}
#	Line 239 | Line 280 | int main(int argc, char* argv[]){
280		//update visitor
281		compositeVisitor->update();
282
283	<	//if dynamic, we need to re-evaluate the selection
243	<	if (evaluator && evaluator->isDynamic()) {
244	<	info->getSelectionManager()->setSelectionSet(evaluator->evaluate());
245	<	}
246	<
283	>
284		//visit stuntdouble
285	<	for (mol = info->beginMolecule(miter); mol != NULL; mol = info->nextMolecule(miter)) {
286	<	for (integrableObject = mol->beginIntegrableObject(iiter); integrableObject != NULL;
285	>	for (mol = info->beginMolecule(miter); mol != NULL;
286	>	mol = info->nextMolecule(miter)) {
287	>	for (integrableObject = mol->beginIntegrableObject(iiter);
288	>	integrableObject != NULL;
289		integrableObject = mol->nextIntegrableObject(iiter)) {
290		integrableObject->accept(compositeVisitor);
291		}
#	Line 256 | Line 295 | int main(int argc, char* argv[]){
295		xyzVisitor->clear();
296
297		}//end for (int i = 0; i < nframes; i += args_info.frame_arg)
298	<
298	>
299		xyzStream.close();
300	<
262	<
300	>	delete prepareVisitor;
301		delete compositeVisitor;
302		delete info;
265	–
303		}

Comparing trunk/src/applications/dump2Xyz/Dump2XYZ.cpp (property svn:keywords):
Revision 291 by tim, Fri Feb 4 22:43:54 2005 UTC vs.
Revision 1474 by gezelter, Wed Jul 21 14:29:14 2010 UTC

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

Diff Legend

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