/******************************************************************************* ** Split visible atoms by specie (position and scalar) *******************************************************************************/ static PyObject* countVisibleBySpecie(PyObject *self, PyObject *args) { int i; npy_intp dims[1]; int NSpecies, NVisible; PyArrayObject *visibleAtoms=NULL; PyArrayObject *specieArray=NULL; PyArrayObject *specieCount=NULL; /* parse and check arguments from Python */ if (!PyArg_ParseTuple(args, "O!iO!", &PyArray_Type, &visibleAtoms, &NSpecies, &PyArray_Type, &specieArray)) return NULL; if (not_intVector(visibleAtoms)) return NULL; NVisible = (int) PyArray_DIM(visibleAtoms, 0); if (not_intVector(specieArray)) return NULL; /* specie counter array */ dims[0] = (npy_intp) NSpecies; specieCount = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_INT32); for (i = 0; i < NSpecies; i++) IIND1(specieCount, i) = 0; /* loop over visible atoms, incrementing specie counter */ for (i = 0; i < NVisible; i++) { int index, specieIndex; index = IIND1(visibleAtoms, i); specieIndex = IIND1(specieArray, index); IIND1(specieCount, specieIndex) = IIND1(specieCount, specieIndex) + 1; } return PyArray_Return(specieCount); }
/******************************************************************************* ** Count antisites by species *******************************************************************************/ static PyObject* countAntisitesBySpecie(PyObject *self, PyObject *args) { int NSpeciesInput, NSpeciesRef; PyArrayObject *antisites=NULL; PyArrayObject *onAntisites=NULL; PyArrayObject *specieRef=NULL; PyArrayObject *specieInput=NULL; PyObject *result=NULL; /* parse and check arguments from Python */ if (PyArg_ParseTuple(args, "O!iO!O!iO!", &PyArray_Type, &antisites, &NSpeciesRef, &PyArray_Type, &specieRef, &PyArray_Type, &onAntisites, &NSpeciesInput, &PyArray_Type, &specieInput)) { int i, nants; npy_intp dims[2]; PyArrayObject *specieCount=NULL; if (not_intVector(antisites)) return NULL; nants = (int) PyArray_DIM(antisites, 0); if (not_intVector(specieRef)) return NULL; if (not_intVector(specieInput)) return NULL; /* specie counter array */ dims[0] = (npy_intp) NSpeciesRef; dims[1] = (npy_intp) NSpeciesInput; specieCount = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_INT32); for (i = 0; i < NSpeciesRef; i++) { int j; for (j = 0; j < NSpeciesInput; j++) IIND2(specieCount, i, j) = 0; } /* loop over antistes, incrementing specie counter */ for (i = 0; i < nants; i++) { int index, index2, specieIndex, specieIndex2; index = IIND1(antisites, i); specieIndex = IIND1(specieRef, index); index2 = IIND1(onAntisites, i); specieIndex2 = IIND1(specieInput, index2); IIND2(specieCount, specieIndex, specieIndex2) = IIND2(specieCount, specieIndex, specieIndex2) + 1; } /* store result */ result = PyArray_Return(specieCount); } return result; }
/******************************************************************************* ** Count split interstitials by species *******************************************************************************/ static PyObject* countSplitIntsBySpecie(PyObject *self, PyObject *args) { int NSpecies; PyArrayObject *splitInts=NULL; PyArrayObject *specie=NULL; PyObject *result=NULL; /* parse and check arguments from Python */ if (PyArg_ParseTuple(args, "O!iO!", &PyArray_Type, &splitInts, &NSpecies, &PyArray_Type, &specie)) { int i, nsplit; npy_intp dims[2]; PyArrayObject *specieCount=NULL; if (not_intVector(splitInts)) return NULL; nsplit = (int) (PyArray_DIM(splitInts, 0) / 3); if (not_intVector(specie)) return NULL; /* specie counter array */ dims[0] = (npy_intp) NSpecies; dims[1] = (npy_intp) NSpecies; specieCount = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_INT32); for (i = 0; i < NSpecies; i++) { int j; for (j = 0; j < NSpecies; j++) IIND2(specieCount, i, j) = 0; } /* loop over antistes, incrementing specie counter */ for (i = 0; i < nsplit; i++) { int i3 = 3 * i; int index, index2, specieIndex, specieIndex2; index = IIND1(splitInts, i3 + 1); specieIndex = IIND1(specie, index); index2 = IIND1(splitInts, i3 + 2); specieIndex2 = IIND1(specie, index2); IIND2(specieCount, specieIndex, specieIndex2) = IIND2(specieCount, specieIndex, specieIndex2) + 1; if (specieIndex != specieIndex2) IIND2(specieCount, specieIndex2, specieIndex) = IIND2(specieCount, specieIndex2, specieIndex) + 1; } /* store result */ result = PyArray_Return(specieCount); } return result; }
/******************************************************************************* ** Make scalars array for visible atoms *******************************************************************************/ static PyObject* makeVisibleScalarArray(PyObject *self, PyObject *args) { int NVisible; PyArrayObject *visibleAtoms=NULL; PyArrayObject *scalarsFull=NULL; int i; npy_intp numpydims[1]; PyArrayObject *scalars=NULL; /* parse and check arguments from Python */ if (!PyArg_ParseTuple(args, "O!O!", &PyArray_Type, &visibleAtoms, &PyArray_Type, &scalarsFull)) return NULL; if (not_intVector(visibleAtoms)) return NULL; NVisible = (int) PyArray_DIM(visibleAtoms, 0); if (not_doubleVector(scalarsFull)) return NULL; /* create radius array */ numpydims[0] = (npy_intp) NVisible; scalars = (PyArrayObject *) PyArray_SimpleNew(1, numpydims, NPY_FLOAT64); /* populate array */ for (i = 0; i < NVisible; i++) { int index; index = IIND1(visibleAtoms, i); DIND1(scalars, i) = DIND1(scalarsFull, index); } return PyArray_Return(scalars); }
/******************************************************************************* * Find separation vector between two pos vectors *******************************************************************************/ static PyObject* separationVector(PyObject *self, PyObject *args) { int length, *PBC; double *returnVector, *pos1, *pos2, *cellDims; PyArrayObject *PBCIn=NULL; PyArrayObject *returnVectorIn=NULL; PyArrayObject *pos1In=NULL; PyArrayObject *pos2In=NULL; PyArrayObject *cellDimsIn=NULL; int i; /* parse and check arguments from Python */ if (!PyArg_ParseTuple(args, "O!O!O!O!O!", &PyArray_Type, &returnVectorIn, &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(returnVectorIn)) return NULL; returnVector = pyvector_to_Cptr_double(returnVectorIn); if (not_doubleVector(cellDimsIn)) return NULL; cellDims = pyvector_to_Cptr_double(cellDimsIn); /* loop */ for (i = 0; i < length; i++) { double atomSepVec[3]; atomSeparationVector(atomSepVec, 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]); returnVector[3*i] = atomSepVec[0]; returnVector[3*i+1] = atomSepVec[1]; returnVector[3*i+2] = atomSepVec[2]; } return Py_BuildValue("i", 0); }
/******************************************************************************* * 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)); }
/******************************************************************************* ** Make points array for visible atoms *******************************************************************************/ static PyObject* makeVisiblePointsArray(PyObject *self, PyObject *args) { int NVisible; PyArrayObject *visibleAtoms=NULL; PyArrayObject *pos=NULL; int i; npy_intp numpydims[2]; PyArrayObject *visiblePos=NULL; /* parse and check arguments from Python */ if (!PyArg_ParseTuple(args, "O!O!", &PyArray_Type, &visibleAtoms, &PyArray_Type, &pos)) return NULL; if (not_intVector(visibleAtoms)) return NULL; NVisible = (int) PyArray_DIM(visibleAtoms, 0); if (not_doubleVector(pos)) return NULL; /* create radius array */ numpydims[0] = (npy_intp) NVisible; numpydims[1] = 3; visiblePos = (PyArrayObject *) PyArray_SimpleNew(2, numpydims, NPY_FLOAT64); /* populate array */ for (i = 0; i < NVisible; i++) { int index, index3, j; index = IIND1(visibleAtoms, i); index3 = index * 3; for (j = 0; j < 3; j++) DIND2(visiblePos, i, j) = DIND1(pos, index3 + j); } return PyArray_Return(visiblePos); }
/******************************************************************************* ** Make arrays for rendering bonds for displacment vectors *******************************************************************************/ static PyObject* makeDisplacementVectorBondsArrays(PyObject *self, PyObject *args) { int numBonds; PyArrayObject *visibleAtoms=NULL; PyArrayObject *scalarsArray=NULL; PyArrayObject *pos=NULL; PyArrayObject *drawBondArray=NULL; PyArrayObject *bondVectorsArray=NULL; PyObject *result=NULL; /* parse arguments from Python */ if (PyArg_ParseTuple(args, "iO!O!O!O!O!", &numBonds, &PyArray_Type, &visibleAtoms, &PyArray_Type, &scalarsArray, &PyArray_Type, &pos, &PyArray_Type, &drawBondArray, &PyArray_Type, &bondVectorsArray)) { int i, count, numVisible; npy_intp numpydims[2]; PyArrayObject *bondCoords = NULL; PyArrayObject *bondScalars = NULL; PyArrayObject *bondVectors = NULL; /* check arguments */ if (not_intVector(visibleAtoms)) return NULL; numVisible = (int) PyArray_DIM(visibleAtoms, 0); if (not_doubleVector(scalarsArray)) return NULL; if (not_doubleVector(pos)) return NULL; if (not_intVector(drawBondArray)) return NULL; if (not_doubleVector(bondVectorsArray)) return NULL; /* create array for bond coordinates */ numpydims[0] = (npy_intp) numBonds; numpydims[1] = 3; bondCoords = (PyArrayObject *) PyArray_SimpleNew(2, numpydims, NPY_FLOAT64); if (bondCoords == NULL) { PyErr_SetString(PyExc_MemoryError, "Could not allocate bondCoords"); return NULL; } /* create array for bond vectors */ numpydims[0] = (npy_intp) numBonds; numpydims[1] = 3; bondVectors = (PyArrayObject *) PyArray_SimpleNew(2, numpydims, NPY_FLOAT64); if (bondVectors == NULL) { PyErr_SetString(PyExc_MemoryError, "Could not allocate bondVectors"); Py_DECREF(bondCoords); return NULL; } /* create array for bond scalars */ numpydims[0] = (npy_intp) numBonds; bondScalars = (PyArrayObject *) PyArray_SimpleNew(1, numpydims, NPY_FLOAT64); if (bondScalars == NULL) { PyErr_SetString(PyExc_MemoryError, "Could not allocate bondScalars"); Py_DECREF(bondCoords); Py_DECREF(bondVectors); return NULL; } /* loop over visible atoms */ count = 0; for (i = 0; i < numVisible; i++) { /* check if we should be drawing this bond */ if (IIND1(drawBondArray, i)) { int j, i3 = 3 * i; int index3 = 3 * IIND1(visibleAtoms, i); /* store bond values */ for (j = 0; j < 3; j++) { DIND2(bondCoords, count, j) = DIND1(pos, index3 + j); DIND2(bondVectors, count, j) = DIND1(bondVectorsArray, i3 + j); } DIND1(bondScalars, count) = DIND1(scalarsArray, i); count++; } } /* tuple for result */ result = PyTuple_New(3); PyTuple_SetItem(result, 0, PyArray_Return(bondCoords)); PyTuple_SetItem(result, 1, PyArray_Return(bondVectors)); PyTuple_SetItem(result, 2, PyArray_Return(bondScalars)); } return result; }
/******************************************************************************* ** Split visible atoms by specie (position and scalar) *******************************************************************************/ static PyObject* splitVisAtomsBySpecie(PyObject *self, PyObject *args) { int NVisible, *visibleAtoms, NSpecies, *specieArray, *specieCount, scalarType, heightAxis, vectorsLen; double *pos, *PE, *KE, *charge, *scalars; PyArrayObject *visibleAtomsIn=NULL; PyArrayObject *specieArrayIn=NULL; PyArrayObject *specieCountIn=NULL; PyArrayObject *posIn=NULL; PyArrayObject *PEIn=NULL; PyArrayObject *KEIn=NULL; PyArrayObject *chargeIn=NULL; PyArrayObject *scalarsIn=NULL; PyArrayObject *vectors=NULL; int i, j, index, specie, count; npy_intp numpyDims[2]; double scalar; PyObject *list=NULL; /* parse and check arguments from Python */ if (!PyArg_ParseTuple(args, "O!iO!O!O!O!O!O!O!iiO!", &PyArray_Type, &visibleAtomsIn, &NSpecies, &PyArray_Type, &specieArrayIn, &PyArray_Type, &specieCountIn, &PyArray_Type, &posIn, &PyArray_Type, &PEIn, &PyArray_Type, &KEIn, &PyArray_Type, &chargeIn, &PyArray_Type, &scalarsIn, &scalarType, &heightAxis, &PyArray_Type, &vectors)) return NULL; if (not_intVector(visibleAtomsIn)) return NULL; visibleAtoms = pyvector_to_Cptr_int(visibleAtomsIn); NVisible = (int) PyArray_DIM(visibleAtomsIn, 0); if (not_intVector(specieArrayIn)) return NULL; specieArray = pyvector_to_Cptr_int(specieArrayIn); if (not_intVector(specieCountIn)) return NULL; specieCount = pyvector_to_Cptr_int(specieCountIn); if (not_doubleVector(posIn)) return NULL; pos = pyvector_to_Cptr_double(posIn); if (not_doubleVector(PEIn)) return NULL; PE = pyvector_to_Cptr_double(PEIn); if (not_doubleVector(KEIn)) return NULL; KE = pyvector_to_Cptr_double(KEIn); if (not_doubleVector(chargeIn)) return NULL; charge = pyvector_to_Cptr_double(chargeIn); if (not_doubleVector(scalarsIn)) return NULL; scalars = pyvector_to_Cptr_double(scalarsIn); if (not_doubleVector(vectors)) return NULL; vectorsLen = (int) PyArray_DIM(vectors, 0); /* first pass to get counters, assume counter zeroed before */ for (i = 0; i < NVisible; i++) { index = visibleAtoms[i]; specie = specieArray[index]; specieCount[specie]++; } /* create list for returning */ list = PyList_New(NSpecies); /* loop over species */ for (i = 0; i < NSpecies; i++) { PyArrayObject *speciePos = NULL; PyArrayObject *specieScalars = NULL; PyArrayObject *specieVectors = NULL; PyObject *tuple = NULL; /* allocate position array */ numpyDims[0] = (npy_intp) specieCount[i]; numpyDims[1] = 3; speciePos = (PyArrayObject *) PyArray_SimpleNew(2, numpyDims, NPY_FLOAT64); /* allocate position array */ numpyDims[0] = (npy_intp) specieCount[i]; specieScalars = (PyArrayObject *) PyArray_SimpleNew(1, numpyDims, NPY_FLOAT64); if (vectorsLen > 0) { /* allocate vectors array */ numpyDims[0] = (npy_intp) specieCount[i]; numpyDims[1] = 3; specieVectors = (PyArrayObject *) PyArray_SimpleNew(2, numpyDims, NPY_FLOAT64); } else { numpyDims[0] = 0; specieVectors = (PyArrayObject *) PyArray_SimpleNew(1, numpyDims, NPY_FLOAT64); } /* loop over atoms */ count = 0; for (j = 0; j < NVisible; j++) { index = visibleAtoms[j]; specie = specieArray[index]; if (specie == i) { /* position */ DIND2(speciePos, count, 0) = pos[3*index+0]; DIND2(speciePos, count, 1) = pos[3*index+1]; DIND2(speciePos, count, 2) = pos[3*index+2]; /* scalar */ if (scalarType == 0) scalar = specie; else if (scalarType == 1) scalar = pos[3*index+heightAxis]; else if (scalarType == 2) scalar = KE[index]; else if (scalarType == 3) scalar = PE[index]; else if (scalarType == 4) scalar = charge[index]; else scalar = scalars[j]; DIND1(specieScalars, count) = scalar; if (vectorsLen > 0) { /* vector */ DIND2(specieVectors, count, 0) = DIND2(vectors, index, 0); DIND2(specieVectors, count, 1) = DIND2(vectors, index, 1); DIND2(specieVectors, count, 2) = DIND2(vectors, index, 2); } count++; } } /* create tuple (setItem steals ownership of array objects!!??) */ tuple = PyTuple_New(3); PyTuple_SetItem(tuple, 0, PyArray_Return(speciePos)); PyTuple_SetItem(tuple, 1, PyArray_Return(specieScalars)); PyTuple_SetItem(tuple, 2, PyArray_Return(specieVectors)); /* store in list (setItem steals ownership of tuple!?) */ PyList_SetItem(list, i, tuple); } return list; }
/******************************************************************************* ** Make arrays for rendering bonds *******************************************************************************/ static PyObject* makeBondsArrays(PyObject *self, PyObject *args) { PyArrayObject *visibleAtoms=NULL; PyArrayObject *scalarsArray=NULL; PyArrayObject *pos=NULL; PyArrayObject *numBondsArray=NULL; PyArrayObject *bondsArray=NULL; PyArrayObject *bondVectorsArray=NULL; PyObject *result=NULL; /* parse arguments from Python */ if (PyArg_ParseTuple(args, "O!O!O!O!O!O!", &PyArray_Type, &visibleAtoms, &PyArray_Type, &scalarsArray, &PyArray_Type, &pos, &PyArray_Type, &numBondsArray, &PyArray_Type, &bondsArray, &PyArray_Type, &bondVectorsArray)) { int i, numVisible, numBonds, count, bondCount; npy_intp numpydims[2]; PyArrayObject *bondCoords = NULL; PyArrayObject *bondScalars = NULL; PyArrayObject *bondVectors = NULL; /* check arguments */ if (not_intVector(visibleAtoms)) return NULL; numVisible = (int) PyArray_DIM(visibleAtoms, 0); if (not_doubleVector(scalarsArray)) return NULL; if (not_doubleVector(pos)) return NULL; if (not_intVector(numBondsArray)) return NULL; if (not_intVector(bondsArray)) return NULL; if (not_doubleVector(bondVectorsArray)) return NULL; /* calculate the number of bonds */ numBonds = 0; for (i = 0; i < numVisible; i++) numBonds += IIND1(numBondsArray, i); /* multiply by two as there are two "bonds" drawn per real bond */ numBonds *= 2; /* create array for bond coordinates */ numpydims[0] = (npy_intp) numBonds; numpydims[1] = 3; bondCoords = (PyArrayObject *) PyArray_SimpleNew(2, numpydims, NPY_FLOAT64); if (bondCoords == NULL) { PyErr_SetString(PyExc_MemoryError, "Could not allocate bondCoords"); return NULL; } /* create array for bond vectors */ numpydims[0] = (npy_intp) numBonds; numpydims[1] = 3; bondVectors = (PyArrayObject *) PyArray_SimpleNew(2, numpydims, NPY_FLOAT64); if (bondVectors == NULL) { PyErr_SetString(PyExc_MemoryError, "Could not allocate bondVectors"); Py_DECREF(bondCoords); return NULL; } /* create array for bond scalars */ numpydims[0] = (npy_intp) numBonds; bondScalars = (PyArrayObject *) PyArray_SimpleNew(1, numpydims, NPY_FLOAT64); if (bondScalars == NULL) { PyErr_SetString(PyExc_MemoryError, "Could not allocate bondScalars"); Py_DECREF(bondCoords); Py_DECREF(bondVectors); return NULL; } /* loop over visible atoms */ count = 0; bondCount = 0; for (i = 0; i < numVisible; i++) { int j; int indexa = IIND1(visibleAtoms, i); int indexa3 = 3 * indexa; int numBondsForAtom = IIND1(numBondsArray, i); double xposa, yposa, zposa, scalara; /* atom position and scalar */ xposa = DIND1(pos, indexa3 ); yposa = DIND1(pos, indexa3 + 1); zposa = DIND1(pos, indexa3 + 2); scalara = DIND1(scalarsArray, i); /* loop over this atoms bonds */ for (j = 0; j < numBondsForAtom; j++) { int cnt3 = count * 3; int visIndex = IIND1(bondsArray, count); int indexb3 = 3 * IIND1(visibleAtoms, visIndex); double xposb = DIND1(pos, indexb3 ); double yposb = DIND1(pos, indexb3 + 1); double zposb = DIND1(pos, indexb3 + 2); double scalarb = DIND1(scalarsArray, visIndex); double bvecx = DIND1(bondVectorsArray, cnt3 ); double bvecy = DIND1(bondVectorsArray, cnt3 + 1); double bvecz = DIND1(bondVectorsArray, cnt3 + 2); /* partial bond from atom a towards b */ DIND2(bondCoords, bondCount, 0) = xposa; DIND2(bondCoords, bondCount, 1) = yposa; DIND2(bondCoords, bondCount, 2) = zposa; DIND2(bondVectors, bondCount, 0) = bvecx; DIND2(bondVectors, bondCount, 1) = bvecy; DIND2(bondVectors, bondCount, 2) = bvecz; DIND1(bondScalars, bondCount) = scalara; bondCount++; /* partial bond from atom b towards a */ DIND2(bondCoords, bondCount, 0) = xposb; DIND2(bondCoords, bondCount, 1) = yposb; DIND2(bondCoords, bondCount, 2) = zposb; DIND2(bondVectors, bondCount, 0) = -1.0 * bvecx; DIND2(bondVectors, bondCount, 1) = -1.0 * bvecy; DIND2(bondVectors, bondCount, 2) = -1.0 * bvecz; DIND1(bondScalars, bondCount) = scalarb; bondCount++; count++; } } /* tuple for result */ result = PyTuple_New(3); PyTuple_SetItem(result, 0, PyArray_Return(bondCoords)); PyTuple_SetItem(result, 1, PyArray_Return(bondVectors)); PyTuple_SetItem(result, 2, PyArray_Return(bondScalars)); } return result; }
/******************************************************************************* ** 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); }
/******************************************************************************* ** Calculate the radial distribution function for the given selections of ** visible atoms. ** ** Inputs are: ** - visibleAtoms: indices of atoms that are to be used for the calculation ** - specie: array containing the species index for each atom ** - pos: array containing the positions of the atoms ** - specieID1: the species of the first selection of atoms ** - specieID2: the species of the second selection of atoms ** - cellDims: the size of the simulation cell ** - pbc: periodic boundary conditions ** - start: minimum separation to use when constructing the histogram ** - finish: maximum separation to use when constructing the histogram ** - interval: the interval between histogram bins ** - numBins: the number of histogram bins ** - rdf: the result is returned in this array *******************************************************************************/ static PyObject* calculateRDF(PyObject *self, PyObject *args) { int numVisible, *visibleAtoms, *specie, specieID1, specieID2, *pbc, numBins; int numAtoms; double *pos, *cellDims, start, finish, *rdf; PyArrayObject *visibleAtomsIn=NULL; PyArrayObject *specieIn=NULL; PyArrayObject *pbcIn=NULL; PyArrayObject *posIn=NULL; PyArrayObject *cellDimsIn=NULL; PyArrayObject *rdfIn=NULL; int i, status, *sel1, *sel2, sel1cnt, sel2cnt, duplicates; double interval; /* parse and check arguments from Python */ if (!PyArg_ParseTuple(args, "O!O!O!iiO!O!dddiO!", &PyArray_Type, &visibleAtomsIn, &PyArray_Type, &specieIn, &PyArray_Type, &posIn, &specieID1, &specieID2, &PyArray_Type, &cellDimsIn, &PyArray_Type, &pbcIn, &start, &finish, &interval, &numBins, &PyArray_Type, &rdfIn)) return NULL; if (not_intVector(visibleAtomsIn)) return NULL; visibleAtoms = pyvector_to_Cptr_int(visibleAtomsIn); numVisible = (int) PyArray_DIM(visibleAtomsIn, 0); if (not_intVector(specieIn)) return NULL; specie = pyvector_to_Cptr_int(specieIn); numAtoms = (int) PyArray_DIM(specieIn, 0); if (not_doubleVector(posIn)) return NULL; pos = pyvector_to_Cptr_double(posIn); if (not_doubleVector(rdfIn)) return NULL; rdf = pyvector_to_Cptr_double(rdfIn); if (not_doubleVector(cellDimsIn)) return NULL; cellDims = pyvector_to_Cptr_double(cellDimsIn); if (not_intVector(pbcIn)) return NULL; pbc = pyvector_to_Cptr_int(pbcIn); /* initialise result array to zero */ for (i = 0; i < numBins; i++) rdf[i] = 0.0; /* create the selections of atoms and check for number of duplicates */ sel1 = malloc(numVisible * sizeof(int)); if (sel1 == NULL) { PyErr_SetString(PyExc_MemoryError, "Could not allocate sel1"); return NULL; } sel2 = malloc(numVisible * sizeof(int)); if (sel2 == NULL) { PyErr_SetString(PyExc_MemoryError, "Could not allocate sel2"); free(sel1); return NULL; } sel1cnt = 0; sel2cnt = 0; duplicates = 0; for (i = 0; i < numVisible; i++) { int index = visibleAtoms[i]; /* check if this atom is in the first selection (negative means all species) */ if (specieID1 < 0 || specie[index] == specieID1) { sel1[i] = 1; sel1cnt++; } else sel1[i] = 0; /* check if this atom is in the second selection (negative means all species) */ if (specieID2 < 0 || specie[index] == specieID2) { sel2[i] = 1; sel2cnt++; } else sel2[i] = 0; /* count the number of atoms that are in both selections */ if (sel1[i] && sel2[i]) duplicates++; } /* compute the histogram for the RDF */ status = computeHistogram(numAtoms, numVisible, visibleAtoms, pos, pbc, cellDims, sel1, sel2, start, finish, interval, rdf); /* free memory used for selections */ free(sel1); free(sel2); /* return if there was an error */ if (status) return NULL; /* normalise the rdf */ normaliseRDF(numBins, sel1cnt, sel2cnt, duplicates, start, interval, cellDims, rdf); /* return None */ Py_INCREF(Py_None); return Py_None; }
/******************************************************************************* ** Calculate the bond order parameters and filter atoms (if required). ** ** Inputs: ** - visibleAtoms: the list of atoms that are currently visible ** - pos: positions of all the atoms ** - maxBondDistance: the maximum bond distance to consider ** - scalarsQ4: array to store the Q4 parameter value ** - scalarsQ6: array to store the Q6 parameter value ** - cellDims: simulation cell dimensions ** - PBC: periodic boundaries conditions ** - NScalars: the number of previously calculated scalar values ** - fullScalars: the full list of previously calculated scalars ** - NVectors: the number of previously calculated vector values ** - fullVectors: the full list of previously calculated vectors ** - filterQ4: filter atoms by the Q4 parameter ** - minQ4: the minimum Q4 for an atom to be visible ** - maxQ4: the maximum Q4 for an atom to be visible ** - filterQ6: filter atoms by the Q6 parameter ** - minQ6: the minimum Q6 for an atom to be visible ** - maxQ6: the maximum Q6 for an atom to be visible *******************************************************************************/ static PyObject* bondOrderFilter(PyObject *self, PyObject *args) { int NVisibleIn, *visibleAtoms, *PBC, NScalars, filterQ4Enabled, filterQ6Enabled; int NVectors; double maxBondDistance, *scalarsQ4, *scalarsQ6, *cellDims; double *pos, *fullScalars, minQ4, maxQ4, minQ6, maxQ6; PyArrayObject *posIn=NULL; PyArrayObject *visibleAtomsIn=NULL; PyArrayObject *PBCIn=NULL; PyArrayObject *scalarsQ4In=NULL; PyArrayObject *scalarsQ6In=NULL; PyArrayObject *cellDimsIn=NULL; PyArrayObject *fullScalarsIn=NULL; PyArrayObject *fullVectors=NULL; int i, NVisible, boxstat; double *visiblePos, maxSep2; struct Boxes *boxes; struct NeighbourList *nebList; struct AtomStructureResults *results; /* parse and check arguments from Python */ if (!PyArg_ParseTuple(args, "O!O!dO!O!O!O!iO!iddiddiO!", &PyArray_Type, &visibleAtomsIn, &PyArray_Type, &posIn, &maxBondDistance, &PyArray_Type, &scalarsQ4In, &PyArray_Type, &scalarsQ6In, &PyArray_Type, &cellDimsIn, &PyArray_Type, &PBCIn, &NScalars, &PyArray_Type, &fullScalarsIn, &filterQ4Enabled, &minQ4, &maxQ4, &filterQ6Enabled, &minQ6, &maxQ6, &NVectors, &PyArray_Type, &fullVectors)) return NULL; if (not_intVector(visibleAtomsIn)) return NULL; visibleAtoms = pyvector_to_Cptr_int(visibleAtomsIn); NVisibleIn = (int) PyArray_DIM(visibleAtomsIn, 0); if (not_doubleVector(posIn)) return NULL; pos = pyvector_to_Cptr_double(posIn); if (not_doubleVector(scalarsQ4In)) return NULL; scalarsQ4 = pyvector_to_Cptr_double(scalarsQ4In); if (not_doubleVector(scalarsQ6In)) return NULL; scalarsQ6 = pyvector_to_Cptr_double(scalarsQ6In); 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_doubleVector(fullScalarsIn)) return NULL; fullScalars = pyvector_to_Cptr_double(fullScalarsIn); if (not_doubleVector(fullVectors)) return NULL; /* construct array of positions of visible atoms */ visiblePos = malloc(3 * NVisibleIn * sizeof(double)); if (visiblePos == NULL) { PyErr_SetString(PyExc_MemoryError, "Could not allocate visiblePos"); return NULL; } for (i = 0; i < NVisibleIn; i++) { int index = visibleAtoms[i]; int ind3 = 3 * index; int i3 = 3 * i; visiblePos[i3 ] = pos[ind3 ]; visiblePos[i3 + 1] = pos[ind3 + 1]; visiblePos[i3 + 2] = pos[ind3 + 2]; } /* box visible atoms */ boxes = setupBoxes(maxBondDistance, PBC, cellDims); if (boxes == NULL) { free(visiblePos); return NULL; } boxstat = putAtomsInBoxes(NVisibleIn, visiblePos, boxes); if (boxstat) { free(visiblePos); return NULL; } /* build neighbour list */ maxSep2 = maxBondDistance * maxBondDistance; nebList = constructNeighbourList(NVisibleIn, visiblePos, boxes, cellDims, PBC, maxSep2); /* only required for building neb list */ free(visiblePos); freeBoxes(boxes); /* return if failed to build the neighbour list */ if (nebList == NULL) return NULL; /* allocate results structure */ results = malloc(NVisibleIn * sizeof(struct AtomStructureResults)); if (results == NULL) { PyErr_SetString(PyExc_MemoryError, "Could not allocate results"); freeNeighbourList(nebList, NVisibleIn); return NULL; } /* first calc q_lm for each atom over all m values */ complex_qlm(NVisibleIn, visibleAtoms, nebList, pos, cellDims, PBC, results); /* free neighbour list */ freeNeighbourList(nebList, NVisibleIn); /* calculate Q4 and Q6 */ calculate_Q(NVisibleIn, results); /* do filtering here, storing results along the way */ NVisible = 0; for (i = 0; i < NVisibleIn; i++) { int j; double q4 = results[i].Q4; double q6 = results[i].Q6; /* skip if not within the valid range */ if (filterQ4Enabled && (q4 < minQ4 || q4 > maxQ4)) continue; if (filterQ6Enabled && (q6 < minQ6 || q6 > maxQ6)) continue; /* store in visible atoms array */ visibleAtoms[NVisible] = visibleAtoms[i]; /* store calculated values */ scalarsQ4[NVisible] = q4; scalarsQ6[NVisible] = q6; /* update full scalars/vectors arrays */ for (j = 0; j < NScalars; j++) { int nj = j * NVisibleIn; fullScalars[nj + NVisible] = fullScalars[nj + i]; } for (j = 0; j < NVectors; j++) { int nj = j * NVisibleIn; DIND2(fullVectors, nj + NVisible, 0) = DIND2(fullVectors, nj + i, 0); DIND2(fullVectors, nj + NVisible, 1) = DIND2(fullVectors, nj + i, 1); DIND2(fullVectors, nj + NVisible, 2) = DIND2(fullVectors, nj + i, 2); } NVisible++; } /* free results memory */ free(results); return Py_BuildValue("i", NVisible); }
/******************************************************************************* * 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); }