--- trunk/src/selection/SelectionManager.cpp 2005/02/12 20:09:28 317 +++ trunk/src/selection/SelectionManager.cpp 2013/12/05 18:19:26 1953 @@ -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,58 +28,207 @@ * 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, 234107 (2008). + * [4] Kuang & Gezelter, J. Chem. Phys. 133, 164101 (2010). + * [5] Vardeman, Stocker & Gezelter, J. Chem. Theory Comput. 7, 834 (2011). */ #include "selection/SelectionManager.hpp" #include "primitives/Molecule.hpp" #include "brains/SimInfo.hpp" -namespace oopse { -SelectionManager::SelectionManager(SimInfo* info) : info_(info){ +namespace OpenMD { + SelectionManager::SelectionManager(SimInfo* info) : info_(info){ + nObjects_.push_back(info_->getNGlobalAtoms()+info_->getNGlobalRigidBodies()); + nObjects_.push_back(info_->getNGlobalBonds()); + nObjects_.push_back(info_->getNGlobalBends()); + nObjects_.push_back(info_->getNGlobalTorsions()); + nObjects_.push_back(info_->getNGlobalInversions()); - int nStuntDoubles = info_->getNGlobalAtoms() + info_->getNGlobalRigidBodies(); - - bsSelection_.resize(nStuntDoubles); - stuntdoubles_.resize(nStuntDoubles); + stuntdoubles_.resize(nObjects_[STUNTDOUBLE]); + bonds_.resize(nObjects_[BOND]); + bends_.resize(nObjects_[BEND]); + torsions_.resize(nObjects_[TORSION]); + inversions_.resize(nObjects_[INVERSION]); SimInfo::MoleculeIterator mi; - Molecule* mol; Molecule::AtomIterator ai; - Atom* atom; Molecule::RigidBodyIterator rbIter; - RigidBody* rb; + Molecule::BondIterator bondIter; + Molecule::BendIterator bendIter; + Molecule::TorsionIterator torsionIter; + Molecule::InversionIterator inversionIter; - - for (mol = info_->beginMolecule(mi); mol != NULL; mol = info_->nextMolecule(mi)) { + Molecule* mol; + Atom* atom; + RigidBody* rb; + Bond* bond; + Bend* bend; + Torsion* torsion; + Inversion* inversion; - for(atom = mol->beginAtom(ai); atom != NULL; atom = mol->nextAtom(ai)) { - stuntdoubles_[atom->getGlobalIndex()] = atom; - } + for (mol = info_->beginMolecule(mi); mol != NULL; + mol = info_->nextMolecule(mi)) { + + for(atom = mol->beginAtom(ai); atom != NULL; + atom = mol->nextAtom(ai)) { + stuntdoubles_[atom->getGlobalIndex()] = atom; + } + for (rb = mol->beginRigidBody(rbIter); rb != NULL; + rb = mol->nextRigidBody(rbIter)) { + stuntdoubles_[rb->getGlobalIndex()] = rb; + } + for (bond = mol->beginBond(bondIter); bond != NULL; + bond = mol->nextBond(bondIter)) { + bonds_[bond->getGlobalIndex()] = bond; + } + for (bend = mol->beginBend(bendIter); bend != NULL; + bend = mol->nextBend(bendIter)) { + bends_[bend->getGlobalIndex()] = bend; + } + for (torsion = mol->beginTorsion(torsionIter); torsion != NULL; + torsion = mol->nextTorsion(torsionIter)) { + torsions_[torsion->getGlobalIndex()] = torsion; + } + for (inversion = mol->beginInversion(inversionIter); inversion != NULL; + inversion = mol->nextInversion(inversionIter)) { + inversions_[inversion->getGlobalIndex()] = inversion; + } + } + } - for (rb = mol->beginRigidBody(rbIter); rb != NULL; rb = mol->nextRigidBody(rbIter)) { - stuntdoubles_[rb->getGlobalIndex()] = rb; - } - - } - -} + StuntDouble* SelectionManager::beginSelected(int& i) { + i = ss_.bitsets_[STUNTDOUBLE].firstOnBit(); + return i == -1 ? NULL : stuntdoubles_[i]; + } + StuntDouble* SelectionManager::nextSelected(int& i) { + i = ss_.bitsets_[STUNTDOUBLE].nextOnBit(i); + return i == -1 ? NULL : stuntdoubles_[i]; + } -StuntDouble* SelectionManager::beginSelected(int& i) { - i = bsSelection_.firstOnBit(); + StuntDouble* SelectionManager::beginUnselected(int& i){ + i = ss_.bitsets_[STUNTDOUBLE].firstOffBit(); return i == -1 ? NULL : stuntdoubles_[i]; -} -StuntDouble* SelectionManager::nextSelected(int& i) { - i = bsSelection_.nextOnBit(i); - return i == -1 ? NULL : stuntdoubles_[i]; -} + } -StuntDouble* SelectionManager::beginUnselected(int& i) { - i = bsSelection_.firstOffBit(); + StuntDouble* SelectionManager::nextUnSelected(int& i) { + i = ss_.bitsets_[STUNTDOUBLE].nextOffBit(i); return i == -1 ? NULL : stuntdoubles_[i]; -} -StuntDouble* SelectionManager::nextUnSelected(int& i) { - i = bsSelection_.nextOffBit(i); - return i == -1 ? NULL : stuntdoubles_[i]; -} + } + Bond* SelectionManager::beginSelectedBond(int& i) { + i = ss_.bitsets_[BOND].firstOnBit(); + return i == -1 ? NULL : bonds_[i]; + } + + Bond* SelectionManager::nextSelectedBond(int& i) { + i = ss_.bitsets_[BOND].nextOnBit(i); + return i == -1 ? NULL : bonds_[i]; + } + + Bond* SelectionManager::beginUnselectedBond(int& i){ + i = ss_.bitsets_[BOND].firstOffBit(); + return i == -1 ? NULL : bonds_[i]; + } + + Bond* SelectionManager::nextUnSelectedBond(int& i) { + i = ss_.bitsets_[BOND].nextOffBit(i); + return i == -1 ? NULL : bonds_[i]; + } + + Bend* SelectionManager::beginSelectedBend(int& i) { + i = ss_.bitsets_[BEND].firstOnBit(); + return i == -1 ? NULL : bends_[i]; + } + + Bend* SelectionManager::nextSelectedBend(int& i) { + i = ss_.bitsets_[BEND].nextOnBit(i); + return i == -1 ? NULL : bends_[i]; + } + + Bend* SelectionManager::beginUnselectedBend(int& i){ + i = ss_.bitsets_[BEND].firstOffBit(); + return i == -1 ? NULL : bends_[i]; + } + + Bend* SelectionManager::nextUnSelectedBend(int& i) { + i = ss_.bitsets_[BEND].nextOffBit(i); + return i == -1 ? NULL : bends_[i]; + } + + Torsion* SelectionManager::beginSelectedTorsion(int& i) { + i = ss_.bitsets_[TORSION].firstOnBit(); + return i == -1 ? NULL : torsions_[i]; + } + + Torsion* SelectionManager::nextSelectedTorsion(int& i) { + i = ss_.bitsets_[TORSION].nextOnBit(i); + return i == -1 ? NULL : torsions_[i]; + } + + Torsion* SelectionManager::beginUnselectedTorsion(int& i){ + i = ss_.bitsets_[TORSION].firstOffBit(); + return i == -1 ? NULL : torsions_[i]; + } + + Torsion* SelectionManager::nextUnSelectedTorsion(int& i) { + i = ss_.bitsets_[TORSION].nextOffBit(i); + return i == -1 ? NULL : torsions_[i]; + } + + Inversion* SelectionManager::beginSelectedInversion(int& i) { + i = ss_.bitsets_[INVERSION].firstOnBit(); + return i == -1 ? NULL : inversions_[i]; + } + + Inversion* SelectionManager::nextSelectedInversion(int& i) { + i = ss_.bitsets_[INVERSION].nextOnBit(i); + return i == -1 ? NULL : inversions_[i]; + } + + Inversion* SelectionManager::beginUnselectedInversion(int& i){ + i = ss_.bitsets_[INVERSION].firstOffBit(); + return i == -1 ? NULL : inversions_[i]; + } + + Inversion* SelectionManager::nextUnSelectedInversion(int& i) { + i = ss_.bitsets_[INVERSION].nextOffBit(i); + return i == -1 ? NULL : inversions_[i]; + } + + SelectionManager operator| (const SelectionManager& sman1, + const SelectionManager& sman2) { + SelectionManager result(sman1); + result |= sman2; + return result; + } + + SelectionManager operator& (const SelectionManager& sman1, + const SelectionManager& sman2) { + SelectionManager result(sman1); + result &= sman2; + return result; + } + + SelectionManager operator^ (const SelectionManager& sman1, + const SelectionManager& sman2) { + SelectionManager result(sman1); + result ^= sman2; + return result; + } + + SelectionManager operator-(const SelectionManager& sman1, + const SelectionManager& sman2){ + SelectionManager result(sman1); + result -= sman2; + return result; + } + }