ViewVC Help

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

root/OpenMD/branches/development/src/applications/dump2Xyz/Dump2XYZ.cpp

Comparing:
trunk/src/applications/dump2Xyz/Dump2XYZ.cpp (file contents), Revision 211 by chrisfen, Fri Nov 5 21:45:14 2004 UTC vs.
branches/development/src/applications/dump2Xyz/Dump2XYZ.cpp (file contents), Revision 1706 by gezelter, Fri Apr 27 20:44:16 2012 UTC

#	Line 1 | Line 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
5	+	* non-exclusive, royalty free, license to use, modify and
6	+	* redistribute this software in source and binary code form, provided
7	+	* that the following conditions are met:
8	+	*
9	+	* 1. Redistributions of source code must retain the above copyright
10	+	*    notice, this list of conditions and the following disclaimer.
11	+	*
12	+	* 2. Redistributions in binary form must reproduce the above copyright
13	+	*    notice, this list of conditions and the following disclaimer in the
14	+	*    documentation and/or other materials provided with the
15	+	*    distribution.
16	+	*
17	+	* This software is provided "AS IS," without a warranty of any
18	+	* kind. All express or implied conditions, representations and
19	+	* warranties, including any implied warranty of merchantability,
20	+	* fitness for a particular purpose or non-infringement, are hereby
21	+	* excluded.  The University of Notre Dame and its licensors shall not
22	+	* be liable for any damages suffered by licensee as a result of
23	+	* using, modifying or distributing the software or its
24	+	* derivatives. In no event will the University of Notre Dame or its
25	+	* licensors be liable for any lost revenue, profit or data, or for
26	+	* direct, indirect, special, consequential, incidental or punitive
27	+	* damages, however caused and regardless of the theory of liability,
28	+	* arising out of the use of or inability to use software, even if the
29	+	* University of Notre Dame has been advised of the possibility of
30	+	* such damages.
31	+	*
32	+	* SUPPORT OPEN SCIENCE!  If you use OpenMD or its source code in your
33	+	* research, please cite the appropriate papers when you publish your
34	+	* work.  Good starting points are:
35	+	*
36	+	* [1]  Meineke, et al., J. Comp. Chem. 26, 252-271 (2005).
37	+	* [2]  Fennell & Gezelter, J. Chem. Phys. 124, 234104 (2006).
38	+	* [3]  Sun, Lin & Gezelter, J. Chem. Phys. 128, 24107 (2008).
39	+	* [4]  Kuang & Gezelter,  J. Chem. Phys. 133, 164101 (2010).
40	+	* [5]  Vardeman, Stocker & Gezelter, J. Chem. Theory Comput. 7, 834 (2011).
41	+	*/
42	+
43		#include <iostream>
44		#include <fstream>
45		#include <string>
46
5	–	#include "brains/SimSetup.hpp"
47		#include "applications/dump2Xyz/Dump2XYZCmd.h"
48	+	#include "brains/Register.hpp"
49	+	#include "brains/SimCreator.hpp"
50	+	#include "brains/SimInfo.hpp"
51	+	#include "brains/ForceManager.hpp"
52	+	#include "io/DumpReader.hpp"
53	+	#include "utils/simError.h"
54		#include "visitors/AtomVisitor.hpp"
55	+	#include "visitors/ReplacementVisitor.hpp"
56		#include "visitors/CompositeVisitor.hpp"
57		#include "visitors/RigidBodyVisitor.hpp"
58		#include "visitors/OtherVisitor.hpp"
59		#include "visitors/ZconsVisitor.hpp"
60	+	#include "selection/SelectionEvaluator.hpp"
61	+	#include "selection/SelectionManager.hpp"
62	+	#include "visitors/LipidTransVisitor.hpp"
63	+	#include "visitors/AtomNameVisitor.hpp"
64
65	<	using namespace std;
65	>	using namespace OpenMD;
66
67	+	using namespace std;
68		int main(int argc, char* argv[]){
69	+
70	+	//register force fields
71	+	registerForceFields();
72	+
73		gengetopt_args_info args_info;
74		string dumpFileName;
18	–	string mdFileName;
19	–	char inFileName[2002];
75		string xyzFileName;
76	<	SimInfo* info;
77	<	SimSetup startMe;
78	<	DumpReader* dumpReader;
79	<	ofstream xyzStream;
80	<	int nframes;
26	<	Molecule* mol;
27	<	vector<StuntDouble*> integrableObjects;
28	<	vector<StuntDouble*>::iterator iter;
29	<	vector<RigidBody*> myRigidBodies;
30	<	vector<RigidBody*>::iterator rbIter;
76	>
77	>	bool printVel(false);
78	>	bool printFrc(false);
79	>	bool printVec(false);
80	>	bool printChrg(false);
81
32	–	CompositeVisitor* compositeVisitor;
33	–	SSDAtomVisitor* ssdVisitor;
34	–	LinearAtomVisitor* linearVisitor;
35	–	DefaultAtomVisitor* defaultAtomVisitor;
36	–	LipidHeadVisitor* lipidVisitor;
37	–	RBCOMVisitor* rbCOMVisitor;
38	–	ReplicateVisitor* replicateVisitor;
39	–	WrappingVisitor* wrappingVisitor;
40	–	IgnoreVisitor* ignoreVisitor;
41	–	XYZVisitor* xyzVisitor;
42	–	ZConsVisitor* zconsVisitor;
43	–	PrepareVisitor* prepareVisitor;
44	–	WaterTypeVisitor* waterTypeVisitor;
45	–
82		//parse the command line option
83	<	if (cmdline_parser (argc, argv, &args_info) != 0)
84	<	exit(1) ;
85	<
86	<
83	>	if (cmdline_parser (argc, argv, &args_info) != 0) {
84	>	exit(1) ;
85	>	}
86	>
87		//get the dumpfile name and meta-data file name
88		if (args_info.input_given){
89		dumpFileName = args_info.input_arg;
90	<	}
55	<	else{
90	>	} else {
91		cerr << "Does not have input file name" << endl;
92		exit(1);
93		}
94	<	mdFileName = dumpFileName;
60	<	mdFileName = mdFileName.substr(0, mdFileName.rfind(".")) + ".md";
61	<
94	>
95		if (args_info.output_given){
96		xyzFileName = args_info.output_arg;
97	<	}
65	<	else{
97	>	} else {
98		xyzFileName = dumpFileName;
99		xyzFileName = xyzFileName.substr(0, xyzFileName.rfind(".")) + ".xyz";
100		}
101	<
101	>
102		//parse md file and set up the system
103	<	info = new SimInfo();
104	<	startMe.setSimInfo(info );
105	<
74	<	strcpy(inFileName, mdFileName.c_str() );
75	<	startMe.parseFile( inFileName );
76	<
77	<	startMe.createSim();
78	<
103	>	SimCreator creator;
104	>	SimInfo* info = creator.createSim(dumpFileName, false);
105	>	ForceManager* forceMan = new ForceManager(info);
106
107	<	//creat visitor list
108	<	compositeVisitor = new CompositeVisitor();
109	<
110	<	//creat ignore visitor
84	<	if(args_info.ignore_given ||args_info.water_flag){
85	<
86	<	ignoreVisitor = new IgnoreVisitor();
87	<
88	<	for(int i = 0; i < args_info.ignore_given; i++)
89	<	ignoreVisitor->addIgnoreType(args_info.ignore_arg[i]);
90	<
91	<	//ignore water
92	<	if(args_info.water_flag){
93	<	ignoreVisitor->addIgnoreType("SSD");
94	<	ignoreVisitor->addIgnoreType("SSD1");
95	<	ignoreVisitor->addIgnoreType("SSD_E");
96	<	ignoreVisitor->addIgnoreType("SSD_RF");
97	<	ignoreVisitor->addIgnoreType("TIP3P_RB_0");
98	<	ignoreVisitor->addIgnoreType("TIP4P_RB_0");
99	<	ignoreVisitor->addIgnoreType("TIP5P_RB_0");
100	<	ignoreVisitor->addIgnoreType("SPCE_RB_0");
101	<	ignoreVisitor->addIgnoreType("DPD_RB_0");
102	<	}
103	<
104	<	compositeVisitor->addVisitor(ignoreVisitor, 1000);
105	<	}
106	<
107	<	//creat RigidBody Visitor
107	>	//create visitor list
108	>	CompositeVisitor* compositeVisitor = new CompositeVisitor();
109	>
110	>	//create RigidBody Visitor
111		if(args_info.rigidbody_flag){
112	<	rbCOMVisitor = new RBCOMVisitor(info);
112	>	RBCOMVisitor* rbCOMVisitor = new RBCOMVisitor(info);
113		compositeVisitor->addVisitor(rbCOMVisitor, 900);
114		}
115	<
116	<	//compositeVisitor->addVisitor(lipidVisitor, 900);
117	<
115	<	//creat SSD atom visitor
116	<	ssdVisitor = new SSDAtomVisitor(info);
115	>
116	>	//create SSD atom visitor
117	>	SSDAtomVisitor* ssdVisitor = new SSDAtomVisitor(info);
118		compositeVisitor->addVisitor(ssdVisitor, 800);
119	<	linearVisitor = new LinearAtomVisitor(info);
120	<	compositeVisitor->addVisitor(linearVisitor, 750);
121	<
122	<	//creat default atom visitor
123	<	defaultAtomVisitor = new DefaultAtomVisitor(info);
119	>
120	>	//create GBtail atom visitor
121	>	GBtailVisitor* gbtVisitor = new GBtailVisitor(info);
122	>	compositeVisitor->addVisitor(gbtVisitor, 790);
123	>
124	>	//create GBhead atom visitor
125	>	GBheadVisitor* gbhVisitor = new GBheadVisitor(info);
126	>	compositeVisitor->addVisitor(gbhVisitor, 789);
127	>
128	>	//create default atom visitor
129	>	DefaultAtomVisitor* defaultAtomVisitor = new DefaultAtomVisitor(info);
130		compositeVisitor->addVisitor(defaultAtomVisitor, 700);
131	<
132	<	//creat waterType visitor
133	<	if(args_info.watertype_flag){
134	<	waterTypeVisitor = new WaterTypeVisitor;
135	<	compositeVisitor->addVisitor(waterTypeVisitor, 600);
131	>
132	>	// if we gave the -w option, we want to skip the waters:
133	>	if (!args_info.water_given) {
134	>	//create waterType visitor
135	>	if(args_info.watertype_flag){
136	>	WaterTypeVisitor* waterTypeVisitor = new WaterTypeVisitor;
137	>	compositeVisitor->addVisitor(waterTypeVisitor, 600);
138	>	}
139	>	}
140	>
141	>	if (args_info.basetype_flag) {
142	>	AtomNameVisitor* atomNameVisitor = new AtomNameVisitor(info);
143	>	compositeVisitor->addVisitor(atomNameVisitor, 550);
144	>	cout << compositeVisitor->toString();
145		}
146	<
146	>
147		//create ZconsVisitor
148		if(args_info.zconstraint_flag){
133	–
134	–	zconsVisitor = new ZConsVisitor(info);
149
150	<	if(zconsVisitor->haveZconsMol())
150	>	ZConsVisitor* zconsVisitor = new ZConsVisitor(info);
151	>
152	>	if(zconsVisitor->haveZconsMol()) {
153		compositeVisitor->addVisitor(zconsVisitor, 500);
154	<	else
154	>	} else {
155		delete zconsVisitor;
156	+	}
157		}
141	–
142	–	//creat wrapping visitor
143	–
144	–	if(args_info.periodicBox_flag){
145	–	wrappingVisitor = new WrappingVisitor(info);
146	–	compositeVisitor->addVisitor(wrappingVisitor, 400);
147	–	}
158
159	<	//creat replicate visitor
160	<	if(args_info.repeatX_given > 0 || args_info.repeatY_given > 0 ||args_info.repeatY_given > 0){
161	<	IntVec3 replicateOpt(args_info.repeatX_arg, args_info.repeatY_arg, args_info.repeatZ_arg);
162	<	replicateVisitor = new ReplicateVisitor(info, replicateOpt);
159	>	//create wrapping visitor
160	>
161	>	//if(args_info.periodicBox_flag){
162	>	//  WrappingVisitor* wrappingVisitor = new WrappingVisitor(info);
163	>	//  compositeVisitor->addVisitor(wrappingVisitor, 400);
164	>	//}
165	>
166	>	//create replicate visitor
167	>	if(args_info.repeatX_given > 0 ||
168	>	args_info.repeatY_given > 0 ||
169	>	args_info.repeatY_given > 0) {
170	>	Vector3i replicateOpt(args_info.repeatX_arg,
171	>	args_info.repeatY_arg,
172	>	args_info.repeatZ_arg);
173	>	ReplicateVisitor* replicateVisitor = new ReplicateVisitor(info,
174	>	replicateOpt);
175		compositeVisitor->addVisitor(replicateVisitor, 300);
176		}
177
156	–	//creat xyzVisitor
157	–	xyzVisitor = new XYZVisitor(info);
158	–	compositeVisitor->addVisitor(xyzVisitor, 200);
178
179	<	cout << compositeVisitor->toString();
179	>	//create rotation visitor
180	>	if (args_info.refsele_given&& args_info.originsele_given) {
181	>	compositeVisitor->addVisitor(new LipidTransVisitor(info,
182	>	args_info.originsele_arg,
183	>	args_info.refsele_arg),
184	>	250);
185	>	} else if (args_info.refsele_given || args_info.originsele_given) {
186	>	cerr << "Both of --refsele and --originsele should appear by pair"
187	>	<< endl;
188	>	exit(1);
189	>	}
190	>
191	>	//create xyzVisitor
192	>	XYZVisitor* xyzVisitor;
193
194	<	//creat prepareVisitor
195	<	prepareVisitor = new PrepareVisitor();
194	>	if (args_info.selection_given) {
195	>	xyzVisitor = new XYZVisitor(info, args_info.selection_arg);
196	>	} else {
197	>	xyzVisitor = new XYZVisitor(info);
198	>	}
199
200	+	if(args_info.velocities_flag){
201	+	printVel = true;
202	+	xyzVisitor->doVelocities(printVel);
203	+	}
204	+	if(args_info.forces_flag){
205	+	printFrc = true;
206	+	xyzVisitor->doForces(printFrc);
207	+	}
208	+	if(args_info.vectors_flag){
209	+	printVec = true;
210	+	xyzVisitor->doVectors(printVec);
211	+	}
212	+	if(args_info.charges_flag){
213	+	printChrg = true;
214	+	xyzVisitor->doCharges(printChrg);
215	+	}
216	+
217	+	compositeVisitor->addVisitor(xyzVisitor, 200);
218	+
219	+	//create prepareVisitor
220	+	PrepareVisitor* prepareVisitor = new PrepareVisitor();
221	+
222		//open dump file
223	<	dumpReader = new DumpReader(dumpFileName.c_str());
224	<	nframes = dumpReader->getNframes();
168	<
169	<	xyzStream .open(xyzFileName.c_str());
223	>	DumpReader* dumpReader = new DumpReader(info, dumpFileName);
224	>	int nframes = dumpReader->getNFrames();
225
226	+	ofstream xyzStream(xyzFileName.c_str());
227	+
228	+	SimInfo::MoleculeIterator miter;
229	+	Molecule::IntegrableObjectIterator  iiter;
230	+	Molecule::RigidBodyIterator rbIter;
231	+	Molecule* mol;
232	+	StuntDouble* integrableObject;
233	+	RigidBody* rb;
234	+	Vector3d molCom;
235	+	Vector3d newMolCom;
236	+	Vector3d displacement;
237	+	Mat3x3d hmat;
238	+	Snapshot* currentSnapshot;
239	+
240		for (int i = 0; i < nframes; i += args_info.frame_arg){
241	<	dumpReader->readFrame(info, i);
242	<
243	<	mol = info->molecules;
244	<
241	>	dumpReader->readFrame(i);
242	>
243	>	if (printFrc) forceMan->calcForces();
244	>
245	>	//wrapping the molecule
246	>	if(args_info.periodicBox_flag) {
247	>	currentSnapshot = info->getSnapshotManager()->getCurrentSnapshot();
248	>	for (mol = info->beginMolecule(miter); mol != NULL;
249	>	mol = info->nextMolecule(miter)) {
250	>	molCom = mol->getCom();
251	>	newMolCom = molCom;
252	>	currentSnapshot->wrapVector(newMolCom);
253	>	displacement = newMolCom - molCom;
254	>	for (integrableObject = mol->beginIntegrableObject(iiter);
255	>	integrableObject != NULL;
256	>	integrableObject = mol->nextIntegrableObject(iiter)) {
257	>	integrableObject->setPos(integrableObject->getPos() + displacement);
258	>	}
259	>	}
260	>	}
261		//update atoms of rigidbody
262	<	for(int j = 0; j < info->n_mol; j++){
263	<	myRigidBodies = mol[j].getMyRigidBodies();
264	<
265	<	for(rbIter = myRigidBodies.begin(); rbIter != myRigidBodies.end(); ++rbIter)
266	<	(*rbIter)->updateAtoms();
267	<	}
268	<
262	>	for (mol = info->beginMolecule(miter); mol != NULL;
263	>	mol = info->nextMolecule(miter)) {
264	>
265	>	//change the positions of atoms which belong to the rigidbodies
266	>	for (rb = mol->beginRigidBody(rbIter); rb != NULL;
267	>	rb = mol->nextRigidBody(rbIter)) {
268	>	rb->updateAtoms();
269	>	if (printVel) rb->updateAtomVel();
270	>	}
271	>	}
272
273		//prepare visit
274	<	for(int j = 0; j < info->n_mol; j++){
275	<	integrableObjects = mol[j].getIntegrableObjects();
276	<
277	<	for(iter = integrableObjects.begin(); iter != integrableObjects.end(); ++iter)
278	<	(*iter)->accept(prepareVisitor);
279	<	}
280	<
274	>	for (mol = info->beginMolecule(miter); mol != NULL;
275	>	mol = info->nextMolecule(miter)) {
276	>	for (integrableObject = mol->beginIntegrableObject(iiter);
277	>	integrableObject != NULL;
278	>	integrableObject = mol->nextIntegrableObject(iiter)) {
279	>	integrableObject->accept(prepareVisitor);
280	>	}
281	>	}
282	>
283		//update visitor
284		compositeVisitor->update();
195	–
196	–	//visit stuntdouble
197	–	for(int j = 0; j < info->n_mol; j++){
198	–	integrableObjects = mol[j].getIntegrableObjects();
285
200	–	for(iter = integrableObjects.begin(); iter != integrableObjects.end(); ++iter)
201	–	(*iter)->accept(compositeVisitor);
202	–	}
286
287	+	//visit stuntdouble
288	+	for (mol = info->beginMolecule(miter); mol != NULL;
289	+	mol = info->nextMolecule(miter)) {
290	+	for (integrableObject = mol->beginIntegrableObject(iiter);
291	+	integrableObject != NULL;
292	+	integrableObject = mol->nextIntegrableObject(iiter)) {
293	+	integrableObject->accept(compositeVisitor);
294	+	}
295	+	}
296	+
297		xyzVisitor->writeFrame(xyzStream);
298		xyzVisitor->clear();
299
300		}//end for (int i = 0; i < nframes; i += args_info.frame_arg)
301	<
301	>
302		xyzStream.close();
303	<
211	<
303	>	delete prepareVisitor;
304		delete compositeVisitor;
305		delete info;
214	–
215	–
306		}

Comparing:
trunk/src/applications/dump2Xyz/Dump2XYZ.cpp (property svn:keywords), Revision 211 by chrisfen, Fri Nov 5 21:45:14 2004 UTC vs.
branches/development/src/applications/dump2Xyz/Dump2XYZ.cpp (property svn:keywords), Revision 1706 by gezelter, Fri Apr 27 20:44:16 2012 UTC

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

Diff Legend

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