int KIM_API_string_init(void * kimmdl, const char *siminputstring, const char * mdlname) {
KIM_API_model * mdl;
mdl = new KIM_API_model[1];
int error = mdl->string_init(siminputstring,mdlname);
if(error == KIM_STATUS_OK) {
*(KIM_API_model **)kimmdl = mdl;
return error;
}
else
{
*(KIM_API_model **)kimmdl=NULL;
delete [] mdl;
return error;
}
}
int KIM_API_model_info(void * kimmdl, const char * mdlname) {
KIM_API_model * mdl;
mdl = new KIM_API_model[1];
int error = mdl->model_info(mdlname);
if(error == KIM_STATUS_OK) {
*(KIM_API_model **)kimmdl = mdl;
return error;
}
else
{
*(KIM_API_model **)kimmdl=NULL;
delete [] mdl;
return error;
}
}
void KIM_API_setm_compute(void *kimmdl, int *err, int numargs, ...) {
KIM_API_model *pkim = (KIM_API_model *) kimmdl;
*err=KIM_STATUS_FAIL;
va_list listPointer;
va_start(listPointer,numargs);
if(numargs % 3 != 0) {
std::cout<<"setm_compute: numargs must be multiple of 3"<<std::endl;
*err=KIM_STATUS_NUMARGS_NOT_DIVISIBLE_BY_3;
va_end(listPointer);
return;
}
for (int i=0; i<numargs/3; i++) {
char *nm = va_arg(listPointer, char *);
int compute_flag = va_arg(listPointer, int);
int key =va_arg(listPointer, int);
if (key != 1 && key != 0 ) {
*err= KIM_STATUS_WRONG_GROUP_ARGUMENT_KEY;
va_end(listPointer);
return;
} else if(key ==0) continue;
int index = pkim->get_index(nm,err);
if (*err != KIM_STATUS_OK) {
std::cout<<"setm_compute: name "<<nm<<" not in KIM\n";
va_end(listPointer);
return;
}
if (compute_flag ==1) {
(*pkim)[index].flag->calculate = 1;
} else if (compute_flag ==0) {
(*pkim)[index].flag->calculate = 0;
} else {
std::cout<<"setm_compute: for "<<nm<<" failed: compute_flag must be 0 or 1\n";
va_end(listPointer);
return;
}
}
*err=KIM_STATUS_OK;
va_end(listPointer);
}
void PairKIM::set_kim_model_has_flags()
{
KIM_API_model mdl;
int kimerror;
// get KIM API object representing the KIM Model only
kimerror = mdl.model_info(kim_modelname);
kim_error(__LINE__,"KIM initialization failed", kimerror);
// determine if the KIM Model can compute the total energy
mdl.get_index((char*) "energy", &kimerror);
kim_model_has_energy = (kimerror == KIM_STATUS_OK);
if (!kim_model_has_energy)
error->warning(FLERR,"KIM Model does not provide `energy'; "
"Potential energy will be zero");
// determine if the KIM Model can compute the forces
mdl.get_index((char*) "forces", &kimerror);
kim_model_has_forces = (kimerror == KIM_STATUS_OK);
if (!kim_model_has_forces)
error->warning(FLERR,"KIM Model does not provide `forces'; "
"Forces will be zero");
// determine if the KIM Model can compute the particleEnergy
mdl.get_index((char*) "particleEnergy", &kimerror);
kim_model_has_particleEnergy = (kimerror == KIM_STATUS_OK);
if (!kim_model_has_particleEnergy)
error->warning(FLERR,"KIM Model does not provide `particleEnergy'; "
"energy per atom will be zero");
// determine if the KIM Model can compute the particleVerial
mdl.get_index((char*) "particleVirial", &kimerror);
kim_model_has_particleVirial = (kimerror == KIM_STATUS_OK);
mdl.get_index((char*) "process_dEdr", &kimerror);
kim_model_has_particleVirial = kim_model_has_particleVirial ||
(kimerror == KIM_STATUS_OK);
if (!kim_model_has_particleVirial)
error->warning(FLERR,"KIM Model does not provide `particleVirial'; "
"virial per atom will be zero");
// tear down KIM API object
mdl.free(&kimerror);
// now destructor will do the remaining tear down for mdl
return;
}
void KIM_API_getm_index(void *kimmdl, int *err, int numargs, ...) {
KIM_API_model *pkim = (KIM_API_model *) kimmdl;
*err=KIM_STATUS_FAIL;
va_list listPointer;
va_start(listPointer,numargs);
if(numargs % 3 != 0) {
std::cout<<"getm_index: numargs must be multiple of 3"<<std::endl;
*err=KIM_STATUS_NUMARGS_NOT_DIVISIBLE_BY_3;
va_end(listPointer);
return;
}
for (int i=0; i<numargs/3; i++) {
char *nm = va_arg(listPointer, char *);
int *ind = va_arg(listPointer, int *);
int key =va_arg(listPointer, int);
if (key != 1 && key != 0 ) {
*err= KIM_STATUS_WRONG_GROUP_ARGUMENT_KEY;
va_end(listPointer);
return;
} else if(key ==0) continue;
*ind = pkim->get_index(nm,err);
if(*err != KIM_STATUS_OK) {
std::cout<<"getm_index: get index for "<<nm<<" failed\n";
va_end(listPointer);
return;
}
}
*err=KIM_STATUS_OK;
va_end(listPointer);
}
int KIM_API_get_version_simulator_minor(void* kimmdl, int* const minor)
{
KIM_API_model* mdl = (KIM_API_model*) kimmdl;
return mdl->get_version_simulator_minor(minor);
}
int KIM_API_get_version_model_major(void* kimmdl, int* const major)
{
KIM_API_model* mdl = (KIM_API_model*) kimmdl;
return mdl->get_version_model_major(major);
}
int PairKIM::get_neigh(void **kimmdl,int *mode,int *request,
int *atom, int *numnei, int **nei1atom, double **pRij)
{
KIM_API_model *pkim = (KIM_API_model *) *kimmdl;
int kimerror;
PairKIM *self = (PairKIM *) pkim->get_sim_buffer(&kimerror);
if (self->kim_model_using_Rij) {
*pRij = &(self->Rij[0]);
} else {
*pRij = 0;
}
// subvert KIM api by using direct access to self->list
//
// get neighObj from KIM API obj
// NeighList * neiobj = (NeighList * )
// (*pkim).get_data_by_index(self->kim_ind_neighObject, &kimerror);
NeighList * neiobj = self->list;
// subvert KIM api by using direct acces to self->lmps_local_tot_num_atoms
//
//int * pnAtoms = (int *)
// (*pkim).get_data_by_index(self->kim_ind_numberOfParticles, &kimerror);
//int nAtoms = *pnAtoms;
int nAtoms = self->lmps_local_tot_num_atoms;
int j, jj, inum, *ilist, *numneigh, **firstneigh;
inum = neiobj->inum; //# of I atoms neighbors are stored for
ilist = neiobj->ilist; //local indices of I atoms
numneigh = neiobj->numneigh; // # of J neighbors for each I atom
firstneigh = neiobj->firstneigh; // ptr to 1st J int value of each I atom
if (*mode==0){ //iterator mode
if (*request==1) { //increment iterator
if (self->kim_iterator_position < inum) {
*atom = ilist[self->kim_iterator_position];
*numnei = numneigh[*atom];
// strip off neighbor mask for molecular systems
if (!self->lmps_using_molecular)
*nei1atom = firstneigh[*atom];
else
{
int n = *numnei;
int *ptr = firstneigh[*atom];
int *lmps_stripped_neigh_list = self->lmps_stripped_neigh_list;
for (int i = 0; i < n; i++)
lmps_stripped_neigh_list[i] = *(ptr++) & NEIGHMASK;
*nei1atom = lmps_stripped_neigh_list;
}
// set Rij if needed
if (self->kim_model_using_Rij) {
double* x = (double *)
(*pkim).get_data_by_index(self->kim_ind_coordinates,
&kimerror);
for (jj=0; jj < *numnei; jj++) {
int i = *atom;
j = (*nei1atom)[jj];
self->Rij[jj*3 +0] = -x[i*3+0] + x[j*3+0];
self->Rij[jj*3 +1] = -x[i*3+1] + x[j*3+1];
self->Rij[jj*3 +2] = -x[i*3+2] + x[j*3+2];
}
}
// increment iterator
self->kim_iterator_position++;
return KIM_STATUS_OK; //successful increment
} else if (self->kim_iterator_position == inum) {
*numnei = 0;
return KIM_STATUS_NEIGH_ITER_PAST_END; //reached end by iterator
} else if (self->kim_iterator_position > inum || inum < 0){
self->error->one(FLERR, "KIM neighbor iterator exceeded range");
}
} else if (*request == 0){ //restart iterator
self->kim_iterator_position = 0;
*numnei = 0;
return KIM_STATUS_NEIGH_ITER_INIT_OK; //succsesful restart
}
} else if (*mode == 1){//locator mode
//...
if (*request < inum) {
*atom = *request;
*numnei = numneigh[*atom];
// strip off neighbor mask for molecular systems
if (!self->lmps_using_molecular)
*nei1atom = firstneigh[*atom];
else
{
int n = *numnei;
int *ptr = firstneigh[*atom];
int *lmps_stripped_neigh_list = self->lmps_stripped_neigh_list;
for (int i = 0; i < n; i++)
lmps_stripped_neigh_list[i] = *(ptr++) & NEIGHMASK;
*nei1atom = lmps_stripped_neigh_list;
}
// set Rij if needed
if (self->kim_model_using_Rij){
double* x = (double *)
(*pkim).get_data_by_index(self->kim_ind_coordinates, &kimerror);
for(int jj=0; jj < *numnei; jj++){
int i = *atom;
int j = (*nei1atom)[jj];
self->Rij[jj*3 +0] = -x[i*3+0] + x[j*3+0];
self->Rij[jj*3 +1] = -x[i*3+1] + x[j*3+1];
self->Rij[jj*3 +2] = -x[i*3+2] + x[j*3+2];
}
}
return KIM_STATUS_OK; //successful end
}
else if (*request >= nAtoms || inum < 0)
return KIM_STATUS_NEIGH_INVALID_REQUEST;
else if (*request >= inum) {
*atom = *request;
*numnei = 0;
return KIM_STATUS_OK; //successfull but no neighbors in the list
}
} else return KIM_STATUS_NEIGH_INVALID_MODE; //invalid mode
return -16; //should not get here: unspecified error
}
