KIM API V2
ex_model_Ar_P_Morse_07C.c
Go to the documentation of this file.
1 /* */
2 /* CDDL HEADER START */
3 /* */
4 /* The contents of this file are subject to the terms of the Common */
5 /* Development and Distribution License Version 1.0 (the "License"). */
6 /* */
7 /* You can obtain a copy of the license at */
8 /* http://www.opensource.org/licenses/CDDL-1.0. See the License for the */
9 /* specific language governing permissions and limitations under the License. */
10 /* */
11 /* When distributing Covered Code, include this CDDL HEADER in each file and */
12 /* include the License file in a prominent location with the name */
13 /* LICENSE.CDDL. If applicable, add the following below this CDDL HEADER, */
14 /* with the fields enclosed by brackets "[]" replaced with your own */
15 /* identifying information: */
16 /* */
17 /* Portions Copyright (c) [yyyy] [name of copyright owner]. */
18 /* All rights reserved. */
19 /* */
20 /* CDDL HEADER END */
21 /* */
22 
23 /* */
24 /* Copyright (c) 2013--2018, Regents of the University of Minnesota. */
25 /* All rights reserved. */
26 /* */
27 /* Contributors: */
28 /* Ryan S. Elliott */
29 /* Ellad B. Tadmor */
30 /* Stephen M. Whalen */
31 /* */
32 
33 /******************************************************************************/
34 /* */
35 /* ex_model_Ar_P_Morse_07C pair potential KIM Model */
36 /* shifted to have zero energy at the cutoff radius */
37 /* */
38 /* Language: C */
39 /* */
40 /******************************************************************************/
41 
42 
43 #include <stdlib.h>
44 #include <stdio.h>
45 #include <string.h>
46 #include <math.h>
47 #include "KIM_ModelHeaders.h"
48 
49 #define TRUE 1
50 #define FALSE 0
51 
52 /******************************************************************************/
53 /* Below are the definitions and values of all Model parameters */
54 /******************************************************************************/
55 #define DIM 3 /* dimensionality of space */
56 #define SPECCODE 1 /* internal species code */
57 #define CUTOFF 8.15 /* Angstroms */
58 #define EPSILON -0.0134783698072604 /* eV */
59 #define PARAM_C 1.545 /* 1/Angstroms */
60 #define RZERO 3.786 /* Angstroms */
61 
62 /* Model buffer definition */
63 struct buffer
64 {
65  double influenceDistance;
66  double cutoff;
68  int halfListHint;
69 };
70 typedef struct buffer buffer;
71 
72 /* Define prototype for Model create */
73 int model_create(KIM_ModelCreate * const modelCreate,
74  KIM_LengthUnit const requestedLengthUnit,
75  KIM_EnergyUnit const requestedEnergyUnit,
76  KIM_ChargeUnit const requestedChargeUnit,
77  KIM_TemperatureUnit const requestedTemperatureUnit,
78  KIM_TimeUnit const requestedTimeUnit);
79 
80 /* Define prototype for other routines */
81 static int compute(
82  KIM_ModelCompute const * const modelCompute,
83  KIM_ModelComputeArguments const * const modelComputeArguments);
84 static int compute_arguments_create(
85  KIM_ModelCompute const * const modelCompute,
86  KIM_ModelComputeArgumentsCreate * const modelComputeArgumentsCreate);
87 static int compute_arguments_destroy(
88  KIM_ModelCompute const * const modelCompute,
89  KIM_ModelComputeArgumentsDestroy * const modelComputeArgumentsDestroy);
90 static int model_refresh(KIM_ModelRefresh * const modelRefresh);
91 static int model_destroy(KIM_ModelDestroy * const modelDestroy);
92 
93 /* Define prototypes for pair potential calculations */
94 static void calc_phi(double* epsilon,
95  double* C,
96  double* Rzero,
97  double* shift,
98  double* cutoff, double r, double* phi);
99 
100 static void calc_phi_dphi(double* epsilon,
101  double* C,
102  double* Rzero,
103  double* shift,
104  double* cutoff, double r, double* phi, double* dphi);
105 
106 static void calc_phi_d2phi(double* epsilon,
107  double* C,
108  double* Rzero,
109  double* shift,
110  double* cutoff, double r, double* phi, double* dphi,
111  double* d2phi);
112 
113 /* Calculate pair potential phi(r) */
114 static void calc_phi(double* epsilon,
115  double* C,
116  double* Rzero,
117  double* shift,
118  double* cutoff, double r, double* phi) {
119  /* local variables */
120  double ep;
121  double ep2;
122 
123  ep = exp(-(*C)*(r-*Rzero));
124  ep2 = ep*ep;
125 
126  if (r > *cutoff) {
127  /* Argument exceeds cutoff radius */
128  *phi = 0.0; }
129  else {
130  *phi = (*epsilon)*( -ep2 + 2.0*ep ) + *shift; }
131 
132  return; }
133 
134 /* Calculate pair potential phi(r) and its derivative dphi(r) */
135 static void calc_phi_dphi(double* epsilon,
136  double* C,
137  double* Rzero,
138  double* shift,
139  double* cutoff, double r, double* phi, double* dphi) {
140  /* local variables */
141  double ep;
142  double ep2;
143 
144  ep = exp(-(*C)*(r-*Rzero));
145  ep2 = ep*ep;
146 
147  if (r > *cutoff) {
148  /* Argument exceeds cutoff radius */
149  *phi = 0.0;
150  *dphi = 0.0; }
151  else {
152  *phi = (*epsilon)*( -ep2 + 2.0*ep ) + *shift;
153  *dphi = 2.0*(*epsilon)*(*C)*( -ep + ep2 ); }
154 
155  return; }
156 
157 /* Calculate pair potential phi(r) and its 1st & 2nd derivatives dphi(r), */
158 /* d2phi(r) */
159 static void calc_phi_d2phi(double* epsilon,
160  double* C,
161  double* Rzero,
162  double* shift,
163  double* cutoff, double r, double* phi, double* dphi,
164  double* d2phi) {
165  /* local variables */
166  double ep;
167  double ep2;
168 
169  ep = exp(-(*C)*(r-*Rzero));
170  ep2 = ep*ep;
171 
172  if (r > *cutoff) {
173  /* Argument exceeds cutoff radius */
174  *phi = 0.0;
175  *dphi = 0.0;
176  *d2phi = 0.0; }
177  else {
178  *phi = (*epsilon)*( -ep2 + 2.0*ep ) + *shift;
179  *dphi = 2.0*(*epsilon)*(*C)*( -ep + ep2 );
180  *d2phi = 2.0*(*epsilon)*(*C)*(*C)*(ep - 2.0*ep2); }
181 
182  return; }
183 
184 /* compute function */
186 static int compute(
187  KIM_ModelCompute const * const modelCompute,
188  KIM_ModelComputeArguments const * const modelComputeArguments)
189 {
190  /* local variables */
191  double R;
192  double R_pairs[2];
193  double *pR_pairs = &(R_pairs[0]);
194  double Rsqij;
195  double phi;
196  double dphi;
197  double d2phi;
198  double dEidr;
199  double d2Eidr;
200  double Rij[DIM];
201  double *pRij = &(Rij[0]);
202  double Rij_pairs[2][3];
203  double const * pRij_pairs = &(Rij_pairs[0][0]);
204  int ier;
205  int i;
206  int i_pairs[2];
207  int *pi_pairs = &(i_pairs[0]);
208  int j;
209  int j_pairs[2];
210  int *pj_pairs = &(j_pairs[0]);
211  int jj;
212  int k;
213  int const * neighListOfCurrentPart;
214  int comp_energy;
215  int comp_force;
216  int comp_particleEnergy;
217  int comp_process_dEdr;
218  int comp_process_d2Edr2;
219 
220  int* nParts;
223  double* cutoff;
224  double cutsq;
225  double epsilon;
226  double C;
227  double Rzero;
228  double shift;
229  double* coords;
230  double* energy;
231  double* force;
232  double* particleEnergy;
233  int numOfPartNeigh;
234  double dummy;
235 
236  /* check to see if we have been asked to compute the forces, */
237  /* particleEnergy, and d1Edr */
238  LOG_INFORMATION("Checking if call backs are present.");
240  modelComputeArguments,
242  &comp_process_dEdr);
244  modelComputeArguments,
246  &comp_process_d2Edr2);
247 
248  LOG_INFORMATION("Getting data pointers");
249  ier =
251  modelComputeArguments,
253  &nParts)
254  ||
256  modelComputeArguments,
259  ||
261  modelComputeArguments,
264  ||
266  modelComputeArguments,
268  &coords)
269  ||
271  modelComputeArguments,
273  &energy)
274  ||
276  modelComputeArguments,
278  &force)
279  ||
281  modelComputeArguments,
283  &particleEnergy);
284  if (ier) {
285  LOG_ERROR("get data pointers failed");
286  return ier; }
287 
288  comp_energy = (energy != NULL);
289  comp_force = (force != NULL);
290  comp_particleEnergy = (particleEnergy != NULL);
291 
292  /* set value of parameters */
293  KIM_ModelCompute_GetModelBufferPointer(modelCompute, (void**) &cutoff);
294  cutsq = (*cutoff)*(*cutoff);
295  epsilon = EPSILON;
296  C = PARAM_C;
297  Rzero = RZERO;
298  /* set value of parameter shift */
299  dummy = 0.0;
300  /* call calc_phi with r=cutoff and shift=0.0 */
301  calc_phi(&epsilon, &C, &Rzero, &dummy, cutoff, *cutoff, &shift);
302  /* set shift to -shift */
303  shift = -(shift);
304 
305  /* Check to be sure that the species are correct */
306 
307  ier = TRUE; /* assume an error */
308  for (i = 0; i < *nParts; ++i) {
309  if ( SPECCODE != particleSpeciesCodes[i]) {
310  LOG_ERROR("Unexpected species code detected");
311  return ier; } }
312  ier = FALSE; /* everything is ok */
313 
314  /* initialize potential energies, forces, and virial term */
315  LOG_INFORMATION("Initializing data");
316  if (comp_particleEnergy) {
317  for (i = 0; i < *nParts; ++i) {
318  particleEnergy[i] = 0.0; } }
319  if (comp_energy) {
320  *energy = 0.0; }
321 
322  if (comp_force) {
323  for (i = 0; i < *nParts; ++i) {
324  for (k = 0; k < DIM; ++k) {
325  force[i*DIM + k] = 0.0; } } }
326 
327  /* Compute energy and forces */
328 
329  /* loop over particles and compute enregy and forces */
330  LOG_INFORMATION("Starting main compute loop");
331  for (i = 0; i< *nParts; ++i) {
332  if (particleContributing[i])
333  {
335  modelComputeArguments,
336  0, i, &numOfPartNeigh, &neighListOfCurrentPart);
337  if (ier) {
338  /* some sort of problem, exit */
339  LOG_ERROR("GetNeighborList failed");
340  ier = TRUE;
341  return ier; }
342 
343  /* loop over the neighbors of particle i */
344  for (jj = 0; jj < numOfPartNeigh; ++ jj) {
345  j = neighListOfCurrentPart[jj]; /* get neighbor ID */
346 
347  /* compute relative position vector and squared distance */
348  Rsqij = 0.0;
349  for (k = 0; k < DIM; ++k) {
350  Rij[k] = coords[j*DIM + k] - coords[i*DIM + k];
351 
352  /* compute squared distance */
353  Rsqij += Rij[k]*Rij[k]; }
354 
355  /* compute energy and force */
356  if (Rsqij < cutsq) {
357  /* particles are interacting ? */
358  R = sqrt(Rsqij);
359  if (comp_process_d2Edr2) {
360  /* compute pair potential and its derivatives */
361  calc_phi_d2phi(&epsilon,
362  &C,
363  &Rzero,
364  &shift,
365  cutoff, R, &phi, &dphi, &d2phi);
366 
367  /* compute dEidr */
368  dEidr = 0.5*dphi;
369  d2Eidr = 0.5*d2phi; }
370  else if (comp_force || comp_process_dEdr) {
371  /* compute pair potential and its derivative */
372  calc_phi_dphi(&epsilon,
373  &C,
374  &Rzero,
375  &shift,
376  cutoff, R, &phi, &dphi);
377 
378  /* compute dEidr */
379  dEidr = 0.5*dphi; }
380  else {
381  /* compute just pair potential */
382  calc_phi(&epsilon,
383  &C,
384  &Rzero,
385  &shift,
386  cutoff, R, &phi); }
387 
388  /* contribution to energy */
389  if (comp_particleEnergy) {
390  particleEnergy[i] += 0.5*phi; }
391  if (comp_energy) {
392  *energy += 0.5*phi; }
393 
394  /* contribution to process_dEdr */
395  if (comp_process_dEdr) {
397  modelComputeArguments, dEidr, R, pRij, i, j); }
398 
399  /* contribution to process_d2Edr2 */
400  if (comp_process_d2Edr2) {
401  R_pairs[0] = R_pairs[1] = R;
402  Rij_pairs[0][0] = Rij_pairs[1][0] = Rij[0];
403  Rij_pairs[0][1] = Rij_pairs[1][1] = Rij[1];
404  Rij_pairs[0][2] = Rij_pairs[1][2] = Rij[2];
405  i_pairs[0] = i_pairs[1] = i;
406  j_pairs[0] = j_pairs[1] = j;
407 
409  modelComputeArguments,
410  d2Eidr, pR_pairs, pRij_pairs, pi_pairs, pj_pairs);
411  }
412 
413  /* contribution to forces */
414  if (comp_force) {
415  for (k = 0; k < DIM; ++k) {
416  force[i*DIM + k] += dEidr*Rij[k]/R; /* accumulate force on i */
417  force[j*DIM + k] -= dEidr*Rij[k]/R; /* accumulate force on j */ } } }
418  } /* loop on jj */
419  } /* if contributing */
420  } /* loop on i */
421  LOG_INFORMATION("Finished compute loop");
422 
423  /* everything is great */
424  ier = FALSE;
425 
426  return ier; }
427 
428 /* Create function */
430 int model_create(KIM_ModelCreate * const modelCreate,
431  KIM_LengthUnit const requestedLengthUnit,
432  KIM_EnergyUnit const requestedEnergyUnit,
433  KIM_ChargeUnit const requestedChargeUnit,
434  KIM_TemperatureUnit const requestedTemperatureUnit,
435  KIM_TimeUnit const requestedTimeUnit)
436 {
437  buffer * bufferPointer;
438  int error;
439 
440  /* set units */
441  LOG_INFORMATION("Set model units");
443  modelCreate, /* ignoring requested units */
449 
450  /* register species */
451  LOG_INFORMATION("Setting species code");
452  error = error ||
453  KIM_ModelCreate_SetSpeciesCode(modelCreate,
455 
456  /* register numbering */
457  LOG_INFORMATION("Setting model numbering");
460 
461  /* register function pointers */
462  LOG_INFORMATION("Register model function pointers");
463  error = error ||
465  modelCreate,
467  (func *) &compute);
468  error = error ||
470  modelCreate,
473  error = error ||
475  modelCreate,
478  error = error ||
480  modelCreate,
482  (func *) &model_destroy);
483  error = error ||
485  modelCreate,
487  (func *) &model_refresh);
488 
489  /* allocate buffer */
490  bufferPointer = (buffer *) malloc(sizeof(buffer));
491 
492  /* store model buffer in KIM object */
493  LOG_INFORMATION("Set influence distance and cutoffs");
495  bufferPointer);
496 
497  /* set buffer values */
498  bufferPointer->influenceDistance = CUTOFF;
499  bufferPointer->cutoff = CUTOFF;
500  bufferPointer->paddingNeighborHint = 1;
501  bufferPointer->halfListHint = 0;
502 
503  /* register influence distance */
505  modelCreate,
506  &(bufferPointer->influenceDistance));
507 
508  /* register cutoff */
510  modelCreate,
511  1,
512  &(bufferPointer->cutoff),
513  &(bufferPointer->paddingNeighborHint),
514  &(bufferPointer->halfListHint));
515 
516  if (error)
517  {
518  free(bufferPointer);
519  LOG_ERROR("Unable to successfully initialize model");
520  return TRUE;
521  }
522  else
523  return FALSE;
524 }
525 
526 /* refresh function */
528 static int model_refresh(KIM_ModelRefresh * const modelRefresh)
529 {
530  /* Local variables */
531  buffer * bufferPointer;
532 
533  /* get model buffer from KIM object */
534  LOG_INFORMATION("Getting model buffer");
536  (void **) &bufferPointer);
537 
538  LOG_INFORMATION("Resetting influence distance and cutoffs");
540  modelRefresh, &(bufferPointer->influenceDistance));
542  modelRefresh,
543  1,
544  &(bufferPointer->cutoff),
545  &(bufferPointer->paddingNeighborHint),
546  &(bufferPointer->halfListHint));
547 
548  return FALSE;
549 }
550 
551 /* Initialization function */
553 int model_destroy(KIM_ModelDestroy * const modelDestroy) {
554  buffer * bufferPointer;
555 
556  LOG_INFORMATION("Getting buffer");
558  (void **) &bufferPointer);
559  LOG_INFORMATION("Freeing model memory");
560  free(bufferPointer);
561 
562  return FALSE; }
563 
564 /* compute arguments create routine */
567  KIM_ModelCompute const * const modelCompute,
568  KIM_ModelComputeArgumentsCreate * const modelComputeArgumentsCreate)
569 {
570  int error;
571  /* register arguments */
572  LOG_INFORMATION("Register argument supportStatus");
573  error =
575  modelComputeArgumentsCreate,
577  error = error ||
579  modelComputeArgumentsCreate,
581  error = error ||
583  modelComputeArgumentsCreate,
586 
587  /* register call backs */
588  LOG_INFORMATION("Register call back supportStatus");
589  error = error ||
591  modelComputeArgumentsCreate,
594  error = error ||
596  modelComputeArgumentsCreate,
599 
600  if (error)
601  {
602  LOG_ERROR("Unable to successfully initialize compute arguments");
603  return TRUE;
604  }
605  else
606  return FALSE;
607 }
608 
609 /* compue arguments destroy routine */
612  KIM_ModelCompute const * const modelCompute,
613  KIM_ModelComputeArgumentsDestroy * const modelComputeArgumentsDestroy)
614 {
615  /* nothing to be done */
616 
617  return FALSE;
618 }
#define TRUE
KIM_SupportStatus const KIM_SUPPORT_STATUS_optional
KIM_ComputeArgumentName const KIM_COMPUTE_ARGUMENT_NAME_coordinates
KIM_ComputeCallbackName const KIM_COMPUTE_CALLBACK_NAME_ProcessD2EDr2Term
KIM_ComputeArgumentName const KIM_COMPUTE_ARGUMENT_NAME_partialParticleEnergy
static int model_destroy(KIM_ModelDestroy *const modelDestroy)
void KIM_ModelDestroy_GetModelBufferPointer(KIM_ModelDestroy const *const modelDestroy, void **const ptr)
KIM_LanguageName const KIM_LANGUAGE_NAME_c
#define RZERO
KIM_ComputeArgumentName const KIM_COMPUTE_ARGUMENT_NAME_partialForces
int KIM_ModelCreate_SetComputePointer(KIM_ModelCreate *const modelCreate, KIM_LanguageName const languageName, func *const fptr)
struct KIM_ModelRefresh KIM_ModelRefresh
int KIM_ModelComputeArguments_GetArgumentPointerDouble(KIM_ModelComputeArguments const *const modelComputeArguments, KIM_ComputeArgumentName const computeArgumentName, double **const ptr)
int KIM_ModelComputeArguments_ProcessD2EDr2Term(KIM_ModelComputeArguments const *const modelComputeArguments, double const de, double const *const r, double const *const dx, int const *const i, int const *const j)
void KIM_ModelRefresh_GetModelBufferPointer(KIM_ModelRefresh const *const modelRefresh, void **const ptr)
KIM_ComputeArgumentName const KIM_COMPUTE_ARGUMENT_NAME_particleSpeciesCodes
int KIM_ModelComputeArgumentsCreate_SetCallbackSupportStatus(KIM_ModelComputeArgumentsCreate *const modelComputeArgumentsCreate, KIM_ComputeCallbackName const computeCallbackName, KIM_SupportStatus const supportStatus)
static int compute_arguments_destroy(KIM_ModelCompute const *const modelCompute, KIM_ModelComputeArgumentsDestroy *const modelComputeArgumentsDestroy)
int KIM_ModelComputeArguments_IsCallbackPresent(KIM_ModelComputeArguments const *const modelComputeArguments, KIM_ComputeCallbackName const computeCallbackName, int *const present)
KIM_TemperatureUnit const KIM_TEMPERATURE_UNIT_unused
static int model_refresh(KIM_ModelRefresh *const modelRefresh)
#define EPSILON
KIM_SpeciesName const KIM_SPECIES_NAME_Ar
ChargeUnit const C
KIM_TimeUnit const KIM_TIME_UNIT_unused
int KIM_ModelCreate_SetComputeArgumentsCreatePointer(KIM_ModelCreate *const modelCreate, KIM_LanguageName const languageName, func *const fptr)
static void calc_phi_d2phi(double *epsilon, double *C, double *Rzero, double *shift, double *cutoff, double r, double *phi, double *dphi, double *d2phi)
struct KIM_ModelDestroy KIM_ModelDestroy
void KIM_ModelCreate_SetModelBufferPointer(KIM_ModelCreate *const modelCreate, void *const ptr)
ComputeArgumentName const particleContributing
int KIM_ModelCreate_SetRefreshPointer(KIM_ModelCreate *const modelCreate, KIM_LanguageName const languageName, func *const fptr)
int KIM_ModelComputeArgumentsCreate_SetArgumentSupportStatus(KIM_ModelComputeArgumentsCreate *const modelComputeArgumentsCreate, KIM_ComputeArgumentName const computeArgumentName, KIM_SupportStatus const supportStatus)
void KIM_ModelCompute_GetModelBufferPointer(KIM_ModelCompute const *const modelCompute, void **const ptr)
void() func()
Definition: KIM_func.h:39
int KIM_ModelCreate_SetComputeArgumentsDestroyPointer(KIM_ModelCreate *const modelCreate, KIM_LanguageName const languageName, func *const fptr)
#define CUTOFF
#define LOG_ERROR(message)
int KIM_ModelCreate_SetDestroyPointer(KIM_ModelCreate *const modelCreate, KIM_LanguageName const languageName, func *const fptr)
KIM_ComputeArgumentName const KIM_COMPUTE_ARGUMENT_NAME_numberOfParticles
struct KIM_ModelComputeArguments KIM_ModelComputeArguments
struct KIM_ModelComputeArgumentsCreate KIM_ModelComputeArgumentsCreate
void KIM_ModelCreate_SetInfluenceDistancePointer(KIM_ModelCreate *const modelCreate, double *const influenceDistance)
int KIM_ModelCreate_SetUnits(KIM_ModelCreate *const modelCreate, KIM_LengthUnit const lengthUnit, KIM_EnergyUnit const energyUnit, KIM_ChargeUnit const chargeUnit, KIM_TemperatureUnit const temperatureUnit, KIM_TimeUnit const timeUnit)
static void calc_phi_dphi(double *epsilon, double *C, double *Rzero, double *shift, double *cutoff, double r, double *phi, double *dphi)
int KIM_ModelCreate_SetModelNumbering(KIM_ModelCreate *const modelCreate, KIM_Numbering const numbering)
#define LOG_INFORMATION(message)
int KIM_ModelCreate_SetSpeciesCode(KIM_ModelCreate *const modelCreate, KIM_SpeciesName const speciesName, int const code)
int KIM_ModelComputeArguments_GetNeighborList(KIM_ModelComputeArguments const *const modelComputeArguments, int const neighborListIndex, int const particleNumber, int *const numberOfNeighbors, int const **const neighborsOfParticle)
double influenceDistance
struct KIM_ModelComputeArgumentsDestroy KIM_ModelComputeArgumentsDestroy
KIM_EnergyUnit const KIM_ENERGY_UNIT_eV
#define PARAM_C
static int compute_arguments_create(KIM_ModelCompute const *const modelCompute, KIM_ModelComputeArgumentsCreate *const modelComputeArgumentsCreate)
void KIM_ModelRefresh_SetInfluenceDistancePointer(KIM_ModelRefresh *const modelRefresh, double *const influenceDistance)
KIM_ChargeUnit const KIM_CHARGE_UNIT_unused
ComputeArgumentName const particleSpeciesCodes
KIM_ComputeArgumentName const KIM_COMPUTE_ARGUMENT_NAME_partialEnergy
void KIM_ModelCreate_SetNeighborListPointers(KIM_ModelCreate *const modelCreate, int const numberOfNeighborLists, double const *const cutoffs, int const *const paddingNeighborHints, int const *const halfListHints)
int model_create(KIM_ModelCreate *const modelCreate, KIM_LengthUnit const requestedLengthUnit, KIM_EnergyUnit const requestedEnergyUnit, KIM_ChargeUnit const requestedChargeUnit, KIM_TemperatureUnit const requestedTemperatureUnit, KIM_TimeUnit const requestedTimeUnit)
KIM_ComputeCallbackName const KIM_COMPUTE_CALLBACK_NAME_ProcessDEDrTerm
struct KIM_ModelCreate KIM_ModelCreate
void KIM_ModelRefresh_SetNeighborListPointers(KIM_ModelRefresh *const modelRefresh, int const numberOfNeighborLists, double const *const cutoffs, int const *const paddingNeighborHints, int const *const halfListHints)
int KIM_ModelComputeArguments_ProcessDEDrTerm(KIM_ModelComputeArguments const *const modelComputeArguments, double const de, double const r, double const *const dx, int const i, int const j)
static int compute(KIM_ModelCompute const *const modelCompute, KIM_ModelComputeArguments const *const modelComputeArguments)
static void calc_phi(double *epsilon, double *C, double *Rzero, double *shift, double *cutoff, double r, double *phi)
KIM_LengthUnit const KIM_LENGTH_UNIT_A
#define FALSE
#define SPECCODE
LogVerbosity const error
KIM_Numbering const KIM_NUMBERING_zeroBased
int KIM_ModelComputeArguments_GetArgumentPointerInteger(KIM_ModelComputeArguments const *const modelComputeArguments, KIM_ComputeArgumentName const computeArgumentName, int **const ptr)
KIM_ComputeArgumentName const KIM_COMPUTE_ARGUMENT_NAME_particleContributing
#define DIM
struct KIM_ModelCompute KIM_ModelCompute