OpenMD 3.0
Molecular Dynamics in the Open
Loading...
Searching...
No Matches
EAMAdapter.cpp
1/*
2 * Copyright (c) 2004-present, The University of Notre Dame. All rights
3 * reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions are met:
7 *
8 * 1. Redistributions of source code must retain the above copyright notice,
9 * this list of conditions and the following disclaimer.
10 *
11 * 2. Redistributions in binary form must reproduce the above copyright notice,
12 * this list of conditions and the following disclaimer in the documentation
13 * and/or other materials provided with the distribution.
14 *
15 * 3. Neither the name of the copyright holder nor the names of its
16 * contributors may be used to endorse or promote products derived from
17 * this software without specific prior written permission.
18 *
19 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
20 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
21 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
22 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
23 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
24 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
25 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
26 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
27 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
28 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
29 * POSSIBILITY OF SUCH DAMAGE.
30 *
31 * SUPPORT OPEN SCIENCE! If you use OpenMD or its source code in your
32 * research, please cite the appropriate papers when you publish your
33 * work. Good starting points are:
34 *
35 * [1] Meineke, et al., J. Comp. Chem. 26, 252-271 (2005).
36 * [2] Fennell & Gezelter, J. Chem. Phys. 124, 234104 (2006).
37 * [3] Sun, Lin & Gezelter, J. Chem. Phys. 128, 234107 (2008).
38 * [4] Vardeman, Stocker & Gezelter, J. Chem. Theory Comput. 7, 834 (2011).
39 * [5] Kuang & Gezelter, Mol. Phys., 110, 691-701 (2012).
40 * [6] Lamichhane, Gezelter & Newman, J. Chem. Phys. 141, 134109 (2014).
41 * [7] Lamichhane, Newman & Gezelter, J. Chem. Phys. 141, 134110 (2014).
42 * [8] Bhattarai, Newman & Gezelter, Phys. Rev. B 99, 094106 (2019).
43 */
44
45#include "types/EAMAdapter.hpp"
46
47#include <cmath>
48#include <cstdio>
49#include <memory>
50
51#include "utils/CaseConversion.hpp"
52#include "utils/simError.h"
53
54namespace OpenMD {
55
56 bool EAMAdapter::isEAM() { return at_->hasProperty(EAMtypeID); }
57
58 EAMParameters EAMAdapter::getEAMParam() {
59 if (!isEAM()) {
60 snprintf(painCave.errMsg, MAX_SIM_ERROR_MSG_LENGTH,
61 "EAMAdapter::getEAMParam was passed an atomType (%s)\n"
62 "\tthat does not appear to be an EAM atom.\n",
63 at_->getName().c_str());
64 painCave.severity = OPENMD_ERROR;
65 painCave.isFatal = 1;
66 simError();
67 }
68
69 std::shared_ptr<GenericData> data = at_->getPropertyByName(EAMtypeID);
70 if (data == nullptr) {
71 snprintf(painCave.errMsg, MAX_SIM_ERROR_MSG_LENGTH,
72 "EAMAdapter::getEAMParam could not find EAM\n"
73 "\tparameters for atomType %s.\n",
74 at_->getName().c_str());
75 painCave.severity = OPENMD_ERROR;
76 painCave.isFatal = 1;
77 simError();
78 }
79
80 std::shared_ptr<EAMData> eamData = std::dynamic_pointer_cast<EAMData>(data);
81 if (eamData == nullptr) {
82 snprintf(painCave.errMsg, MAX_SIM_ERROR_MSG_LENGTH,
83 "EAMAdapter::getEAMParam could not convert\n"
84 "\tGenericData to EAMData for atom type %s\n",
85 at_->getName().c_str());
86 painCave.severity = OPENMD_ERROR;
87 painCave.isFatal = 1;
88 simError();
89 }
90
91 return eamData->getData();
92 }
93
94 FuncflParameters EAMAdapter::getFuncflParam() {
95 if (!isEAM()) {
96 snprintf(painCave.errMsg, MAX_SIM_ERROR_MSG_LENGTH,
97 "EAMAdapter::getFuncflParam was passed an atomType (%s)\n"
98 "\tthat does not appear to be an EAM atom.\n",
99 at_->getName().c_str());
100 painCave.severity = OPENMD_ERROR;
101 painCave.isFatal = 1;
102 simError();
103 }
104
105 std::shared_ptr<GenericData> data = at_->getPropertyByName(FuncflTypeID);
106 if (data == nullptr) {
107 snprintf(painCave.errMsg, MAX_SIM_ERROR_MSG_LENGTH,
108 "EAMAdapter::getFuncflParam could not find Funcfl\n"
109 "\tparameters for atomType %s.\n",
110 at_->getName().c_str());
111 painCave.severity = OPENMD_ERROR;
112 painCave.isFatal = 1;
113 simError();
114 }
115
116 std::shared_ptr<FuncflData> funcflData =
117 std::dynamic_pointer_cast<FuncflData>(data);
118 if (funcflData == nullptr) {
119 snprintf(painCave.errMsg, MAX_SIM_ERROR_MSG_LENGTH,
120 "EAMAdapter::getFuncflParam could not convert\n"
121 "\tGenericData to FuncflData for atom type %s\n",
122 at_->getName().c_str());
123 painCave.severity = OPENMD_ERROR;
124 painCave.isFatal = 1;
125 simError();
126 }
127
128 return funcflData->getData();
129 }
130
131 ZhouParameters EAMAdapter::getZhouParam() {
132 if (!isEAM()) {
133 snprintf(painCave.errMsg, MAX_SIM_ERROR_MSG_LENGTH,
134 "EAMAdapter::getZhouParam was passed an atomType (%s)\n"
135 "\tthat does not appear to be an EAM atom.\n",
136 at_->getName().c_str());
137 painCave.severity = OPENMD_ERROR;
138 painCave.isFatal = 1;
139 simError();
140 }
141
142 std::shared_ptr<GenericData> data = at_->getPropertyByName(ZhouTypeID);
143 if (data == nullptr) {
144 snprintf(painCave.errMsg, MAX_SIM_ERROR_MSG_LENGTH,
145 "EAMAdapter::getZhouParam could not find Zhou\n"
146 "\tparameters for atomType %s.\n",
147 at_->getName().c_str());
148 painCave.severity = OPENMD_ERROR;
149 painCave.isFatal = 1;
150 simError();
151 }
152
153 std::shared_ptr<ZhouData> zhouData =
154 std::dynamic_pointer_cast<ZhouData>(data);
155 if (zhouData == nullptr) {
156 snprintf(painCave.errMsg, MAX_SIM_ERROR_MSG_LENGTH,
157 "EAMAdapter::getZhouParam could not convert\n"
158 "\tGenericData to ZhouData for atom type %s\n",
159 at_->getName().c_str());
160 painCave.severity = OPENMD_ERROR;
161 painCave.isFatal = 1;
162 simError();
163 }
164
165 return zhouData->getData();
166 }
167
168 EAMType EAMAdapter::getEAMType() {
169 EAMParameters eamParam = getEAMParam();
170 return eamParam.eamType;
171 }
172
173 std::string EAMAdapter::getLatticeType() {
174 EAMParameters eamParam = getEAMParam();
175 return eamParam.latticeType;
176 }
177
178 RealType EAMAdapter::getLatticeConstant() {
179 EAMParameters eamParam = getEAMParam();
180 return eamParam.latticeConstant;
181 }
182
183 CubicSplinePtr EAMAdapter::getZSpline() {
184 FuncflParameters funcflParam = getFuncflParam();
185 int nr = funcflParam.nr;
186 RealType dr = funcflParam.dr;
187 std::vector<RealType> rvals;
188
189 for (int i = 0; i < nr; i++)
190 rvals.push_back(RealType(i) * dr);
191
192 CubicSplinePtr cs {std::make_shared<CubicSpline>()};
193 cs->addPoints(rvals, funcflParam.Z);
194 return cs;
195 }
196
197 CubicSplinePtr EAMAdapter::getRhoSpline() {
198 FuncflParameters funcflParam = getFuncflParam();
199 int nr = funcflParam.nr;
200 RealType dr = funcflParam.dr;
201 std::vector<RealType> rvals;
202
203 for (int i = 0; i < nr; i++)
204 rvals.push_back(RealType(i) * dr);
205
206 CubicSplinePtr cs {std::make_shared<CubicSpline>()};
207 cs->addPoints(rvals, funcflParam.rho);
208 return cs;
209 }
210
211 CubicSplinePtr EAMAdapter::getFSpline() {
212 FuncflParameters funcflParam = getFuncflParam();
213 int nrho = funcflParam.nrho;
214 RealType drho = funcflParam.drho;
215 std::vector<RealType> rhovals;
216
217 for (int i = 0; i < nrho; i++) {
218 rhovals.push_back(RealType(i) * drho);
219 }
220
221 CubicSplinePtr cs {std::make_shared<CubicSpline>()};
222 cs->addPoints(rhovals, funcflParam.F);
223 return cs;
224 }
225
226 void EAMAdapter::makeFuncfl(RealType latticeConstant, std::string latticeType,
227 int nrho, RealType drho, int nr, RealType dr,
228 RealType rcut, vector<RealType> Z,
229 vector<RealType> rho, vector<RealType> F) {
230 if (isEAM()) {
231 at_->removeProperty(EAMtypeID);
232 at_->removeProperty(FuncflTypeID);
233 }
234
235 EAMParameters eamParam {};
236 FuncflParameters funcflParam {};
237
238 eamParam.eamType = eamFuncfl;
239 eamParam.latticeConstant = latticeConstant;
240 eamParam.latticeType = latticeType;
241
242 funcflParam.nrho = nrho;
243 funcflParam.drho = drho;
244 funcflParam.nr = nr;
245 funcflParam.dr = dr;
246 funcflParam.rcut = rcut;
247 funcflParam.Z = Z;
248 funcflParam.rho = rho;
249 funcflParam.F = F;
250
251 at_->addProperty(std::make_shared<EAMData>(EAMtypeID, eamParam));
252 at_->addProperty(std::make_shared<FuncflData>(FuncflTypeID, funcflParam));
253 }
254
255 void EAMAdapter::makeZhou2001(std::string latticeType, RealType re,
256 RealType fe, RealType rhoe, RealType alpha,
257 RealType beta, RealType A, RealType B,
258 RealType kappa, RealType lambda,
259 std::vector<RealType> Fn,
260 std::vector<RealType> F, RealType eta,
261 RealType Fe) {
262 if (isEAM()) {
263 at_->removeProperty(EAMtypeID);
264 at_->removeProperty(ZhouTypeID);
265 }
266
267 EAMParameters eamParam {};
268 ZhouParameters zhouParam {};
269
270 eamParam.eamType = eamZhou2001;
271
272 toUpper(latticeType);
273 eamParam.latticeType = latticeType;
274 // default to FCC if we don't specify HCP or BCC:
275 if (latticeType == "HCP")
276 eamParam.latticeConstant = re;
277 else if (latticeType == "BCC")
278 eamParam.latticeConstant = 2.0 * re / sqrt(3.0);
279 else
280 eamParam.latticeConstant = 2.0 * re / sqrt(2.0);
281
282 zhouParam.re = re;
283 zhouParam.fe = fe;
284 zhouParam.rhoe = rhoe;
285 zhouParam.alpha = alpha;
286 zhouParam.beta = beta;
287 zhouParam.A = A;
288 zhouParam.B = B;
289 zhouParam.kappa = kappa;
290 zhouParam.lambda = lambda;
291 zhouParam.Fn = Fn;
292 zhouParam.F = F;
293 zhouParam.eta = eta;
294 zhouParam.Fe = Fe;
295
296 at_->addProperty(std::make_shared<EAMData>(EAMtypeID, eamParam));
297 at_->addProperty(std::make_shared<ZhouData>(ZhouTypeID, zhouParam));
298 }
299
300 void EAMAdapter::makeZhou2004(std::string latticeType, RealType re,
301 RealType fe, RealType rhoe, RealType rhos,
302 RealType alpha, RealType beta, RealType A,
303 RealType B, RealType kappa, RealType lambda,
304 std::vector<RealType> Fn,
305 std::vector<RealType> F, RealType eta,
306 RealType Fe, RealType rhol, RealType rhoh) {
307 if (isEAM()) {
308 at_->removeProperty(EAMtypeID);
309 at_->removeProperty(ZhouTypeID);
310 }
311
312 EAMParameters eamParam {};
313 ZhouParameters zhouParam {};
314
315 eamParam.eamType = eamZhou2004;
316
317 toUpper(latticeType);
318 eamParam.latticeType = latticeType;
319 // default to FCC if we don't specify HCP or BCC:
320 if (latticeType == "HCP")
321 eamParam.latticeConstant = re;
322 else if (latticeType == "BCC")
323 eamParam.latticeConstant = 2.0 * re / sqrt(3.0);
324 else
325 eamParam.latticeConstant = 2.0 * re / sqrt(2.0);
326
327 zhouParam.re = re;
328 zhouParam.fe = fe;
329 zhouParam.rhoe = rhoe;
330 zhouParam.alpha = alpha;
331 zhouParam.beta = beta;
332 zhouParam.A = A;
333 zhouParam.B = B;
334 zhouParam.kappa = kappa;
335 zhouParam.lambda = lambda;
336 zhouParam.Fn = Fn;
337 zhouParam.F = F;
338 zhouParam.eta = eta;
339 zhouParam.Fe = Fe;
340 zhouParam.rhos = rhos;
341 zhouParam.rhol = rhol;
342 zhouParam.rhoh = rhoh;
343
344 at_->addProperty(std::make_shared<EAMData>(EAMtypeID, eamParam));
345 at_->addProperty(std::make_shared<ZhouData>(ZhouTypeID, zhouParam));
346 }
347
348 void EAMAdapter::makeZhou2005(std::string latticeType, RealType re,
349 RealType fe, RealType rhoe, RealType rhos,
350 RealType alpha, RealType beta, RealType A,
351 RealType B, RealType kappa, RealType lambda,
352 std::vector<RealType> Fn,
353 std::vector<RealType> F, RealType F3plus,
354 RealType F3minus, RealType eta, RealType Fe) {
355 if (isEAM()) {
356 at_->removeProperty(EAMtypeID);
357 at_->removeProperty(ZhouTypeID);
358 }
359
360 EAMParameters eamParam {};
361 ZhouParameters zhouParam {};
362
363 eamParam.eamType = eamZhou2005;
364
365 toUpper(latticeType);
366 eamParam.latticeType = latticeType;
367 // default to FCC if we don't specify HCP or BCC:
368 if (latticeType == "HCP")
369 eamParam.latticeConstant = re;
370 else if (latticeType == "BCC")
371 eamParam.latticeConstant = 2.0 * re / sqrt(3.0);
372 else
373 eamParam.latticeConstant = 2.0 * re / sqrt(2.0);
374
375 zhouParam.re = re;
376 zhouParam.fe = fe;
377 zhouParam.rhoe = rhoe;
378 zhouParam.alpha = alpha;
379 zhouParam.beta = beta;
380 zhouParam.A = A;
381 zhouParam.B = B;
382 zhouParam.kappa = kappa;
383 zhouParam.lambda = lambda;
384 zhouParam.Fn = Fn;
385 zhouParam.F = F;
386 zhouParam.F3plus = F3plus;
387 zhouParam.F3minus = F3minus;
388 zhouParam.eta = eta;
389 zhouParam.Fe = Fe;
390 zhouParam.rhos = rhos;
391
392 at_->addProperty(std::make_shared<EAMData>(EAMtypeID, eamParam));
393 at_->addProperty(std::make_shared<ZhouData>(ZhouTypeID, zhouParam));
394 }
395
396 void EAMAdapter::makeZhou2005Oxygen(RealType re, RealType fe, RealType alpha,
397 RealType beta, RealType A, RealType B,
398 RealType kappa, RealType lambda,
399 RealType gamma, RealType nu,
400 std::vector<RealType> OrhoLimits,
401 std::vector<RealType> OrhoE,
402 std::vector<std::vector<RealType>> OF) {
403 if (isEAM()) {
404 at_->removeProperty(EAMtypeID);
405 at_->removeProperty(ZhouTypeID);
406 }
407
408 EAMParameters eamParam {};
409 ZhouParameters zhouParam {};
410
411 eamParam.eamType = eamZhou2005Oxygen;
412
413 eamParam.latticeConstant = re;
414
415 zhouParam.re = re;
416 zhouParam.fe = fe;
417 zhouParam.alpha = alpha;
418 zhouParam.beta = beta;
419 zhouParam.A = A;
420 zhouParam.B = B;
421 zhouParam.kappa = kappa;
422 zhouParam.lambda = lambda;
423 zhouParam.gamma = gamma;
424 zhouParam.nu = nu;
425 zhouParam.OrhoLimits = OrhoLimits;
426 zhouParam.OrhoE = OrhoE;
427 zhouParam.OF = OF;
428
429 at_->addProperty(std::make_shared<EAMData>(EAMtypeID, eamParam));
430 at_->addProperty(std::make_shared<ZhouData>(ZhouTypeID, zhouParam));
431 }
432
433 void EAMAdapter::makeZhouRose(RealType re, RealType fe, RealType rhoe,
434 RealType alpha, RealType beta, RealType A,
435 RealType B, RealType kappa, RealType lambda,
436 RealType F0) {
437 if (isEAM()) {
438 at_->removeProperty(EAMtypeID);
439 at_->removeProperty(ZhouTypeID);
440 }
441
442 EAMParameters eamParam {};
443 ZhouParameters zhouParam {};
444
445 eamParam.eamType = eamZhouRose;
446 eamParam.latticeConstant = re;
447 zhouParam.re = re;
448 zhouParam.fe = fe;
449 zhouParam.rhoe = rhoe;
450 zhouParam.alpha = alpha;
451 zhouParam.beta = beta;
452 zhouParam.A = A;
453 zhouParam.B = B;
454 zhouParam.kappa = kappa;
455 zhouParam.lambda = lambda;
456 zhouParam.F0 = F0;
457
458 at_->addProperty(std::make_shared<EAMData>(EAMtypeID, eamParam));
459 at_->addProperty(std::make_shared<ZhouData>(ZhouTypeID, zhouParam));
460 }
461
462 void EAMAdapter::makeOxygenFuncfl(RealType re, RealType fe, RealType alpha,
463 RealType beta, RealType A, RealType B,
464 RealType kappa, RealType lambda,
465 RealType drho, RealType nrho,
466 std::vector<RealType> F) {
467 if (isEAM()) {
468 at_->removeProperty(EAMtypeID);
469 at_->removeProperty(ZhouTypeID);
470 at_->removeProperty(FuncflTypeID);
471 }
472
473 EAMParameters eamParam {};
474 FuncflParameters funcflParam {};
475 ZhouParameters zhouParam {};
476
477 eamParam.eamType = eamOxygenFuncfl;
478 eamParam.latticeConstant = re;
479 zhouParam.re = re;
480 zhouParam.fe = fe;
481 zhouParam.alpha = alpha;
482 zhouParam.beta = beta;
483 zhouParam.A = A;
484 zhouParam.B = B;
485 zhouParam.kappa = kappa;
486 zhouParam.lambda = lambda;
487
488 funcflParam.F = F;
489 funcflParam.drho = drho;
490 funcflParam.nrho = nrho;
491
492 at_->addProperty(std::make_shared<EAMData>(EAMtypeID, eamParam));
493 at_->addProperty(std::make_shared<ZhouData>(ZhouTypeID, zhouParam));
494 at_->addProperty(std::make_shared<FuncflData>(FuncflTypeID, funcflParam));
495 }
496
497 int EAMAdapter::getNrho() {
498 FuncflParameters funcflParam = getFuncflParam();
499 return funcflParam.nrho;
500 }
501
502 RealType EAMAdapter::getDrho() {
503 FuncflParameters funcflParam = getFuncflParam();
504 return funcflParam.drho;
505 }
506
507 int EAMAdapter::getNr() {
508 FuncflParameters funcflParam = getFuncflParam();
509 return funcflParam.nr;
510 }
511
512 RealType EAMAdapter::getDr() {
513 FuncflParameters funcflParam = getFuncflParam();
514 return funcflParam.dr;
515 }
516
517 RealType EAMAdapter::getRcut() {
518 FuncflParameters funcflParam = getFuncflParam();
519 return funcflParam.rcut;
520 }
521
522 RealType EAMAdapter::getRe() {
523 ZhouParameters zhouParam = getZhouParam();
524 return zhouParam.re;
525 }
526 RealType EAMAdapter::get_fe() {
527 ZhouParameters zhouParam = getZhouParam();
528 return zhouParam.fe;
529 }
530 RealType EAMAdapter::getRhoe() {
531 ZhouParameters zhouParam = getZhouParam();
532 return zhouParam.rhoe;
533 }
534 RealType EAMAdapter::getAlpha() {
535 ZhouParameters zhouParam = getZhouParam();
536 return zhouParam.alpha;
537 }
538 RealType EAMAdapter::getBeta() {
539 ZhouParameters zhouParam = getZhouParam();
540 return zhouParam.beta;
541 }
542 RealType EAMAdapter::getA() {
543 ZhouParameters zhouParam = getZhouParam();
544 return zhouParam.A;
545 }
546 RealType EAMAdapter::getB() {
547 ZhouParameters zhouParam = getZhouParam();
548 return zhouParam.B;
549 }
550 RealType EAMAdapter::getKappa() {
551 ZhouParameters zhouParam = getZhouParam();
552 return zhouParam.kappa;
553 }
554 RealType EAMAdapter::getLambda() {
555 ZhouParameters zhouParam = getZhouParam();
556 return zhouParam.lambda;
557 }
558 RealType EAMAdapter::getGamma() {
559 ZhouParameters zhouParam = getZhouParam();
560 return zhouParam.gamma;
561 }
562 RealType EAMAdapter::getNu() {
563 ZhouParameters zhouParam = getZhouParam();
564 return zhouParam.nu;
565 }
566 std::vector<RealType> EAMAdapter::getFn() {
567 ZhouParameters zhouParam = getZhouParam();
568 return zhouParam.Fn;
569 }
570 std::vector<RealType> EAMAdapter::getF() {
571 ZhouParameters zhouParam = getZhouParam();
572 return zhouParam.F;
573 }
574 RealType EAMAdapter::getF3plus() {
575 ZhouParameters zhouParam = getZhouParam();
576 return zhouParam.F3plus;
577 }
578 RealType EAMAdapter::getF3minus() {
579 ZhouParameters zhouParam = getZhouParam();
580 return zhouParam.F3minus;
581 }
582
583 RealType EAMAdapter::getEta() {
584 ZhouParameters zhouParam = getZhouParam();
585 return zhouParam.eta;
586 }
587
588 RealType EAMAdapter::getFe() {
589 ZhouParameters zhouParam = getZhouParam();
590 return zhouParam.Fe;
591 }
592
593 RealType EAMAdapter::getRhos() {
594 ZhouParameters zhouParam = getZhouParam();
595 return zhouParam.rhos;
596 }
597
598 RealType EAMAdapter::getRhol() {
599 ZhouParameters zhouParam = getZhouParam();
600 return zhouParam.rhol;
601 }
602
603 RealType EAMAdapter::getRhoh() {
604 ZhouParameters zhouParam = getZhouParam();
605 return zhouParam.rhoh;
606 }
607
608 std::vector<RealType> EAMAdapter::getOrhoLimits() {
609 ZhouParameters zhouParam = getZhouParam();
610 return zhouParam.OrhoLimits;
611 }
612 std::vector<RealType> EAMAdapter::getOrhoE() {
613 ZhouParameters zhouParam = getZhouParam();
614 return zhouParam.OrhoE;
615 }
616
617 std::vector<std::vector<RealType>> EAMAdapter::getOF() {
618 ZhouParameters zhouParam = getZhouParam();
619 return zhouParam.OF;
620 }
621 RealType EAMAdapter::getF0() {
622 ZhouParameters zhouParam = getZhouParam();
623 return zhouParam.F0;
624 }
625} // namespace OpenMD
OpenMD::AtomType::getPropertyByName
std::shared_ptr< GenericData > getPropertyByName(const string &propName)
Returns property.
Definition AtomType.cpp:134
OpenMD::AtomType::removeProperty
void removeProperty(const string &propName)
Removes property from PropertyMap by name.
Definition AtomType.cpp:114
OpenMD::AtomType::hasProperty
bool hasProperty(const string &propName)
Checks if property is in this PropertyMap.
Definition AtomType.cpp:127
OpenMD::AtomType::addProperty
void addProperty(std::shared_ptr< GenericData > genData)
Adds property into property map.
Definition AtomType.cpp:109
OpenMD
This basic Periodic Table class was originally taken from the data.cpp file in OpenBabel.
Definition ActionCorrFunc.cpp:60