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

Comparing trunk/OOPSE-3.0/src/selection/NameFinder.cpp (file contents):
Revision 1968 by tim, Fri Feb 4 04:57:04 2005 UTC vs.
Revision 2147 by tim, Tue Apr 5 23:09:48 2005 UTC

# Line 40 | Line 40 | namespace oopse {
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   TreeNode::~TreeNode(){
# Line 52 | Line 55 | NameFinder::NameFinder(SimInfo* info) : info_(info), r
55  
56  
57   NameFinder::NameFinder(SimInfo* info) : info_(info), root_(NULL){
58 <    nStuntDouble_ = info_->getNGlobalAtoms() + info_->getNGlobalRigidBodies()
58 >    nStuntDouble_ = info_->getNGlobalAtoms() + info_->getNGlobalRigidBodies();
59      loadNames();
60   }
61  
# Line 72 | Line 75 | void NameFinder::loadNames() {
75      RigidBody* rb;
76  
77      root_ = new TreeNode;
78 <    root_->bs.resize(nStuntDobule_);
78 >    root_->bs.resize(nStuntDouble_);
79      root_->bs.setAll(); //
80      
81      for (mol = info_->beginMolecule(mi); mol != NULL; mol = info_->nextMolecule(mi)) {
82 <        TreeNode* currentMolNode;            
82 >          
83          std::string molName = mol->getMoleculeName();
84 <
82 <        foundIter = root_->children.find(molName);
83 <        if ( foundIter  == root_->children.end()) {
84 <            currentMolNode = new TreeNode;
85 <            currentMolNode->name = molName;
86 <            currentMolNode->bs.resize(nStuntDouble_);
87 <        }else {
88 <            currentMolNode = i->second;
89 <        }
84 >         TreeNode* currentMolNode = createNode(root_, molName);
85          
86          for(atom = mol->beginAtom(ai); atom != NULL; atom = mol->nextAtom(ai)) {
87              std::string atomName = atom->getType();
88 <            TreeNode* currentAtomNode;
89 <            foundIter = currentMolNode->children.find(molName);
95 <            if (foundIter == currentMolNode->children.end()) {
96 <                currentAtomNode = new TreeNode;
97 <                currentAtomNode->name = atomName;
98 <                currentAtomNode->bs.resize(nStuntDouble_);
99 <            } else {
100 <                currentAtomNode = foundIter->second;
101 <            }
88 >            TreeNode* currentAtomNode = createNode(currentMolNode, atomName);
89 >            
90              currentMolNode->bs.setBitOn(atom->getGlobalIndex());
91              currentAtomNode->bs.setBitOn(atom->getGlobalIndex());
92          }
93  
94          for (rb = mol->beginRigidBody(rbIter); rb != NULL; rb = mol->nextRigidBody(rbIter)) {
95 <            std::string rbName = atom->getType();
96 <            TreeNode* currentRbNode;
109 <            foundIter = currentMolNode->children.find(molName);
110 <            if (foundIter == currentMolNode->children.end()) {
111 <                currentRbNode = new TreeNode;
112 <                currentRbNode->name = rbName;
113 <                currentRbNode->bs.resize(nStuntDouble_);
114 <            } else {
115 <                currentRbNode = foundIter->second;
116 <            }
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); rb != NULL; atom = rb->nextAtom(ai)) {
102 >            for(atom = rb->beginAtom(ai); atom != NULL; atom = rb->nextAtom(ai)) {
103                  std::string rbAtomName = atom->getType();
104 <                TreeNode* currentRbAtomNode;
105 <                foundIter = currentRbNode->children.find(molName);
126 <                if (foundIter == currentRbNode->children.end()) {
127 <                    currentRbAtomNode = new TreeNode;
128 <                    currentRbAtomNode->name = rbAtomName;
129 <                    currentRbAtomNode->bs.resize(nStuntDouble_);
130 <                } else {
131 <                    currentRbAtomNode = foundIter->second;
132 <                }
104 >                TreeNode* currentRbAtomNode = createNode(currentRbNode, rbName);;
105 >
106                  currentRbAtomNode->bs.setBitOn(atom->getGlobalIndex());
107              }
108  
# Line 137 | Line 110 | void NameFinder::loadNames() {
110          
111      }    
112  
113 <    std::map<std::string, TreeNode*>::iterator i;
114 <    for( i = root_->children.begin(); i != ; ++i){
115 <        i->bs =
113 > }
114 >
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 NameFinder::match(const std::string& name, BitSet& bs){
131 <
132 <    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 157 | Line 141 | bool NameFinder::match(const std::string& name, BitSet
141      switch(size) {
142          case 1 :
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
162 <                bs.setAll();
163 <            } else{
164 <                matchMolecule(name[0]);
165 <                matchStuntDouble("*", names[0]);
166 <            }
144 >            matchMolecule(names[0], bs);
145 >            matchStuntDouble("*", names[0], bs);
146              
147              break;
148          case 2:
149              //could be molecule.*(include atoms and rigidbodies) or rigidbody.*(atoms belong to rigidbody)
150 <            matchRigidAtoms("*", names[0], names[1], bs);
151 <            matchStuntDouble(names[0], names[1]);
150 >
151 >            if (!isInteger(names[1])){
152 >                matchRigidAtoms("*", names[0], names[1], bs);
153 >                matchStuntDouble(names[0], names[1], bs);
154 >            } else {
155 >                int internalIndex = lexi_cast<int>(names[1]);
156 >                if (internalIndex < 0) {
157 >                    std::cerr << names[0] << ". " << names[1] << " is an invalid name" << std::endl;          
158 >                } else {
159 >                    matchInternalIndex(names[0], internalIndex, bs);
160 >                }
161 >            }
162              
163              break;
164          case 3:
165              //must be molecule.rigidbody.*
166 <            matchRigidAtoms(names[0], names[1], names[2], bs)
166 >            matchRigidAtoms(names[0], names[1], names[2], bs);
167              break;
168 <        default:            
168 >        default:      
169 >            std::cerr << "invalid name: " << name << std::endl;
170              break;          
171      }
172  
173 <    return matched;
173 >    return bs;
174   }
175  
176   void NameFinder::matchMolecule(const std::string& molName, BitSet& bs) {
177      std::vector<TreeNode*> molNodes = getMatchedChildren(root_, molName);            
178      std::vector<TreeNode*>::iterator i;
179      for( i = molNodes.begin(); i != molNodes.end(); ++i ) {
180 <        bs |= i->bs;
180 >        bs |= (*i)->bs;
181      }    
182   }
183  
# Line 198 | Line 188 | void NameFinder::matchStuntDouble(const std::string& m
188          std::vector<TreeNode*> sdNodes = getMatchedChildren(*i, sdName);  
189          std::vector<TreeNode*>::iterator j;
190          for (j = sdNodes.begin(); j != sdNodes.end(); ++j) {
191 <            bs |= j->bs;
191 >            bs |= (*j)->bs;
192          }
193      }
194  
# Line 214 | Line 204 | void NameFinder::matchRigidAtoms(const std::string& mo
204              std::vector<TreeNode*> rbAtomNodes = getMatchedChildren(*j, rbAtomName);
205              std::vector<TreeNode*>::iterator k;
206              for(k = rbAtomNodes.begin(); k != rbAtomNodes.end(); ++k){
207 <                bs |= k->bs;
207 >                bs |= (*k)->bs;
208              }
209          }
210      }
# Line 238 | Line 228 | bool NameFinder::isMatched(const std::string& str, con
228      return Wildcard::wildcardfit (wildcard.c_str(), str.c_str());
229   }
230  
231 +
232 + void NameFinder::matchInternalIndex(const std::string& name, int internalIndex, BitSet& bs){
233 +
234 +    std::map<std::string, TreeNode*>::iterator foundIter;
235 +    SimInfo::MoleculeIterator mi;
236 +    Molecule* mol;
237 +
238 +    for (mol = info_->beginMolecule(mi); mol != NULL; mol = info_->nextMolecule(mi)) {
239 +          
240 +        if (isMatched(mol->getMoleculeName(), name) ) {
241 +            int natoms = mol->getNAtoms();
242 +            int nrigidbodies = mol->getNRigidBodies();
243 +            if (internalIndex >= natoms + nrigidbodies) {
244 +                continue;
245 +            } else if (internalIndex < natoms) {
246 +                bs.setBitOn(mol->getAtomAt(internalIndex)->getGlobalIndex());
247 +                continue;
248 +            } else if ( internalIndex < natoms + nrigidbodies) {
249 +                bs.setBitOn(mol->getRigidBodyAt(internalIndex - natoms)->getGlobalIndex());
250 +            }
251 +        }
252 +        
253 +    }    
254 +    
255   }
256 +
257 + bool NameFinder::isInteger(const std::string str) {
258 +    for(int i =0; i < str.size(); ++i){
259 +        if (!std::isdigit(str[i])) {
260 +            return false;
261 +        }
262 +    }
263 +
264 +    return true;
265 + }
266 +
267 + }

Diff Legend

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