void RepulsivePower::initialize() {
RPtypes.clear();
RPtids.clear();
MixingMap.clear();
RPtids.resize( forceField_->getNAtomType(), -1);
ForceField::NonBondedInteractionTypeContainer* nbiTypes = forceField_->getNonBondedInteractionTypes();
ForceField::NonBondedInteractionTypeContainer::MapTypeIterator j;
ForceField::NonBondedInteractionTypeContainer::KeyType keys;
NonBondedInteractionType* nbt;
int rptid1, rptid2;
for (nbt = nbiTypes->beginType(j); nbt != NULL;
nbt = nbiTypes->nextType(j)) {
if (nbt->isRepulsivePower()) {
keys = nbiTypes->getKeys(j);
AtomType* at1 = forceField_->getAtomType(keys[0]);
AtomType* at2 = forceField_->getAtomType(keys[1]);
int atid1 = at1->getIdent();
if (RPtids[atid1] == -1) {
rptid1 = RPtypes.size();
RPtypes.insert(atid1);
RPtids[atid1] = rptid1;
}
int atid2 = at2->getIdent();
if (RPtids[atid2] == -1) {
rptid2 = RPtypes.size();
RPtypes.insert(atid2);
RPtids[atid2] = rptid2;
}
RepulsivePowerInteractionType* rpit = dynamic_cast<RepulsivePowerInteractionType*>(nbt);
if (rpit == NULL) {
sprintf( painCave.errMsg,
"RepulsivePower::initialize could not convert NonBondedInteractionType\n"
"\tto RepulsivePowerInteractionType for %s - %s interaction.\n",
at1->getName().c_str(),
at2->getName().c_str());
painCave.severity = OPENMD_ERROR;
painCave.isFatal = 1;
simError();
}
RealType sigma = rpit->getSigma();
RealType epsilon = rpit->getEpsilon();
int nRep = rpit->getNrep();
addExplicitInteraction(at1, at2, sigma, epsilon, nRep);
}
}
initialized_ = true;
}
void InteractionManager::initialize() {
if (initialized_) return;
ForceField* forceField_ = info_->getForceField();
lj_->setForceField(forceField_);
gb_->setForceField(forceField_);
sticky_->setForceField(forceField_);
eam_->setForceField(forceField_);
sc_->setForceField(forceField_);
morse_->setForceField(forceField_);
electrostatic_->setSimInfo(info_);
electrostatic_->setForceField(forceField_);
maw_->setForceField(forceField_);
repulsivePower_->setForceField(forceField_);
ForceField::AtomTypeContainer* atomTypes = forceField_->getAtomTypes();
int nTypes = atomTypes->size();
sHash_.resize(nTypes);
iHash_.resize(nTypes);
interactions_.resize(nTypes);
ForceField::AtomTypeContainer::MapTypeIterator i1, i2;
AtomType* atype1;
AtomType* atype2;
int atid1, atid2;
// We only need to worry about the types that are actually in the
// simulation:
set<AtomType*> atypes = info_->getSimulatedAtomTypes();
lj_->setSimulatedAtomTypes(atypes);
gb_->setSimulatedAtomTypes(atypes);
sticky_->setSimulatedAtomTypes(atypes);
eam_->setSimulatedAtomTypes(atypes);
sc_->setSimulatedAtomTypes(atypes);
morse_->setSimulatedAtomTypes(atypes);
electrostatic_->setSimInfo(info_);
electrostatic_->setSimulatedAtomTypes(atypes);
maw_->setSimulatedAtomTypes(atypes);
repulsivePower_->setSimulatedAtomTypes(atypes);
set<AtomType*>::iterator at;
for (at = atypes.begin(); at != atypes.end(); ++at) {
atype1 = *at;
atid1 = atype1->getIdent();
iHash_[atid1].resize(nTypes);
interactions_[atid1].resize(nTypes);
// add it to the map:
pair<map<int,AtomType*>::iterator,bool> ret;
ret = typeMap_.insert( pair<int, AtomType*>(atid1, atype1) );
if (ret.second == false) {
sprintf( painCave.errMsg,
"InteractionManager already had a previous entry with ident %d\n",
atype1->getIdent());
painCave.severity = OPENMD_INFO;
painCave.isFatal = 0;
simError();
}
if (atype1->isLennardJones()) {
sHash_[atid1] |= LJ_INTERACTION;
}
if (atype1->isElectrostatic()) {
sHash_[atid1] |= ELECTROSTATIC_INTERACTION;
}
if (atype1->isSticky()) {
sHash_[atid1] |= STICKY_INTERACTION;
}
if (atype1->isStickyPower()) {
sHash_[atid1] |= STICKY_INTERACTION;
}
if (atype1->isEAM()) {
sHash_[atid1] |= EAM_INTERACTION;
}
if (atype1->isSC()) {
sHash_[atid1] |= SC_INTERACTION;
}
if (atype1->isGayBerne()) {
sHash_[atid1] |= GB_INTERACTION;
}
}
// Now, iterate over all known types and add to the interaction map:
map<int, AtomType*>::iterator it1, it2;
for (it1 = typeMap_.begin(); it1 != typeMap_.end(); ++it1) {
atype1 = (*it1).second;
atid1 = atype1->getIdent();
for( it2 = typeMap_.begin(); it2 != typeMap_.end(); ++it2) {
atype2 = (*it2).second;
atid2 = atype2->getIdent();
iHash_[atid1][atid2] = 0;
if (atype1->isLennardJones() && atype2->isLennardJones()) {
interactions_[atid1][atid2].insert(lj_);
iHash_[atid1][atid2] |= LJ_INTERACTION;
}
if (atype1->isElectrostatic() && atype2->isElectrostatic() ) {
interactions_[atid1][atid2].insert(electrostatic_);
iHash_[atid1][atid2] |= ELECTROSTATIC_INTERACTION;
}
if (atype1->isSticky() && atype2->isSticky() ) {
interactions_[atid1][atid2].insert(sticky_);
iHash_[atid1][atid2] |= STICKY_INTERACTION;
}
if (atype1->isStickyPower() && atype2->isStickyPower() ) {
interactions_[atid1][atid2].insert(sticky_);
iHash_[atid1][atid2] |= STICKY_INTERACTION;
}
if (atype1->isEAM() && atype2->isEAM() ) {
interactions_[atid1][atid2].insert(eam_);
iHash_[atid1][atid2] |= EAM_INTERACTION;
}
if (atype1->isSC() && atype2->isSC() ) {
interactions_[atid1][atid2].insert(sc_);
iHash_[atid1][atid2] |= SC_INTERACTION;
}
if (atype1->isGayBerne() && atype2->isGayBerne() ) {
interactions_[atid1][atid2].insert(gb_);
iHash_[atid1][atid2] |= GB_INTERACTION;
}
if ((atype1->isGayBerne() && atype2->isLennardJones())
|| (atype1->isLennardJones() && atype2->isGayBerne())) {
interactions_[atid1][atid2].insert(gb_);
iHash_[atid1][atid2] |= GB_INTERACTION;
}
// look for an explicitly-set non-bonded interaction type using the
// two atom types.
NonBondedInteractionType* nbiType = forceField_->getNonBondedInteractionType(atype1->getName(), atype2->getName());
if (nbiType != NULL) {
bool vdwExplicit = false;
bool metExplicit = false;
// bool hbExplicit = false;
if (nbiType->isLennardJones()) {
// We found an explicit Lennard-Jones interaction.
// override all other vdw entries for this pair of atom types:
set<NonBondedInteraction*>::iterator it;
for (it = interactions_[atid1][atid2].begin();
it != interactions_[atid1][atid2].end(); ++it) {
InteractionFamily ifam = (*it)->getFamily();
if (ifam == VANDERWAALS_FAMILY) {
interactions_[atid1][atid2].erase(*it);
iHash_[atid1][atid2] ^= (*it)->getHash();
}
}
interactions_[atid1][atid2].insert(lj_);
iHash_[atid1][atid2] |= LJ_INTERACTION;
LennardJonesInteractionType* ljit = dynamic_cast<LennardJonesInteractionType*>(nbiType);
lj_->addExplicitInteraction(atype1, atype2, ljit->getSigma(),
ljit->getEpsilon());
vdwExplicit = true;
}
if (nbiType->isMorse()) {
if (vdwExplicit) {
sprintf( painCave.errMsg,
"InteractionManager::initialize found more than one "
"explicit \n"
"\tvan der Waals interaction for atom types %s - %s\n",
atype1->getName().c_str(), atype2->getName().c_str());
painCave.severity = OPENMD_ERROR;
painCave.isFatal = 1;
simError();
}
// We found an explicit Morse interaction.
// override all other vdw entries for this pair of atom types:
set<NonBondedInteraction*>::iterator it;
for (it = interactions_[atid1][atid2].begin();
it != interactions_[atid1][atid2].end(); ++it) {
InteractionFamily ifam = (*it)->getFamily();
if (ifam == VANDERWAALS_FAMILY) {
interactions_[atid1][atid2].erase(*it);
iHash_[atid1][atid2] ^= (*it)->getHash();
}
}
interactions_[atid1][atid2].insert(morse_);
iHash_[atid1][atid2] |= MORSE_INTERACTION;
MorseInteractionType* mit = dynamic_cast<MorseInteractionType*>(nbiType);
morse_->addExplicitInteraction(atype1, atype2, mit->getD(),
mit->getR(), mit->getBeta(),
mit->getInteractionType());
vdwExplicit = true;
}
if (nbiType->isRepulsivePower()) {
if (vdwExplicit) {
sprintf( painCave.errMsg,
"InteractionManager::initialize found more than one "
"explicit \n"
"\tvan der Waals interaction for atom types %s - %s\n",
atype1->getName().c_str(), atype2->getName().c_str());
painCave.severity = OPENMD_ERROR;
painCave.isFatal = 1;
simError();
}
// We found an explicit RepulsivePower interaction.
// override all other vdw entries for this pair of atom types:
set<NonBondedInteraction*>::iterator it;
for (it = interactions_[atid1][atid2].begin();
it != interactions_[atid1][atid2].end(); ++it) {
InteractionFamily ifam = (*it)->getFamily();
if (ifam == VANDERWAALS_FAMILY) {
interactions_[atid1][atid2].erase(*it);
iHash_[atid1][atid2] ^= (*it)->getHash();
}
}
interactions_[atid1][atid2].insert(repulsivePower_);
iHash_[atid1][atid2] |= REPULSIVEPOWER_INTERACTION;
RepulsivePowerInteractionType* rpit = dynamic_cast<RepulsivePowerInteractionType*>(nbiType);
repulsivePower_->addExplicitInteraction(atype1, atype2,
rpit->getSigma(),
rpit->getEpsilon(),
rpit->getNrep());
vdwExplicit = true;
}
if (nbiType->isEAM()) {
// We found an explicit EAM interaction.
// override all other metallic entries for this pair of atom types:
set<NonBondedInteraction*>::iterator it;
for (it = interactions_[atid1][atid2].begin();
it != interactions_[atid1][atid2].end(); ++it) {
InteractionFamily ifam = (*it)->getFamily();
if (ifam == METALLIC_FAMILY) {
interactions_[atid1][atid2].erase(*it);
iHash_[atid1][atid2] ^= (*it)->getHash();
}
}
interactions_[atid1][atid2].insert(eam_);
iHash_[atid1][atid2] |= EAM_INTERACTION;
metExplicit = true;
}
if (nbiType->isSC()) {
if (metExplicit) {
sprintf( painCave.errMsg,
"InteractionManager::initialize found more than one "
"explicit\n"
"\tmetallic interaction for atom types %s - %s\n",
atype1->getName().c_str(), atype2->getName().c_str());
painCave.severity = OPENMD_ERROR;
painCave.isFatal = 1;
simError();
}
// We found an explicit Sutton-Chen interaction.
// override all other metallic entries for this pair of atom types:
set<NonBondedInteraction*>::iterator it;
for (it = interactions_[atid1][atid2].begin();
it != interactions_[atid1][atid2].end(); ++it) {
InteractionFamily ifam = (*it)->getFamily();
if (ifam == METALLIC_FAMILY) {
interactions_[atid1][atid2].erase(*it);
iHash_[atid1][atid2] ^= (*it)->getHash();
}
}
interactions_[atid1][atid2].insert(sc_);
iHash_[atid1][atid2] |= SC_INTERACTION;
metExplicit = true;
}
if (nbiType->isMAW()) {
if (vdwExplicit) {
sprintf( painCave.errMsg,
"InteractionManager::initialize found more than one "
"explicit\n"
"\tvan der Waals interaction for atom types %s - %s\n",
atype1->getName().c_str(), atype2->getName().c_str());
painCave.severity = OPENMD_ERROR;
painCave.isFatal = 1;
simError();
}
// We found an explicit MAW interaction.
// override all other vdw entries for this pair of atom types:
set<NonBondedInteraction*>::iterator it;
for (it = interactions_[atid1][atid2].begin();
it != interactions_[atid1][atid2].end(); ++it) {
InteractionFamily ifam = (*it)->getFamily();
if (ifam == VANDERWAALS_FAMILY) {
interactions_[atid1][atid2].erase(*it);
iHash_[atid1][atid2] ^= (*it)->getHash();
}
}
interactions_[atid1][atid2].insert(maw_);
iHash_[atid1][atid2] |= MAW_INTERACTION;
MAWInteractionType* mit = dynamic_cast<MAWInteractionType*>(nbiType);
maw_->addExplicitInteraction(atype1, atype2, mit->getD(),
mit->getBeta(), mit->getR(),
mit->getCA1(), mit->getCB1());
vdwExplicit = true;
}
}
}
}
// Make sure every pair of atom types in this simulation has a
// non-bonded interaction. If not, just inform the user.
set<AtomType*> simTypes = info_->getSimulatedAtomTypes();
set<AtomType*>::iterator it, jt;
for (it = simTypes.begin(); it != simTypes.end(); ++it) {
atype1 = (*it);
atid1 = atype1->getIdent();
for (jt = it; jt != simTypes.end(); ++jt) {
atype2 = (*jt);
atid2 = atype2->getIdent();
if (interactions_[atid1][atid2].size() == 0) {
sprintf( painCave.errMsg,
"InteractionManager could not find a matching non-bonded\n"
"\tinteraction for atom types %s - %s\n"
"\tProceeding without this interaction.\n",
atype1->getName().c_str(), atype2->getName().c_str());
painCave.severity = OPENMD_INFO;
painCave.isFatal = 0;
simError();
}
}
}
initialized_ = true;
}
void EAM::initialize() {
// set up the mixing method:
ForceFieldOptions& fopts = forceField_->getForceFieldOptions();
string EAMMixMeth = fopts.getEAMMixingMethod();
toUpper(EAMMixMeth);
if (EAMMixMeth == "JOHNSON")
mixMeth_ = eamJohnson;
else if (EAMMixMeth == "DAW")
mixMeth_ = eamDaw;
else
mixMeth_ = eamUnknown;
// find all of the EAM atom Types:
EAMtypes.clear();
EAMtids.clear();
EAMdata.clear();
MixingMap.clear();
nEAM_ = 0;
EAMtids.resize( forceField_->getNAtomType(), -1);
set<AtomType*>::iterator at;
for (at = simTypes_.begin(); at != simTypes_.end(); ++at) {
if ((*at)->isEAM()) nEAM_++;
}
EAMdata.resize(nEAM_);
MixingMap.resize(nEAM_);
for (at = simTypes_.begin(); at != simTypes_.end(); ++at) {
if ((*at)->isEAM()) addType(*at);
}
// find all of the explicit EAM interactions (setfl):
ForceField::NonBondedInteractionTypeContainer* nbiTypes = forceField_->getNonBondedInteractionTypes();
ForceField::NonBondedInteractionTypeContainer::MapTypeIterator j;
NonBondedInteractionType* nbt;
for (nbt = nbiTypes->beginType(j); nbt != NULL;
nbt = nbiTypes->nextType(j)) {
if (nbt->isEAM()) {
pair<AtomType*, AtomType*> atypes = nbt->getAtomTypes();
GenericData* data = nbt->getPropertyByName("EAM");
if (data == NULL) {
sprintf( painCave.errMsg, "EAM::rebuildMixingMap could not find\n"
"\tEAM parameters for %s - %s interaction.\n",
atypes.first->getName().c_str(),
atypes.second->getName().c_str());
painCave.severity = OPENMD_ERROR;
painCave.isFatal = 1;
simError();
}
EAMMixingData* eamData = dynamic_cast<EAMMixingData*>(data);
if (eamData == NULL) {
sprintf( painCave.errMsg,
"EAM::rebuildMixingMap could not convert GenericData to\n"
"\tEAMMixingData for %s - %s interaction.\n",
atypes.first->getName().c_str(),
atypes.second->getName().c_str());
painCave.severity = OPENMD_ERROR;
painCave.isFatal = 1;
simError();
}
EAMMixingParam eamParam = eamData->getData();
vector<RealType> phiAB = eamParam.phi;
RealType dr = eamParam.dr;
int nr = eamParam.nr;
addExplicitInteraction(atypes.first, atypes.second, dr, nr, phiAB);
}
}
initialized_ = true;
}
