/*******************************************************************************
* return magnitude of separation vector between two pos vectors
*******************************************************************************/
static PyObject*
separationMagnitude(PyObject *self, PyObject *args)
{
int length, *PBC;
double *pos1, *pos2, *cellDims;
PyArrayObject *PBCIn=NULL;
PyArrayObject *pos1In=NULL;
PyArrayObject *pos2In=NULL;
PyArrayObject *cellDimsIn=NULL;
int i;
double sum;
/* parse and check arguments from Python */
if (!PyArg_ParseTuple(args, "O!O!O!O!", &PyArray_Type, &pos1In, &PyArray_Type, &pos2In,
&PyArray_Type, &cellDimsIn, &PyArray_Type, &PBCIn))
return NULL;
if (not_intVector(PBCIn)) return NULL;
PBC = pyvector_to_Cptr_int(PBCIn);
if (not_doubleVector(pos1In)) return NULL;
pos1 = pyvector_to_Cptr_double(pos1In);
length = ((int) PyArray_DIM(pos1In, 0)) / 3;
if (not_doubleVector(pos2In)) return NULL;
pos2 = pyvector_to_Cptr_double(pos2In);
if (not_doubleVector(cellDimsIn)) return NULL;
cellDims = pyvector_to_Cptr_double(cellDimsIn);
/* loop */
sum = 0;
for (i = 0; i < length; i++ )
{
double r2;
r2 = atomicSeparation2( pos1[3*i], pos1[3*i+1], pos1[3*i+2], pos2[3*i], pos2[3*i+1], pos2[3*i+2], cellDims[0], cellDims[4], cellDims[8], PBC[0], PBC[1], PBC[2]);
sum += r2;
}
return Py_BuildValue("d", sqrt(sum));
}
/*******************************************************************************
* Construct neighbour lists for "ref" atoms where the neighbour lists contain
* "input" atoms only. If separation is very close to 0 we don't add it.
*******************************************************************************/
struct NeighbourList2 * constructNeighbourList2DiffPos(int NAtomsRef, double *refPos, int NAtomsInp, double *inpPos, double *cellDims, int *PBC, double maxSep)
{
int i;
int boxstat;
double approxBoxWidth;
double maxSep2 = maxSep * maxSep;
double rxb, ryb, rzb, sep2;
struct Boxes *boxes;
struct NeighbourList2 *nebList;
/* box input atoms */
approxBoxWidth = maxSep;
boxes = setupBoxes(approxBoxWidth, PBC, cellDims);
if (boxes == NULL) return NULL;
boxstat = putAtomsInBoxes(NAtomsInp, inpPos, boxes);
if (boxstat) return NULL;
/* allocate neb list */
nebList = malloc(NAtomsRef * sizeof(struct NeighbourList2));
if (nebList == NULL)
{
PyErr_SetString(PyExc_MemoryError, "Could not allocate nebList");
freeBoxes(boxes);
return NULL;
}
/* initialise */
for (i = 0; i < NAtomsRef; i++)
{
nebList[i].chunk = 16;
nebList[i].neighbourCount = 0;
nebList[i].neighbour = NULL;
}
/* loop over ref atoms */
for (i = 0; i < NAtomsRef; i++)
{
int i3 = 3 * i;
int j, boxNebListSize, boxIndex, boxNebList[27];
double rxa, rya, rza;
/* atom position */
rxa = refPos[i3 ];
rya = refPos[i3 + 1];
rza = refPos[i3 + 2];
/* get box index of this atom */
boxIndex = boxIndexOfAtom(rxa, rya, rza, boxes);
if (boxIndex < 0)
{
freeNeighbourList2(nebList, NAtomsRef);
freeBoxes(boxes);
return NULL;
}
/* find neighbouring boxes */
boxNebListSize = getBoxNeighbourhood(boxIndex, boxNebList, boxes);
/* loop over box neighbourhood */
for (j = 0; j < boxNebListSize; j++)
{
int k;
boxIndex = boxNebList[j];
/* loop over atoms in box */
for (k = 0; k < boxes->boxNAtoms[boxIndex]; k++)
{
int indexb = boxes->boxAtoms[boxIndex][k];
int indb3 = indexb * 3;
/* atom position */
rxb = inpPos[indb3 ];
ryb = inpPos[indb3 + 1];
rzb = inpPos[indb3 + 2];
/* separation */
sep2 = atomicSeparation2(rxa, rya, rza, rxb, ryb, rzb, cellDims[0], cellDims[1], cellDims[2], PBC[0], PBC[1], PBC[2]);
/* check if neighbour */
if (sep2 < maxSep2)
{
if (fabs(sep2 - 0.0) > 1e-6)
{
int addstat;
double sep = sqrt(sep2);
addstat = addAtomToNebList(i, indexb, sep, nebList);
if (addstat)
{
freeNeighbourList2(nebList, NAtomsRef);
freeBoxes(boxes);
return NULL;
}
}
}
}
}
}
freeBoxes(boxes);
return nebList;
}
struct NeighbourList2 * constructNeighbourList2(int NAtoms, double *pos, struct Boxes *boxes, double *cellDims, int *PBC, double maxSep2)
{
int i, j, k, boxIndex, indexb;
int boxNebList[27];
double rxa, rya, rza, rxb, ryb, rzb, sep2;
struct NeighbourList2 *nebList;
/* allocate neb list */
nebList = malloc(NAtoms * sizeof(struct NeighbourList2));
if (nebList == NULL)
{
PyErr_SetString(PyExc_MemoryError, "Could not allocate nebList");
return NULL;
}
/* initialise */
for (i = 0; i < NAtoms; i++)
{
nebList[i].chunk = 16;
nebList[i].neighbourCount = 0;
nebList[i].neighbour = NULL;
}
/* loop over atoms */
for (i = 0; i < NAtoms; i++)
{
int boxNebListSize;
/* atom position */
rxa = pos[3*i];
rya = pos[3*i+1];
rza = pos[3*i+2];
/* get box index of this atom */
boxIndex = boxIndexOfAtom(rxa, rya, rza, boxes);
if (boxIndex < 0)
{
freeNeighbourList2(nebList, NAtoms);
return NULL;
}
/* find neighbouring boxes */
boxNebListSize = getBoxNeighbourhood(boxIndex, boxNebList, boxes);
/* loop over box neighbourhood */
for (j = 0; j < boxNebListSize; j++)
{
boxIndex = boxNebList[j];
/* loop over atoms in box */
for (k=0; k<boxes->boxNAtoms[boxIndex]; k++)
{
indexb = boxes->boxAtoms[boxIndex][k];
if (indexb <= i) continue;
/* atom position */
rxb = pos[3*indexb];
ryb = pos[3*indexb+1];
rzb = pos[3*indexb+2];
/* separation */
sep2 = atomicSeparation2(rxa, rya, rza, rxb, ryb, rzb, cellDims[0], cellDims[1], cellDims[2], PBC[0], PBC[1], PBC[2]);
/* check if neighbour */
if (sep2 < maxSep2)
{
int addstat;
double sep = sqrt(sep2);
addstat = addAtomToNebList(i, indexb, sep, nebList);
if (addstat)
{
freeNeighbourList2(nebList, NAtoms);
return NULL;
}
addstat = addAtomToNebList(indexb, i, sep, nebList);
if (addstat)
{
freeNeighbourList2(nebList, NAtoms);
return NULL;
}
}
}
}
}
return nebList;
}
struct NeighbourList * constructNeighbourList(int NAtoms, double *pos, struct Boxes *boxes, double *cellDims, int *PBC, double maxSep2)
{
int i, j, k, boxIndex, indexb, newsize;
int boxNebList[27];
double rxa, rya, rza, rxb, ryb, rzb, sep2;
struct NeighbourList *nebList;
/* allocate neb list */
nebList = malloc(NAtoms * sizeof(struct NeighbourList));
if (nebList == NULL)
{
PyErr_SetString(PyExc_MemoryError, "Could not allocate nebList");
return NULL;
}
/* initialise */
for (i = 0; i < NAtoms; i++)
{
nebList[i].chunk = 16;
nebList[i].neighbourCount = 0;
}
/* loop over atoms */
for (i = 0; i < NAtoms; i++)
{
int boxNebListSize;
/* atom position */
rxa = pos[3*i];
rya = pos[3*i+1];
rza = pos[3*i+2];
/* get box index of this atom */
boxIndex = boxIndexOfAtom(rxa, rya, rza, boxes);
if (boxIndex < 0)
{
freeNeighbourList(nebList, NAtoms);
return NULL;
}
/* find neighbouring boxes */
boxNebListSize = getBoxNeighbourhood(boxIndex, boxNebList, boxes);
/* loop over box neighbourhood */
for (j = 0; j < boxNebListSize; j++)
{
boxIndex = boxNebList[j];
/* loop over atoms in box */
for (k = 0; k < boxes->boxNAtoms[boxIndex]; k++)
{
indexb = boxes->boxAtoms[boxIndex][k];
if (indexb == i) continue;
/* atom position */
rxb = pos[3*indexb];
ryb = pos[3*indexb+1];
rzb = pos[3*indexb+2];
/* separation */
sep2 = atomicSeparation2(rxa, rya, rza, rxb, ryb, rzb, cellDims[0], cellDims[1], cellDims[2], PBC[0], PBC[1], PBC[2]);
/* check if neighbour */
if (sep2 < maxSep2)
{
/* check if need to resize neighbour pointers */
if (nebList[i].neighbourCount == 0)
{
nebList[i].neighbour = malloc(nebList[i].chunk * sizeof(int));
if (nebList[i].neighbour == NULL)
{
char errstring[128];
sprintf(errstring, "Could not allocate nebList[%d].neighbour\n", i);
PyErr_SetString(PyExc_MemoryError, errstring);
freeNeighbourList(nebList, NAtoms);
return NULL;
}
nebList[i].neighbourSep = malloc(nebList[i].chunk * sizeof(double));
if (nebList[i].neighbourSep == NULL)
{
char errstring[128];
sprintf(errstring, "Could not allocate nebList[%d].neighbourSep\n", i);
PyErr_SetString(PyExc_MemoryError, errstring);
freeNeighbourList(nebList, NAtoms);
return NULL;
}
}
else if (nebList[i].neighbourCount % nebList[i].chunk == 0)
{
newsize = nebList[i].neighbourCount + nebList[i].chunk;
nebList[i].neighbour = realloc(nebList[i].neighbour, newsize * sizeof(int));
if (nebList[i].neighbour == NULL)
{
char errstring[128];
sprintf(errstring, "Could not reallocate nebList[%d].neighbour\n", i);
PyErr_SetString(PyExc_MemoryError, errstring);
freeNeighbourList(nebList, NAtoms);
return NULL;
}
nebList[i].neighbourSep = realloc(nebList[i].neighbourSep, newsize * sizeof(double));
if (nebList[i].neighbourSep == NULL)
{
char errstring[128];
sprintf(errstring, "Could not reallocate nebList[%d].neighbourSep\n", i);
PyErr_SetString(PyExc_MemoryError, errstring);
freeNeighbourList(nebList, NAtoms);
return NULL;
}
}
/* add neighbour */
nebList[i].neighbour[nebList[i].neighbourCount] = indexb;
nebList[i].neighbourSep[nebList[i].neighbourCount] = sqrt(sep2);
nebList[i].neighbourCount++;
// if (i < 1)
// printf("NEB OF %d: %d; sep %lf\n", i, indexb, sqrt(sep2));
}
}
}
// if (i < 1)
// printf("NUM NEBS FOR %d: %d\n", i, nebList[i].neighbourCount);
}
return nebList;
}
/*******************************************************************************
** Check if an object has been picked
*******************************************************************************/
static PyObject*
pickObject(PyObject *self, PyObject *args)
{
int visibleAtomsDim, *visibleAtoms, vacsDim, *vacs, intsDim, *ints, onAntsDim, *onAnts, splitsDim, *splits;
int *PBC, *specie, *refSpecie;
double *pickPos, *pos, *refPos, *cellDims, *specieCovRad, *refSpecieCovRad, *result;
PyArrayObject *visibleAtomsIn=NULL;
PyArrayObject *vacsIn=NULL;
PyArrayObject *intsIn=NULL;
PyArrayObject *onAntsIn=NULL;
PyArrayObject *splitsIn=NULL;
PyArrayObject *pickPosIn=NULL;
PyArrayObject *posIn=NULL;
PyArrayObject *refPosIn=NULL;
PyArrayObject *PBCIn=NULL;
PyArrayObject *cellDimsIn=NULL;
PyArrayObject *specieIn=NULL;
PyArrayObject *refSpecieIn=NULL;
PyArrayObject *specieCovRadIn=NULL;
PyArrayObject *refSpecieCovRadIn=NULL;
PyArrayObject *resultIn=NULL;
int minSepIndex, minSepType;
double approxBoxWidth, minSepRad, minSep2, minSep;
/* parse and check arguments from Python */
if (!PyArg_ParseTuple(args, "O!O!O!O!O!O!O!O!O!O!O!O!O!O!O!", &PyArray_Type, &visibleAtomsIn, &PyArray_Type, &vacsIn,
&PyArray_Type, &intsIn, &PyArray_Type, &onAntsIn, &PyArray_Type, &splitsIn, &PyArray_Type, &pickPosIn, &PyArray_Type,
&posIn, &PyArray_Type, &refPosIn, &PyArray_Type, &PBCIn, &PyArray_Type, &cellDimsIn, &PyArray_Type, &specieIn,
&PyArray_Type, &refSpecieIn, &PyArray_Type, &specieCovRadIn, &PyArray_Type, &refSpecieCovRadIn, &PyArray_Type,
&resultIn))
return NULL;
if (not_intVector(visibleAtomsIn)) return NULL;
visibleAtoms = pyvector_to_Cptr_int(visibleAtomsIn);
visibleAtomsDim = (int) PyArray_DIM(visibleAtomsIn, 0);
if (not_intVector(vacsIn)) return NULL;
vacs = pyvector_to_Cptr_int(vacsIn);
vacsDim = (int) PyArray_DIM(vacsIn, 0);
if (not_intVector(intsIn)) return NULL;
ints = pyvector_to_Cptr_int(intsIn);
intsDim = (int) PyArray_DIM(intsIn, 0);
if (not_intVector(onAntsIn)) return NULL;
onAnts = pyvector_to_Cptr_int(onAntsIn);
onAntsDim = (int) PyArray_DIM(onAntsIn, 0);
if (not_intVector(splitsIn)) return NULL;
splits = pyvector_to_Cptr_int(splitsIn);
splitsDim = (int) PyArray_DIM(splitsIn, 0);
if (not_doubleVector(pickPosIn)) return NULL;
pickPos = pyvector_to_Cptr_double(pickPosIn);
if (not_doubleVector(posIn)) return NULL;
pos = pyvector_to_Cptr_double(posIn);
if (not_doubleVector(refPosIn)) return NULL;
refPos = pyvector_to_Cptr_double(refPosIn);
if (not_doubleVector(cellDimsIn)) return NULL;
cellDims = pyvector_to_Cptr_double(cellDimsIn);
if (not_intVector(PBCIn)) return NULL;
PBC = pyvector_to_Cptr_int(PBCIn);
if (not_intVector(specieIn)) return NULL;
specie = pyvector_to_Cptr_int(specieIn);
if (not_intVector(refSpecieIn)) return NULL;
refSpecie = pyvector_to_Cptr_int(refSpecieIn);
if (not_doubleVector(specieCovRadIn)) return NULL;
specieCovRad = pyvector_to_Cptr_double(specieCovRadIn);
if (not_doubleVector(refSpecieCovRadIn)) return NULL;
refSpecieCovRad = pyvector_to_Cptr_double(refSpecieCovRadIn);
if (not_doubleVector(resultIn)) return NULL;
result = pyvector_to_Cptr_double(resultIn);
// this should be detected automatically depending on cell size...
approxBoxWidth = 4.0;
/* initialise */
minSep2 = 9999999.0;
minSepIndex = -1;
minSepRad = 0.0;
minSepType = 0;
/* pick atoms (if there are any) */
if (visibleAtomsDim > 0)
{
int i, boxIndex, boxNebList[27], boxstat;
int boxNebListSize;
double *visPos;
struct Boxes *boxes;
#ifdef DEBUG
printf("PICKC: Picking atoms\n");
#endif
/* vis atoms pos */
visPos = malloc(3 * visibleAtomsDim * sizeof(double));
if (visPos == NULL)
{
PyErr_SetString(PyExc_RuntimeError, "Could not allocate visPos");
return NULL;
}
for (i = 0; i < visibleAtomsDim; i++)
{
int i3 = 3 * i;
int index = visibleAtoms[i];
int index3 = 3 * index;
visPos[i3 ] = pos[index3 ];
visPos[i3 + 1] = pos[index3 + 1];
visPos[i3 + 2] = pos[index3 + 2];
}
/* box vis atoms */
boxes = setupBoxes(approxBoxWidth, PBC, cellDims);
if (boxes == NULL)
{
free(visPos);
return NULL;
}
boxstat = putAtomsInBoxes(visibleAtomsDim, visPos, boxes);
if (boxstat)
{
free(visPos);
return NULL;
}
/* box index of picked pos */
boxIndex = boxIndexOfAtom(pickPos[0], pickPos[1], pickPos[2], boxes);
if (boxIndex < 0)
{
free(visPos);
freeBoxes(boxes);
return NULL;
}
/* neighbouring boxes */
boxNebListSize = getBoxNeighbourhood(boxIndex, boxNebList, boxes);
/* loop over neighbouring boxes, looking for nearest atom */
for (i = 0; i < boxNebListSize; i++)
{
int k;
int checkBox = boxNebList[i];
for (k = 0; k < boxes->boxNAtoms[checkBox]; k++)
{
int index, realIndex;
double sep2, rad;
index = boxes->boxAtoms[checkBox][k];
/* atomic separation */
sep2 = atomicSeparation2(pickPos[0], pickPos[1], pickPos[2],
visPos[3*index], visPos[3*index+1], visPos[3*index+2],
cellDims[0], cellDims[1], cellDims[2],
PBC[0], PBC[1], PBC[2]);
/* need radius too */
realIndex = visibleAtoms[index];
rad = specieCovRad[specie[realIndex]];
if (sep2 < minSep2)
{
minSep2 = sep2;
minSepIndex = index;
minSepRad = rad;
}
}
}
/* free memory */
free(visPos);
freeBoxes(boxes);
}
/* now check defects (if there are any) */
if (vacsDim + intsDim + onAntsDim + splitsDim > 0)
{
int i, NVis, count, boxNebListSize, minSepIsDefect;
int boxIndex, boxNebList[27], boxstat;
double *visPos, *visCovRad;
struct Boxes *boxes;
#ifdef DEBUG
printf("PICKC: Picking defect\n");
#endif
/* build positions array of all defects */
NVis = vacsDim + intsDim + onAntsDim + splitsDim;
visPos = malloc(3 * NVis * sizeof(double));
if (visPos == NULL)
{
PyErr_SetString(PyExc_RuntimeError, "Could not allocate visPos");
return NULL;
}
visCovRad = malloc(NVis * sizeof(double));
if (visCovRad == NULL)
{
PyErr_SetString(PyExc_RuntimeError, "Could not allocate visCovRad");
free(visPos);
return NULL;
}
/* add defects positions: vac then int then ant */
count = 0;
for (i = 0; i < vacsDim; i++)
{
int c3 = 3 * count;
int index = vacs[i];
int index3 = 3 * index;
visPos[c3 ] = refPos[index3 ];
visPos[c3 + 1] = refPos[index3 + 1];
visPos[c3 + 2] = refPos[index3 + 2];
visCovRad[count++] = refSpecieCovRad[refSpecie[index]] * 1.2; // * 0.75; // multiply by 0.75 because vacs aren't full size (rendering.py)
}
for (i = 0; i < intsDim; i++)
{
int c3 = 3 * count;
int index = ints[i];
int index3 = 3 * index;
visPos[c3 ] = pos[index3 ];
visPos[c3 + 1] = pos[index3 + 1];
visPos[c3 + 2] = pos[index3 + 2];
visCovRad[count++] = specieCovRad[specie[index]];
}
for (i = 0; i < onAntsDim; i++)
{
int c3 = 3 * count;
int index = onAnts[i];
int index3 = 3 * index;
visPos[c3 ] = pos[index3 ];
visPos[c3 + 1] = pos[index3 + 1];
visPos[c3 + 2] = pos[index3 + 2];
visCovRad[count++] = specieCovRad[specie[index]];
}
for (i = 0; i < splitsDim / 3; i++)
{
int i3 = 3 * i;
int index, c3, index3;
index = splits[i3 ];
index3 = index * 3;
c3 = count * 3;
visPos[c3 ] = refPos[index3 ];
visPos[c3 + 1] = refPos[index3 + 1];
visPos[c3 + 2] = refPos[index3 + 2];
visCovRad[count++] = refSpecieCovRad[refSpecie[index]];
index = splits[i3 + 1];
index3 = index * 3;
c3 = count * 3;
visPos[c3 ] = pos[index3 ];
visPos[c3 + 1] = pos[index3 + 1];
visPos[c3 + 2] = pos[index3 + 2];
visCovRad[count++] = specieCovRad[specie[index]];
index = splits[i3 + 2];
index3 = index * 3;
c3 = count * 3;
visPos[c3 ] = pos[index3 ];
visPos[c3 + 1] = pos[index3 + 1];
visPos[c3 + 2] = pos[index3 + 2];
visCovRad[count++] = specieCovRad[specie[index]];
}
/* box vis atoms */
boxes = setupBoxes(approxBoxWidth, PBC, cellDims);
if (boxes == NULL)
{
free(visPos);
free(visCovRad);
return NULL;
}
boxstat = putAtomsInBoxes(NVis, visPos, boxes);
if (boxstat)
{
free(visPos);
free(visCovRad);
return NULL;
}
/* box index of picked pos */
boxIndex = boxIndexOfAtom(pickPos[0], pickPos[1], pickPos[2], boxes);
if (boxIndex < 0)
{
free(visPos);
free(visCovRad);
freeBoxes(boxes);
return NULL;
}
/* neighbouring boxes */
boxNebListSize = getBoxNeighbourhood(boxIndex, boxNebList, boxes);
/* loop over neighbouring boxes, looking for nearest atom */
minSepIsDefect = 0;
for (i = 0; i < boxNebListSize; i++)
{
int k;
int checkBox = boxNebList[i];
for (k = 0; k < boxes->boxNAtoms[checkBox]; k++)
{
int index;
double sep2, rad;
index = boxes->boxAtoms[checkBox][k];
/* atomic separation */
sep2 = atomicSeparation2(pickPos[0], pickPos[1], pickPos[2],
visPos[3*index], visPos[3*index+1], visPos[3*index+2],
cellDims[0], cellDims[1], cellDims[2],
PBC[0], PBC[1], PBC[2]);
/* need radius too */
rad = visCovRad[index];
if (sep2 < minSep2)
{
minSep2 = sep2;
minSepIndex = index;
minSepRad = rad;
minSepIsDefect = 1;
}
}
}
if (minSepIsDefect)
{
/* picked type */
if (minSepIndex < vacsDim)
{
minSepType = 1;
}
else if (minSepIndex < vacsDim + intsDim)
{
minSepIndex -= vacsDim;
minSepType = 2;
}
else if (minSepIndex < vacsDim + intsDim + onAntsDim)
{
minSepIndex -= vacsDim + intsDim;
minSepType = 3;
}
else
{
minSepIndex -= vacsDim + intsDim + onAntsDim;
minSepIndex = (int) (minSepIndex / 3);
minSepType = 4;
}
}
/* free memory */
freeBoxes(boxes);
free(visPos);
free(visCovRad);
}
/* min separation */
minSep = sqrt(minSep2);
/* if separation is greater than radius, subtract radius,
* otherwise set to zero (within radius is good enough for me)
*/
minSep = (minSep > minSepRad) ? minSep - minSepRad : 0.0;
/* store result */
result[0] = minSepType;
result[1] = minSepIndex;
result[2] = minSep;
#ifdef DEBUG
printf("PICKC: End\n");
#endif
return Py_BuildValue("i", 0);
}
/*******************************************************************************
** Compute the histogram for the RDF
*******************************************************************************/
static int
computeHistogram(int NAtoms, int NVisible, int *visibleAtoms, double *pos, int *PBC, double *cellDims,
int *sel1, int *sel2, double start, double finish, double interval, double *hist)
{
int i, errorCount, boxstat;
double *visiblePos, approxBoxWidth;
const double start2 = start * start;
const double finish2 = finish * finish;
struct Boxes *boxes;
/* positions of visible atoms */
if (NAtoms == NVisible) visiblePos = pos;
else
{
visiblePos = malloc(3 * NVisible * sizeof(double));
if (visiblePos == NULL)
{
PyErr_SetString(PyExc_MemoryError, "Could not allocate visiblePos");
return 1;
}
for (i = 0; i < NVisible; i++)
{
int index = visibleAtoms[i];
int i3 = 3 * i;
int ind3 = 3 * index;
visiblePos[i3 ] = pos[ind3 ];
visiblePos[i3 + 1] = pos[ind3 + 1];
visiblePos[i3 + 2] = pos[ind3 + 2];
}
}
/* spatial decomposition - box width must be at least `finish` */
approxBoxWidth = finish;
boxes = setupBoxes(approxBoxWidth, PBC, cellDims);
if (boxes == NULL)
{
if (NAtoms != NVisible) free(visiblePos);
return 2;
}
boxstat = putAtomsInBoxes(NVisible, visiblePos, boxes);
if (NAtoms != NVisible) free(visiblePos);
if (boxstat) return 3;
/* loop over visible atoms */
errorCount = 0;
#pragma omp parallel for reduction(+: errorCount) num_threads(prefs_numThreads)
for (i = 0; i < NVisible; i++)
{
int j, index, ind3, boxIndex, boxNebList[27], boxNebListSize;
double rxa, rya, rza;
/* skip if this atom is not in the first selection */
if (!sel1[i]) continue;
/* the index of this atom in the pos array */
index = visibleAtoms[i];
/* position of this atom and its box index */
ind3 = index * 3;
rxa = pos[ind3 ];
rya = pos[ind3 + 1];
rza = pos[ind3 + 2];
boxIndex = boxIndexOfAtom(rxa, rya, rza, boxes);
if (boxIndex < 0) errorCount++;
if (!errorCount)
{
/* find neighbouring boxes */
boxNebListSize = getBoxNeighbourhood(boxIndex, boxNebList, boxes);
/* loop over the box neighbourhood */
for (j = 0; j < boxNebListSize; j++)
{
int k;
int checkBox = boxNebList[j];
for (k = 0; k < boxes->boxNAtoms[checkBox]; k++)
{
int visIndex, index2, ind23;
double sep2;
/* the index of this atom in the visibleAtoms array */
visIndex = boxes->boxAtoms[checkBox][k];
/* skip if this atom is not in the second selection */
if (!sel2[visIndex]) continue;
/* atom index */
index2 = visibleAtoms[visIndex];
/* skip if same atom */
if (index == index2) continue;
/* atomic separation */
ind23 = index2 * 3;
sep2 = atomicSeparation2(rxa, rya, rza,
pos[ind23], pos[ind23 + 1], pos[ind23 + 2],
cellDims[0], cellDims[1], cellDims[2],
PBC[0], PBC[1], PBC[2]);
/* put in bin */
if (sep2 >= start2 && sep2 < finish2)
{
int binIndex;
double sep;
sep = sqrt(sep2);
binIndex = (int) ((sep - start) / interval);
#pragma omp atomic
hist[binIndex]++;
}
}
}
}
}
/* free memory */
freeBoxes(boxes);
/* raise an exception if there were any errors */
if (errorCount)
{
PyErr_SetString(PyExc_RuntimeError,
"computeHistogram failed; probably box index error (check stderr)");
return 4;
}
return 0;
}
/*******************************************************************************
* Search for defects and return the sub-system surrounding them
*******************************************************************************/
int findDefects( int includeVacs, int includeInts, int includeAnts,
int* defectList, int* NDefectsByType,
int* vacancies, int* interstitials, int* antisites, int* onAntisites,
int inclSpecDim, int* inclSpec, int exclSpecInputDim, int* exclSpecInput, int exclSpecRefDim, int* exclSpecRef,
int NAtoms, char* specieList, int* specie, double* pos,
int refNAtoms, char* specieListRef, int* specieRef, double* refPos,
double *cellDims, int *PBC, double vacancyRadius, double inclusionRadius, double *minPos, double *maxPos,
int verboseLevel, int debugDefects)
{
int i, exitLoop, k, j, index;
double vacRad2, xpos, ypos, zpos;
int boxNebList[27];
char symtemp[3], symtemp2[3];
int checkBox, refIndex, comp, boxIndex;
double refxpos, refypos, refzpos;
double sep2, incRad2, approxBoxWidth;
int NDefects, NAntisites, NInterstitials, NVacancies;
int *possibleVacancy, *possibleInterstitial;
int *possibleAntisite, *possibleOnAntisite;
int count, addToInt, skip;
struct Boxes *boxes;
if ( verboseLevel > 2)
{
printf("CLIB: finding defects\n");
printf(" vac rad %f\n", vacancyRadius);
printf(" inc rad %f\n", inclusionRadius);
}
/* approx width, must be at least vacRad */
approxBoxWidth = 1.1 * vacancyRadius;
/* box reference atoms */
boxes = setupBoxes(approxBoxWidth, minPos, maxPos, PBC, cellDims);
putAtomsInBoxes(refNAtoms, refPos, boxes);
/* allocate local arrays for checking atoms */
possibleVacancy = malloc( refNAtoms * sizeof(int) );
if (possibleVacancy == NULL)
{
printf("ERROR: Boxes: could not allocate possibleVacancy\n");
exit(1);
}
possibleInterstitial = malloc( NAtoms * sizeof(int) );
if (possibleInterstitial == NULL)
{
printf("ERROR: Boxes: could not allocate possibleInterstitial\n");
exit(1);
}
possibleAntisite = malloc( refNAtoms * sizeof(int) );
if (possibleAntisite == NULL)
{
printf("ERROR: Boxes: could not allocate possibleAntisite\n");
exit(1);
}
possibleOnAntisite = malloc( refNAtoms * sizeof(int) );
if (possibleOnAntisite == NULL)
{
printf("ERROR: Boxes: could not allocate possibleOnAntisite\n");
exit(1);
}
/* initialise arrays */
for ( i=0; i<NAtoms; i++ )
{
possibleInterstitial[i] = 1;
}
for ( i=0; i<refNAtoms; i++ )
{
possibleVacancy[i] = 1;
possibleAntisite[i] = 1;
}
/* build local specie list */
vacRad2 = vacancyRadius * vacancyRadius;
incRad2 = inclusionRadius * inclusionRadius;
/* loop over all input atoms */
for ( i=0; i<NAtoms; i++ )
{
int nboxes;
xpos = pos[3*i];
ypos = pos[3*i+1];
zpos = pos[3*i+2];
/* get box index of this atom */
boxIndex = boxIndexOfAtom(xpos, ypos, zpos, boxes);
/* find neighbouring boxes */
nboxes = getBoxNeighbourhood(boxIndex, boxNebList, boxes);
/* loop over neighbouring boxes */
exitLoop = 0;
for (j = 0; j < nboxes; j++)
{
if (exitLoop)
{
break;
}
checkBox = boxNebList[j];
/* now loop over all reference atoms in the box */
for ( k=0; k<boxes->boxNAtoms[checkBox]; k++ )
{
refIndex = boxes->boxAtoms[checkBox][k];
/* if this vacancy has already been filled then skip to the next one */
if ( possibleVacancy[refIndex] == 0 )
{
continue;
}
refxpos = refPos[3*refIndex];
refypos = refPos[3*refIndex+1];
refzpos = refPos[3*refIndex+2];
/* atomic separation of possible vacancy and possible interstitial */
sep2 = atomicSeparation2(xpos, ypos, zpos, refxpos, refypos, refzpos,
cellDims[0], cellDims[1], cellDims[2], PBC[0], PBC[1], PBC[2]);
/* if within vacancy radius, is it an antisite or normal lattice point */
if ( sep2 < vacRad2 )
{
/* compare symbols */
symtemp[0] = specieList[2*specie[i]];
symtemp[1] = specieList[2*specie[i]+1];
symtemp[2] = '\0';
symtemp2[0] = specieListRef[2*specieRef[refIndex]];
symtemp2[1] = specieListRef[2*specieRef[refIndex]+1];
symtemp2[2] = '\0';
comp = strcmp( symtemp, symtemp2 );
if ( comp == 0 )
{
/* match, so not antisite */
possibleAntisite[refIndex] = 0;
}
else
{
possibleOnAntisite[refIndex] = i;
}
/* not an interstitial or vacancy */
possibleInterstitial[i] = 0;
possibleVacancy[refIndex] = 0;
/* no need to check further for this (no longer) possible interstitial */
exitLoop = 1;
break;
}
}
}
}
/* free boxes structure */
freeBoxes(boxes);
/* now box input atoms, approx width must be at least incRad */
approxBoxWidth = 1.1 * inclusionRadius;
boxes = setupBoxes(approxBoxWidth, minPos, maxPos, PBC, cellDims);
putAtomsInBoxes(NAtoms, pos, boxes);
/* now classify defects */
NVacancies = 0;
NInterstitials = 0;
NAntisites = 0;
count = 0;
for ( i=0; i<refNAtoms; i++ )
{
skip = 0;
for (j=0; j<exclSpecRefDim; j++)
{
if (specieRef[i] == exclSpecRef[j])
{
skip = 1;
}
}
if (skip == 1)
{
continue;
}
/* vacancies */
if (possibleVacancy[i] == 1)
{
if (includeVacs == 1)
{
int nboxes;
vacancies[NVacancies] = i;
NVacancies++;
/* find input atoms within inclusionRadius of this vacancy */
refxpos = refPos[3*i];
refypos = refPos[3*i+1];
refzpos = refPos[3*i+2];
boxIndex = boxIndexOfAtom(refxpos, refypos, refzpos, boxes);
/* find neighbouring boxes */
nboxes = getBoxNeighbourhood(boxIndex, boxNebList, boxes);
for (j = 0; j < nboxes; j++ )
{
checkBox = boxNebList[j];
/* loop over atoms in box */
for ( k=0; k<boxes->boxNAtoms[checkBox]; k++ )
{
index = boxes->boxAtoms[checkBox][k];
/* if already on defect list continue */
if (defectList[index] == 1)
{
continue;
}
/* if close to defect add to list */
xpos = pos[3*index];
ypos = pos[3*index+1];
zpos = pos[3*index+2];
sep2 = atomicSeparation2(xpos, ypos, zpos, refxpos, refypos, refzpos,
cellDims[0], cellDims[1], cellDims[2], PBC[0], PBC[1], PBC[2]);
if ( sep2 < incRad2 )
{
defectList[index] = 1;
count++;
}
}
}
}
}
/* antisites */
else if ( (possibleAntisite[i] == 1) && (includeAnts == 1) )
{
int nboxes;
antisites[NAntisites] = i;
onAntisites[NAntisites] = possibleOnAntisite[i];
NAntisites++;
/* find input atoms within inclusionRadius of this antisite */
refxpos = refPos[3*i];
refypos = refPos[3*i+1];
refzpos = refPos[3*i+2];
boxIndex = boxIndexOfAtom(refxpos, refypos, refzpos, boxes);
/* find neighbouring boxes */
nboxes = getBoxNeighbourhood(boxIndex, boxNebList, boxes);
for (j = 0; j < nboxes; j++)
{
checkBox = boxNebList[j];
/* loop over atoms in box */
for ( k=0; k<boxes->boxNAtoms[checkBox]; k++ )
{
index = boxes->boxAtoms[checkBox][k];
/* if already on defect list continue */
if (defectList[index] == 1)
{
continue;
}
/* if close to defect add to list */
xpos = pos[3*index];
ypos = pos[3*index+1];
zpos = pos[3*index+2];
sep2 = atomicSeparation2(xpos, ypos, zpos, refxpos, refypos, refzpos,
cellDims[0], cellDims[1], cellDims[2], PBC[0], PBC[1], PBC[2]);
if ( sep2 < incRad2 )
{
defectList[index] = 1;
count++;
}
}
}
}
}
if (includeInts == 1)
{
for ( i=0; i<NAtoms; i++ )
{
skip = 0;
for (j=0; j<exclSpecInputDim; j++)
{
if (specie[i] == exclSpecInput[j])
{
skip = 1;
break;
}
}
if (skip == 1)
{
continue;
}
addToInt = 0;
for (j=0; j<inclSpecDim; j++)
{
if (specie[i] == inclSpec[j])
{
addToInt = 1;
break;
}
}
/* interstitials */
if ( (possibleInterstitial[i] == 1) || (addToInt == 1) )
{
int nboxes;
interstitials[NInterstitials] = i;
NInterstitials++;
defectList[i] = 1;
count++;
/* find input atoms within inclusionRadius of this interstitial */
refxpos = pos[3*i];
refypos = pos[3*i+1];
refzpos = pos[3*i+2];
boxIndex = boxIndexOfAtom(refxpos, refypos, refzpos, boxes);
/* find neighbouring boxes */
nboxes = getBoxNeighbourhood(boxIndex, boxNebList, boxes);
for (j = 0; j < nboxes; j++)
{
checkBox = boxNebList[j];
/* loop over atoms in box */
for ( k=0; k<boxes->boxNAtoms[checkBox]; k++ )
{
index = boxes->boxAtoms[checkBox][k];
/* if same atom continue */
if ( index == i )
{
continue;
}
/* if already on defect list continue */
if (defectList[index] == 1)
{
continue;
}
/* if close to defect add to list */
xpos = pos[3*index];
ypos = pos[3*index+1];
zpos = pos[3*index+2];
sep2 = atomicSeparation2(xpos, ypos, zpos, refxpos, refypos, refzpos,
cellDims[0], cellDims[1], cellDims[2], PBC[0], PBC[1], PBC[2]);
if ( sep2 < incRad2 )
{
defectList[index] = 1;
count++;
}
}
}
}
}
}
/* shift indexes to zero */
count = 0;
for (i=0; i<NAtoms; i++)
{
if (defectList[i] == 1)
{
defectList[count] = i;
count++;
}
}
NDefects = NVacancies + NInterstitials + NAntisites;
if ( verboseLevel > 2 )
{
printf(" found %d defects\n", NDefects);
printf(" %d vacancies\n", NVacancies);
printf(" %d interstitials\n", NInterstitials);
printf(" %d antisites\n", NAntisites);
printf(" including %d atoms in sub-system\n", count);
}
NDefectsByType[0] = NDefects;
NDefectsByType[1] = NVacancies;
NDefectsByType[2] = NInterstitials;
NDefectsByType[3] = NAntisites;
freeBoxes(boxes);
free(possibleVacancy);
free(possibleInterstitial);
free(possibleAntisite);
free(possibleOnAntisite);
return count;
}
/*******************************************************************************
* eliminate pbc flicker
*******************************************************************************/
static PyObject*
eliminatePBCFlicker(PyObject *self, PyObject *args)
{
int NAtoms, *pbc;
double *pos, *previousPos, *cellDims;
PyArrayObject *posIn=NULL;
PyArrayObject *previousPosIn=NULL;
PyArrayObject *cellDimsIn=NULL;
PyArrayObject *pbcIn=NULL;
int i, j, count;
double sep, absSep, halfDims[3];
/* parse and check arguments from Python */
if (!PyArg_ParseTuple(args, "iO!O!O!O!", &NAtoms, &PyArray_Type, &posIn, &PyArray_Type, &previousPosIn,
&PyArray_Type, &cellDimsIn, &PyArray_Type, &pbcIn))
return NULL;
if (not_intVector(pbcIn)) return NULL;
pbc = pyvector_to_Cptr_int(pbcIn);
if (not_doubleVector(posIn)) return NULL;
pos = pyvector_to_Cptr_double(posIn);
if (not_doubleVector(previousPosIn)) return NULL;
previousPos = pyvector_to_Cptr_double(previousPosIn);
if (not_doubleVector(cellDimsIn)) return NULL;
cellDims = pyvector_to_Cptr_double(cellDimsIn);
/* half of cellDims */
halfDims[0] = cellDims[0] * 0.5;
halfDims[1] = cellDims[1] * 0.5;
halfDims[2] = cellDims[2] * 0.5;
/* loop over atoms */
count = 0;
for (i = 0; i < NAtoms; i++)
{
sep = atomicSeparation2(pos[3*i], pos[3*i+1], pos[3*i+2], previousPos[3*i], previousPos[3*i+1], previousPos[3*i+2],
cellDims[0], cellDims[1], cellDims[2], pbc[0], pbc[1], pbc[2]);
for (j = 0; j < 3; j++)
{
if (sep < 1.0 && pos[3*i+j] < 1.0)
{
absSep = fabs(pos[3*i+j] - previousPos[3*i+j]);
if (absSep > halfDims[j])
{
pos[3*i+j] += cellDims[j];
count++;
}
}
else if (sep < 1.0 && fabs(cellDims[j] - pos[3*i+j]) < 1.0)
{
absSep = fabs(pos[3*i+j] - previousPos[3*i+j]);
if (absSep > halfDims[j])
{
pos[3*i+j] -= cellDims[j];
count++;
}
}
}
}
return Py_BuildValue("i", count);
}
