ViewVC Help

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

root/OpenMD/trunk/src/selection/NameFinder.cpp

Comparing trunk/src/selection/NameFinder.cpp (file contents):
Revision 1390 by gezelter, Wed Nov 25 20:02:06 2009 UTC vs.
Revision 1962 by gezelter, Wed Jan 15 22:26:18 2014 UTC

#	Line 35 | Line 35
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).
38	>	* [3]  Sun, Lin & Gezelter, J. Chem. Phys. 128, 234107 (2008).
39	>	* [4]  Kuang & Gezelter,  J. Chem. Phys. 133, 164101 (2010).
40	>	* [5]  Vardeman, Stocker & Gezelter, J. Chem. Theory Comput. 7, 834 (2011).
41		*/
42		#include "selection/NameFinder.hpp"
43		#include "utils/wildcards.hpp"
#	Line 53 | Line 54 | namespace OpenMD {
54		children.clear();
55		}
56
56	–
57		NameFinder::NameFinder(SimInfo* info) : info_(info), root_(NULL){
58	<	nStuntDouble_ = info_->getNGlobalAtoms() + info_->getNGlobalRigidBodies();
58	>	nObjects_.push_back(info_->getNGlobalAtoms()+info_->getNGlobalRigidBodies());
59	>	nObjects_.push_back(info_->getNGlobalBonds());
60	>	nObjects_.push_back(info_->getNGlobalBends());
61	>	nObjects_.push_back(info_->getNGlobalTorsions());
62	>	nObjects_.push_back(info_->getNGlobalInversions());
63		loadNames();
64		}
65
62	–
66		NameFinder::~NameFinder(){
67		delete root_;
68		}
69
70		void NameFinder::loadNames() {
68	–
69	–	std::map<std::string, TreeNode*>::iterator foundIter;
71		SimInfo::MoleculeIterator mi;
71	–	Molecule* mol;
72		Molecule::AtomIterator ai;
73	–	Atom* atom;
73		Molecule::RigidBodyIterator rbIter;
74	+	Molecule::BondIterator bondIter;
75	+	Molecule::BendIterator bendIter;
76	+	Molecule::TorsionIterator torsionIter;
77	+	Molecule::InversionIterator inversionIter;
78	+
79	+	Molecule* mol;
80	+	Atom* atom;
81		RigidBody* rb;
82	+	Bond* bond;
83	+	Bend* bend;
84	+	Torsion* torsion;
85	+	Inversion* inversion;
86
87		root_ = new TreeNode;
88	<	root_->bs.resize(nStuntDouble_);
88	>	root_->bs.resize(nObjects_);
89		root_->bs.setAll(); //
90
91	<	for (mol = info_->beginMolecule(mi); mol != NULL; mol = info_->nextMolecule(mi)) {
91	>	for (mol = info_->beginMolecule(mi); mol != NULL;
92	>	mol = info_->nextMolecule(mi)) {
93
94		std::string molName = mol->getMoleculeName();
95	<	TreeNode* currentMolNode = createNode(root_, molName);
95	>	TreeNode* molNode = createNode(root_, molName);
96
97		for(atom = mol->beginAtom(ai); atom != NULL; atom = mol->nextAtom(ai)) {
98		std::string atomName = atom->getType();
99	<	TreeNode* currentAtomNode = createNode(currentMolNode, atomName);
99	>	TreeNode* atomNode = createNode(molNode, atomName);
100
101	<	currentMolNode->bs.setBitOn(atom->getGlobalIndex());
102	<	currentAtomNode->bs.setBitOn(atom->getGlobalIndex());
101	>	molNode->bs.bitsets_[STUNTDOUBLE].setBitOn(atom->getGlobalIndex());
102	>	atomNode->bs.bitsets_[STUNTDOUBLE].setBitOn(atom->getGlobalIndex());
103		}
104
105	<	for (rb = mol->beginRigidBody(rbIter); rb != NULL; rb = mol->nextRigidBody(rbIter)) {
105	>	for (rb = mol->beginRigidBody(rbIter); rb != NULL;
106	>	rb = mol->nextRigidBody(rbIter)) {
107		std::string rbName = rb->getType();
108	<	TreeNode* currentRbNode = createNode(currentMolNode, rbName);
108	>	TreeNode* rbNode = createNode(molNode, rbName);
109
110	<	currentMolNode->bs.setBitOn(rb->getGlobalIndex());
111	<	currentRbNode->bs.setBitOn(rb->getGlobalIndex());
110	>	molNode->bs.bitsets_[STUNTDOUBLE].setBitOn(rb->getGlobalIndex());
111	>	rbNode->bs.bitsets_[STUNTDOUBLE].setBitOn(rb->getGlobalIndex());
112
113	<	//create nodes for atoms belong to this rigidbody
114	<	for(atom = rb->beginAtom(ai); atom != NULL; atom = rb->nextAtom(ai)) {
115	<	std::string rbAtomName = atom->getType();
116	<	TreeNode* currentRbAtomNode = createNode(currentRbNode, rbName);;
113	>	// COMMENTED OUT because rigid bodies are IntegrableObjects
114	>	// (e.g. they are independently mobile, so selecting their
115	>	// member atoms will give some odd results if we are computing
116	>	// degrees of freedom elsewhere.
117
118	<	currentRbAtomNode->bs.setBitOn(atom->getGlobalIndex());
119	<	}
118	>	// //create nodes for atoms belong to this rigidbody
119	>	// for(atom = rb->beginAtom(ai); atom != NULL; atom = rb->nextAtom(ai)) {
120	>	//   std::string rbAtomName = atom->getType();
121	>	//   TreeNode* rbAtomNode = createNode(rbNode, rbAtomName);
122
123	+	//   rbAtomNode->bs.bitsets_[STUNTDOUBLE].setBitOn(atom->getGlobalIndex());
124	+	// }
125		}
126	+
127	+	for (bond = mol->beginBond(bondIter); bond != NULL;
128	+	bond = mol->nextBond(bondIter)) {
129	+
130	+	std::string bondName = bond->getName();
131	+	TreeNode* bondNode = createNode(molNode, bondName);
132	+
133	+	molNode->bs.bitsets_[BOND].setBitOn(bond->getGlobalIndex());
134	+	bondNode->bs.bitsets_[BOND].setBitOn(bond->getGlobalIndex());
135	+
136	+	std::vector<Atom*> atoms = bond->getAtoms();
137	+	std::vector<Atom*>::iterator ai;
138
139	<	}
139	>	for (ai = atoms.begin(); ai != atoms.end(); ++ai) {
140	>	std::string atomName = (*ai)->getType();
141	>	TreeNode* atomNode = createNode(bondNode, atomName);
142	>	atomNode->bs.bitsets_[STUNTDOUBLE].setBitOn((*ai)->getGlobalIndex());
143	>	}
144	>	}
145	>	for (bend = mol->beginBend(bendIter); bend != NULL;
146	>	bend = mol->nextBend(bendIter)) {
147
148	+	std::string bendName = bend->getName();
149	+	TreeNode* bendNode = createNode(molNode, bendName);
150	+
151	+	molNode->bs.bitsets_[BEND].setBitOn(bend->getGlobalIndex());
152	+	bendNode->bs.bitsets_[BEND].setBitOn(bend->getGlobalIndex());
153	+
154	+	std::vector<Atom*> atoms = bend->getAtoms();
155	+	std::vector<Atom*>::iterator ai;
156	+
157	+	for (ai = atoms.begin(); ai != atoms.end(); ++ai) {
158	+	std::string atomName = (*ai)->getType();
159	+	TreeNode* atomNode = createNode(bendNode, atomName);
160	+	atomNode->bs.bitsets_[STUNTDOUBLE].setBitOn((*ai)->getGlobalIndex());
161	+	}
162	+
163	+	}
164	+	for (torsion = mol->beginTorsion(torsionIter); torsion != NULL;
165	+	torsion = mol->nextTorsion(torsionIter)) {
166	+
167	+	std::string torsionName = torsion->getName();
168	+	TreeNode* torsionNode = createNode(molNode, torsionName);
169	+
170	+	molNode->bs.bitsets_[TORSION].setBitOn(torsion->getGlobalIndex());
171	+	torsionNode->bs.bitsets_[TORSION].setBitOn(torsion->getGlobalIndex());
172	+
173	+	std::vector<Atom*> atoms = torsion->getAtoms();
174	+	std::vector<Atom*>::iterator ai;
175	+
176	+	for (ai = atoms.begin(); ai != atoms.end(); ++ai) {
177	+	std::string atomName = (*ai)->getType();
178	+	TreeNode* atomNode = createNode(torsionNode, atomName);
179	+	atomNode->bs.bitsets_[STUNTDOUBLE].setBitOn((*ai)->getGlobalIndex());
180	+	}
181	+
182	+	}
183	+	for (inversion = mol->beginInversion(inversionIter); inversion != NULL;
184	+	inversion = mol->nextInversion(inversionIter)) {
185	+
186	+	std::string inversionName = inversion->getName();
187	+	TreeNode* inversionNode = createNode(molNode, inversionName);
188	+
189	+	molNode->bs.bitsets_[INVERSION].setBitOn(inversion->getGlobalIndex());
190	+	inversionNode->bs.bitsets_[INVERSION].setBitOn(inversion->getGlobalIndex());
191	+	std::vector<Atom*> atoms = inversion->getAtoms();
192	+	std::vector<Atom*>::iterator ai;
193	+
194	+	for (ai = atoms.begin(); ai != atoms.end(); ++ai) {
195	+	std::string atomName = (*ai)->getType();
196	+	TreeNode* atomNode = createNode(inversionNode, atomName);
197	+	atomNode->bs.bitsets_[STUNTDOUBLE].setBitOn((*ai)->getGlobalIndex());
198	+	}
199	+	}
200	+	}
201		}
202
203		TreeNode* NameFinder::createNode(TreeNode* parent, const std::string& name) {
#	Line 119 | Line 207 | namespace OpenMD {
207		if ( foundIter  == parent->children.end()) {
208		node = new TreeNode;
209		node->name = name;
210	<	node->bs.resize(nStuntDouble_);
210	>	node->bs.resize(nObjects_);
211		parent->children.insert(std::make_pair(name, node));
212		}else {
213		node = foundIter->second;
#	Line 127 | Line 215 | namespace OpenMD {
215		return node;
216		}
217
218	<	OpenMDBitSet NameFinder::match(const std::string& name){
219	<	OpenMDBitSet bs(nStuntDouble_);
218	>	SelectionSet NameFinder::match(const std::string& name){
219	>	SelectionSet bs(nObjects_);
220
221		StringTokenizer tokenizer(name, ".");
222
#	Line 138 | Line 226 | namespace OpenMD {
226		}
227
228		int size = names.size();
229	+
230		switch(size) {
231		case 1 :
232		//could be molecule name, atom name and rigidbody name
233		matchMolecule(names[0], bs);
234		matchStuntDouble("*", names[0], bs);
235	+	matchBond("*", names[0], bs);
236	+	matchBend("*", names[0], bs);
237	+	matchTorsion("*", names[0], bs);
238	+	matchInversion("*", names[0], bs);
239
240		break;
241		case 2:
#	Line 173 | Line 266 | namespace OpenMD {
266		return bs;
267		}
268
269	<	void NameFinder::matchMolecule(const std::string& molName, OpenMDBitSet& bs) {
269	>	void NameFinder::matchMolecule(const std::string& molName, SelectionSet& bs) {
270		std::vector<TreeNode*> molNodes = getMatchedChildren(root_, molName);
271		std::vector<TreeNode*>::iterator i;
272		for( i = molNodes.begin(); i != molNodes.end(); ++i ) {
#	Line 181 | Line 274 | namespace OpenMD {
274		}
275		}
276
277	<	void NameFinder::matchStuntDouble(const std::string& molName, const std::string& sdName, OpenMDBitSet& bs){
277	>	void NameFinder::matchStuntDouble(const std::string& molName, const std::string& sdName, SelectionSet& bs){
278		std::vector<TreeNode*> molNodes = getMatchedChildren(root_, molName);
279		std::vector<TreeNode*>::iterator i;
280		for( i = molNodes.begin(); i != molNodes.end(); ++i ) {
#	Line 194 | Line 287 | namespace OpenMD {
287
288		}
289
290	<	void NameFinder::matchRigidAtoms(const std::string& molName, const std::string& rbName, const std::string& rbAtomName, OpenMDBitSet& bs){
290	>	void NameFinder::matchBond(const std::string& molName,
291	>	const std::string& bondName, SelectionSet& bs){
292		std::vector<TreeNode*> molNodes = getMatchedChildren(root_, molName);
293		std::vector<TreeNode*>::iterator i;
294		for( i = molNodes.begin(); i != molNodes.end(); ++i ) {
295	+	std::vector<TreeNode*> bondNodes = getMatchedChildren(*i, bondName);
296	+	std::vector<TreeNode*>::iterator j;
297	+	for (j = bondNodes.begin(); j != bondNodes.end(); ++j) {
298	+	bs |= (*j)->bs;
299	+	std::vector<TreeNode*> bondAtomNodes = getAllChildren(*j);
300	+	std::vector<TreeNode*>::iterator k;
301	+	for(k = bondAtomNodes.begin(); k != bondAtomNodes.end(); ++k){
302	+	bs |= (*k)->bs;
303	+	}
304	+	}
305	+	}
306	+	}
307	+
308	+	void NameFinder::matchBend(const std::string& molName, const std::string& bendName,  SelectionSet& bs){
309	+	std::vector<TreeNode*> molNodes = getMatchedChildren(root_, molName);
310	+	std::vector<TreeNode*>::iterator i;
311	+	for( i = molNodes.begin(); i != molNodes.end(); ++i ) {
312	+	std::vector<TreeNode*> bendNodes = getMatchedChildren(*i, bendName);
313	+	std::vector<TreeNode*>::iterator j;
314	+	for (j = bendNodes.begin(); j != bendNodes.end(); ++j) {
315	+	std::vector<TreeNode*> bendAtomNodes = getAllChildren(*j);
316	+	std::vector<TreeNode*>::iterator k;
317	+	for(k = bendAtomNodes.begin(); k != bendAtomNodes.end(); ++k){
318	+	bs |= (*k)->bs;
319	+	}
320	+	}
321	+	}
322	+	}
323	+	void NameFinder::matchTorsion(const std::string& molName, const std::string& torsionName, SelectionSet& bs){
324	+	std::vector<TreeNode*> molNodes = getMatchedChildren(root_, molName);
325	+	std::vector<TreeNode*>::iterator i;
326	+	for( i = molNodes.begin(); i != molNodes.end(); ++i ) {
327	+	std::vector<TreeNode*> torsionNodes = getMatchedChildren(*i, torsionName);
328	+	std::vector<TreeNode*>::iterator j;
329	+	for (j = torsionNodes.begin(); j != torsionNodes.end(); ++j) {
330	+	std::vector<TreeNode*> torsionAtomNodes = getAllChildren(*j);
331	+	std::vector<TreeNode*>::iterator k;
332	+	for(k = torsionAtomNodes.begin(); k != torsionAtomNodes.end(); ++k){
333	+	bs |= (*k)->bs;
334	+	}
335	+	}
336	+	}
337	+	}
338	+	void NameFinder::matchInversion(const std::string& molName, const std::string& inversionName, SelectionSet& bs){
339	+	std::vector<TreeNode*> molNodes = getMatchedChildren(root_, molName);
340	+	std::vector<TreeNode*>::iterator i;
341	+	for( i = molNodes.begin(); i != molNodes.end(); ++i ) {
342	+	std::vector<TreeNode*> inversionNodes = getMatchedChildren(*i, inversionName);
343	+	std::vector<TreeNode*>::iterator j;
344	+	for (j = inversionNodes.begin(); j != inversionNodes.end(); ++j) {
345	+	std::vector<TreeNode*> inversionAtomNodes = getAllChildren(*j);
346	+	std::vector<TreeNode*>::iterator k;
347	+	for(k = inversionAtomNodes.begin(); k != inversionAtomNodes.end(); ++k){
348	+	bs |= (*k)->bs;
349	+	}
350	+	}
351	+	}
352	+	}
353	+
354	+	void NameFinder::matchRigidAtoms(const std::string& molName, const std::string& rbName, const std::string& rbAtomName, SelectionSet& bs){
355	+	std::vector<TreeNode*> molNodes = getMatchedChildren(root_, molName);
356	+	std::vector<TreeNode*>::iterator i;
357	+	for( i = molNodes.begin(); i != molNodes.end(); ++i ) {
358		std::vector<TreeNode*> rbNodes = getMatchedChildren(*i, rbName);
359		std::vector<TreeNode*>::iterator j;
360		for (j = rbNodes.begin(); j != rbNodes.end(); ++j) {
#	Line 211 | Line 368 | namespace OpenMD {
368
369		}
370
371	+	std::vector<TreeNode*> NameFinder::getAllChildren(TreeNode* node)  {
372	+	std::vector<TreeNode*> childNodes;
373	+	std::map<std::string, TreeNode*>::iterator i;
374	+	for (i = node->children.begin(); i != node->children.end(); ++i) {
375	+	childNodes.push_back(i->second);
376	+	}
377	+	return childNodes;
378	+	}
379
380		std::vector<TreeNode*> NameFinder::getMatchedChildren(TreeNode* node, const std::string& name) {
381		std::vector<TreeNode*> matchedNodes;
#	Line 225 | Line 390 | namespace OpenMD {
390		}
391
392		bool NameFinder::isMatched(const std::string& str, const std::string& wildcard) {
393	<	return Wildcard::wildcardfit (wildcard.c_str(), str.c_str());
393	>	return Wildcard::wildcardfit(wildcard.c_str(), str.c_str()) > 0 ? true : false;
394		}
395
396
397	<	void NameFinder::matchInternalIndex(const std::string& name, int internalIndex, OpenMDBitSet& bs){
397	>	void NameFinder::matchInternalIndex(const std::string& name, int internalIndex, SelectionSet& bs){
398
234	–	std::map<std::string, TreeNode*>::iterator foundIter;
399		SimInfo::MoleculeIterator mi;
400		Molecule* mol;
401
402	<	for (mol = info_->beginMolecule(mi); mol != NULL; mol = info_->nextMolecule(mi)) {
402	>	for (mol = info_->beginMolecule(mi); mol != NULL;
403	>	mol = info_->nextMolecule(mi)) {
404
405		if (isMatched(mol->getMoleculeName(), name) ) {
406		int natoms = mol->getNAtoms();
#	Line 243 | Line 408 | namespace OpenMD {
408		if (internalIndex >= natoms + nrigidbodies) {
409		continue;
410		} else if (internalIndex < natoms) {
411	<	bs.setBitOn(mol->getAtomAt(internalIndex)->getGlobalIndex());
411	>	bs.bitsets_[STUNTDOUBLE].setBitOn(mol->getAtomAt(internalIndex)->getGlobalIndex());
412		continue;
413		} else if ( internalIndex < natoms + nrigidbodies) {
414	<	bs.setBitOn(mol->getRigidBodyAt(internalIndex - natoms)->getGlobalIndex());
414	>	bs.bitsets_[STUNTDOUBLE].setBitOn(mol->getRigidBodyAt(internalIndex - natoms)->getGlobalIndex());
415		}
416		}
417	<
253	<	}
254	<
417	>	}
418		}
419
420	<	bool NameFinder::isInteger(const std::string str) {
421	<	for(int i =0; i < str.size(); ++i){
420	>	bool NameFinder::isInteger(const std::string &str) {
421	>	for(unsigned int i = 0; i < str.size(); ++i){
422		if (!std::isdigit(str[i])) {
423		return false;
424		}
425		}
263	–
426		return true;
427		}
266	–
428		}

Comparing trunk/src/selection/NameFinder.cpp (property svn:keywords):
Revision 1390 by gezelter, Wed Nov 25 20:02:06 2009 UTC vs.
Revision 1962 by gezelter, Wed Jan 15 22:26:18 2014 UTC

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

Diff Legend

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