ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/group/trunk/OOPSE-2.0/src/selection/NameFinder.cpp
(Generate patch)

Comparing trunk/OOPSE-2.0/src/selection/NameFinder.cpp (file contents):
Revision 1967 by tim, Thu Feb 3 23:14:05 2005 UTC vs.
Revision 1987 by tim, Mon Feb 7 22:36:32 2005 UTC

# Line 39 | Line 39 | namespace oopse {
39   * such damages.
40   */
41   #include "selection/NameFinder.hpp"
42 + #include "utils/wildcards.hpp"
43 + #include "utils/StringTokenizer.hpp"
44 + #include "primitives/Molecule.hpp"
45 + #include "utils/StringUtils.hpp"
46   namespace oopse {
47  
48 < NameFinder::NameFinder(SimInfo* info) {
48 > TreeNode::~TreeNode(){
49 >    std::map<std::string, TreeNode*>::iterator i;
50 >    for ( i = children.begin(); i != children.end(); ++i) {
51 >        i->second->~TreeNode();
52 >    }
53 >    children.clear();
54 > }
55 >
56 >
57 > NameFinder::NameFinder(SimInfo* info) : info_(info), root_(NULL){
58 >    nStuntDouble_ = info_->getNGlobalAtoms() + info_->getNGlobalRigidBodies();
59      loadNames();
60   }
61  
62  
63 + NameFinder::~NameFinder(){
64 +    delete root_;
65 + }
66  
67   void NameFinder::loadNames() {
68  
69 <    root_ = new NameNode;
53 <    root_.type = rootNode;
54 <
55 <    NameNode* newNode;            
69 >    std::map<std::string, TreeNode*>::iterator foundIter;
70      SimInfo::MoleculeIterator mi;
71      Molecule* mol;
72      Molecule::AtomIterator ai;
73      Atom* atom;
74      Molecule::RigidBodyIterator rbIter;
75      RigidBody* rb;
76 +
77 +    root_ = new TreeNode;
78 +    root_->bs.resize(nStuntDouble_);
79 +    root_->bs.setAll(); //
80 +    
81      for (mol = info_->beginMolecule(mi); mol != NULL; mol = info_->nextMolecule(mi)) {
82 <        newNode = new NameNode;
83 <        newNode.type = molNode;
84 <        newNode.name = mol->getMoleculeName();
82 >          
83 >        std::string molName = mol->getMoleculeName();
84 >         TreeNode* currentMolNode = createNode(root_, molName);
85          
86          for(atom = mol->beginAtom(ai); atom != NULL; atom = mol->nextAtom(ai)) {
87 <            atomNames_.insert(atom->getType());
87 >            std::string atomName = atom->getType();
88 >            TreeNode* currentAtomNode = createNode(currentMolNode, atomName);
89 >            
90 >            currentMolNode->bs.setBitOn(atom->getGlobalIndex());
91 >            currentAtomNode->bs.setBitOn(atom->getGlobalIndex());
92          }
93 <        
71 <        //change the positions of atoms which belong to the rigidbodies
93 >
94          for (rb = mol->beginRigidBody(rbIter); rb != NULL; rb = mol->nextRigidBody(rbIter)) {
95 <            rbNames_.insert(rb->getType());
96 <        }        
95 >            std::string rbName = rb->getType();
96 >            TreeNode* currentRbNode = createNode(currentMolNode, rbName);
97 >            
98 >            currentMolNode->bs.setBitOn(rb->getGlobalIndex());
99 >            currentRbNode->bs.setBitOn(rb->getGlobalIndex());
100 >
101 >            //create nodes for atoms belong to this rigidbody
102 >            for(atom = rb->beginAtom(ai); atom != NULL; atom = rb->nextAtom(ai)) {
103 >                std::string rbAtomName = atom->getType();
104 >                TreeNode* currentRbAtomNode = createNode(currentRbNode, rbName);;
105 >
106 >                currentRbAtomNode->bs.setBitOn(atom->getGlobalIndex());
107 >            }
108 >
109 >        }
110 >        
111      }    
112 +
113   }
114  
115 < bool NameFinder::match(const std::string& name, BitSet& bs){
115 > TreeNode* NameFinder::createNode(TreeNode* parent, const std::string& name) {
116 >    TreeNode* node;    
117 >    std::map<std::string, TreeNode*>::iterator foundIter;
118 >    foundIter = parent->children.find(name);
119 >    if ( foundIter  == parent->children.end()) {
120 >        node = new TreeNode;
121 >        node->name = name;
122 >        node->bs.resize(nStuntDouble_);
123 >        parent->children.insert(std::make_pair(name, node));
124 >    }else {
125 >        node = foundIter->second;
126 >    }
127 >    return node;
128 > }
129  
130 <    bool error = true;
130 > BitSet NameFinder::match(const std::string& name){
131 >    BitSet bs(nStuntDouble_);
132 >  
133      StringTokenizer tokenizer(name, ".");
134  
135      std::vector<std::string> names;
# Line 88 | Line 140 | bool NameFinder::match(const std::string& name, BitSet
140      int size = names.size();
141      switch(size) {
142          case 1 :
143 <            //could be molecule name, atom name, rigidbody name
144 <            isMolName();
145 <            isAtomName();
146 <            isRigidBodyName();
143 >            //could be molecule name, atom name and rigidbody name
144 >            if (names[0] == "*"){
145 >                //if all molecules are selected, we don't need to do the matching, just set all of the bits
146 >                bs.setAll();
147 >            } else{
148 >                matchMolecule(names[0], bs);
149 >                matchStuntDouble("*", names[0], bs);
150 >            }
151 >            
152              break;
153          case 2:
154 <            //could be molecule.*(include atoms and rigidbodies) or rigidbody.*
154 >            //could be molecule.*(include atoms and rigidbodies) or rigidbody.*(atoms belong to rigidbody)
155 >
156 >            if (!isInteger(names[1])){
157 >                matchRigidAtoms("*", names[0], names[1], bs);
158 >                matchStuntDouble(names[0], names[1], bs);
159 >            } else {
160 >                int internalIndex = lexi_cast<int>(names[1]);
161 >                if (internalIndex < 0) {
162 >                    std::cerr << names[0] << ". " << names[1] << " is an invalid name" << std::endl;          
163 >                } else {
164 >                    matchInternalIndex(names[0], internalIndex, bs);
165 >                }
166 >            }
167 >            
168              break;
169          case 3:
170              //must be molecule.rigidbody.*
171 <            
171 >            matchRigidAtoms(names[0], names[1], names[2], bs);
172              break;
173 <        default:            
173 >        default:      
174 >            std::cerr << "invalid name: " << name << std::endl;
175              break;          
176      }
177  
178 <    return matched;
178 >    return bs;
179   }
180  
181 + void NameFinder::matchMolecule(const std::string& molName, BitSet& bs) {
182 +    std::vector<TreeNode*> molNodes = getMatchedChildren(root_, molName);            
183 +    std::vector<TreeNode*>::iterator i;
184 +    for( i = molNodes.begin(); i != molNodes.end(); ++i ) {
185 +        bs |= (*i)->bs;
186 +    }    
187   }
188 +
189 + void NameFinder::matchStuntDouble(const std::string& molName, const std::string& sdName, BitSet& bs){
190 +    std::vector<TreeNode*> molNodes = getMatchedChildren(root_, molName);            
191 +    std::vector<TreeNode*>::iterator i;
192 +    for( i = molNodes.begin(); i != molNodes.end(); ++i ) {
193 +        std::vector<TreeNode*> sdNodes = getMatchedChildren(*i, sdName);  
194 +        std::vector<TreeNode*>::iterator j;
195 +        for (j = sdNodes.begin(); j != sdNodes.end(); ++j) {
196 +            bs |= (*j)->bs;
197 +        }
198 +    }
199 +
200 + }
201 +
202 + void NameFinder::matchRigidAtoms(const std::string& molName, const std::string& rbName, const std::string& rbAtomName, BitSet& bs){
203 +    std::vector<TreeNode*> molNodes = getMatchedChildren(root_, molName);            
204 +    std::vector<TreeNode*>::iterator i;
205 +    for( i = molNodes.begin(); i != molNodes.end(); ++i ) {
206 +        std::vector<TreeNode*> rbNodes = getMatchedChildren(*i, rbName);  
207 +        std::vector<TreeNode*>::iterator j;
208 +        for (j = rbNodes.begin(); j != rbNodes.end(); ++j) {
209 +            std::vector<TreeNode*> rbAtomNodes = getMatchedChildren(*j, rbAtomName);
210 +            std::vector<TreeNode*>::iterator k;
211 +            for(k = rbAtomNodes.begin(); k != rbAtomNodes.end(); ++k){
212 +                bs |= (*k)->bs;
213 +            }
214 +        }
215 +    }
216 +
217 + }
218 +
219 +
220 + std::vector<TreeNode*> NameFinder::getMatchedChildren(TreeNode* node, const std::string& name) {
221 +    std::vector<TreeNode*> matchedNodes;
222 +    std::map<std::string, TreeNode*>::iterator i;
223 +    for (i = node->children.begin(); i != node->children.end(); ++i) {
224 +        if (isMatched( i->first, name)) {
225 +            matchedNodes.push_back(i->second);
226 +        }
227 +    }
228 +
229 +    return matchedNodes;
230 + }
231 +
232 + bool NameFinder::isMatched(const std::string& str, const std::string& wildcard) {
233 +    return Wildcard::wildcardfit (wildcard.c_str(), str.c_str());
234 + }
235 +
236 +
237 + void NameFinder::matchInternalIndex(const std::string& name, int internalIndex, BitSet& bs){
238 +
239 +    std::map<std::string, TreeNode*>::iterator foundIter;
240 +    SimInfo::MoleculeIterator mi;
241 +    Molecule* mol;
242 +
243 +    for (mol = info_->beginMolecule(mi); mol != NULL; mol = info_->nextMolecule(mi)) {
244 +          
245 +        if (isMatched(mol->getMoleculeName(), name) ) {
246 +            int natoms = mol->getNAtoms();
247 +            int nrigidbodies = mol->getNRigidBodies();
248 +            if (internalIndex >= natoms + nrigidbodies) {
249 +                continue;
250 +            } else if (internalIndex < natoms) {
251 +                bs.setBitOn(mol->getAtomAt(internalIndex)->getGlobalIndex());
252 +                continue;
253 +            } else if ( internalIndex < natoms + nrigidbodies) {
254 +                bs.setBitOn(mol->getRigidBodyAt(internalIndex - natoms)->getGlobalIndex());
255 +            }
256 +        }
257 +        
258 +    }    
259 +    
260 + }
261 +
262 + bool NameFinder::isInteger(const std::string str) {
263 +    for(int i =0; i < str.size(); ++i){
264 +        if (!std::isdigit(str[i])) {
265 +            return false;
266 +        }
267 +    }
268 +
269 +    return true;
270 + }
271 +
272 + }

Diff Legend

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