--- trunk/src/brains/ForceManager.cpp 2005/11/16 23:10:02 749 +++ trunk/src/brains/ForceManager.cpp 2011/08/12 14:37:25 1610 @@ -6,19 +6,10 @@ * redistribute this software in source and binary code form, provided * that the following conditions are met: * - * 1. Acknowledgement of the program authors must be made in any - * publication of scientific results based in part on use of the - * program. An acceptable form of acknowledgement is citation of - * the article in which the program was described (Matthew - * A. Meineke, Charles F. Vardeman II, Teng Lin, Christopher - * J. Fennell and J. Daniel Gezelter, "OOPSE: An Object-Oriented - * Parallel Simulation Engine for Molecular Dynamics," - * J. Comput. Chem. 26, pp. 252-271 (2005)) - * - * 2. Redistributions of source code must retain the above copyright + * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * - * 3. Redistributions in binary form must reproduce the above copyright + * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the * distribution. @@ -37,6 +28,15 @@ * arising out of the use of or inability to use software, even if the * University of Notre Dame has been advised of the possibility of * such damages. + * + * SUPPORT OPEN SCIENCE! If you use OpenMD or its source code in your + * research, please cite the appropriate papers when you publish your + * work. Good starting points are: + * + * [1] Meineke, et al., J. Comp. Chem. 26, 252-271 (2005). + * [2] Fennell & Gezelter, J. Chem. Phys. 124, 234104 (2006). + * [3] Sun, Lin & Gezelter, J. Chem. Phys. 128, 24107 (2008). + * [4] Vardeman & Gezelter, in progress (2009). */ /** @@ -50,77 +50,31 @@ #include "brains/ForceManager.hpp" #include "primitives/Molecule.hpp" #include "UseTheForce/doForces_interface.h" -#define __C +#define __OPENMD_C #include "UseTheForce/DarkSide/fInteractionMap.h" #include "utils/simError.h" +#include "primitives/Bond.hpp" #include "primitives/Bend.hpp" -#include "primitives/Bend.hpp" -namespace oopse { +#include "primitives/Torsion.hpp" +#include "primitives/Inversion.hpp" +namespace OpenMD { - struct BendOrderStruct { - Bend* bend; - BendDataSet dataSet; - }; - struct TorsionOrderStruct { - Torsion* torsion; - TorsionDataSet dataSet; - }; - - bool BendSortFunctor(const BendOrderStruct& b1, const BendOrderStruct& b2) { - return b1.dataSet.deltaV < b2.dataSet.deltaV; - } - - bool TorsionSortFunctor(const TorsionOrderStruct& t1, const TorsionOrderStruct& t2) { - return t1.dataSet.deltaV < t2.dataSet.deltaV; - } - - void ForceManager::calcForces(bool needPotential, bool needStress) { - + void ForceManager::calcForces() { + if (!info_->isFortranInitialized()) { info_->update(); } - + preCalculation(); calcShortRangeInteraction(); - calcLongRangeInteraction(needPotential, needStress); + calcLongRangeInteraction(); postCalculation(); - - std::vector bendOrderStruct; - for(std::map::iterator i = bendDataSets.begin(); i != bendDataSets.end(); ++i) { - BendOrderStruct tmp; - tmp.bend= const_cast(i->first); - tmp.dataSet = i->second; - bendOrderStruct.push_back(tmp); - } - - std::vector torsionOrderStruct; - for(std::map::iterator j = torsionDataSets.begin(); j != torsionDataSets.end(); ++j) { - TorsionOrderStruct tmp; - tmp.torsion = const_cast(j->first); - tmp.dataSet = j->second; - torsionOrderStruct.push_back(tmp); - } - std::sort(bendOrderStruct.begin(), bendOrderStruct.end(), std::ptr_fun(BendSortFunctor)); - std::sort(torsionOrderStruct.begin(), torsionOrderStruct.end(), std::ptr_fun(TorsionSortFunctor)); - std::cout << "bend" << std::endl; - for (std::vector::iterator k = bendOrderStruct.begin(); k != bendOrderStruct.end(); ++k) { - Bend* bend = k->bend; - std::cout << "atom1=" <getAtomA()->getGlobalIndex() << ",atom2 = "<< bend->getAtomB()->getGlobalIndex() << ",atom3="<getAtomC()->getGlobalIndex() << " "; - std::cout << "deltaV=" << k->dataSet.deltaV << ",p_theta=" << k->dataSet.prev.angle <<",p_pot=" << k->dataSet.prev.potential<< ",c_theta=" << k->dataSet.curr.angle << ", c_pot = " << k->dataSet.curr.potential <::iterator l = torsionOrderStruct.begin(); l != torsionOrderStruct.end(); ++l) { - Torsion* torsion = l->torsion; - std::cout << "atom1=" <getAtomA()->getGlobalIndex() << ",atom2 = "<< torsion->getAtomB()->getGlobalIndex() << ",atom3="<getAtomC()->getGlobalIndex() << ",atom4="<getAtomD()->getGlobalIndex()<< " "; - std::cout << "deltaV=" << l->dataSet.deltaV << ",p_theta=" << l->dataSet.prev.angle <<",p_pot=" << l->dataSet.prev.potential<< ",c_theta=" << l->dataSet.curr.angle << ", c_pot = " << l->dataSet.curr.potential <beginMolecule(mi); mol != NULL; mol = info_->nextMolecule(mi)) { + + for (mol = info_->beginMolecule(mi); mol != NULL; + mol = info_->nextMolecule(mi)) { for(atom = mol->beginAtom(ai); atom != NULL; atom = mol->nextAtom(ai)) { atom->zeroForcesAndTorques(); } - + //change the positions of atoms which belong to the rigidbodies - for (rb = mol->beginRigidBody(rbIter); rb != NULL; rb = mol->nextRigidBody(rbIter)) { + for (rb = mol->beginRigidBody(rbIter); rb != NULL; + rb = mol->nextRigidBody(rbIter)) { rb->zeroForcesAndTorques(); } + } + // Zero out the stress tensor + tau *= 0.0; + } - + void ForceManager::calcShortRangeInteraction() { Molecule* mol; RigidBody* rb; Bond* bond; Bend* bend; Torsion* torsion; + Inversion* inversion; SimInfo::MoleculeIterator mi; Molecule::RigidBodyIterator rbIter; Molecule::BondIterator bondIter;; Molecule::BendIterator bendIter; Molecule::TorsionIterator torsionIter; - double bondPotential = 0.0; - double bendPotential = 0.0; - double torsionPotential = 0.0; + Molecule::InversionIterator inversionIter; + RealType bondPotential = 0.0; + RealType bendPotential = 0.0; + RealType torsionPotential = 0.0; + RealType inversionPotential = 0.0; //calculate short range interactions - for (mol = info_->beginMolecule(mi); mol != NULL; mol = info_->nextMolecule(mi)) { + for (mol = info_->beginMolecule(mi); mol != NULL; + mol = info_->nextMolecule(mi)) { //change the positions of atoms which belong to the rigidbodies - for (rb = mol->beginRigidBody(rbIter); rb != NULL; rb = mol->nextRigidBody(rbIter)) { - rb->updateAtoms(); + for (rb = mol->beginRigidBody(rbIter); rb != NULL; + rb = mol->nextRigidBody(rbIter)) { + rb->updateAtoms(); } - for (bond = mol->beginBond(bondIter); bond != NULL; bond = mol->nextBond(bondIter)) { + for (bond = mol->beginBond(bondIter); bond != NULL; + bond = mol->nextBond(bondIter)) { bond->calcForce(); bondPotential += bond->getPotential(); } - //int i =0; - for (bend = mol->beginBend(bendIter); bend != NULL; bend = mol->nextBend(bendIter)) { - //std::cout << i++ << "\t"; - double angle; - bend->calcForce(angle); - double currBendPot = bend->getPotential(); - bendPotential += bend->getPotential(); - std::map::iterator i = bendDataSets.find(bend); - if (i == bendDataSets.end()) { - BendDataSet dataSet; - dataSet.prev.angle = dataSet.curr.angle = angle; - dataSet.prev.potential = dataSet.curr.potential = currBendPot; - dataSet.deltaV = 0.0; - bendDataSets.insert(std::map::value_type(bend, dataSet)); - }else { - i->second.prev.angle = i->second.curr.angle; - i->second.prev.potential = i->second.curr.potential; - i->second.curr.angle = angle; - i->second.curr.potential = currBendPot; - i->second.deltaV = fabs(i->second.curr.potential - i->second.prev.potential); - } - } - - for (torsion = mol->beginTorsion(torsionIter); torsion != NULL; torsion = mol->nextTorsion(torsionIter)) { - double angle; - torsion->calcForce(angle); - double currTorsionPot = torsion->getPotential(); - torsionPotential += torsion->getPotential(); - std::map::iterator i = torsionDataSets.find(torsion); - if (i == torsionDataSets.end()) { - TorsionDataSet dataSet; - dataSet.prev.angle = dataSet.curr.angle = angle; - dataSet.prev.potential = dataSet.curr.potential = currTorsionPot; - dataSet.deltaV = 0.0; - torsionDataSets.insert(std::map::value_type(torsion, dataSet)); - }else { - i->second.prev.angle = i->second.curr.angle; - i->second.prev.potential = i->second.curr.potential; - i->second.curr.angle = angle; - i->second.curr.potential = currTorsionPot; - i->second.deltaV = fabs(i->second.curr.potential - i->second.prev.potential); - } + for (bend = mol->beginBend(bendIter); bend != NULL; + bend = mol->nextBend(bendIter)) { + + RealType angle; + bend->calcForce(angle); + RealType currBendPot = bend->getPotential(); + + bendPotential += bend->getPotential(); + std::map::iterator i = bendDataSets.find(bend); + if (i == bendDataSets.end()) { + BendDataSet dataSet; + dataSet.prev.angle = dataSet.curr.angle = angle; + dataSet.prev.potential = dataSet.curr.potential = currBendPot; + dataSet.deltaV = 0.0; + bendDataSets.insert(std::map::value_type(bend, dataSet)); + }else { + i->second.prev.angle = i->second.curr.angle; + i->second.prev.potential = i->second.curr.potential; + i->second.curr.angle = angle; + i->second.curr.potential = currBendPot; + i->second.deltaV = fabs(i->second.curr.potential - + i->second.prev.potential); + } } + + for (torsion = mol->beginTorsion(torsionIter); torsion != NULL; + torsion = mol->nextTorsion(torsionIter)) { + RealType angle; + torsion->calcForce(angle); + RealType currTorsionPot = torsion->getPotential(); + torsionPotential += torsion->getPotential(); + std::map::iterator i = torsionDataSets.find(torsion); + if (i == torsionDataSets.end()) { + TorsionDataSet dataSet; + dataSet.prev.angle = dataSet.curr.angle = angle; + dataSet.prev.potential = dataSet.curr.potential = currTorsionPot; + dataSet.deltaV = 0.0; + torsionDataSets.insert(std::map::value_type(torsion, dataSet)); + }else { + i->second.prev.angle = i->second.curr.angle; + i->second.prev.potential = i->second.curr.potential; + i->second.curr.angle = angle; + i->second.curr.potential = currTorsionPot; + i->second.deltaV = fabs(i->second.curr.potential - + i->second.prev.potential); + } + } + for (inversion = mol->beginInversion(inversionIter); + inversion != NULL; + inversion = mol->nextInversion(inversionIter)) { + RealType angle; + inversion->calcForce(angle); + RealType currInversionPot = inversion->getPotential(); + inversionPotential += inversion->getPotential(); + std::map::iterator i = inversionDataSets.find(inversion); + if (i == inversionDataSets.end()) { + InversionDataSet dataSet; + dataSet.prev.angle = dataSet.curr.angle = angle; + dataSet.prev.potential = dataSet.curr.potential = currInversionPot; + dataSet.deltaV = 0.0; + inversionDataSets.insert(std::map::value_type(inversion, dataSet)); + }else { + i->second.prev.angle = i->second.curr.angle; + i->second.prev.potential = i->second.curr.potential; + i->second.curr.angle = angle; + i->second.curr.potential = currInversionPot; + i->second.deltaV = fabs(i->second.curr.potential - + i->second.prev.potential); + } + } } - double shortRangePotential = bondPotential + bendPotential + torsionPotential; + RealType shortRangePotential = bondPotential + bendPotential + + torsionPotential + inversionPotential; Snapshot* curSnapshot = info_->getSnapshotManager()->getCurrentSnapshot(); curSnapshot->statData[Stats::SHORT_RANGE_POTENTIAL] = shortRangePotential; curSnapshot->statData[Stats::BOND_POTENTIAL] = bondPotential; curSnapshot->statData[Stats::BEND_POTENTIAL] = bendPotential; curSnapshot->statData[Stats::DIHEDRAL_POTENTIAL] = torsionPotential; + curSnapshot->statData[Stats::INVERSION_POTENTIAL] = inversionPotential; } - - void ForceManager::calcLongRangeInteraction(bool needPotential, bool needStress) { + + void ForceManager::calcLongRangeInteraction() { Snapshot* curSnapshot; DataStorage* config; - double* frc; - double* pos; - double* trq; - double* A; - double* electroFrame; - double* rc; + RealType* frc; + RealType* pos; + RealType* trq; + RealType* A; + RealType* electroFrame; + RealType* rc; + RealType* particlePot; //get current snapshot from SimInfo curSnapshot = info_->getSnapshotManager()->getCurrentSnapshot(); - + //get array pointers config = &(curSnapshot->atomData); frc = config->getArrayPointer(DataStorage::dslForce); @@ -247,6 +244,7 @@ namespace oopse { trq = config->getArrayPointer(DataStorage::dslTorque); A = config->getArrayPointer(DataStorage::dslAmat); electroFrame = config->getArrayPointer(DataStorage::dslElectroFrame); + particlePot = config->getArrayPointer(DataStorage::dslParticlePot); //calculate the center of mass of cutoff group SimInfo::MoleculeIterator mi; @@ -255,11 +253,13 @@ namespace oopse { CutoffGroup* cg; Vector3d com; std::vector rcGroup; - + if(info_->getNCutoffGroups() > 0){ - - for (mol = info_->beginMolecule(mi); mol != NULL; mol = info_->nextMolecule(mi)) { - for(cg = mol->beginCutoffGroup(ci); cg != NULL; cg = mol->nextCutoffGroup(ci)) { + + for (mol = info_->beginMolecule(mi); mol != NULL; + mol = info_->nextMolecule(mi)) { + for(cg = mol->beginCutoffGroup(ci); cg != NULL; + cg = mol->nextCutoffGroup(ci)) { cg->getCOM(com); rcGroup.push_back(com); } @@ -267,35 +267,32 @@ namespace oopse { rc = rcGroup[0].getArrayPointer(); } else { - // center of mass of the group is the same as position of the atom if cutoff group does not exist + // center of mass of the group is the same as position of the atom + // if cutoff group does not exist rc = pos; } - - //initialize data before passing to fortran - double longRangePotential[LR_POT_TYPES]; - double lrPot = 0.0; - Mat3x3d tau; - short int passedCalcPot = needPotential; - short int passedCalcStress = needStress; + //initialize data before passing to fortran + RealType longRangePotential[LR_POT_TYPES]; + RealType lrPot = 0.0; + Vector3d totalDipole; int isError = 0; for (int i=0; igetCalcBoxDipole()){ + getAccumulatedBoxDipole(totalDipole.getArrayPointer()); + + curSnapshot->statData[Stats::BOX_DIPOLE_X] = totalDipole(0); + curSnapshot->statData[Stats::BOX_DIPOLE_Y] = totalDipole(1); + curSnapshot->statData[Stats::BOX_DIPOLE_Z] = totalDipole(2); + } + //store the tau and long range potential curSnapshot->statData[Stats::LONG_RANGE_POTENTIAL] = lrPot; curSnapshot->statData[Stats::VANDERWAALS_POTENTIAL] = longRangePotential[VDW_POT]; curSnapshot->statData[Stats::ELECTROSTATIC_POTENTIAL] = longRangePotential[ELECTROSTATIC_POT]; - - curSnapshot->statData.setTau(tau); } - + void ForceManager::postCalculation() { SimInfo::MoleculeIterator mi; Molecule* mol; Molecule::RigidBodyIterator rbIter; RigidBody* rb; + Snapshot* curSnapshot = info_->getSnapshotManager()->getCurrentSnapshot(); // collect the atomic forces onto rigid bodies - for (mol = info_->beginMolecule(mi); mol != NULL; mol = info_->nextMolecule(mi)) { - for (rb = mol->beginRigidBody(rbIter); rb != NULL; rb = mol->nextRigidBody(rbIter)) { - rb->calcForcesAndTorques(); + + for (mol = info_->beginMolecule(mi); mol != NULL; + mol = info_->nextMolecule(mi)) { + for (rb = mol->beginRigidBody(rbIter); rb != NULL; + rb = mol->nextRigidBody(rbIter)) { + Mat3x3d rbTau = rb->calcForcesAndTorquesAndVirial(); + tau += rbTau; } } - + +#ifdef IS_MPI + Mat3x3d tmpTau(tau); + MPI_Allreduce(tmpTau.getArrayPointer(), tau.getArrayPointer(), + 9, MPI_REALTYPE, MPI_SUM, MPI_COMM_WORLD); +#endif + curSnapshot->statData.setTau(tau); } -} //end namespace oopse +} //end namespace OpenMD