NeighborSearch.hpp

Go to the documentation of this file.

#if defined(__unix__) || defined(__linux__) || defined(__APPLE__) || defined(__MACH__)
#define OS_UNIX
#endif

#if defined(__APPLE__) || defined(__MACH__)
#define OS_OSX
#endif

#if defined(_MSC_VER)
#define OS_WINDOWS
#endif

//
// API export macro
// //
// #if defined(OS_OSX)
// #define API __attribute__((visibility("default")))
// #elif defined(OS_WINDOWS)
#define API __declspec(dllexport)
// #else
// #define API
// #endif


int clamp(int x, int minV, int maxV) {
    return max(minV, max(x, minV));
}

float computeMaxDist(float3 minVal, float3 maxVal, float maxAtomRad) {
    return std::max(maxVal.x - minVal.x, std::max(maxVal.y - minVal.y, maxVal.z - minVal.z)) + (2 * maxAtomRad);
}


int3 spaceToGrid(float3 pos3D, float3 originGrid, float dx) {

    // float3 tmp = ((pos3D - originGrid) / dx);

    int3 res;
    res.x = (int)( (pos3D.x - originGrid.x) / dx);
    res.y = (int)( (pos3D.y - originGrid.y) / dx);
    res.z = (int)( (pos3D.z - originGrid.z) / dx);
    return res;

}
float3 gridToSpace(int3 cellPos, float3 originGrid, float dx) {
    float3 res;
    res.x = originGrid.x + cellPos.x * dx;
    res.y = originGrid.y + cellPos.y * dx;
    res.z = originGrid.z + cellPos.z * dx;
    return res;
    // return (originGrid + (make_float3(cellPos.x, cellPos.y, cellPos.z) * dx) );
}

int flatten3DTo1D(int3 id3d, int3 gridDim) {
    return (gridDim.y * gridDim.z * id3d.x) + (gridDim.z * id3d.y) + id3d.z;
}


int3 unflatten1DTo3D(int index, int3 gridDim) {
    int3 res;
    res.x = index / (gridDim.y * gridDim.z); //Note the integer division . This is x
    res.y = (index - res.x * gridDim.y * gridDim.z) / gridDim.z; //This is y
    res.z = index - res.x * gridDim.y * gridDim.z - res.y * gridDim.z; //This is z
    return res;
}

float sqr_distance(float3 p1, float3 p2) {
    float x = (p1.x - p2.x) * (p1.x - p2.x);
    float y = (p1.y - p2.y) * (p1.y - p2.y);
    float z = (p1.z - p2.z) * (p1.z - p2.z);

    return x + y + z;
}

struct compare_int2 {
    bool operator()(int2 a, int2 b) {return a.x < b.x;}
};




void getMinMax(float3 *pos, float *radii, unsigned int N, float3 *minVal, float3 *maxVal, float *maxAtom) {

    *maxAtom = 0.0f;
    float3 vmin, vmax, coords;

    vmin.x = vmin.y = vmin.z = 100000.0f;
    vmax.x = vmax.y = vmax.z = -100000.0f;

    for (int a = 0; a < N; a++) {
        coords = pos[a];
        vmin.x = std::min(vmin.x, coords.x);
        vmin.y = std::min(vmin.y, coords.y);
        vmin.z = std::min(vmin.z, coords.z);

        vmax.x = std::max(vmax.x, coords.x);
        vmax.y = std::max(vmax.y, coords.y);
        vmax.z = std::max(vmax.z, coords.z);

        float atomRad = radii[a];

        *maxAtom = std::max(*maxAtom, atomRad);

    }
    *minVal = vmin;
    *maxVal = vmax;
}

extern "C"{
    API void initGridNeighbor(float3 *atomPos, float *radii, int N);
    API int findClosestAtom(float3 p);
    API int *findAtomsInRadius(float3 p, float rad, int *resSize);
    API void freeMem();
}