# | Line 58 | Line 58 | |
---|---|---|
58 | #include "utils/simError.h" | |
59 | #include "utils/MemoryUtils.hpp" | |
60 | #include "utils/StringTokenizer.hpp" | |
61 | + | #include "brains/Thermo.hpp" |
62 | ||
63 | #ifdef IS_MPI | |
63 | – | |
64 | #include <mpi.h> | |
65 | < | #define TAKE_THIS_TAG_CHAR 0 |
66 | < | #define TAKE_THIS_TAG_INT 1 |
65 | > | #endif |
66 | ||
68 | – | #endif // is_mpi |
67 | ||
70 | – | |
68 | namespace OpenMD { | |
69 | ||
70 | DumpReader::DumpReader(SimInfo* info, const std::string& filename) | |
# | Line 245 | Line 242 | namespace OpenMD { | |
242 | ||
243 | if (needCOMprops_) { | |
244 | Snapshot* s = info_->getSnapshotManager()->getCurrentSnapshot(); | |
245 | + | Thermo thermo(info_); |
246 | Vector3d com; | |
249 | – | Vector3d comvel; |
250 | – | Vector3d comw; |
251 | – | if (needPos_ && needVel_){ |
252 | – | info_->getComAll(com, comvel); |
253 | – | comw = info_->getAngularMomentum(); |
254 | – | }else{ |
255 | – | com = info_->getCom(); |
256 | – | comvel = 0.0; |
257 | – | comw = 0.0; |
258 | – | } |
259 | – | s->setCOMprops(com, comvel, comw); |
260 | – | } |
247 | ||
248 | + | if (needPos_ && needVel_) { |
249 | + | Vector3d comvel; |
250 | + | Vector3d comw; |
251 | + | thermo.getComAll(com, comvel); |
252 | + | comw = thermo.getAngularMomentum(); |
253 | + | } else { |
254 | + | com = thermo.getCom(); |
255 | + | } |
256 | + | } |
257 | } | |
258 | ||
259 | void DumpReader::readSet(int whichFrame) { | |
# | Line 357 | Line 352 | namespace OpenMD { | |
352 | ||
353 | int index = tokenizer.nextTokenAsInt(); | |
354 | ||
355 | < | StuntDouble* integrableObject = info_->getIOIndexToIntegrableObject(index); |
355 | > | StuntDouble* sd = info_->getIOIndexToIntegrableObject(index); |
356 | ||
357 | < | if (integrableObject == NULL) { |
357 | > | if (sd == NULL) { |
358 | return; | |
359 | } | |
360 | std::string type = tokenizer.nextToken(); | |
# | Line 379 | Line 374 | namespace OpenMD { | |
374 | } | |
375 | } | |
376 | ||
377 | < | if (integrableObject->isDirectional()) { |
377 | > | if (sd->isDirectional()) { |
378 | if (needQuaternion_) { | |
379 | found = type.find("q"); | |
380 | if (found == std::string::npos) { | |
# | Line 402 | Line 397 | namespace OpenMD { | |
397 | pos[1] = tokenizer.nextTokenAsDouble(); | |
398 | pos[2] = tokenizer.nextTokenAsDouble(); | |
399 | if (needPos_) { | |
400 | < | integrableObject->setPos(pos); |
400 | > | sd->setPos(pos); |
401 | } | |
402 | break; | |
403 | } | |
# | Line 412 | Line 407 | namespace OpenMD { | |
407 | vel[1] = tokenizer.nextTokenAsDouble(); | |
408 | vel[2] = tokenizer.nextTokenAsDouble(); | |
409 | if (needVel_) { | |
410 | < | integrableObject->setVel(vel); |
410 | > | sd->setVel(vel); |
411 | } | |
412 | break; | |
413 | } | |
414 | ||
415 | case 'q' : { | |
416 | Quat4d q; | |
417 | < | if (integrableObject->isDirectional()) { |
417 | > | if (sd->isDirectional()) { |
418 | ||
419 | q[0] = tokenizer.nextTokenAsDouble(); | |
420 | q[1] = tokenizer.nextTokenAsDouble(); | |
# | Line 438 | Line 433 | namespace OpenMD { | |
433 | ||
434 | q.normalize(); | |
435 | if (needQuaternion_) { | |
436 | < | integrableObject->setQ(q); |
436 | > | sd->setQ(q); |
437 | } | |
438 | } | |
439 | break; | |
440 | } | |
441 | case 'j' : { | |
442 | Vector3d ji; | |
443 | < | if (integrableObject->isDirectional()) { |
443 | > | if (sd->isDirectional()) { |
444 | ji[0] = tokenizer.nextTokenAsDouble(); | |
445 | ji[1] = tokenizer.nextTokenAsDouble(); | |
446 | ji[2] = tokenizer.nextTokenAsDouble(); | |
447 | if (needAngMom_) { | |
448 | < | integrableObject->setJ(ji); |
448 | > | sd->setJ(ji); |
449 | } | |
450 | } | |
451 | break; | |
# | Line 461 | Line 456 | namespace OpenMD { | |
456 | force[0] = tokenizer.nextTokenAsDouble(); | |
457 | force[1] = tokenizer.nextTokenAsDouble(); | |
458 | force[2] = tokenizer.nextTokenAsDouble(); | |
459 | < | integrableObject->setFrc(force); |
459 | > | sd->setFrc(force); |
460 | break; | |
461 | } | |
462 | case 't' : { | |
# | Line 470 | Line 465 | namespace OpenMD { | |
465 | torque[0] = tokenizer.nextTokenAsDouble(); | |
466 | torque[1] = tokenizer.nextTokenAsDouble(); | |
467 | torque[2] = tokenizer.nextTokenAsDouble(); | |
468 | < | integrableObject->setTrq(torque); |
468 | > | sd->setTrq(torque); |
469 | break; | |
470 | } | |
471 | case 'u' : { | |
472 | ||
473 | RealType particlePot; | |
474 | particlePot = tokenizer.nextTokenAsDouble(); | |
475 | < | integrableObject->setParticlePot(particlePot); |
475 | > | sd->setParticlePot(particlePot); |
476 | break; | |
477 | } | |
478 | case 'c' : { | |
479 | ||
480 | RealType flucQPos; | |
481 | flucQPos = tokenizer.nextTokenAsDouble(); | |
482 | < | integrableObject->setFlucQPos(flucQPos); |
482 | > | sd->setFlucQPos(flucQPos); |
483 | break; | |
484 | } | |
485 | case 'w' : { | |
486 | ||
487 | RealType flucQVel; | |
488 | flucQVel = tokenizer.nextTokenAsDouble(); | |
489 | < | integrableObject->setFlucQVel(flucQVel); |
489 | > | sd->setFlucQVel(flucQVel); |
490 | break; | |
491 | } | |
492 | case 'g' : { | |
493 | ||
494 | RealType flucQFrc; | |
495 | flucQFrc = tokenizer.nextTokenAsDouble(); | |
496 | < | integrableObject->setFlucQFrc(flucQFrc); |
496 | > | sd->setFlucQFrc(flucQFrc); |
497 | break; | |
498 | } | |
499 | case 'e' : { | |
# | Line 507 | Line 502 | namespace OpenMD { | |
502 | eField[0] = tokenizer.nextTokenAsDouble(); | |
503 | eField[1] = tokenizer.nextTokenAsDouble(); | |
504 | eField[2] = tokenizer.nextTokenAsDouble(); | |
505 | < | integrableObject->setElectricField(eField); |
505 | > | sd->setElectricField(eField); |
506 | break; | |
507 | } | |
508 | default: { | |
# | Line 543 | Line 538 | namespace OpenMD { | |
538 | */ | |
539 | ||
540 | int index = tokenizer.nextTokenAsInt(); | |
541 | < | StuntDouble* integrableObject = info_->getIOIndexToIntegrableObject(index); |
542 | < | if (integrableObject == NULL) { |
541 | > | StuntDouble* sd = info_->getIOIndexToIntegrableObject(index); |
542 | > | if (sd == NULL) { |
543 | return; | |
544 | } | |
550 | – | StuntDouble* sd = integrableObject; |
545 | ||
546 | /** | |
547 | * Test to see if the next token is an integer or not. If not, | |
# | Line 561 | Line 555 | namespace OpenMD { | |
555 | if (i >> siteIndex) { | |
556 | // chew up this token and parse as an int: | |
557 | siteIndex = tokenizer.nextTokenAsInt(); | |
558 | < | RigidBody* rb = static_cast<RigidBody*>(integrableObject); |
558 | > | RigidBody* rb = static_cast<RigidBody*>(sd); |
559 | sd = rb->getAtoms()[siteIndex]; | |
560 | } | |
561 | ||
# | Line 714 | Line 708 | namespace OpenMD { | |
708 | hmat(2, 2) = tokenizer.nextTokenAsDouble(); | |
709 | s->setHmat(hmat); | |
710 | } else if (propertyName == "Thermostat") { | |
711 | < | RealType chi = tokenizer.nextTokenAsDouble(); |
712 | < | RealType integralOfChiDt = tokenizer.nextTokenAsDouble(); |
713 | < | s->setChi(chi); |
714 | < | s->setIntegralOfChiDt(integralOfChiDt); |
711 | > | pair<RealType, RealType> thermostat; |
712 | > | thermostat.first = tokenizer.nextTokenAsDouble(); |
713 | > | thermostat.second = tokenizer.nextTokenAsDouble(); |
714 | > | s->setThermostat(thermostat); |
715 | } else if (propertyName == "Barostat") { | |
716 | Mat3x3d eta; | |
717 | eta(0, 0) = tokenizer.nextTokenAsDouble(); | |
# | Line 729 | Line 723 | namespace OpenMD { | |
723 | eta(2, 0) = tokenizer.nextTokenAsDouble(); | |
724 | eta(2, 1) = tokenizer.nextTokenAsDouble(); | |
725 | eta(2, 2) = tokenizer.nextTokenAsDouble(); | |
726 | < | s->setEta(eta); |
726 | > | s->setBarostat(eta); |
727 | } else { | |
728 | sprintf(painCave.errMsg, | |
729 | "DumpReader Error: %s is an invalid property in <FrameData>\n", propertyName.c_str()); |
– | Removed lines |
+ | Added lines |
< | Changed lines |
> | Changed lines |