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 2204 by gezelter, Fri Apr 15 22:04:00 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) {
49 <    loadNames();
50 < }
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  
50 – void NameFinder::loadNames() {
62  
63 <    root_ = new NameNode;
64 <    root_.type = rootNode;
63 >  NameFinder::~NameFinder(){
64 >    delete root_;
65 >  }
66  
67 <    NameNode* newNode;            
67 >  void NameFinder::loadNames() {
68 >
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());
88 <        }
86 >      for(atom = mol->beginAtom(ai); atom != NULL; atom = mol->nextAtom(ai)) {
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 >
94 >      for (rb = mol->beginRigidBody(rbIter); rb != NULL; rb = mol->nextRigidBody(rbIter)) {
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          
71 –        //change the positions of atoms which belong to the rigidbodies
72 –        for (rb = mol->beginRigidBody(rbIter); rb != NULL; rb = mol->nextRigidBody(rbIter)) {
73 –            rbNames_.insert(rb->getType());
74 –        }        
111      }    
76 – }
112  
113 < bool NameFinder::match(const std::string& name, BitSet& bs){
113 >  }
114  
115 <    bool error = true;
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 >  BitSet NameFinder::match(const std::string& name){
131 >    BitSet bs(nStuntDouble_);
132 >  
133      StringTokenizer tokenizer(name, ".");
134  
135      std::vector<std::string> names;
136      while(tokenizer.hasMoreTokens()) {
137 <        names.push_back(tokenizer.nextToken());
137 >      names.push_back(tokenizer.nextToken());
138      }
139  
140      int size = names.size();
141      switch(size) {
142 <        case 1 :
143 <            //could be molecule name, atom name, rigidbody name
144 <            isMolName();
145 <            isAtomName();
94 <            isRigidBodyName();
95 <            break;
96 <        case 2:
97 <            //could be molecule.*(include atoms and rigidbodies) or rigidbody.*
98 <            break;
99 <        case 3:
100 <            //must be molecule.rigidbody.*
142 >    case 1 :
143 >      //could be molecule name, atom name and rigidbody name
144 >      matchMolecule(names[0], bs);
145 >      matchStuntDouble("*", names[0], bs);
146              
147 <            break;
148 <        default:            
149 <            break;          
147 >      break;
148 >    case 2:
149 >      //could be molecule.*(include atoms and rigidbodies) or rigidbody.*(atoms belong to rigidbody)
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);
167 >      break;
168 >    default:      
169 >      std::cerr << "invalid name: " << name << std::endl;
170 >      break;          
171      }
172  
173 <    return matched;
174 < }
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;
181 +    }    
182 +  }
183 +
184 +  void NameFinder::matchStuntDouble(const std::string& molName, const std::string& sdName, BitSet& bs){
185 +    std::vector<TreeNode*> molNodes = getMatchedChildren(root_, molName);            
186 +    std::vector<TreeNode*>::iterator i;
187 +    for( i = molNodes.begin(); i != molNodes.end(); ++i ) {
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;
192 +      }
193 +    }
194 +
195 +  }
196 +
197 +  void NameFinder::matchRigidAtoms(const std::string& molName, const std::string& rbName, const std::string& rbAtomName, BitSet& bs){
198 +    std::vector<TreeNode*> molNodes = getMatchedChildren(root_, molName);            
199 +    std::vector<TreeNode*>::iterator i;
200 +    for( i = molNodes.begin(); i != molNodes.end(); ++i ) {
201 +      std::vector<TreeNode*> rbNodes = getMatchedChildren(*i, rbName);  
202 +      std::vector<TreeNode*>::iterator j;
203 +      for (j = rbNodes.begin(); j != rbNodes.end(); ++j) {
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;
208 +        }
209 +      }
210 +    }
211 +
212 +  }
213 +
214 +
215 +  std::vector<TreeNode*> NameFinder::getMatchedChildren(TreeNode* node, const std::string& name) {
216 +    std::vector<TreeNode*> matchedNodes;
217 +    std::map<std::string, TreeNode*>::iterator i;
218 +    for (i = node->children.begin(); i != node->children.end(); ++i) {
219 +      if (isMatched( i->first, name)) {
220 +        matchedNodes.push_back(i->second);
221 +      }
222 +    }
223 +
224 +    return matchedNodes;
225 +  }
226 +
227 +  bool NameFinder::isMatched(const std::string& str, const std::string& wildcard) {
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