49 |
|
namespace oopse { |
50 |
|
|
51 |
|
|
52 |
< |
SelectionEvaluator::SelectionEvaluator(SimInfo* si) : info(si), nameFinder(info), distanceFinder(info), isLoaded_(false){ |
52 |
> |
SelectionEvaluator::SelectionEvaluator(SimInfo* si) |
53 |
> |
: info(si), nameFinder(info), distanceFinder(info), indexFinder(info), isLoaded_(false){ |
54 |
> |
|
55 |
|
nStuntDouble = info->getNGlobalAtoms() + info->getNRigidBodies(); |
56 |
|
} |
57 |
|
|
86 |
|
} |
87 |
|
|
88 |
|
void SelectionEvaluator::clearState() { |
87 |
– |
//for (int i = scriptLevelMax; --i >= 0; ) |
88 |
– |
// stack[i].clear(); |
89 |
– |
//scriptLevel = 0; |
89 |
|
error = false; |
90 |
|
errorMessage = ""; |
91 |
|
} |
101 |
|
} |
102 |
|
|
103 |
|
bool SelectionEvaluator::loadScriptFileInternal(const std::string & filename) { |
104 |
< |
ifstream ifs(filename.c_str()); |
104 |
> |
std::ifstream ifs(filename.c_str()); |
105 |
|
if (!ifs.is_open()) { |
106 |
|
return false; |
107 |
|
} |
227 |
|
compareProperty(atom, bs, property, comparator, comparisonValue); |
228 |
|
} |
229 |
|
|
231 |
– |
//change the positions of atoms which belong to the rigidbodies |
230 |
|
for (rb = mol->beginRigidBody(rbIter); rb != NULL; rb = mol->nextRigidBody(rbIter)) { |
231 |
|
compareProperty(rb, bs, property, comparator, comparisonValue); |
232 |
|
} |
236 |
|
} |
237 |
|
|
238 |
|
void SelectionEvaluator::compareProperty(StuntDouble* sd, BitSet& bs, int property, int comparator, float comparisonValue) { |
239 |
< |
double propertyValue; |
239 |
> |
double propertyValue = 0.0; |
240 |
|
switch (property) { |
241 |
|
case Token::mass: |
242 |
|
propertyValue = sd->getMass(); |
243 |
|
break; |
244 |
|
case Token::charge: |
245 |
< |
return; |
246 |
< |
//break; |
247 |
< |
case Token::dipole: |
248 |
< |
return; |
249 |
< |
//break; |
245 |
> |
if (sd->isAtom()){ |
246 |
> |
Atom* atom = static_cast<Atom*>(sd); |
247 |
> |
propertyValue = getCharge(atom); |
248 |
> |
} else if (sd->isRigidBody()) { |
249 |
> |
RigidBody* rb = static_cast<RigidBody*>(sd); |
250 |
> |
RigidBody::AtomIterator ai; |
251 |
> |
Atom* atom; |
252 |
> |
for (atom = rb->beginAtom(ai); atom != NULL; atom = rb->nextAtom(ai)) { |
253 |
> |
propertyValue+= getCharge(atom); |
254 |
> |
} |
255 |
> |
} |
256 |
> |
break; |
257 |
|
default: |
258 |
|
unrecognizedAtomProperty(property); |
259 |
|
} |
305 |
|
|
306 |
|
std::string variable = boost::any_cast<std::string>(statement[1].value); |
307 |
|
|
308 |
< |
variables.insert(std::make_pair(variable, expression(statement, 2))); |
308 |
> |
variables.insert(VariablesType::value_type(variable, expression(statement, 2))); |
309 |
|
} |
310 |
|
|
311 |
|
|
324 |
|
int tok = statement[1].tok; |
325 |
|
if (tok == Token::identifier || (tok & Token::predefinedset) == Token::predefinedset) { |
326 |
|
std::string variable = boost::any_cast<std::string>(statement[1].value); |
327 |
< |
variables.insert(std::make_pair(variable, statement)); |
327 |
> |
variables.insert(VariablesType::value_type(variable, statement)); |
328 |
|
|
329 |
|
} else { |
330 |
|
evalError("invalid variable name:" + script); |
391 |
|
BitSet SelectionEvaluator::evaluate() { |
392 |
|
BitSet bs(nStuntDouble); |
393 |
|
if (isLoaded_) { |
394 |
+ |
pc = 0; |
395 |
|
instructionDispatchLoop(bs); |
396 |
|
} |
397 |
|
|
406 |
|
if (index < 0 || index >= bs.size()) { |
407 |
|
invalidIndex(index); |
408 |
|
} else { |
409 |
< |
bs.setBitOn(index); |
409 |
> |
bs = indexFinder.find(index); |
410 |
|
} |
411 |
|
} else if (value.type() == typeid(std::pair<int, int>)) { |
412 |
|
std::pair<int, int> indexRange= boost::any_cast<std::pair<int, int> >(value); |
414 |
|
if (indexRange.first < 0 || indexRange.second >= bs.size()) { |
415 |
|
invalidIndexRange(indexRange); |
416 |
|
}else { |
417 |
< |
bs.setRangeOn(indexRange.first, indexRange.second); |
417 |
> |
bs = indexFinder.find(indexRange.first, indexRange.second); |
418 |
|
} |
419 |
|
} |
420 |
|
|
421 |
|
return bs; |
422 |
|
} |
423 |
|
|
418 |
– |
//BitSet SelectionEvaluator::evaluate(int frameNo) { |
419 |
– |
// |
420 |
– |
//} |
424 |
|
|
425 |
+ |
double SelectionEvaluator::getCharge(Atom* atom) { |
426 |
+ |
double charge =0.0; |
427 |
+ |
AtomType* atomType = atom->getAtomType(); |
428 |
+ |
if (atomType->isCharge()) { |
429 |
+ |
GenericData* data = atomType->getPropertyByName("Charge"); |
430 |
+ |
if (data != NULL) { |
431 |
+ |
DoubleGenericData* doubleData= dynamic_cast<DoubleGenericData*>(data); |
432 |
+ |
|
433 |
+ |
if (doubleData != NULL) { |
434 |
+ |
charge = doubleData->getData(); |
435 |
+ |
|
436 |
+ |
} else { |
437 |
+ |
sprintf( painCave.errMsg, |
438 |
+ |
"Can not cast GenericData to DoubleGenericData\n"); |
439 |
+ |
painCave.severity = OOPSE_ERROR; |
440 |
+ |
painCave.isFatal = 1; |
441 |
+ |
simError(); |
442 |
+ |
} |
443 |
+ |
} |
444 |
+ |
} |
445 |
+ |
|
446 |
+ |
return charge; |
447 |
|
} |
448 |
+ |
|
449 |
+ |
} |