| 47 |
|
#include "nonbonded/Electrostatic.hpp" |
| 48 |
|
#include "utils/simError.h" |
| 49 |
|
#include "types/NonBondedInteractionType.hpp" |
| 50 |
< |
#include "types/DirectionalAtomType.hpp" |
| 50 |
> |
#include "types/FixedChargeAdapter.hpp" |
| 51 |
> |
#include "types/MultipoleAdapter.hpp" |
| 52 |
|
#include "io/Globals.hpp" |
| 53 |
|
|
| 54 |
|
namespace OpenMD { |
| 281 |
|
electrostaticAtomData.is_SplitDipole = false; |
| 282 |
|
electrostaticAtomData.is_Quadrupole = false; |
| 283 |
|
|
| 284 |
< |
if (atomType->isCharge()) { |
| 284 |
< |
GenericData* data = atomType->getPropertyByName("Charge"); |
| 284 |
> |
FixedChargeAdapter fca = FixedChargeAdapter(atomType); |
| 285 |
|
|
| 286 |
< |
if (data == NULL) { |
| 287 |
< |
sprintf( painCave.errMsg, "Electrostatic::addType could not find " |
| 288 |
< |
"Charge\n" |
| 289 |
< |
"\tparameters for atomType %s.\n", |
| 290 |
< |
atomType->getName().c_str()); |
| 291 |
< |
painCave.severity = OPENMD_ERROR; |
| 292 |
< |
painCave.isFatal = 1; |
| 293 |
< |
simError(); |
| 294 |
< |
} |
| 295 |
< |
|
| 296 |
< |
DoubleGenericData* doubleData = dynamic_cast<DoubleGenericData*>(data); |
| 297 |
< |
if (doubleData == NULL) { |
| 298 |
< |
sprintf( painCave.errMsg, |
| 299 |
< |
"Electrostatic::addType could not convert GenericData to " |
| 300 |
< |
"Charge for\n" |
| 301 |
< |
"\tatom type %s\n", atomType->getName().c_str()); |
| 302 |
< |
painCave.severity = OPENMD_ERROR; |
| 303 |
< |
painCave.isFatal = 1; |
| 304 |
< |
simError(); |
| 305 |
< |
} |
| 286 |
> |
if (fca.isFixedCharge()) { |
| 287 |
|
electrostaticAtomData.is_Charge = true; |
| 288 |
< |
electrostaticAtomData.charge = doubleData->getData(); |
| 288 |
> |
electrostaticAtomData.charge = fca.getCharge(); |
| 289 |
|
} |
| 290 |
|
|
| 291 |
< |
if (atomType->isDirectional()) { |
| 292 |
< |
DirectionalAtomType* daType = dynamic_cast<DirectionalAtomType*>(atomType); |
| 293 |
< |
|
| 313 |
< |
if (daType->isDipole()) { |
| 314 |
< |
GenericData* data = daType->getPropertyByName("Dipole"); |
| 315 |
< |
|
| 316 |
< |
if (data == NULL) { |
| 317 |
< |
sprintf( painCave.errMsg, |
| 318 |
< |
"Electrostatic::addType could not find Dipole\n" |
| 319 |
< |
"\tparameters for atomType %s.\n", |
| 320 |
< |
daType->getName().c_str()); |
| 321 |
< |
painCave.severity = OPENMD_ERROR; |
| 322 |
< |
painCave.isFatal = 1; |
| 323 |
< |
simError(); |
| 324 |
< |
} |
| 325 |
< |
|
| 326 |
< |
DoubleGenericData* doubleData = dynamic_cast<DoubleGenericData*>(data); |
| 327 |
< |
if (doubleData == NULL) { |
| 328 |
< |
sprintf( painCave.errMsg, |
| 329 |
< |
"Electrostatic::addType could not convert GenericData to " |
| 330 |
< |
"Dipole Moment\n" |
| 331 |
< |
"\tfor atom type %s\n", daType->getName().c_str()); |
| 332 |
< |
painCave.severity = OPENMD_ERROR; |
| 333 |
< |
painCave.isFatal = 1; |
| 334 |
< |
simError(); |
| 335 |
< |
} |
| 291 |
> |
MultipoleAdapter ma = MultipoleAdapter(atomType); |
| 292 |
> |
if (ma.isMultipole()) { |
| 293 |
> |
if (ma.isDipole()) { |
| 294 |
|
electrostaticAtomData.is_Dipole = true; |
| 295 |
< |
electrostaticAtomData.dipole_moment = doubleData->getData(); |
| 295 |
> |
electrostaticAtomData.dipole_moment = ma.getDipoleMoment(); |
| 296 |
|
} |
| 297 |
< |
|
| 340 |
< |
if (daType->isSplitDipole()) { |
| 341 |
< |
GenericData* data = daType->getPropertyByName("SplitDipoleDistance"); |
| 342 |
< |
|
| 343 |
< |
if (data == NULL) { |
| 344 |
< |
sprintf(painCave.errMsg, |
| 345 |
< |
"Electrostatic::addType could not find SplitDipoleDistance\n" |
| 346 |
< |
"\tparameter for atomType %s.\n", |
| 347 |
< |
daType->getName().c_str()); |
| 348 |
< |
painCave.severity = OPENMD_ERROR; |
| 349 |
< |
painCave.isFatal = 1; |
| 350 |
< |
simError(); |
| 351 |
< |
} |
| 352 |
< |
|
| 353 |
< |
DoubleGenericData* doubleData = dynamic_cast<DoubleGenericData*>(data); |
| 354 |
< |
if (doubleData == NULL) { |
| 355 |
< |
sprintf( painCave.errMsg, |
| 356 |
< |
"Electrostatic::addType could not convert GenericData to " |
| 357 |
< |
"SplitDipoleDistance for\n" |
| 358 |
< |
"\tatom type %s\n", daType->getName().c_str()); |
| 359 |
< |
painCave.severity = OPENMD_ERROR; |
| 360 |
< |
painCave.isFatal = 1; |
| 361 |
< |
simError(); |
| 362 |
< |
} |
| 297 |
> |
if (ma.isSplitDipole()) { |
| 298 |
|
electrostaticAtomData.is_SplitDipole = true; |
| 299 |
< |
electrostaticAtomData.split_dipole_distance = doubleData->getData(); |
| 299 |
> |
electrostaticAtomData.split_dipole_distance = ma.getSplitDipoleDistance(); |
| 300 |
|
} |
| 301 |
< |
|
| 367 |
< |
if (daType->isQuadrupole()) { |
| 368 |
< |
GenericData* data = daType->getPropertyByName("QuadrupoleMoments"); |
| 369 |
< |
|
| 370 |
< |
if (data == NULL) { |
| 371 |
< |
sprintf( painCave.errMsg, |
| 372 |
< |
"Electrostatic::addType could not find QuadrupoleMoments\n" |
| 373 |
< |
"\tparameter for atomType %s.\n", |
| 374 |
< |
daType->getName().c_str()); |
| 375 |
< |
painCave.severity = OPENMD_ERROR; |
| 376 |
< |
painCave.isFatal = 1; |
| 377 |
< |
simError(); |
| 378 |
< |
} |
| 379 |
< |
|
| 301 |
> |
if (ma.isQuadrupole()) { |
| 302 |
|
// Quadrupoles in OpenMD are set as the diagonal elements |
| 303 |
|
// of the diagonalized traceless quadrupole moment tensor. |
| 304 |
|
// The column vectors of the unitary matrix that diagonalizes |
| 305 |
|
// the quadrupole moment tensor become the eFrame (or the |
| 306 |
|
// electrostatic version of the body-fixed frame. |
| 385 |
– |
|
| 386 |
– |
Vector3dGenericData* v3dData = dynamic_cast<Vector3dGenericData*>(data); |
| 387 |
– |
if (v3dData == NULL) { |
| 388 |
– |
sprintf( painCave.errMsg, |
| 389 |
– |
"Electrostatic::addType could not convert GenericData to " |
| 390 |
– |
"Quadrupole Moments for\n" |
| 391 |
– |
"\tatom type %s\n", daType->getName().c_str()); |
| 392 |
– |
painCave.severity = OPENMD_ERROR; |
| 393 |
– |
painCave.isFatal = 1; |
| 394 |
– |
simError(); |
| 395 |
– |
} |
| 307 |
|
electrostaticAtomData.is_Quadrupole = true; |
| 308 |
< |
electrostaticAtomData.quadrupole_moments = v3dData->getData(); |
| 308 |
> |
electrostaticAtomData.quadrupole_moments = ma.getQuadrupoleMoments(); |
| 309 |
|
} |
| 310 |
|
} |
| 311 |
|
|
| 401 |
– |
AtomTypeProperties atp = atomType->getATP(); |
| 312 |
|
|
| 313 |
|
pair<map<int,AtomType*>::iterator,bool> ret; |
| 314 |
< |
ret = ElectrostaticList.insert( pair<int,AtomType*>(atp.ident, atomType) ); |
| 314 |
> |
ret = ElectrostaticList.insert( pair<int,AtomType*>(atomType->getIdent(), |
| 315 |
> |
atomType) ); |
| 316 |
|
if (ret.second == false) { |
| 317 |
|
sprintf( painCave.errMsg, |
| 318 |
|
"Electrostatic already had a previous entry with ident %d\n", |
| 319 |
< |
atp.ident); |
| 319 |
> |
atomType->getIdent() ); |
| 320 |
|
painCave.severity = OPENMD_INFO; |
| 321 |
|
painCave.isFatal = 0; |
| 322 |
|
simError(); |
