kim-api 2.3.0+AppleClang.AppleClang.GNU
An Application Programming Interface (API) for the Knowledgebase of Interatomic Models (KIM).
Loading...
Searching...
No Matches
ex_model_driver_P_Morse.c
Go to the documentation of this file.
1/* */
2/* KIM-API: An API for interatomic models */
3/* Copyright (c) 2013--2022, Regents of the University of Minnesota. */
4/* All rights reserved. */
5/* */
6/* Contributors: */
7/* Ryan S. Elliott */
8/* Ellad B. Tadmor */
9/* Stephen M. Whalen */
10/* */
11/* SPDX-License-Identifier: LGPL-2.1-or-later */
12/* */
13/* This library is free software; you can redistribute it and/or */
14/* modify it under the terms of the GNU Lesser General Public */
15/* License as published by the Free Software Foundation; either */
16/* version 2.1 of the License, or (at your option) any later version. */
17/* */
18/* This library is distributed in the hope that it will be useful, */
19/* but WITHOUT ANY WARRANTY; without even the implied warranty of */
20/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU */
21/* Lesser General Public License for more details. */
22/* */
23/* You should have received a copy of the GNU Lesser General Public License */
24/* along with this library; if not, write to the Free Software Foundation, */
25/* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */
26/* */
27
28/******************************************************************************/
29/* */
30/* ex_model_driver_P_Morse pair potential KIM Model Driver */
31/* shifted to have zero energy at the cutoff radius */
32/* */
33/* Language: C */
34/* */
35/******************************************************************************/
36
37
38#include "KIM_LogMacros.h"
40#include <math.h>
41#include <stdio.h>
42#include <stdlib.h>
43
44#define TRUE 1
45#define FALSE 0
46
47/******************************************************************************/
48/* Below are the definitions for some constants */
49/******************************************************************************/
50#define DIM 3 /* dimensionality of space */
51#define SPECCODE 1 /* internal species code */
52#define SPEC_NAME_LEN 64 /* max length of species name string */
53#define SPEC_NAME_FMT "%63s"
54
55
56/* Define prototype for Model Driver init */
57int model_driver_create(KIM_ModelDriverCreate * const modelDriverCreate,
58 KIM_LengthUnit const requestedLengthUnit,
59 KIM_EnergyUnit const requestedEnergyUnit,
60 KIM_ChargeUnit const requestedChargeUnit,
61 KIM_TemperatureUnit const requestedTemperatureUnit,
62 KIM_TimeUnit const requestedTimeUnit);
63
64/* Define prototypes for destroy */
65/* defined as static to avoid namespace clashes with other codes */
66static int destroy_routine(KIM_ModelDestroy * const modelDestroy);
67
68/* Define prototype for routines */
69static int
70compute_routine(KIM_ModelCompute const * const modelCompute,
71 KIM_ModelComputeArguments const * const modelComputeArguments);
73 KIM_ModelCompute const * const modelCompute,
74 KIM_ModelComputeArgumentsCreate * const modelComputeArgumentsCreate);
76 KIM_ModelCompute const * const modelCompute,
77 KIM_ModelComputeArgumentsDestroy * const modelComputeArgumentsDestroy);
78static int refresh_routine(KIM_ModelRefresh * const modelRefresh);
79static int
81 modelWriteParameterizedModel);
82
83/* Define prototypes for pair potential calculations */
84static void calc_phi(double const * epsilon,
85 double const * C,
86 double const * Rzero,
87 double const * shift,
88 double const cutoff,
89 double const r,
90 double * phi);
91
92static void calc_phi_dphi(double const * epsilon,
93 double const * C,
94 double const * Rzero,
95 double const * shift,
96 double const cutoff,
97 double const r,
98 double * phi,
99 double * dphi);
100
101/* Define model_buffer structure */
103{
105 double cutoff;
106 double cutsq;
109 double epsilon;
110 double C;
111 double Rzero;
112 double shift;
113};
114
115
116/* Calculate pair potential phi(r) */
117static void calc_phi(double const * epsilon,
118 double const * C,
119 double const * Rzero,
120 double const * shift,
121 double const cutoff,
122 double const r,
123 double * phi)
124{
125 /* local variables */
126 double ep;
127 double ep2;
128
129 ep = exp(-(*C) * (r - *Rzero));
130 ep2 = ep * ep;
131
132 if (r > cutoff)
133 {
134 /* Argument exceeds cutoff radius */
135 *phi = 0.0;
136 }
137 else
138 {
139 *phi = (*epsilon) * (-ep2 + 2.0 * ep) + *shift;
140 }
141
142 return;
143}
144
145/* Calculate pair potential phi(r) and its derivative dphi(r) */
146static void calc_phi_dphi(double const * epsilon,
147 double const * C,
148 double const * Rzero,
149 double const * shift,
150 double const cutoff,
151 double const r,
152 double * phi,
153 double * dphi)
154{
155 /* local variables */
156 double ep;
157 double ep2;
158
159 ep = exp(-(*C) * (r - *Rzero));
160 ep2 = ep * ep;
161
162 if (r > cutoff)
163 {
164 /* Argument exceeds cutoff radius */
165 *phi = 0.0;
166 *dphi = 0.0;
167 }
168 else
169 {
170 *phi = (*epsilon) * (-ep2 + 2.0 * ep) + *shift;
171 *dphi = 2.0 * (*epsilon) * (*C) * (-ep + ep2);
172 }
173
174 return;
175}
176
177/* compute function */
178#undef KIM_LOGGER_FUNCTION_NAME
179#define KIM_LOGGER_FUNCTION_NAME KIM_ModelCompute_LogEntry
180#undef KIM_LOGGER_OBJECT_NAME
181#define KIM_LOGGER_OBJECT_NAME modelCompute
182static int
183compute_routine(KIM_ModelCompute const * const modelCompute,
184 KIM_ModelComputeArguments const * const modelComputeArguments)
185{
186 /* local variables */
187 double R;
188 double Rsqij;
189 double phi;
190 double dphi;
191 double dEidr;
192 double Rij[DIM];
193 int ier;
194 int i;
195 int j;
196 int jj;
197 int k;
198 int const * neighListOfCurrentPart;
199 struct model_buffer * buffer;
200 int comp_energy;
201 int comp_force;
202 int comp_particleEnergy;
203
204 int * nParts;
205 int * particleSpeciesCodes;
206 int * particleContributing;
207 double cutoff;
208 double * cutsq;
209 double * epsilon;
210 double * C;
211 double * Rzero;
212 double * shift;
213 double * coords;
214 double * energy;
215 double * force;
216 double * particleEnergy;
217 int numOfPartNeigh;
218
219 /* get buffer from KIM object */
220 KIM_ModelCompute_GetModelBufferPointer(modelCompute, (void **) &buffer);
221
222 /* unpack info from the buffer */
224 cutsq = &(buffer->cutsq);
225 epsilon = &(buffer->epsilon);
226 C = &(buffer->C);
227 Rzero = &(buffer->Rzero);
228 shift = &(buffer->shift);
229
231 modelComputeArguments,
233 &nParts)
235 modelComputeArguments,
237 &particleSpeciesCodes)
239 modelComputeArguments,
241 &particleContributing)
243 modelComputeArguments,
245 &coords)
247 modelComputeArguments,
249 &energy)
251 modelComputeArguments,
253 &force)
255 modelComputeArguments,
257 &particleEnergy);
258 if (ier)
259 {
260 LOG_ERROR("GetArgumentPointer");
261 return ier;
262 }
263
264 comp_energy = (energy != NULL);
265 comp_force = (force != NULL);
266 comp_particleEnergy = (particleEnergy != NULL);
267
268 /* Check to be sure that the species are correct */
269
270 ier = TRUE; /* assume an error */
271 for (i = 0; i < *nParts; ++i)
272 {
273 if (SPECCODE != particleSpeciesCodes[i])
274 {
275 LOG_ERROR("Unexpected species code detected");
276 return ier;
277 }
278 }
279 ier = FALSE; /* everything is ok */
280
281 /* initialize potential energies, forces, and virial term */
282 if (comp_particleEnergy)
283 {
284 for (i = 0; i < *nParts; ++i) { particleEnergy[i] = 0.0; }
285 }
286 if (comp_energy) { *energy = 0.0; }
287
288 if (comp_force)
289 {
290 for (i = 0; i < *nParts; ++i)
291 {
292 for (k = 0; k < DIM; ++k) { force[i * DIM + k] = 0.0; }
293 }
294 }
295
296 /* Compute energy and forces */
297
298 /* loop over particles and compute enregy and forces */
299 for (i = 0; i < *nParts; ++i)
300 {
301 if (particleContributing[i])
302 {
303 ier = KIM_ModelComputeArguments_GetNeighborList(modelComputeArguments,
304 0,
305 i,
306 &numOfPartNeigh,
307 &neighListOfCurrentPart);
308 if (ier)
309 {
310 /* some sort of problem, exit */
311 LOG_ERROR("KIM_get_neigh");
312 ier = TRUE;
313 return ier;
314 }
315
316 /* loop over the neighbors of particle i */
317 for (jj = 0; jj < numOfPartNeigh; ++jj)
318 {
319 j = neighListOfCurrentPart[jj]; /* get neighbor ID */
320
321 /* compute relative position vector and squared distance */
322 Rsqij = 0.0;
323 for (k = 0; k < DIM; ++k)
324 {
325 Rij[k] = coords[j * DIM + k] - coords[i * DIM + k];
326 /* compute squared distance */
327 Rsqij += Rij[k] * Rij[k];
328 }
329
330 /* compute energy and force */
331 if (Rsqij < *cutsq)
332 {
333 /* particles are interacting ? */
334 R = sqrt(Rsqij);
335 if (comp_force)
336 {
337 /* compute pair potential and its derivative */
338 calc_phi_dphi(epsilon, C, Rzero, shift, cutoff, R, &phi, &dphi);
339
340 /* compute dEidr */
341 dEidr = 0.5 * dphi;
342 }
343 else
344 {
345 /* compute just pair potential */
346 calc_phi(epsilon, C, Rzero, shift, cutoff, R, &phi);
347 }
348
349 /* contribution to energy */
350 if (comp_particleEnergy) { particleEnergy[i] += 0.5 * phi; }
351 if (comp_energy) { *energy += 0.5 * phi; }
352
353 /* contribution to forces */
354 if (comp_force)
355 {
356 for (k = 0; k < DIM; ++k)
357 {
358 force[i * DIM + k]
359 += dEidr * Rij[k] / R; /* accumulate force on i */
360 force[j * DIM + k]
361 -= dEidr * Rij[k] / R; /* accumulate force on j */
362 }
363 }
364 } /* if Rsqij */
365 } /* loop on jj */
366 } /* if particleContributing */
367 } /* infinite while loop (terminated by break statements above) */
368
369 /* everything is great */
370 ier = FALSE;
371
372 return ier;
373}
374
375/* Create function */
376#undef KIM_LOGGER_FUNCTION_NAME
377#define KIM_LOGGER_FUNCTION_NAME KIM_ModelDriverCreate_LogEntry
378#undef KIM_LOGGER_OBJECT_NAME
379#define KIM_LOGGER_OBJECT_NAME modelDriverCreate
380int model_driver_create(KIM_ModelDriverCreate * const modelDriverCreate,
381 KIM_LengthUnit const requestedLengthUnit,
382 KIM_EnergyUnit const requestedEnergyUnit,
383 KIM_ChargeUnit const requestedChargeUnit,
384 KIM_TemperatureUnit const requestedTemperatureUnit,
385 KIM_TimeUnit const requestedTimeUnit)
386{
387 /* KIM variables */
388 int numberOfParameterFiles;
389 char const * paramfiledirname;
390 char const * paramfilebasename;
391 char paramfile1name[2048];
392
393 /* Local variables */
394 FILE * fid;
395 char speciesNameString[SPEC_NAME_LEN];
397 double cutoff;
398 double epsilon;
399 double C;
400 double Rzero;
401 int ier;
402 double dummy;
403 struct model_buffer * buffer;
404
405 /* Use function pointer definitions to verify prototypes */
415
416
417 (void) create; /* avoid unused parameter warnings */
418 (void) requestedLengthUnit;
419 (void) requestedEnergyUnit;
420 (void) requestedChargeUnit;
421 (void) requestedTemperatureUnit;
422 (void) requestedTimeUnit;
423
424
425 /* using fixed units */
426 ier = KIM_ModelDriverCreate_SetUnits(modelDriverCreate,
432 if (ier == TRUE)
433 {
434 LOG_ERROR("Problem setting units");
435 return ier;
436 }
437
438 ier = KIM_ModelDriverCreate_SetModelNumbering(modelDriverCreate,
440 if (ier == TRUE)
441 {
442 LOG_ERROR("Unable to set numbering");
443 return ier;
444 }
445
446 /* store pointer to functions in KIM object */
448 modelDriverCreate,
451 TRUE,
452 (KIM_Function *) CACreate)
454 modelDriverCreate,
457 TRUE,
460 modelDriverCreate,
463 TRUE,
464 (KIM_Function *) refresh)
466 modelDriverCreate,
469 FALSE,
470 (KIM_Function *) writeModel)
472 modelDriverCreate,
475 TRUE,
476 (KIM_Function *) CADestroy)
478 modelDriverCreate,
481 TRUE,
482 (KIM_Function *) destroy);
483
484 /* get number of parameter files */
486 &numberOfParameterFiles);
487 /* set paramfile1name */
488 if (numberOfParameterFiles != 1)
489 {
490 ier = TRUE;
491 LOG_ERROR("Incorrect number of parameter files.");
492 return ier;
493 }
495 &paramfiledirname);
497 modelDriverCreate, 0, &paramfilebasename);
498 if (ier == TRUE)
499 {
500 LOG_ERROR("Unable to get parameter file basename.");
501 return ier;
502 }
503 sprintf(paramfile1name, "%s/%s", paramfiledirname, paramfilebasename);
504
505 /* Read in model parameters from parameter file */
506 fid = fopen(paramfile1name, "r");
507 if (fid == NULL)
508 {
509 ier = TRUE;
510 LOG_ERROR("Unable to open parameter file for Morse parameters");
511 return ier;
512 }
513
514 ier = fscanf(fid,
515 SPEC_NAME_FMT " \n%lf \n%lf \n%lf \n%lf",
516 speciesNameString, /* element symbol */
517 &cutoff, /* cutoff distance in angstroms */
518 &epsilon, /* Morse epsilon in eV */
519 &C, /* Morse C in 1/Angstroms */
520 &Rzero /* Morse Rzero in Angstroms */
521 );
522 fclose(fid);
523
524 /* check that we read the right number of parameters */
525 if (5 != ier)
526 {
527 ier = TRUE;
528 LOG_ERROR("Unable to read all parameters");
529 return ier;
530 }
531
532 /* register species */
533 speciesName = KIM_SpeciesName_FromString(speciesNameString);
535 modelDriverCreate, speciesName, SPECCODE);
536 if (ier == TRUE)
537 {
538 LOG_ERROR("Unable to set species code for Ar.");
539 return ier;
540 }
541
542
543 /* allocate buffer */
544 buffer = (struct model_buffer *) malloc(sizeof(struct model_buffer));
545 if (NULL == buffer)
546 {
547 ier = TRUE;
548 LOG_ERROR("malloc");
549 return ier;
550 }
551
552 /* setup buffer */
553 /* set value of parameters */
556 buffer->cutsq = (cutoff) * (cutoff);
558 sprintf(buffer->speciesName, "%s", speciesNameString);
559 buffer->epsilon = epsilon;
560 buffer->C = C;
561 buffer->Rzero = Rzero;
562 /* set value of parameter shift */
563 dummy = 0.0;
564 /* call calc_phi with r=cutoff and shift=0.0 */
565 calc_phi(&(buffer->epsilon),
566 &(buffer->C),
567 &(buffer->Rzero),
568 &dummy,
569 cutoff,
570 cutoff,
571 &(buffer->shift));
572 /* set shift to -shift */
573 buffer->shift = -buffer->shift;
574
575 /* end setup buffer */
576
577 /* store in model buffer */
579 (void *) buffer);
580
581 /* publish model parameters */
583 1,
584 &(buffer->cutoff),
585 "cutoff",
586 "pair cutoff distance")
588 1,
589 &(buffer->epsilon),
590 "epsilon",
591 "Morse epsilon")
593 modelDriverCreate, 1, &(buffer->C), "C", "Morse C")
595 modelDriverCreate, 1, &(buffer->Rzero), "Rzero", "Morse Rzero");
596 if (ier == TRUE)
597 {
598 LOG_ERROR("Unable to set parameter pointer(s).");
599 return TRUE;
600 }
601
602 /* store model cutoff in KIM object */
604 modelDriverCreate, &(buffer->influenceDistance));
606 modelDriverCreate,
607 1,
608 &(buffer->cutoff),
610
611 return FALSE;
612}
613
614/* Refresh function */
615#undef KIM_LOGGER_FUNCTION_NAME
616#define KIM_LOGGER_FUNCTION_NAME KIM_ModelRefresh_LogEntry
617#undef KIM_LOGGER_OBJECT_NAME
618#define KIM_LOGGER_OBJECT_NAME modelRefresh
619int refresh_routine(KIM_ModelRefresh * const modelRefresh)
620{
621 double dummy;
622 struct model_buffer * buffer;
623
624 /* get model buffer from KIM object */
625 KIM_ModelRefresh_GetModelBufferPointer(modelRefresh, (void **) &buffer);
626
627 /* set value of parameter shift */
628 dummy = 0.0;
629 /* call calc_phi with r=cutoff and shift=0.0 */
630 calc_phi(&(buffer->epsilon),
631 &(buffer->C),
632 &(buffer->Rzero),
633 &dummy,
634 buffer->cutoff,
635 buffer->cutoff,
636 &(buffer->shift));
637 /* set shift to -shift */
638 buffer->shift = -buffer->shift;
639
640 /* set influence distance to current value of cutoff parameter */
642
643 /* store model cutoff in KIM object */
647 modelRefresh,
648 1,
649 &(buffer->cutoff),
651
652 return FALSE;
653}
654
655
656/* destroy function */
657static int destroy_routine(KIM_ModelDestroy * const modelDestroy)
658{
659 /* Local variables */
660 struct model_buffer * buffer;
661 int ier;
662
663 /* get model buffer from KIM object */
664 KIM_ModelDestroy_GetModelBufferPointer(modelDestroy, (void **) &buffer);
665
666 /* free the buffer */
667 free(buffer);
668
669 ier = FALSE;
670 return ier;
671}
672
673/* compute arguments create routine */
674#undef KIM_LOGGER_FUNCTION_NAME
675#define KIM_LOGGER_FUNCTION_NAME KIM_ModelComputeArgumentsCreate_LogEntry
676#undef KIM_LOGGER_OBJECT_NAME
677#define KIM_LOGGER_OBJECT_NAME modelComputeArgumentsCreate
679 KIM_ModelCompute const * const modelCompute,
680 KIM_ModelComputeArgumentsCreate * const modelComputeArgumentsCreate)
681{
682 int ier;
683
684 (void) modelCompute; /* avoid unused parameter warning */
685
686 /* register arguments */
688 modelComputeArgumentsCreate,
692 modelComputeArgumentsCreate,
696 modelComputeArgumentsCreate,
699 if (ier == TRUE)
700 {
701 LOG_ERROR("Unable to set argument supportStatus.");
702 return TRUE;
703 }
704 else
705 {
706 return FALSE;
707 }
708}
709
710/* compute arguments destroy routine */
712 KIM_ModelCompute const * const modelCompute,
713 KIM_ModelComputeArgumentsDestroy * const modelComputeArgumentsDestroy)
714{
715 (void) modelCompute; /* avoid unused parameter warning */
716 (void) modelComputeArgumentsDestroy;
717
718 /* Nothing further to do */
719
720 return FALSE;
721}
722
723/* write parameterized model routine */
724#undef KIM_LOGGER_FUNCTION_NAME
725#define KIM_LOGGER_FUNCTION_NAME KIM_ModelWriteParameterizedModel_LogEntry
726#undef KIM_LOGGER_OBJECT_NAME
727#define KIM_LOGGER_OBJECT_NAME modelWriteParameterizedModel
729 KIM_ModelWriteParameterizedModel const * const modelWriteParameterizedModel)
730{
731 FILE * fp;
732 char stringBuffer[2048];
733 struct model_buffer const * buffer;
734 char const * path;
735 char const * modelName;
736
737 /* get buffer from KIM object */
739 modelWriteParameterizedModel, (void **) &buffer);
740
741 KIM_ModelWriteParameterizedModel_GetPath(modelWriteParameterizedModel, &path);
742 KIM_ModelWriteParameterizedModel_GetModelName(modelWriteParameterizedModel,
743 &modelName);
744
745 sprintf(stringBuffer, "%s.params", modelName);
747 modelWriteParameterizedModel, stringBuffer);
748 sprintf(stringBuffer, "%s/%s.params", path, modelName);
749 fp = fopen(stringBuffer, "w");
750 if (NULL == fp)
751 {
752 LOG_ERROR("Unable to open parameter file for writing.");
753 return TRUE;
754 }
755
756 fprintf(fp, "%s\n", buffer->speciesName);
757 fprintf(fp, "%20.10f\n", buffer->cutoff);
758 fprintf(fp, "%20.10f\n", buffer->epsilon);
759 fprintf(fp, "%20.10f\n", buffer->C);
760 fprintf(fp, "%20.10f\n", buffer->Rzero);
761 fclose(fp);
762
763 return FALSE;
764}
KIM_ChargeUnit const KIM_CHARGE_UNIT_unused
Indicates that a ChargeUnit is not used.
KIM_ComputeArgumentName const KIM_COMPUTE_ARGUMENT_NAME_numberOfParticles
The standard numberOfParticles argument.
KIM_ComputeArgumentName const KIM_COMPUTE_ARGUMENT_NAME_particleContributing
The standard particleContributing argument.
KIM_ComputeArgumentName const KIM_COMPUTE_ARGUMENT_NAME_coordinates
The standard coordinates argument.
KIM_ComputeArgumentName const KIM_COMPUTE_ARGUMENT_NAME_particleSpeciesCodes
The standard particleSpeciesCodes argument.
KIM_ComputeArgumentName const KIM_COMPUTE_ARGUMENT_NAME_partialForces
The standard partialForces argument.
KIM_ComputeArgumentName const KIM_COMPUTE_ARGUMENT_NAME_partialParticleEnergy
The standard partialParticleEnergy argument.
KIM_ComputeArgumentName const KIM_COMPUTE_ARGUMENT_NAME_partialEnergy
The standard partialEnergy argument.
KIM_EnergyUnit const KIM_ENERGY_UNIT_eV
The standard electronvolt unit of energy.
int KIM_ModelComputeArgumentsCreateFunction(KIM_ModelCompute const *const modelCompute, KIM_ModelComputeArgumentsCreate *const modelComputeArgumentsCreate)
Prototype for MODEL_ROUTINE_NAME::ComputeArgumentsCreate routine.
struct KIM_ModelWriteParameterizedModel KIM_ModelWriteParameterizedModel
Forward declaration.
int KIM_ModelDestroyFunction(KIM_ModelDestroy *const modelDestroy)
Prototype for MODEL_ROUTINE_NAME::Destroy routine.
struct KIM_ModelComputeArgumentsCreate KIM_ModelComputeArgumentsCreate
Forward declaration.
struct KIM_ModelComputeArgumentsDestroy KIM_ModelComputeArgumentsDestroy
Forward declaration.
struct KIM_ModelDestroy KIM_ModelDestroy
Forward declaration.
int KIM_ModelWriteParameterizedModelFunction(KIM_ModelWriteParameterizedModel const *const modelWriteParameterizedModel)
Prototype for MODEL_ROUTINE_NAME::WriteParameterizedModel routine.
struct KIM_ModelCompute KIM_ModelCompute
Forward declaration.
struct KIM_ModelComputeArguments KIM_ModelComputeArguments
Forward declaration.
void() KIM_Function(void)
Generic function type.
struct KIM_ModelDriverCreate KIM_ModelDriverCreate
Forward declaration.
int KIM_ModelDriverCreateFunction(KIM_ModelDriverCreate *const modelDriverCreate, KIM_LengthUnit const requestedLengthUnit, KIM_EnergyUnit const requestedEnergyUnit, KIM_ChargeUnit const requestedChargeUnit, KIM_TemperatureUnit const requestedTemperatureUnit, KIM_TimeUnit const requestedTimeUnit)
Prototype for MODEL_ROUTINE_NAME::Create routine.
int KIM_ModelRefreshFunction(KIM_ModelRefresh *const modelRefresh)
Prototype for MODEL_ROUTINE_NAME::Refresh routine.
int KIM_ModelComputeArgumentsDestroyFunction(KIM_ModelCompute const *const modelCompute, KIM_ModelComputeArgumentsDestroy *const modelComputeArgumentsDestroy)
Prototype for MODEL_ROUTINE_NAME::ComputeArgumentsDestroy routine.
int KIM_ModelComputeFunction(KIM_ModelCompute const *const modelCompute, KIM_ModelComputeArguments const *const modelComputeArguments)
Prototype for MODEL_ROUTINE_NAME::Compute routine.
struct KIM_ModelRefresh KIM_ModelRefresh
Forward declaration.
KIM_LanguageName const KIM_LANGUAGE_NAME_c
The standard c language.
KIM_LengthUnit const KIM_LENGTH_UNIT_A
The standard angstrom unit of length.
#define LOG_ERROR(message)
Convenience macro for ERROR Log entries with compile-time optimization.
void KIM_ModelCompute_GetModelBufferPointer(KIM_ModelCompute const *const modelCompute, void **const ptr)
Get the Model's buffer pointer within the Model object.
int KIM_ModelComputeArguments_GetNeighborList(KIM_ModelComputeArguments const *const modelComputeArguments, int const neighborListIndex, int const particleNumber, int *const numberOfNeighbors, int const **const neighborsOfParticle)
Get the neighbor list for a particle of interest corresponding to a particular neighbor list cutoff d...
int KIM_ModelComputeArguments_GetArgumentPointerInteger(KIM_ModelComputeArguments const *const modelComputeArguments, KIM_ComputeArgumentName const computeArgumentName, int **const ptr)
Get the data pointer for a ComputeArgumentName.
int KIM_ModelComputeArguments_GetArgumentPointerDouble(KIM_ModelComputeArguments const *const modelComputeArguments, KIM_ComputeArgumentName const computeArgumentName, double **const ptr)
Get the data pointer for a ComputeArgumentName.
int KIM_ModelComputeArgumentsCreate_SetArgumentSupportStatus(KIM_ModelComputeArgumentsCreate *const modelComputeArgumentsCreate, KIM_ComputeArgumentName const computeArgumentName, KIM_SupportStatus const supportStatus)
Set the SupportStatus of a ComputeArgumentName.
void KIM_ModelDestroy_GetModelBufferPointer(KIM_ModelDestroy const *const modelDestroy, void **const ptr)
Get the Model's buffer pointer within the Model object.
void KIM_ModelDriverCreate_GetParameterFileDirectoryName(KIM_ModelDriverCreate const *const modelDriverCreate, char const **const directoryName)
Get absolute path name of the temporary directory where parameter files provided by the model are wri...
void KIM_ModelDriverCreate_SetInfluenceDistancePointer(KIM_ModelDriverCreate *const modelDriverCreate, double const *const influenceDistance)
Set the Model's influence distance data pointer.
int KIM_ModelDriverCreate_SetRoutinePointer(KIM_ModelDriverCreate *const modelDriverCreate, KIM_ModelRoutineName const modelRoutineName, KIM_LanguageName const languageName, int const required, KIM_Function *const fptr)
Set the function pointer for the ModelRoutineName of interest.
void KIM_ModelDriverCreate_GetNumberOfParameterFiles(KIM_ModelDriverCreate const *const modelDriverCreate, int *const numberOfParameterFiles)
Get the number of parameter files provided by the parameterized model.
void KIM_ModelDriverCreate_SetNeighborListPointers(KIM_ModelDriverCreate *const modelDriverCreate, int const numberOfNeighborLists, double const *const cutoffs, int const *const modelWillNotRequestNeighborsOfNoncontributingParticles)
Set the Model's neighbor list data pointers.
int KIM_ModelDriverCreate_GetParameterFileBasename(KIM_ModelDriverCreate const *const modelDriverCreate, int const index, char const **const parameterFileBasename)
Get a particular parameter file basename. The file is located in the Model's parameter file directory...
int KIM_ModelDriverCreate_SetModelNumbering(KIM_ModelDriverCreate *const modelDriverCreate, KIM_Numbering const numbering)
Set the Model's particle Numbering.
int KIM_ModelDriverCreate_SetUnits(KIM_ModelDriverCreate *const modelDriverCreate, KIM_LengthUnit const lengthUnit, KIM_EnergyUnit const energyUnit, KIM_ChargeUnit const chargeUnit, KIM_TemperatureUnit const temperatureUnit, KIM_TimeUnit const timeUnit)
Set the Model's base unit values.
int KIM_ModelDriverCreate_SetParameterPointerDouble(KIM_ModelDriverCreate *const modelDriverCreate, int const extent, double *const ptr, char const *const name, char const *const description)
Set the next parameter data pointer to be provided by the model.
int KIM_ModelDriverCreate_SetSpeciesCode(KIM_ModelDriverCreate *const modelDriverCreate, KIM_SpeciesName const speciesName, int const code)
Set integer code for supported SpeciesName.
void KIM_ModelDriverCreate_SetModelBufferPointer(KIM_ModelDriverCreate *const modelDriverCreate, void *const ptr)
Set the Model's buffer pointer within the Model object.
void KIM_ModelRefresh_SetInfluenceDistancePointer(KIM_ModelRefresh *const modelRefresh, double const *const influenceDistance)
Set the Model's influence distance data pointer.
void KIM_ModelRefresh_GetModelBufferPointer(KIM_ModelRefresh const *const modelRefresh, void **const ptr)
Get the Model's buffer pointer within the Model object.
void KIM_ModelRefresh_SetNeighborListPointers(KIM_ModelRefresh *const modelRefresh, int const numberOfNeighborLists, double const *const cutoffs, int const *const modelWillNotRequestNeighborsOfNoncontributingParticles)
Set the Model's neighbor list data pointers.
KIM_ModelRoutineName const KIM_MODEL_ROUTINE_NAME_Destroy
The standard Destroy routine.
KIM_ModelRoutineName const KIM_MODEL_ROUTINE_NAME_Refresh
The standard Refresh routine.
KIM_ModelRoutineName const KIM_MODEL_ROUTINE_NAME_Compute
The standard Compute routine.
KIM_ModelRoutineName const KIM_MODEL_ROUTINE_NAME_WriteParameterizedModel
The standard WriteParameterizedModel routine.
KIM_ModelRoutineName const KIM_MODEL_ROUTINE_NAME_ComputeArgumentsCreate
The standard ComputeArgumentsCreate routine.
KIM_ModelRoutineName const KIM_MODEL_ROUTINE_NAME_ComputeArgumentsDestroy
The standard ComputeArgumentsDestroy routine.
void KIM_ModelWriteParameterizedModel_GetModelBufferPointer(KIM_ModelWriteParameterizedModel const *const modelWriteParameterizedModel, void **const ptr)
Get the Model's buffer pointer within the Model object.
void KIM_ModelWriteParameterizedModel_GetModelName(KIM_ModelWriteParameterizedModel const *const modelWriteParameterizedModel, char const **const modelName)
Get the name of the new parameterized model.
void KIM_ModelWriteParameterizedModel_GetPath(KIM_ModelWriteParameterizedModel const *const modelWriteParameterizedModel, char const **const path)
Get the directory path where the parameterized model files should be written.
void KIM_ModelWriteParameterizedModel_SetParameterFileName(KIM_ModelWriteParameterizedModel const *const modelWriteParameterizedModel, char const *const fileName)
Set the file name for the next parameter file.
KIM_Numbering const KIM_NUMBERING_zeroBased
The standard zeroBased numbering.
KIM_SpeciesName KIM_SpeciesName_FromString(char const *const str)
Create a SpeciesName object corresponding to the provided string. If the string does not match one of...
KIM_SupportStatus const KIM_SUPPORT_STATUS_optional
The standard optional status.
KIM_TemperatureUnit const KIM_TEMPERATURE_UNIT_unused
Indicates that a TemperatureUnit is not used.
KIM_TimeUnit const KIM_TIME_UNIT_unused
Indicates that a TimeUnit is not used.
static int refresh_routine(KIM_ModelRefresh *const modelRefresh)
int model_driver_create(KIM_ModelDriverCreate *const modelDriverCreate, KIM_LengthUnit const requestedLengthUnit, KIM_EnergyUnit const requestedEnergyUnit, KIM_ChargeUnit const requestedChargeUnit, KIM_TemperatureUnit const requestedTemperatureUnit, KIM_TimeUnit const requestedTimeUnit)
static int destroy_routine(KIM_ModelDestroy *const modelDestroy)
static void calc_phi(double const *epsilon, double const *C, double const *Rzero, double const *shift, double const cutoff, double const r, double *phi)
#define SPEC_NAME_FMT
#define TRUE
#define FALSE
static void calc_phi_dphi(double const *epsilon, double const *C, double const *Rzero, double const *shift, double const cutoff, double const r, double *phi, double *dphi)
#define SPEC_NAME_LEN
#define DIM
#define SPECCODE
static int compute_routine(KIM_ModelCompute const *const modelCompute, KIM_ModelComputeArguments const *const modelComputeArguments)
An Extensible Enumeration for the ChargeUnit's supported by the KIM API.
An Extensible Enumeration for the EnergyUnit's supported by the KIM API.
An Extensible Enumeration for the LengthUnit's supported by the KIM API.
An Extensible Enumeration for the SpeciesName's supported by the KIM API.
An Extensible Enumeration for the TemperatureUnit's supported by the KIM API.
An Extensible Enumeration for the TimeUnit's supported by the KIM API.
Definition: KIM_TimeUnit.h:42
int modelWillNotRequestNeighborsOfNoncontributingParticles
double influenceDistance
char speciesName[SPEC_NAME_LEN]
int modelWillNotRequestNeighborsOfNoncontributingParticles