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