--- trunk/src/brains/MoleculeCreator.cpp 2005/03/08 21:06:49 403 +++ trunk/src/brains/MoleculeCreator.cpp 2009/11/25 20:02:06 1390 @@ -1,4 +1,4 @@ - /* +/* * Copyright (c) 2005 The University of Notre Dame. All Rights Reserved. * * The University of Notre Dame grants you ("Licensee") a @@ -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,17 +28,27 @@ * 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). */ - /** - * @file MoleculeCreator.cpp - * @author tlin - * @date 11/04/2004 - * @time 13:44am - * @version 1.0 - */ +/** + * @file MoleculeCreator.cpp + * @author tlin + * @date 11/04/2004 + * @time 13:44am + * @version 1.0 + */ #include +#include #include #include "brains/MoleculeCreator.hpp" @@ -58,21 +59,22 @@ #include "utils/simError.h" #include "utils/StringUtils.hpp" -namespace oopse { - -Molecule* MoleculeCreator::createMolecule(ForceField* ff, MoleculeStamp *molStamp, - int stampId, int globalIndex, LocalIndexManager* localIndexMan) { - - Molecule* mol = new Molecule(stampId, globalIndex, molStamp->getID()); +namespace OpenMD { + + Molecule* MoleculeCreator::createMolecule(ForceField* ff, + MoleculeStamp *molStamp, + int stampId, int globalIndex, + LocalIndexManager* localIndexMan) { + Molecule* mol = new Molecule(stampId, globalIndex, molStamp->getName()); //create atoms Atom* atom; AtomStamp* currentAtomStamp; int nAtom = molStamp->getNAtoms(); for (int i = 0; i < nAtom; ++i) { - currentAtomStamp = molStamp->getAtom(i); - atom = createAtom(ff, mol, currentAtomStamp, localIndexMan); - mol->addAtom(atom); + currentAtomStamp = molStamp->getAtomStamp(i); + atom = createAtom(ff, mol, currentAtomStamp, localIndexMan); + mol->addAtom(atom); } //create rigidbodies @@ -81,20 +83,21 @@ Molecule* MoleculeCreator::createMolecule(ForceField* int nRigidbodies = molStamp->getNRigidBodies(); for (int i = 0; i < nRigidbodies; ++i) { - currentRigidBodyStamp = molStamp->getRigidBody(i); - rb = createRigidBody(molStamp, mol, currentRigidBodyStamp, localIndexMan); - mol->addRigidBody(rb); + currentRigidBodyStamp = molStamp->getRigidBodyStamp(i); + rb = createRigidBody(molStamp, mol, currentRigidBodyStamp, + localIndexMan); + mol->addRigidBody(rb); } - + //create bonds Bond* bond; BondStamp* currentBondStamp; int nBonds = molStamp->getNBonds(); for (int i = 0; i < nBonds; ++i) { - currentBondStamp = molStamp->getBond(i); - bond = createBond(ff, mol, currentBondStamp); - mol->addBond(bond); + currentBondStamp = molStamp->getBondStamp(i); + bond = createBond(ff, mol, currentBondStamp); + mol->addBond(bond); } //create bends @@ -102,9 +105,9 @@ Molecule* MoleculeCreator::createMolecule(ForceField* BendStamp* currentBendStamp; int nBends = molStamp->getNBends(); for (int i = 0; i < nBends; ++i) { - currentBendStamp = molStamp->getBend(i); - bend = createBend(ff, mol, currentBendStamp); - mol->addBend(bend); + currentBendStamp = molStamp->getBendStamp(i); + bend = createBend(ff, mol, currentBendStamp); + mol->addBend(bend); } //create torsions @@ -112,65 +115,62 @@ Molecule* MoleculeCreator::createMolecule(ForceField* TorsionStamp* currentTorsionStamp; int nTorsions = molStamp->getNTorsions(); for (int i = 0; i < nTorsions; ++i) { - currentTorsionStamp = molStamp->getTorsion(i); - torsion = createTorsion(ff, mol, currentTorsionStamp); - mol->addTorsion(torsion); + currentTorsionStamp = molStamp->getTorsionStamp(i); + torsion = createTorsion(ff, mol, currentTorsionStamp); + mol->addTorsion(torsion); } + //create inversions + Inversion* inversion; + InversionStamp* currentInversionStamp; + int nInversions = molStamp->getNInversions(); + for (int i = 0; i < nInversions; ++i) { + currentInversionStamp = molStamp->getInversionStamp(i); + inversion = createInversion(ff, mol, currentInversionStamp); + if (inversion != NULL ) { + mol->addInversion(inversion); + } + } + //create cutoffGroups CutoffGroup* cutoffGroup; CutoffGroupStamp* currentCutoffGroupStamp; int nCutoffGroups = molStamp->getNCutoffGroups(); for (int i = 0; i < nCutoffGroups; ++i) { - currentCutoffGroupStamp = molStamp->getCutoffGroup(i); - cutoffGroup = createCutoffGroup(mol, currentCutoffGroupStamp); - mol->addCutoffGroup(cutoffGroup); + currentCutoffGroupStamp = molStamp->getCutoffGroupStamp(i); + cutoffGroup = createCutoffGroup(mol, currentCutoffGroupStamp); + mol->addCutoffGroup(cutoffGroup); } //every free atom is a cutoff group - std::set allAtoms; - Molecule::AtomIterator ai; + std::vector freeAtoms; + std::vector::iterator ai; + std::vector::iterator fai; //add all atoms into allAtoms set - for(atom = mol->beginAtom(ai); atom != NULL; atom = mol->nextAtom(ai)) { - allAtoms.insert(atom); + for(atom = mol->beginAtom(fai); atom != NULL; atom = mol->nextAtom(fai)) { + freeAtoms.push_back(atom); } Molecule::CutoffGroupIterator ci; CutoffGroup* cg; - std::set cutoffAtoms; - //add all of the atoms belong to cutoff groups into cutoffAtoms set - for (cg = mol->beginCutoffGroup(ci); cg != NULL; cg = mol->nextCutoffGroup(ci)) { - - for(atom = cg->beginAtom(ai); atom != NULL; atom = cg->nextAtom(ai)) { - cutoffAtoms.insert(atom); - } - + for (cg = mol->beginCutoffGroup(ci); cg != NULL; + cg = mol->nextCutoffGroup(ci)) { + + for(atom = cg->beginAtom(ai); atom != NULL; atom = cg->nextAtom(ai)) { + //erase the atoms belong to cutoff groups from freeAtoms vector + freeAtoms.erase(std::remove(freeAtoms.begin(), freeAtoms.end(), atom), + freeAtoms.end()); + } } - //find all free atoms (which do not belong to cutoff groups) - //performs the "difference" operation from set theory, the output range contains a copy of every - //element that is contained in [allAtoms.begin(), allAtoms.end()) and not contained in - //[cutoffAtoms.begin(), cutoffAtoms.end()). - std::vector freeAtoms; - std::set_difference(allAtoms.begin(), allAtoms.end(), cutoffAtoms.begin(), cutoffAtoms.end(), - std::back_inserter(freeAtoms)); - - if (freeAtoms.size() != allAtoms.size() - cutoffAtoms.size()) { - //Some atoms in rigidAtoms are not in allAtoms, something must be wrong - sprintf(painCave.errMsg, "Atoms in cutoff groups are not in the atom list of the same molecule"); - - painCave.isFatal = 1; - simError(); - } - - //loop over the free atoms and then create one cutoff group for every single free atom - std::vector::iterator fai; - + // loop over the free atoms and then create one cutoff group for + // every single free atom + for (fai = freeAtoms.begin(); fai != freeAtoms.end(); ++fai) { - cutoffGroup = createCutoffGroup(mol, *fai); - mol->addCutoffGroup(cutoffGroup); + cutoffGroup = createCutoffGroup(mol, *fai); + mol->addCutoffGroup(cutoffGroup); } //create constraints createConstraintPair(mol); @@ -178,54 +178,56 @@ Molecule* MoleculeCreator::createMolecule(ForceField* //the construction of this molecule is finished mol->complete(); - + return mol; -} + } -Atom* MoleculeCreator::createAtom(ForceField* ff, Molecule* mol, AtomStamp* stamp, - LocalIndexManager* localIndexMan) { + Atom* MoleculeCreator::createAtom(ForceField* ff, Molecule* mol, + AtomStamp* stamp, + LocalIndexManager* localIndexMan) { AtomType * atomType; Atom* atom; atomType = ff->getAtomType(stamp->getType()); - + if (atomType == NULL) { - sprintf(painCave.errMsg, "Can not find Matching Atom Type for[%s]", - stamp->getType()); + sprintf(painCave.errMsg, "Can not find Matching Atom Type for[%s]", + stamp->getType().c_str()); - painCave.isFatal = 1; - simError(); + painCave.isFatal = 1; + simError(); } //below code still have some kind of hard-coding smell if (atomType->isDirectional()){ - DirectionalAtomType* dAtomType = dynamic_cast(atomType); + DirectionalAtomType* dAtomType = dynamic_cast(atomType); - if (dAtomType == NULL) { - sprintf(painCave.errMsg, "Can not cast AtomType to DirectionalAtomType"); + if (dAtomType == NULL) { + sprintf(painCave.errMsg, "Can not cast AtomType to DirectionalAtomType"); - painCave.isFatal = 1; - simError(); - } + painCave.isFatal = 1; + simError(); + } - DirectionalAtom* dAtom; - dAtom = new DirectionalAtom(dAtomType); - atom = dAtom; + DirectionalAtom* dAtom; + dAtom = new DirectionalAtom(dAtomType); + atom = dAtom; } else{ - atom = new Atom(atomType); + atom = new Atom(atomType); } atom->setLocalIndex(localIndexMan->getNextAtomIndex()); return atom; -} - -RigidBody* MoleculeCreator::createRigidBody(MoleculeStamp *molStamp, Molecule* mol, - RigidBodyStamp* rbStamp, - LocalIndexManager* localIndexMan) { + } + + RigidBody* MoleculeCreator::createRigidBody(MoleculeStamp *molStamp, + Molecule* mol, + RigidBodyStamp* rbStamp, + LocalIndexManager* localIndexMan) { Atom* atom; int nAtoms; Vector3d refCoor; @@ -234,14 +236,16 @@ RigidBody* MoleculeCreator::createRigidBody(MoleculeSt RigidBody* rb = new RigidBody(); nAtoms = rbStamp->getNMembers(); for (int i = 0; i < nAtoms; ++i) { - //rbStamp->getMember(i) return the local index of current atom inside the molecule. - //It is not the same as local index of atom which is the index of atom at DataStorage class - atom = mol->getAtomAt(rbStamp->getMember(i)); - atomStamp= molStamp->getAtom(rbStamp->getMember(i)); - rb->addAtom(atom, atomStamp); + //rbStamp->getMember(i) return the local index of current atom + //inside the molecule. It is not the same as local index of + //atom which is the index of atom at DataStorage class + atom = mol->getAtomAt(rbStamp->getMemberAt(i)); + atomStamp= molStamp->getAtomStamp(rbStamp->getMemberAt(i)); + rb->addAtom(atom, atomStamp); } - //after all of the atoms are added, we need to calculate the reference coordinates + //after all of the atoms are added, we need to calculate the + //reference coordinates rb->calcRefCoords(); //set the local index of this rigid body, global index will be set later @@ -253,188 +257,199 @@ RigidBody* MoleculeCreator::createRigidBody(MoleculeSt //The third part is the index of the rigidbody defined in meta-data file //For example, Butane_RB_0 is a valid rigid body name of butane molecule /**@todo replace itoa by lexi_cast */ - std::string s = OOPSE_itoa(mol->getNRigidBodies(), 10); + std::string s = OpenMD_itoa(mol->getNRigidBodies(), 10); rb->setType(mol->getType() + "_RB_" + s.c_str()); return rb; -} + } -Bond* MoleculeCreator::createBond(ForceField* ff, Molecule* mol, BondStamp* stamp) { + Bond* MoleculeCreator::createBond(ForceField* ff, Molecule* mol, + BondStamp* stamp) { BondType* bondType; Atom* atomA; Atom* atomB; - + atomA = mol->getAtomAt(stamp->getA()); atomB = mol->getAtomAt(stamp->getB()); - + assert( atomA && atomB); bondType = ff->getBondType(atomA->getType(), atomB->getType()); if (bondType == NULL) { - sprintf(painCave.errMsg, "Can not find Matching Bond Type for[%s, %s]", - atomA->getType().c_str(), - atomB->getType().c_str()); - - painCave.isFatal = 1; - simError(); + sprintf(painCave.errMsg, "Can not find Matching Bond Type for[%s, %s]", + atomA->getType().c_str(), + atomB->getType().c_str()); + + painCave.isFatal = 1; + simError(); } return new Bond(atomA, atomB, bondType); -} + } + + Bend* MoleculeCreator::createBend(ForceField* ff, Molecule* mol, + BendStamp* stamp) { + Bend* bend = NULL; + std::vector bendAtoms = stamp->getMembers(); + if (bendAtoms.size() == 3) { + Atom* atomA = mol->getAtomAt(bendAtoms[0]); + Atom* atomB = mol->getAtomAt(bendAtoms[1]); + Atom* atomC = mol->getAtomAt(bendAtoms[2]); + + assert( atomA && atomB && atomC); + + BendType* bendType = ff->getBendType(atomA->getType().c_str(), + atomB->getType().c_str(), + atomC->getType().c_str()); + + if (bendType == NULL) { + sprintf(painCave.errMsg, "Can not find Matching Bend Type for[%s, %s, %s]", + atomA->getType().c_str(), + atomB->getType().c_str(), + atomC->getType().c_str()); + + painCave.isFatal = 1; + simError(); + } + + bend = new Bend(atomA, atomB, atomC, bendType); + } else if ( bendAtoms.size() == 2 && stamp->haveGhostVectorSource()) { + int ghostIndex = stamp->getGhostVectorSource(); + int normalIndex = ghostIndex != bendAtoms[0] ? bendAtoms[0] : bendAtoms[1]; + Atom* normalAtom = mol->getAtomAt(normalIndex) ; + DirectionalAtom* ghostAtom = dynamic_cast(mol->getAtomAt(ghostIndex)); + if (ghostAtom == NULL) { + sprintf(painCave.errMsg, "Can not cast Atom to DirectionalAtom"); + painCave.isFatal = 1; + simError(); + } + + BendType* bendType = ff->getBendType(normalAtom->getType(), ghostAtom->getType(), "GHOST"); -Bend* MoleculeCreator::createBend(ForceField* ff, Molecule* mol, BendStamp* stamp) { - bool isGhostBend = false; - int ghostIndex; + if (bendType == NULL) { + sprintf(painCave.errMsg, "Can not find Matching Bend Type for[%s, %s, %s]", + normalAtom->getType().c_str(), + ghostAtom->getType().c_str(), + "GHOST"); + painCave.isFatal = 1; + simError(); + } + + bend = new GhostBend(normalAtom, ghostAtom, bendType); + + } - // - if (stamp->haveExtras()){ - LinkedAssign* extras = stamp->getExtras(); - LinkedAssign* currentExtra = extras; + return bend; + } - while (currentExtra != NULL){ - if (!strcmp(currentExtra->getlhs(), "ghostVectorSource")){ - switch (currentExtra->getType()){ - case 0: - ghostIndex = currentExtra->getInt(); - isGhostBend = true; - break; + Torsion* MoleculeCreator::createTorsion(ForceField* ff, Molecule* mol, + TorsionStamp* stamp) { - default: - sprintf(painCave.errMsg, - "SimSetup Error: ghostVectorSource must be an int.\n"); - painCave.isFatal = 1; - simError(); - } - } else{ - sprintf(painCave.errMsg, - "SimSetup Error: unhandled bend assignment:\n"); - painCave.isFatal = 1; - simError(); - } - currentExtra = currentExtra->getNext(); - } - + Torsion* torsion = NULL; + std::vector torsionAtoms = stamp->getMembers(); + if (torsionAtoms.size() < 3) { + return torsion; } - if (isGhostBend) { + Atom* atomA = mol->getAtomAt(torsionAtoms[0]); + Atom* atomB = mol->getAtomAt(torsionAtoms[1]); + Atom* atomC = mol->getAtomAt(torsionAtoms[2]); - int indexA = stamp->getA(); - int indexB= stamp->getB(); + if (torsionAtoms.size() == 4) { + Atom* atomD = mol->getAtomAt(torsionAtoms[3]); - assert(indexA != indexB); - - int normalIndex; - if (indexA == ghostIndex) { - normalIndex = indexB; - } else if (indexB == ghostIndex) { - normalIndex = indexA; - } + assert(atomA && atomB && atomC && atomD); - Atom* normalAtom = mol->getAtomAt(normalIndex) ; - DirectionalAtom* ghostAtom = dynamic_cast(mol->getAtomAt(ghostIndex)); - if (ghostAtom == NULL) { - sprintf(painCave.errMsg, "Can not cast Atom to DirectionalAtom"); - painCave.isFatal = 1; - simError(); - } - - BendType* bendType = ff->getBendType(normalAtom->getType(), ghostAtom->getType(), "GHOST"); - - if (bendType == NULL) { - sprintf(painCave.errMsg, "Can not find Matching Bend Type for[%s, %s, %s]", - normalAtom->getType().c_str(), - ghostAtom->getType().c_str(), - "GHOST"); - - painCave.isFatal = 1; - simError(); - } + TorsionType* torsionType = ff->getTorsionType(atomA->getType(), + atomB->getType(), + atomC->getType(), + atomD->getType()); + if (torsionType == NULL) { + sprintf(painCave.errMsg, "Can not find Matching Torsion Type for[%s, %s, %s, %s]", + atomA->getType().c_str(), + atomB->getType().c_str(), + atomC->getType().c_str(), + atomD->getType().c_str()); - return new GhostBend(normalAtom, ghostAtom, bendType); - - } else { - - Atom* atomA = mol->getAtomAt(stamp->getA()); - Atom* atomB = mol->getAtomAt(stamp->getB()); - Atom* atomC = mol->getAtomAt(stamp->getC()); - - assert( atomA && atomB && atomC); + painCave.isFatal = 1; + simError(); + } + + torsion = new Torsion(atomA, atomB, atomC, atomD, torsionType); + } + else { + + DirectionalAtom* dAtom = dynamic_cast(mol->getAtomAt(stamp->getGhostVectorSource())); + if (dAtom == NULL) { + sprintf(painCave.errMsg, "Can not cast Atom to DirectionalAtom"); + painCave.isFatal = 1; + simError(); + } + + TorsionType* torsionType = ff->getTorsionType(atomA->getType(), atomB->getType(), + atomC->getType(), "GHOST"); + + if (torsionType == NULL) { + sprintf(painCave.errMsg, "Can not find Matching Torsion Type for[%s, %s, %s, %s]", + atomA->getType().c_str(), + atomB->getType().c_str(), + atomC->getType().c_str(), + "GHOST"); - BendType* bendType = ff->getBendType(atomA->getType(), atomB->getType(), atomC->getType()); - - if (bendType == NULL) { - sprintf(painCave.errMsg, "Can not find Matching Bend Type for[%s, %s, %s]", - atomA->getType().c_str(), - atomB->getType().c_str(), - atomC->getType().c_str()); - - painCave.isFatal = 1; - simError(); - } - - return new Bend(atomA, atomB, atomC, bendType); + painCave.isFatal = 1; + simError(); + } + + torsion = new GhostTorsion(atomA, atomB, dAtom, torsionType); } -} + + return torsion; + } -Torsion* MoleculeCreator::createTorsion(ForceField* ff, Molecule* mol, TorsionStamp* stamp) { - - Atom* atomA = mol->getAtomAt(stamp->getA()); - Atom* atomB = mol->getAtomAt(stamp->getB()); - Atom* atomC = mol->getAtomAt(stamp->getC()); - Torsion* torsion; - - if (stamp->getD() != -1) { - Atom* atomD = mol->getAtomAt(stamp->getD()); - - assert(atomA && atomB && atomC && atomD); - - TorsionType* torsionType = ff->getTorsionType(atomA->getType(), atomB->getType(), - atomC->getType(), atomD->getType()); - - if (torsionType == NULL) { - sprintf(painCave.errMsg, "Can not find Matching Torsion Type for[%s, %s, %s, %s]", - atomA->getType().c_str(), - atomB->getType().c_str(), - atomC->getType().c_str(), - atomD->getType().c_str()); - - painCave.isFatal = 1; - simError(); - } - - torsion = new Torsion(atomA, atomB, atomC, atomD, torsionType); + Inversion* MoleculeCreator::createInversion(ForceField* ff, Molecule* mol, + InversionStamp* stamp) { + + Inversion* inversion = NULL; + int center = stamp->getCenter(); + std::vector satellites = stamp->getSatellites(); + if (satellites.size() != 3) { + return inversion; } - else { - DirectionalAtom* dAtom = dynamic_cast(atomC); - if (dAtom == NULL) { - sprintf(painCave.errMsg, "Can not cast Atom to DirectionalAtom"); - painCave.isFatal = 1; - simError(); - } + Atom* atomA = mol->getAtomAt(center); + Atom* atomB = mol->getAtomAt(satellites[0]); + Atom* atomC = mol->getAtomAt(satellites[1]); + Atom* atomD = mol->getAtomAt(satellites[2]); + + assert(atomA && atomB && atomC && atomD); + + InversionType* inversionType = ff->getInversionType(atomA->getType(), + atomB->getType(), + atomC->getType(), + atomD->getType()); - TorsionType* torsionType = ff->getTorsionType(atomA->getType(), atomB->getType(), - atomC->getType(), "GHOST"); - - if (torsionType == NULL) { - sprintf(painCave.errMsg, "Can not find Matching Torsion Type for[%s, %s, %s, %s]", - atomA->getType().c_str(), - atomB->getType().c_str(), - atomC->getType().c_str(), - "GHOST"); - - painCave.isFatal = 1; - simError(); - } - - torsion = new GhostTorsion(atomA, atomB, dAtom, torsionType); + if (inversionType == NULL) { + sprintf(painCave.errMsg, "No Matching Inversion Type for[%s, %s, %s, %s]\n" + "\t(May not be a problem: not all inversions are parametrized)\n", + atomA->getType().c_str(), + atomB->getType().c_str(), + atomC->getType().c_str(), + atomD->getType().c_str()); + + painCave.isFatal = 0; + painCave.severity = OPENMD_INFO; + simError(); + return NULL; + } else { + + inversion = new Inversion(atomA, atomB, atomC, atomD, inversionType); + return inversion; } + } + - return torsion; -} - -CutoffGroup* MoleculeCreator::createCutoffGroup(Molecule* mol, CutoffGroupStamp* stamp) { + CutoffGroup* MoleculeCreator::createCutoffGroup(Molecule* mol, CutoffGroupStamp* stamp) { int nAtoms; CutoffGroup* cg; Atom* atom; @@ -442,71 +457,71 @@ CutoffGroup* MoleculeCreator::createCutoffGroup(Molecu nAtoms = stamp->getNMembers(); for (int i =0; i < nAtoms; ++i) { - atom = mol->getAtomAt(stamp->getMember(i)); - assert(atom); - cg->addAtom(atom); + atom = mol->getAtomAt(stamp->getMemberAt(i)); + assert(atom); + cg->addAtom(atom); } return cg; -} + } -CutoffGroup* MoleculeCreator::createCutoffGroup(Molecule * mol, Atom* atom) { + CutoffGroup* MoleculeCreator::createCutoffGroup(Molecule * mol, Atom* atom) { CutoffGroup* cg; cg = new CutoffGroup(); cg->addAtom(atom); return cg; -} + } -void MoleculeCreator::createConstraintPair(Molecule* mol) { + void MoleculeCreator::createConstraintPair(Molecule* mol) { //add bond constraints Molecule::BondIterator bi; Bond* bond; for (bond = mol->beginBond(bi); bond != NULL; bond = mol->nextBond(bi)) { - BondType* bt = bond->getBondType(); + BondType* bt = bond->getBondType(); - //class Parent1 {}; - //class Child1 : public Parent {}; - //class Child2 : public Parent {}; - //Child1* ch1 = new Child1(); - //Child2* ch2 = dynamic_cast(ch1); - //the dynamic_cast is succeed in above line. A compiler bug? + //class Parent1 {}; + //class Child1 : public Parent {}; + //class Child2 : public Parent {}; + //Child1* ch1 = new Child1(); + //Child2* ch2 = dynamic_cast(ch1); + //the dynamic_cast is succeed in above line. A compiler bug? - if (typeid(FixedBondType) == typeid(*bt)) { - FixedBondType* fbt = dynamic_cast(bt); + if (typeid(FixedBondType) == typeid(*bt)) { + FixedBondType* fbt = dynamic_cast(bt); - ConstraintElem* consElemA = new ConstraintElem(bond->getAtomA()); - ConstraintElem* consElemB = new ConstraintElem(bond->getAtomB()); - ConstraintPair* consPair = new ConstraintPair(consElemA, consElemB, fbt->getEquilibriumBondLength()); - mol->addConstraintPair(consPair); - } + ConstraintElem* consElemA = new ConstraintElem(bond->getAtomA()); + ConstraintElem* consElemB = new ConstraintElem(bond->getAtomB()); + ConstraintPair* consPair = new ConstraintPair(consElemA, consElemB, fbt->getEquilibriumBondLength()); + mol->addConstraintPair(consPair); + } } //rigidbody -- rigidbody constraint is not support yet -} + } -void MoleculeCreator::createConstraintElem(Molecule* mol) { + void MoleculeCreator::createConstraintElem(Molecule* mol) { ConstraintPair* consPair; Molecule::ConstraintPairIterator cpi; std::set sdSet; for (consPair = mol->beginConstraintPair(cpi); consPair != NULL; consPair = mol->nextConstraintPair(cpi)) { - StuntDouble* sdA = consPair->getConsElem1()->getStuntDouble(); - if (sdSet.find(sdA) == sdSet.end()){ - sdSet.insert(sdA); - mol->addConstraintElem(new ConstraintElem(sdA)); - } + StuntDouble* sdA = consPair->getConsElem1()->getStuntDouble(); + if (sdSet.find(sdA) == sdSet.end()){ + sdSet.insert(sdA); + mol->addConstraintElem(new ConstraintElem(sdA)); + } - StuntDouble* sdB = consPair->getConsElem2()->getStuntDouble(); - if (sdSet.find(sdB) == sdSet.end()){ - sdSet.insert(sdB); - mol->addConstraintElem(new ConstraintElem(sdB)); - } + StuntDouble* sdB = consPair->getConsElem2()->getStuntDouble(); + if (sdSet.find(sdB) == sdSet.end()){ + sdSet.insert(sdB); + mol->addConstraintElem(new ConstraintElem(sdB)); + } } -} + } }