--- branches/development/src/nonbonded/Electrostatic.cpp 2011/05/27 16:45:44 1571 +++ branches/development/src/nonbonded/Electrostatic.cpp 2012/06/07 12:53:46 1750 @@ -34,9 +34,10 @@ * 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). + * [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). + * [4] Kuang & Gezelter, J. Chem. Phys. 133, 164101 (2010). + * [5] Vardeman, Stocker & Gezelter, J. Chem. Theory Comput. 7, 834 (2011). */ #include @@ -46,19 +47,30 @@ #include "nonbonded/Electrostatic.hpp" #include "utils/simError.h" #include "types/NonBondedInteractionType.hpp" -#include "types/DirectionalAtomType.hpp" +#include "types/FixedChargeAdapter.hpp" +#include "types/FluctuatingChargeAdapter.hpp" +#include "types/MultipoleAdapter.hpp" #include "io/Globals.hpp" +#include "nonbonded/SlaterIntegrals.hpp" +#include "utils/PhysicalConstants.hpp" + namespace OpenMD { Electrostatic::Electrostatic(): name_("Electrostatic"), initialized_(false), - forceField_(NULL) {} + forceField_(NULL), info_(NULL), + haveCutoffRadius_(false), + haveDampingAlpha_(false), + haveDielectric_(false), + haveElectroSpline_(false) + {} void Electrostatic::initialize() { + + Globals* simParams_ = info_->getSimParams(); - Globals* simParams_; - summationMap_["HARD"] = esm_HARD; + summationMap_["NONE"] = esm_HARD; summationMap_["SWITCHING_FUNCTION"] = esm_SWITCHING_FUNCTION; summationMap_["SHIFTED_POTENTIAL"] = esm_SHIFTED_POTENTIAL; summationMap_["SHIFTED_FORCE"] = esm_SHIFTED_FORCE; @@ -97,10 +109,6 @@ namespace OpenMD { screeningMethod_ = UNDAMPED; dielectric_ = 1.0; one_third_ = 1.0 / 3.0; - haveCutoffRadius_ = false; - haveDampingAlpha_ = false; - haveDielectric_ = false; - haveElectroSpline_ = false; // check the summation method: if (simParams_->haveElectrostaticSummationMethod()) { @@ -115,7 +123,7 @@ namespace OpenMD { sprintf( painCave.errMsg, "Electrostatic::initialize: Unknown electrostaticSummationMethod.\n" "\t(Input file specified %s .)\n" - "\telectrostaticSummationMethod must be one of: \"none\",\n" + "\telectrostaticSummationMethod must be one of: \"hard\",\n" "\t\"shifted_potential\", \"shifted_force\", or \n" "\t\"reaction_field\".\n", myMethod.c_str() ); painCave.isFatal = 1; @@ -185,8 +193,9 @@ namespace OpenMD { // throw warning sprintf( painCave.errMsg, - "Electrostatic::initialize: dampingAlpha was not specified in the input file.\n" - "\tA default value of %f (1/ang) will be used for the cutoff of\n\t%f (ang).\n", + "Electrostatic::initialize: dampingAlpha was not specified in the\n" + "\tinput file. A default value of %f (1/ang) will be used for the\n" + "\tcutoff of %f (ang).\n", dampingAlpha_, cutoffRadius_); painCave.severity = OPENMD_INFO; painCave.isFatal = 0; @@ -209,7 +218,6 @@ namespace OpenMD { addType(at); } - cutoffRadius2_ = cutoffRadius_ * cutoffRadius_; rcuti_ = 1.0 / cutoffRadius_; rcuti2_ = rcuti_ * rcuti_; @@ -248,7 +256,12 @@ namespace OpenMD { preRF2_ = 2.0 * preRF_; } - RealType dx = cutoffRadius_ / RealType(np_ - 1); + // Add a 2 angstrom safety window to deal with cutoffGroups that + // have charged atoms longer than the cutoffRadius away from each + // other. Splining may not be the best choice here. Direct calls + // to erfc might be preferrable. + + RealType dx = (cutoffRadius_ + 2.0) / RealType(np_ - 1); RealType rval; vector rvals; vector yvals; @@ -271,149 +284,117 @@ namespace OpenMD { electrostaticAtomData.is_Dipole = false; electrostaticAtomData.is_SplitDipole = false; electrostaticAtomData.is_Quadrupole = false; - - if (atomType->isCharge()) { - GenericData* data = atomType->getPropertyByName("Charge"); + electrostaticAtomData.is_Fluctuating = false; - if (data == NULL) { - sprintf( painCave.errMsg, "Electrostatic::addType could not find " - "Charge\n" - "\tparameters for atomType %s.\n", - atomType->getName().c_str()); - painCave.severity = OPENMD_ERROR; - painCave.isFatal = 1; - simError(); - } - - DoubleGenericData* doubleData = dynamic_cast(data); - if (doubleData == NULL) { - sprintf( painCave.errMsg, - "Electrostatic::addType could not convert GenericData to " - "Charge for\n" - "\tatom type %s\n", atomType->getName().c_str()); - painCave.severity = OPENMD_ERROR; - painCave.isFatal = 1; - simError(); - } + FixedChargeAdapter fca = FixedChargeAdapter(atomType); + + if (fca.isFixedCharge()) { electrostaticAtomData.is_Charge = true; - electrostaticAtomData.charge = doubleData->getData(); + electrostaticAtomData.fixedCharge = fca.getCharge(); } - if (atomType->isDirectional()) { - DirectionalAtomType* daType = dynamic_cast(atomType); - - if (daType->isDipole()) { - GenericData* data = daType->getPropertyByName("Dipole"); - - if (data == NULL) { - sprintf( painCave.errMsg, - "Electrostatic::addType could not find Dipole\n" - "\tparameters for atomType %s.\n", - daType->getName().c_str()); - painCave.severity = OPENMD_ERROR; - painCave.isFatal = 1; - simError(); - } - - DoubleGenericData* doubleData = dynamic_cast(data); - if (doubleData == NULL) { - sprintf( painCave.errMsg, - "Electrostatic::addType could not convert GenericData to " - "Dipole Moment\n" - "\tfor atom type %s\n", daType->getName().c_str()); - painCave.severity = OPENMD_ERROR; - painCave.isFatal = 1; - simError(); - } + MultipoleAdapter ma = MultipoleAdapter(atomType); + if (ma.isMultipole()) { + if (ma.isDipole()) { electrostaticAtomData.is_Dipole = true; - electrostaticAtomData.dipole_moment = doubleData->getData(); + electrostaticAtomData.dipole_moment = ma.getDipoleMoment(); } - - if (daType->isSplitDipole()) { - GenericData* data = daType->getPropertyByName("SplitDipoleDistance"); - - if (data == NULL) { - sprintf(painCave.errMsg, - "Electrostatic::addType could not find SplitDipoleDistance\n" - "\tparameter for atomType %s.\n", - daType->getName().c_str()); - painCave.severity = OPENMD_ERROR; - painCave.isFatal = 1; - simError(); - } - - DoubleGenericData* doubleData = dynamic_cast(data); - if (doubleData == NULL) { - sprintf( painCave.errMsg, - "Electrostatic::addType could not convert GenericData to " - "SplitDipoleDistance for\n" - "\tatom type %s\n", daType->getName().c_str()); - painCave.severity = OPENMD_ERROR; - painCave.isFatal = 1; - simError(); - } + if (ma.isSplitDipole()) { electrostaticAtomData.is_SplitDipole = true; - electrostaticAtomData.split_dipole_distance = doubleData->getData(); + electrostaticAtomData.split_dipole_distance = ma.getSplitDipoleDistance(); } - - if (daType->isQuadrupole()) { - GenericData* data = daType->getPropertyByName("QuadrupoleMoments"); - - if (data == NULL) { - sprintf( painCave.errMsg, - "Electrostatic::addType could not find QuadrupoleMoments\n" - "\tparameter for atomType %s.\n", - daType->getName().c_str()); - painCave.severity = OPENMD_ERROR; - painCave.isFatal = 1; - simError(); - } - + if (ma.isQuadrupole()) { // Quadrupoles in OpenMD are set as the diagonal elements // of the diagonalized traceless quadrupole moment tensor. // The column vectors of the unitary matrix that diagonalizes // the quadrupole moment tensor become the eFrame (or the // electrostatic version of the body-fixed frame. - - Vector3dGenericData* v3dData = dynamic_cast(data); - if (v3dData == NULL) { - sprintf( painCave.errMsg, - "Electrostatic::addType could not convert GenericData to " - "Quadrupole Moments for\n" - "\tatom type %s\n", daType->getName().c_str()); - painCave.severity = OPENMD_ERROR; - painCave.isFatal = 1; - simError(); - } electrostaticAtomData.is_Quadrupole = true; - electrostaticAtomData.quadrupole_moments = v3dData->getData(); + electrostaticAtomData.quadrupole_moments = ma.getQuadrupoleMoments(); } } - AtomTypeProperties atp = atomType->getATP(); + FluctuatingChargeAdapter fqa = FluctuatingChargeAdapter(atomType); + + if (fqa.isFluctuatingCharge()) { + electrostaticAtomData.is_Fluctuating = true; + electrostaticAtomData.electronegativity = fqa.getElectronegativity(); + electrostaticAtomData.hardness = fqa.getHardness(); + electrostaticAtomData.slaterN = fqa.getSlaterN(); + electrostaticAtomData.slaterZeta = fqa.getSlaterZeta(); + } pair::iterator,bool> ret; - ret = ElectrostaticList.insert( pair(atp.ident, atomType) ); + ret = ElectrostaticList.insert( pair(atomType->getIdent(), + atomType) ); if (ret.second == false) { sprintf( painCave.errMsg, "Electrostatic already had a previous entry with ident %d\n", - atp.ident); + atomType->getIdent() ); painCave.severity = OPENMD_INFO; painCave.isFatal = 0; simError(); } - ElectrostaticMap[atomType] = electrostaticAtomData; + ElectrostaticMap[atomType] = electrostaticAtomData; + + // Now, iterate over all known types and add to the mixing map: + + map::iterator it; + for( it = ElectrostaticMap.begin(); it != ElectrostaticMap.end(); ++it) { + AtomType* atype2 = (*it).first; + ElectrostaticAtomData eaData2 = (*it).second; + if (eaData2.is_Fluctuating && electrostaticAtomData.is_Fluctuating) { + + RealType a = electrostaticAtomData.slaterZeta; + RealType b = eaData2.slaterZeta; + int m = electrostaticAtomData.slaterN; + int n = eaData2.slaterN; + + // Create the spline of the coulombic integral for s-type + // Slater orbitals. Add a 2 angstrom safety window to deal + // with cutoffGroups that have charged atoms longer than the + // cutoffRadius away from each other. + + RealType rval; + RealType dr = (cutoffRadius_ + 2.0) / RealType(np_ - 1); + vector rvals; + vector J1vals; + vector J2vals; + for (int i = 0; i < np_; i++) { + rval = RealType(i) * dr; + rvals.push_back(rval); + J1vals.push_back(electrostaticAtomData.hardness * sSTOCoulInt( a, b, m, n, rval * PhysicalConstants::angstromsToBohr ) ); + // may not be necessary if Slater coulomb integral is symmetric + J2vals.push_back(eaData2.hardness * sSTOCoulInt( b, a, n, m, rval * PhysicalConstants::angstromsToBohr ) ); + } + + CubicSpline* J1 = new CubicSpline(); + J1->addPoints(rvals, J1vals); + CubicSpline* J2 = new CubicSpline(); + J2->addPoints(rvals, J2vals); + + pair key1, key2; + key1 = make_pair(atomType, atype2); + key2 = make_pair(atype2, atomType); + + Jij[key1] = J1; + Jij[key2] = J2; + } + } + return; } - void Electrostatic::setElectrostaticCutoffRadius( RealType theECR, - RealType theRSW ) { - cutoffRadius_ = theECR; + void Electrostatic::setCutoffRadius( RealType rCut ) { + cutoffRadius_ = rCut; rrf_ = cutoffRadius_; - rt_ = theRSW; haveCutoffRadius_ = true; } + + void Electrostatic::setSwitchingRadius( RealType rSwitch ) { + rt_ = rSwitch; + } void Electrostatic::setElectrostaticSummationMethod( ElectrostaticSummationMethod esm ) { summationMethod_ = esm; } @@ -443,13 +424,15 @@ namespace OpenMD { RealType ct_i, ct_j, ct_ij, a1; RealType riji, ri, ri2, ri3, ri4; RealType pref, vterm, epot, dudr; + RealType vpair(0.0); RealType scale, sc2; RealType pot_term, preVal, rfVal; RealType c2ri, c3ri, c4rij, cti3, ctj3, ctidotj; RealType preSw, preSwSc; RealType c1, c2, c3, c4; - RealType erfcVal, derfcVal; + RealType erfcVal(1.0), derfcVal(0.0); RealType BigR; + RealType two(2.0), three(3.0); Vector3d Q_i, Q_j; Vector3d ux_i, uy_i, uz_i; @@ -459,8 +442,19 @@ namespace OpenMD { Vector3d rhatdot2, rhatc4; Vector3d dVdr; + // variables for indirect (reaction field) interactions for excluded pairs: + RealType indirect_Pot(0.0); + RealType indirect_vpair(0.0); + Vector3d indirect_dVdr(V3Zero); + Vector3d indirect_duduz_i(V3Zero), indirect_duduz_j(V3Zero); + + RealType coulInt, vFluc1(0.0), vFluc2(0.0); pair res; + // splines for coulomb integrals + CubicSpline* J1; + CubicSpline* J2; + if (!initialized_) initialize(); ElectrostaticAtomData data1 = ElectrostaticMap[idat.atypes.first]; @@ -477,15 +471,26 @@ namespace OpenMD { bool i_is_Dipole = data1.is_Dipole; bool i_is_SplitDipole = data1.is_SplitDipole; bool i_is_Quadrupole = data1.is_Quadrupole; + bool i_is_Fluctuating = data1.is_Fluctuating; bool j_is_Charge = data2.is_Charge; bool j_is_Dipole = data2.is_Dipole; bool j_is_SplitDipole = data2.is_SplitDipole; bool j_is_Quadrupole = data2.is_Quadrupole; + bool j_is_Fluctuating = data2.is_Fluctuating; - if (i_is_Charge) - q_i = data1.charge; + if (i_is_Charge) { + q_i = data1.fixedCharge; + if (i_is_Fluctuating) { + q_i += *(idat.flucQ1); + } + + if (idat.excluded) { + *(idat.skippedCharge2) += q_i; + } + } + if (i_is_Dipole) { mu_i = data1.dipole_moment; uz_i = idat.eFrame1->getColumn(2); @@ -517,9 +522,18 @@ namespace OpenMD { duduz_i = V3Zero; } - if (j_is_Charge) - q_j = data2.charge; + if (j_is_Charge) { + q_j = data2.fixedCharge; + if (j_is_Fluctuating) + q_j += *(idat.flucQ2); + + if (idat.excluded) { + *(idat.skippedCharge1) += q_j; + } + } + + if (j_is_Dipole) { mu_j = data2.dipole_moment; uz_j = idat.eFrame2->getColumn(2); @@ -551,6 +565,11 @@ namespace OpenMD { duduz_j = V3Zero; } + if (i_is_Fluctuating && j_is_Fluctuating) { + J1 = Jij[idat.atypes]; + J2 = Jij[make_pair(idat.atypes.second, idat.atypes.first)]; + } + epot = 0.0; dVdr = V3Zero; @@ -559,9 +578,13 @@ namespace OpenMD { if (j_is_Charge) { if (screeningMethod_ == DAMPED) { // assemble the damping variables - res = erfcSpline_->getValueAndDerivativeAt( *(idat.rij) ); - erfcVal = res.first; - derfcVal = res.second; + //res = erfcSpline_->getValueAndDerivativeAt( *(idat.rij) ); + //erfcVal = res.first; + //derfcVal = res.second; + + erfcVal = erfc(dampingAlpha_ * *(idat.rij)); + derfcVal = - alphaPi_ * exp(-alpha2_ * *(idat.r2)); + c1 = erfcVal * riji; c2 = (-derfcVal + c1) * riji; } else { @@ -569,7 +592,7 @@ namespace OpenMD { c2 = c1 * riji; } - preVal = *(idat.electroMult) * pre11_ * q_i * q_j; + preVal = *(idat.electroMult) * pre11_; if (summationMethod_ == esm_SHIFTED_POTENTIAL) { vterm = preVal * (c1 - c1c_); @@ -580,21 +603,56 @@ namespace OpenMD { dudr = *(idat.sw) * preVal * (c2c_ - c2); } else if (summationMethod_ == esm_REACTION_FIELD) { - rfVal = *(idat.electroMult) * preRF_ * *(idat.rij) * *(idat.rij) ; + rfVal = preRF_ * *(idat.rij) * *(idat.rij); + vterm = preVal * ( riji + rfVal ); dudr = *(idat.sw) * preVal * ( 2.0 * rfVal - riji ) * riji; + + // if this is an excluded pair, there are still indirect + // interactions via the reaction field we must worry about: + if (idat.excluded) { + indirect_vpair += preVal * rfVal; + indirect_Pot += *(idat.sw) * preVal * rfVal; + indirect_dVdr += *(idat.sw) * preVal * two * rfVal * riji * rhat; + } + } else { - vterm = preVal * riji * erfcVal; + vterm = preVal * riji * erfcVal; dudr = - *(idat.sw) * preVal * c2; + + } + + vpair += vterm * q_i * q_j; + epot += *(idat.sw) * vterm * q_i * q_j; + dVdr += dudr * rhat * q_i * q_j; + + if (i_is_Fluctuating) { + if (idat.excluded) { + // vFluc1 is the difference between the direct coulomb integral + // and the normal 1/r-like interaction between point charges. + coulInt = J1->getValueAt( *(idat.rij) ); + vFluc1 = coulInt - (*(idat.sw) * vterm); + } else { + vFluc1 = 0.0; + } + *(idat.dVdFQ1) += ( *(idat.sw) * vterm + vFluc1 ) * q_j; + } + if (j_is_Fluctuating) { + if (idat.excluded) { + // vFluc2 is the difference between the direct coulomb integral + // and the normal 1/r-like interaction between point charges. + coulInt = J2->getValueAt( *(idat.rij) ); + vFluc2 = coulInt - (*(idat.sw) * vterm); + } else { + vFluc2 = 0.0; + } + *(idat.dVdFQ2) += ( *(idat.sw) * vterm + vFluc2 ) * q_i; } + - *(idat.vpair) += vterm; - epot += *(idat.sw) * vterm; - - dVdr += dudr * rhat; } if (j_is_Dipole) { @@ -607,12 +665,23 @@ namespace OpenMD { ri3 = ri2 * riji; vterm = - pref * ct_j * ( ri2 - preRF2_ * *(idat.rij) ); - *(idat.vpair) += vterm; + vpair += vterm; epot += *(idat.sw) * vterm; - dVdr += -preSw * (ri3 * (uz_j - 3.0 * ct_j * rhat) - preRF2_*uz_j); + dVdr += -preSw * (ri3 * (uz_j - three * ct_j * rhat) - preRF2_*uz_j); duduz_j += -preSw * rhat * (ri2 - preRF2_ * *(idat.rij) ); + // Even if we excluded this pair from direct interactions, + // we still have the reaction-field-mediated charge-dipole + // interaction: + + if (idat.excluded) { + indirect_vpair += pref * ct_j * preRF2_ * *(idat.rij); + indirect_Pot += preSw * ct_j * preRF2_ * *(idat.rij); + indirect_dVdr += preSw * preRF2_ * uz_j; + indirect_duduz_j += preSw * rhat * preRF2_ * *(idat.rij); + } + } else { // determine the inverse r used if we have split dipoles if (j_is_SplitDipole) { @@ -628,9 +697,11 @@ namespace OpenMD { if (screeningMethod_ == DAMPED) { // assemble the damping variables - res = erfcSpline_->getValueAndDerivativeAt( *(idat.rij) ); - erfcVal = res.first; - derfcVal = res.second; + //res = erfcSpline_->getValueAndDerivativeAt( *(idat.rij) ); + //erfcVal = res.first; + //derfcVal = res.second; + erfcVal = erfc(dampingAlpha_ * *(idat.rij)); + derfcVal = - alphaPi_ * exp(-alpha2_ * *(idat.r2)); c1 = erfcVal * ri; c2 = (-derfcVal + c1) * ri; c3 = -2.0 * derfcVal * alpha2_ + 3.0 * c2 * ri; @@ -645,7 +716,7 @@ namespace OpenMD { // calculate the potential pot_term = scale * c2; vterm = -pref * ct_j * pot_term; - *(idat.vpair) += vterm; + vpair += vterm; epot += *(idat.sw) * vterm; // calculate derivatives for forces and torques @@ -654,6 +725,9 @@ namespace OpenMD { duduz_j += -preSw * pot_term * rhat; } + if (i_is_Fluctuating) { + *(idat.dVdFQ1) += ( *(idat.sw) * vterm ) / q_i; + } } if (j_is_Quadrupole) { @@ -665,9 +739,11 @@ namespace OpenMD { if (screeningMethod_ == DAMPED) { // assemble the damping variables - res = erfcSpline_->getValueAndDerivativeAt( *(idat.rij) ); - erfcVal = res.first; - derfcVal = res.second; + //res = erfcSpline_->getValueAndDerivativeAt( *(idat.rij) ); + //erfcVal = res.first; + //derfcVal = res.second; + erfcVal = erfc(dampingAlpha_ * *(idat.rij)); + derfcVal = - alphaPi_ * exp(-alpha2_ * *(idat.r2)); c1 = erfcVal * riji; c2 = (-derfcVal + c1) * riji; c3 = -2.0 * derfcVal * alpha2_ + 3.0 * c2 * riji; @@ -684,7 +760,7 @@ namespace OpenMD { c2ri = c2 * riji; c3ri = c3 * riji; c4rij = c4 * *(idat.rij) ; - rhatdot2 = 2.0 * rhat * c3; + rhatdot2 = two * rhat * c3; rhatc4 = rhat * c4rij; // calculate the potential @@ -692,18 +768,22 @@ namespace OpenMD { qyy_j * (cy2*c3 - c2ri) + qzz_j * (cz2*c3 - c2ri) ); vterm = pref * pot_term; - *(idat.vpair) += vterm; + vpair += vterm; epot += *(idat.sw) * vterm; // calculate derivatives for the forces and torques - dVdr += -preSw * ( qxx_j* (cx2*rhatc4 - (2.0*cx_j*ux_j + rhat)*c3ri) + - qyy_j* (cy2*rhatc4 - (2.0*cy_j*uy_j + rhat)*c3ri) + - qzz_j* (cz2*rhatc4 - (2.0*cz_j*uz_j + rhat)*c3ri)); + dVdr += -preSw * ( qxx_j* (cx2*rhatc4 - (two*cx_j*ux_j + rhat)*c3ri) + + qyy_j* (cy2*rhatc4 - (two*cy_j*uy_j + rhat)*c3ri) + + qzz_j* (cz2*rhatc4 - (two*cz_j*uz_j + rhat)*c3ri)); dudux_j += preSw * qxx_j * cx_j * rhatdot2; duduy_j += preSw * qyy_j * cy_j * rhatdot2; duduz_j += preSw * qzz_j * cz_j * rhatdot2; + if (i_is_Fluctuating) { + *(idat.dVdFQ1) += ( *(idat.sw) * vterm ) / q_i; + } + } } @@ -720,12 +800,23 @@ namespace OpenMD { ri3 = ri2 * riji; vterm = pref * ct_i * ( ri2 - preRF2_ * *(idat.rij) ); - *(idat.vpair) += vterm; + vpair += vterm; epot += *(idat.sw) * vterm; - dVdr += preSw * (ri3 * (uz_i - 3.0 * ct_i * rhat) - preRF2_ * uz_i); + dVdr += preSw * (ri3 * (uz_i - three * ct_i * rhat) - preRF2_ * uz_i); duduz_i += preSw * rhat * (ri2 - preRF2_ * *(idat.rij) ); + + // Even if we excluded this pair from direct interactions, + // we still have the reaction-field-mediated charge-dipole + // interaction: + + if (idat.excluded) { + indirect_vpair += -pref * ct_i * preRF2_ * *(idat.rij); + indirect_Pot += -preSw * ct_i * preRF2_ * *(idat.rij); + indirect_dVdr += -preSw * preRF2_ * uz_i; + indirect_duduz_i += -preSw * rhat * preRF2_ * *(idat.rij); + } } else { @@ -743,9 +834,11 @@ namespace OpenMD { if (screeningMethod_ == DAMPED) { // assemble the damping variables - res = erfcSpline_->getValueAndDerivativeAt( *(idat.rij) ); - erfcVal = res.first; - derfcVal = res.second; + //res = erfcSpline_->getValueAndDerivativeAt( *(idat.rij) ); + //erfcVal = res.first; + //derfcVal = res.second; + erfcVal = erfc(dampingAlpha_ * *(idat.rij)); + derfcVal = - alphaPi_ * exp(-alpha2_ * *(idat.r2)); c1 = erfcVal * ri; c2 = (-derfcVal + c1) * ri; c3 = -2.0 * derfcVal * alpha2_ + 3.0 * c2 * ri; @@ -760,13 +853,18 @@ namespace OpenMD { // calculate the potential pot_term = c2 * scale; vterm = pref * ct_i * pot_term; - *(idat.vpair) += vterm; + vpair += vterm; epot += *(idat.sw) * vterm; // calculate derivatives for the forces and torques dVdr += preSw * (uz_i * c2ri - ct_i * rhat * sc2 * c3); duduz_i += preSw * pot_term * rhat; } + + if (j_is_Fluctuating) { + *(idat.dVdFQ2) += ( *(idat.sw) * vterm ) / q_j; + } + } if (j_is_Dipole) { @@ -783,16 +881,23 @@ namespace OpenMD { vterm = pref * ( ri3 * (ct_ij - 3.0 * ct_i * ct_j) - preRF2_ * ct_ij ); - *(idat.vpair) += vterm; + vpair += vterm; epot += *(idat.sw) * vterm; a1 = 5.0 * ct_i * ct_j - ct_ij; - dVdr += preSw * 3.0 * ri4 * (a1 * rhat - ct_i * uz_j - ct_j * uz_i); + dVdr += preSw * three * ri4 * (a1 * rhat - ct_i * uz_j - ct_j * uz_i); - duduz_i += preSw * (ri3 * (uz_j - 3.0 * ct_j * rhat) - preRF2_*uz_j); - duduz_j += preSw * (ri3 * (uz_i - 3.0 * ct_i * rhat) - preRF2_*uz_i); + duduz_i += preSw * (ri3 * (uz_j - three * ct_j * rhat) - preRF2_*uz_j); + duduz_j += preSw * (ri3 * (uz_i - three * ct_i * rhat) - preRF2_*uz_i); + if (idat.excluded) { + indirect_vpair += - pref * preRF2_ * ct_ij; + indirect_Pot += - preSw * preRF2_ * ct_ij; + indirect_duduz_i += -preSw * preRF2_ * uz_j; + indirect_duduz_j += -preSw * preRF2_ * uz_i; + } + } else { if (i_is_SplitDipole) { @@ -815,9 +920,11 @@ namespace OpenMD { } if (screeningMethod_ == DAMPED) { // assemble damping variables - res = erfcSpline_->getValueAndDerivativeAt( *(idat.rij) ); - erfcVal = res.first; - derfcVal = res.second; + //res = erfcSpline_->getValueAndDerivativeAt( *(idat.rij) ); + //erfcVal = res.first; + //derfcVal = res.second; + erfcVal = erfc(dampingAlpha_ * *(idat.rij)); + derfcVal = - alphaPi_ * exp(-alpha2_ * *(idat.r2)); c1 = erfcVal * ri; c2 = (-derfcVal + c1) * ri; c3 = -2.0 * derfcVal * alpha2_ + 3.0 * c2 * ri; @@ -842,7 +949,7 @@ namespace OpenMD { // calculate the potential pot_term = (ct_ij * c2ri - ctidotj * c3); vterm = pref * pot_term; - *(idat.vpair) += vterm; + vpair += vterm; epot += *(idat.sw) * vterm; // calculate derivatives for the forces and torques @@ -866,9 +973,11 @@ namespace OpenMD { if (screeningMethod_ == DAMPED) { // assemble the damping variables - res = erfcSpline_->getValueAndDerivativeAt( *(idat.rij) ); - erfcVal = res.first; - derfcVal = res.second; + //res = erfcSpline_->getValueAndDerivativeAt( *(idat.rij) ); + //erfcVal = res.first; + //derfcVal = res.second; + erfcVal = erfc(dampingAlpha_ * *(idat.rij)); + derfcVal = - alphaPi_ * exp(-alpha2_ * *(idat.r2)); c1 = erfcVal * riji; c2 = (-derfcVal + c1) * riji; c3 = -2.0 * derfcVal * alpha2_ + 3.0 * c2 * riji; @@ -885,7 +994,7 @@ namespace OpenMD { c2ri = c2 * riji; c3ri = c3 * riji; c4rij = c4 * *(idat.rij) ; - rhatdot2 = 2.0 * rhat * c3; + rhatdot2 = two * rhat * c3; rhatc4 = rhat * c4rij; // calculate the potential @@ -894,159 +1003,87 @@ namespace OpenMD { qzz_i * (cz2 * c3 - c2ri) ); vterm = pref * pot_term; - *(idat.vpair) += vterm; + vpair += vterm; epot += *(idat.sw) * vterm; // calculate the derivatives for the forces and torques - dVdr += -preSw * (qxx_i* (cx2*rhatc4 - (2.0*cx_i*ux_i + rhat)*c3ri) + - qyy_i* (cy2*rhatc4 - (2.0*cy_i*uy_i + rhat)*c3ri) + - qzz_i* (cz2*rhatc4 - (2.0*cz_i*uz_i + rhat)*c3ri)); + dVdr += -preSw * (qxx_i* (cx2*rhatc4 - (two*cx_i*ux_i + rhat)*c3ri) + + qyy_i* (cy2*rhatc4 - (two*cy_i*uy_i + rhat)*c3ri) + + qzz_i* (cz2*rhatc4 - (two*cz_i*uz_i + rhat)*c3ri)); dudux_i += preSw * qxx_i * cx_i * rhatdot2; duduy_i += preSw * qyy_i * cy_i * rhatdot2; duduz_i += preSw * qzz_i * cz_i * rhatdot2; + + if (j_is_Fluctuating) { + *(idat.dVdFQ2) += ( *(idat.sw) * vterm ) / q_j; + } + } } - idat.pot[ELECTROSTATIC_FAMILY] += epot; - *(idat.f1) += dVdr; - if (i_is_Dipole || i_is_Quadrupole) - *(idat.t1) -= cross(uz_i, duduz_i); - if (i_is_Quadrupole) { - *(idat.t1) -= cross(ux_i, dudux_i); - *(idat.t1) -= cross(uy_i, duduy_i); - } - - if (j_is_Dipole || j_is_Quadrupole) - *(idat.t2) -= cross(uz_j, duduz_j); - if (j_is_Quadrupole) { - *(idat.t2) -= cross(uz_j, dudux_j); - *(idat.t2) -= cross(uz_j, duduy_j); - } + if (!idat.excluded) { + *(idat.vpair) += vpair; + (*(idat.pot))[ELECTROSTATIC_FAMILY] += epot; + *(idat.f1) += dVdr; + + if (i_is_Dipole || i_is_Quadrupole) + *(idat.t1) -= cross(uz_i, duduz_i); + if (i_is_Quadrupole) { + *(idat.t1) -= cross(ux_i, dudux_i); + *(idat.t1) -= cross(uy_i, duduy_i); + } + + if (j_is_Dipole || j_is_Quadrupole) + *(idat.t2) -= cross(uz_j, duduz_j); + if (j_is_Quadrupole) { + *(idat.t2) -= cross(uz_j, dudux_j); + *(idat.t2) -= cross(uz_j, duduy_j); + } - return; - } + } else { - void Electrostatic::calcSkipCorrection(InteractionData &idat) { + // only accumulate the forces and torques resulting from the + // indirect reaction field terms. - if (!initialized_) initialize(); - - ElectrostaticAtomData data1 = ElectrostaticMap[idat.atypes.first]; - ElectrostaticAtomData data2 = ElectrostaticMap[idat.atypes.second]; - - // logicals - - bool i_is_Charge = data1.is_Charge; - bool i_is_Dipole = data1.is_Dipole; - - bool j_is_Charge = data2.is_Charge; - bool j_is_Dipole = data2.is_Dipole; - - RealType q_i, q_j; - - // The skippedCharge computation is needed by the real-space cutoff methods - // (i.e. shifted force and shifted potential) - - if (i_is_Charge) { - q_i = data1.charge; - *(idat.skippedCharge2) += q_i; - } - - if (j_is_Charge) { - q_j = data2.charge; - *(idat.skippedCharge1) += q_j; - } - - // the rest of this function should only be necessary for reaction field. - - if (summationMethod_ == esm_REACTION_FIELD) { - RealType riji, ri2, ri3; - RealType mu_i, ct_i; - RealType mu_j, ct_j; - RealType preVal, rfVal, vterm, dudr, pref, myPot(0.0); - Vector3d dVdr, uz_i, uz_j, duduz_i, duduz_j, rhat; - - // some variables we'll need independent of electrostatic type: + *(idat.vpair) += indirect_vpair; + (*(idat.pot))[ELECTROSTATIC_FAMILY] += indirect_Pot; + *(idat.f1) += indirect_dVdr; - riji = 1.0 / *(idat.rij) ; - rhat = *(idat.d) * riji; - - if (i_is_Dipole) { - mu_i = data1.dipole_moment; - uz_i = idat.eFrame1->getColumn(2); - ct_i = dot(uz_i, rhat); - duduz_i = V3Zero; - } - - if (j_is_Dipole) { - mu_j = data2.dipole_moment; - uz_j = idat.eFrame2->getColumn(2); - ct_j = dot(uz_j, rhat); - duduz_j = V3Zero; - } - - if (i_is_Charge) { - if (j_is_Charge) { - preVal = *(idat.electroMult) * pre11_ * q_i * q_j; - rfVal = preRF_ * *(idat.rij) * *(idat.rij) ; - vterm = preVal * rfVal; - myPot += *(idat.sw) * vterm; - dudr = *(idat.sw) * preVal * 2.0 * rfVal * riji; - dVdr += dudr * rhat; - } - - if (j_is_Dipole) { - ri2 = riji * riji; - ri3 = ri2 * riji; - pref = *(idat.electroMult) * pre12_ * q_i * mu_j; - vterm = - pref * ct_j * ( ri2 - preRF2_ * *(idat.rij) ); - myPot += *(idat.sw) * vterm; - dVdr += - *(idat.sw) * pref * ( ri3 * ( uz_j - 3.0 * ct_j * rhat) - preRF2_ * uz_j); - duduz_j += - *(idat.sw) * pref * rhat * (ri2 - preRF2_ * *(idat.rij) ); - } - } - if (i_is_Dipole) { - if (j_is_Charge) { - ri2 = riji * riji; - ri3 = ri2 * riji; - pref = *(idat.electroMult) * pre12_ * q_j * mu_i; - vterm = - pref * ct_i * ( ri2 - preRF2_ * *(idat.rij) ); - myPot += *(idat.sw) * vterm; - dVdr += *(idat.sw) * pref * ( ri3 * ( uz_i - 3.0 * ct_i * rhat) - preRF2_ * uz_i); - duduz_i += *(idat.sw) * pref * rhat * (ri2 - preRF2_ * *(idat.rij)); - } - } - - // accumulate the forces and torques resulting from the self term - idat.pot[ELECTROSTATIC_FAMILY] += myPot; - *(idat.f1) += dVdr; - if (i_is_Dipole) - *(idat.t1) -= cross(uz_i, duduz_i); + *(idat.t1) -= cross(uz_i, indirect_duduz_i); if (j_is_Dipole) - *(idat.t2) -= cross(uz_j, duduz_j); + *(idat.t2) -= cross(uz_j, indirect_duduz_j); } - } + + return; + } void Electrostatic::calcSelfCorrection(SelfData &sdat) { - RealType mu1, preVal, chg1, self; - + RealType mu1, preVal, self; if (!initialized_) initialize(); - + ElectrostaticAtomData data = ElectrostaticMap[sdat.atype]; // logicals - bool i_is_Charge = data.is_Charge; bool i_is_Dipole = data.is_Dipole; + bool i_is_Fluctuating = data.is_Fluctuating; + RealType chg1 = data.fixedCharge; + + if (i_is_Fluctuating) { + chg1 += *(sdat.flucQ); + // dVdFQ is really a force, so this is negative the derivative + *(sdat.dVdFQ) -= *(sdat.flucQ) * data.hardness + data.electronegativity; + } if (summationMethod_ == esm_REACTION_FIELD) { if (i_is_Dipole) { mu1 = data.dipole_moment; preVal = pre22_ * preRF2_ * mu1 * mu1; - sdat.pot[2] -= 0.5 * preVal; + (*(sdat.pot))[ELECTROSTATIC_FAMILY] -= 0.5 * preVal; // The self-correction term adds into the reaction field vector Vector3d uz_i = sdat.eFrame->getColumn(2); @@ -1057,13 +1094,12 @@ namespace OpenMD { } } else if (summationMethod_ == esm_SHIFTED_FORCE || summationMethod_ == esm_SHIFTED_POTENTIAL) { if (i_is_Charge) { - chg1 = data.charge; if (screeningMethod_ == DAMPED) { self = - 0.5 * (c1c_ + alphaPi_) * chg1 * (chg1 + *(sdat.skippedCharge)) * pre11_; } else { self = - 0.5 * rcuti_ * chg1 * (chg1 + *(sdat.skippedCharge)) * pre11_; } - sdat.pot[ELECTROSTATIC_FAMILY] += self; + (*(sdat.pot))[ELECTROSTATIC_FAMILY] += self; } } }