# | 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 78 | Line 75 | namespace OpenMD { | |
75 | if (worldRank == 0) { | |
76 | #endif | |
77 | ||
78 | < | inFile_ = new std::ifstream(filename_.c_str()); |
78 | > | inFile_ = new std::ifstream(filename_.c_str(), |
79 | > | ifstream::in | ifstream::binary); |
80 | ||
81 | if (inFile_->fail()) { | |
82 | sprintf(painCave.errMsg, | |
# | Line 143 | Line 141 | namespace OpenMD { | |
141 | prevPos = currPos; | |
142 | bool foundOpenSnapshotTag = false; | |
143 | bool foundClosedSnapshotTag = false; | |
144 | < | bool foundOpenSiteDataTag = false; |
144 | > | |
145 | while(inFile_->getline(buffer, bufferSize)) { | |
146 | ++lineNo; | |
147 | ||
# | Line 204 | Line 202 | namespace OpenMD { | |
202 | #ifdef IS_MPI | |
203 | } | |
204 | ||
205 | < | MPI_Bcast(&nframes_, 1, MPI_INT, 0, MPI_COMM_WORLD); |
205 | > | MPI::COMM_WORLD.Bcast(&nframes_, 1, MPI::INT, 0); |
206 | ||
207 | #endif // is_mpi | |
208 | ||
# | Line 229 | Line 227 | namespace OpenMD { | |
227 | needVel_ = false; | |
228 | } | |
229 | ||
230 | < | if (storageLayout & DataStorage::dslAmat || storageLayout & DataStorage::dslElectroFrame) { |
230 | > | if (storageLayout & DataStorage::dslAmat || |
231 | > | storageLayout & DataStorage::dslDipole || |
232 | > | storageLayout & DataStorage::dslQuadrupole) { |
233 | needQuaternion_ = true; | |
234 | } else { | |
235 | needQuaternion_ = false; | |
# | Line 245 | Line 245 | namespace OpenMD { | |
245 | ||
246 | if (needCOMprops_) { | |
247 | Snapshot* s = info_->getSnapshotManager()->getCurrentSnapshot(); | |
248 | + | Thermo thermo(info_); |
249 | Vector3d com; | |
250 | < | Vector3d comvel; |
251 | < | Vector3d comw; |
252 | < | if (needPos_ && needVel_){ |
253 | < | info_->getComAll(com, comvel); |
254 | < | comw = info_->getAngularMomentum(); |
255 | < | }else{ |
256 | < | com = info_->getCom(); |
257 | < | comvel = 0.0; |
258 | < | comw = 0.0; |
258 | < | } |
259 | < | s->setCOMprops(com, comvel, comw); |
250 | > | |
251 | > | if (needPos_ && needVel_) { |
252 | > | Vector3d comvel; |
253 | > | Vector3d comw; |
254 | > | thermo.getComAll(com, comvel); |
255 | > | comw = thermo.getAngularMomentum(); |
256 | > | } else { |
257 | > | com = thermo.getCom(); |
258 | > | } |
259 | } | |
261 | – | |
260 | } | |
261 | ||
262 | void DumpReader::readSet(int whichFrame) { | |
# | Line 290 | Line 288 | namespace OpenMD { | |
288 | } | |
289 | ||
290 | int sendBufferSize = sendBuffer.size(); | |
291 | < | MPI_Bcast(&sendBufferSize, 1, MPI_INT, masterNode, MPI_COMM_WORLD); |
292 | < | MPI_Bcast((void *)sendBuffer.c_str(), sendBufferSize, MPI_CHAR, masterNode, MPI_COMM_WORLD); |
291 | > | MPI::COMM_WORLD.Bcast(&sendBufferSize, 1, MPI::INT, masterNode); |
292 | > | MPI::COMM_WORLD.Bcast((void *)sendBuffer.c_str(), sendBufferSize, |
293 | > | MPI::CHAR, masterNode); |
294 | ||
295 | sstream.str(sendBuffer); | |
296 | } else { | |
297 | int sendBufferSize; | |
298 | < | MPI_Bcast(&sendBufferSize, 1, MPI_INT, masterNode, MPI_COMM_WORLD); |
298 | > | MPI::COMM_WORLD.Bcast(&sendBufferSize, 1, MPI::INT, masterNode); |
299 | char * recvBuffer = new char[sendBufferSize+1]; | |
300 | assert(recvBuffer); | |
301 | recvBuffer[sendBufferSize] = '\0'; | |
302 | < | MPI_Bcast(recvBuffer, sendBufferSize, MPI_CHAR, masterNode, MPI_COMM_WORLD); |
302 | > | MPI::COMM_WORLD.Bcast(recvBuffer, sendBufferSize, MPI::CHAR, masterNode); |
303 | sstream.str(recvBuffer); | |
304 | delete [] recvBuffer; | |
305 | } | |
# | Line 357 | Line 356 | namespace OpenMD { | |
356 | ||
357 | int index = tokenizer.nextTokenAsInt(); | |
358 | ||
359 | < | StuntDouble* integrableObject = info_->getIOIndexToIntegrableObject(index); |
359 | > | StuntDouble* sd = info_->getIOIndexToIntegrableObject(index); |
360 | ||
361 | < | if (integrableObject == NULL) { |
361 | > | if (sd == NULL) { |
362 | return; | |
363 | } | |
364 | std::string type = tokenizer.nextToken(); | |
# | Line 379 | Line 378 | namespace OpenMD { | |
378 | } | |
379 | } | |
380 | ||
381 | < | if (integrableObject->isDirectional()) { |
381 | > | if (sd->isDirectional()) { |
382 | if (needQuaternion_) { | |
383 | found = type.find("q"); | |
384 | if (found == std::string::npos) { | |
# | Line 402 | Line 401 | namespace OpenMD { | |
401 | pos[1] = tokenizer.nextTokenAsDouble(); | |
402 | pos[2] = tokenizer.nextTokenAsDouble(); | |
403 | if (needPos_) { | |
404 | < | integrableObject->setPos(pos); |
404 | > | sd->setPos(pos); |
405 | } | |
406 | break; | |
407 | } | |
# | Line 412 | Line 411 | namespace OpenMD { | |
411 | vel[1] = tokenizer.nextTokenAsDouble(); | |
412 | vel[2] = tokenizer.nextTokenAsDouble(); | |
413 | if (needVel_) { | |
414 | < | integrableObject->setVel(vel); |
414 | > | sd->setVel(vel); |
415 | } | |
416 | break; | |
417 | } | |
418 | ||
419 | case 'q' : { | |
420 | Quat4d q; | |
421 | < | if (integrableObject->isDirectional()) { |
421 | > | if (sd->isDirectional()) { |
422 | ||
423 | q[0] = tokenizer.nextTokenAsDouble(); | |
424 | q[1] = tokenizer.nextTokenAsDouble(); | |
# | Line 438 | Line 437 | namespace OpenMD { | |
437 | ||
438 | q.normalize(); | |
439 | if (needQuaternion_) { | |
440 | < | integrableObject->setQ(q); |
440 | > | sd->setQ(q); |
441 | } | |
442 | } | |
443 | break; | |
444 | } | |
445 | case 'j' : { | |
446 | Vector3d ji; | |
447 | < | if (integrableObject->isDirectional()) { |
447 | > | if (sd->isDirectional()) { |
448 | ji[0] = tokenizer.nextTokenAsDouble(); | |
449 | ji[1] = tokenizer.nextTokenAsDouble(); | |
450 | ji[2] = tokenizer.nextTokenAsDouble(); | |
451 | if (needAngMom_) { | |
452 | < | integrableObject->setJ(ji); |
452 | > | sd->setJ(ji); |
453 | } | |
454 | } | |
455 | break; | |
# | Line 461 | Line 460 | namespace OpenMD { | |
460 | force[0] = tokenizer.nextTokenAsDouble(); | |
461 | force[1] = tokenizer.nextTokenAsDouble(); | |
462 | force[2] = tokenizer.nextTokenAsDouble(); | |
463 | < | integrableObject->setFrc(force); |
463 | > | sd->setFrc(force); |
464 | break; | |
465 | } | |
466 | case 't' : { | |
# | Line 470 | Line 469 | namespace OpenMD { | |
469 | torque[0] = tokenizer.nextTokenAsDouble(); | |
470 | torque[1] = tokenizer.nextTokenAsDouble(); | |
471 | torque[2] = tokenizer.nextTokenAsDouble(); | |
472 | < | integrableObject->setTrq(torque); |
472 | > | sd->setTrq(torque); |
473 | break; | |
474 | } | |
475 | case 'u' : { | |
476 | ||
477 | RealType particlePot; | |
478 | particlePot = tokenizer.nextTokenAsDouble(); | |
479 | < | integrableObject->setParticlePot(particlePot); |
479 | > | sd->setParticlePot(particlePot); |
480 | break; | |
481 | } | |
482 | case 'c' : { | |
483 | ||
484 | RealType flucQPos; | |
485 | flucQPos = tokenizer.nextTokenAsDouble(); | |
486 | < | integrableObject->setFlucQPos(flucQPos); |
486 | > | sd->setFlucQPos(flucQPos); |
487 | break; | |
488 | } | |
489 | case 'w' : { | |
490 | ||
491 | RealType flucQVel; | |
492 | flucQVel = tokenizer.nextTokenAsDouble(); | |
493 | < | integrableObject->setFlucQVel(flucQVel); |
493 | > | sd->setFlucQVel(flucQVel); |
494 | break; | |
495 | } | |
496 | case 'g' : { | |
497 | ||
498 | RealType flucQFrc; | |
499 | flucQFrc = tokenizer.nextTokenAsDouble(); | |
500 | < | integrableObject->setFlucQFrc(flucQFrc); |
500 | > | sd->setFlucQFrc(flucQFrc); |
501 | break; | |
502 | } | |
503 | case 'e' : { | |
# | Line 507 | Line 506 | namespace OpenMD { | |
506 | eField[0] = tokenizer.nextTokenAsDouble(); | |
507 | eField[1] = tokenizer.nextTokenAsDouble(); | |
508 | eField[2] = tokenizer.nextTokenAsDouble(); | |
509 | < | integrableObject->setElectricField(eField); |
509 | > | sd->setElectricField(eField); |
510 | break; | |
511 | } | |
512 | default: { | |
# | Line 543 | Line 542 | namespace OpenMD { | |
542 | */ | |
543 | ||
544 | int index = tokenizer.nextTokenAsInt(); | |
545 | < | StuntDouble* integrableObject = info_->getIOIndexToIntegrableObject(index); |
546 | < | if (integrableObject == NULL) { |
545 | > | StuntDouble* sd = info_->getIOIndexToIntegrableObject(index); |
546 | > | if (sd == NULL) { |
547 | return; | |
548 | } | |
550 | – | StuntDouble* sd = integrableObject; |
549 | ||
550 | /** | |
551 | * Test to see if the next token is an integer or not. If not, | |
# | Line 561 | Line 559 | namespace OpenMD { | |
559 | if (i >> siteIndex) { | |
560 | // chew up this token and parse as an int: | |
561 | siteIndex = tokenizer.nextTokenAsInt(); | |
562 | < | RigidBody* rb = static_cast<RigidBody*>(integrableObject); |
562 | > | RigidBody* rb = static_cast<RigidBody*>(sd); |
563 | sd = rb->getAtoms()[siteIndex]; | |
564 | } | |
565 | ||
# | Line 714 | Line 712 | namespace OpenMD { | |
712 | hmat(2, 2) = tokenizer.nextTokenAsDouble(); | |
713 | s->setHmat(hmat); | |
714 | } else if (propertyName == "Thermostat") { | |
715 | < | RealType chi = tokenizer.nextTokenAsDouble(); |
716 | < | RealType integralOfChiDt = tokenizer.nextTokenAsDouble(); |
717 | < | s->setChi(chi); |
718 | < | s->setIntegralOfChiDt(integralOfChiDt); |
715 | > | pair<RealType, RealType> thermostat; |
716 | > | thermostat.first = tokenizer.nextTokenAsDouble(); |
717 | > | thermostat.second = tokenizer.nextTokenAsDouble(); |
718 | > | s->setThermostat(thermostat); |
719 | } else if (propertyName == "Barostat") { | |
720 | Mat3x3d eta; | |
721 | eta(0, 0) = tokenizer.nextTokenAsDouble(); | |
# | Line 729 | Line 727 | namespace OpenMD { | |
727 | eta(2, 0) = tokenizer.nextTokenAsDouble(); | |
728 | eta(2, 1) = tokenizer.nextTokenAsDouble(); | |
729 | eta(2, 2) = tokenizer.nextTokenAsDouble(); | |
730 | < | s->setEta(eta); |
730 | > | s->setBarostat(eta); |
731 | } else { | |
732 | sprintf(painCave.errMsg, | |
733 | "DumpReader Error: %s is an invalid property in <FrameData>\n", propertyName.c_str()); |
– | Removed lines |
+ | Added lines |
< | Changed lines |
> | Changed lines |