Line data    Source code

       1             : /*----------------------------------------------------------------------------*/
       2             : /*  CP2K: A general program to perform molecular dynamics simulations         */
       3             : /*  Copyright 2000-2024 CP2K developers group <https://cp2k.org>              */
       4             : /*                                                                            */
       5             : /*  SPDX-License-Identifier: BSD-3-Clause                                     */
       6             : /*----------------------------------------------------------------------------*/
       7             : 
       8             : #include "grid_sphere_cache.h"
       9             : #include "grid_common.h"
      10             : #include "grid_library.h"
      11             : #include <assert.h>
      12             : #include <math.h>
      13             : #include <stdio.h>
      14             : #include <stdlib.h>
      15             : #include <string.h>
      16             : 
      17             : /*******************************************************************************
      18             :  * \brief Compute the sphere bounds for a given single radius.
      19             :  * \author Ole Schuett
      20             :  ******************************************************************************/
      21     1613240 : static int single_sphere_bounds(const double disr_radius, const double dh[3][3],
      22             :                                 const double dh_inv[3][3], int *bounds) {
      23             : 
      24     1613240 :   int ibound = 0;
      25             : 
      26             :   // The cube contains an even number of grid points in each direction and
      27             :   // collocation is always performed on a pair of two opposing grid points.
      28             :   // Hence, the points with index 0 and 1 are both assigned distance zero via
      29             :   // the formular distance=(2*index-1)/2.
      30     1613240 :   const int kgmin = ceil(-1e-8 - disr_radius * dh_inv[2][2]);
      31     1613240 :   if (bounds != NULL) {
      32      806620 :     bounds[ibound] = kgmin;
      33             :   }
      34             :   ibound++;
      35    15896068 :   for (int kg = kgmin; kg <= 0; kg++) {
      36    14282828 :     const int kd = (2 * kg - 1) / 2; // distance from center in grid points
      37    14282828 :     const double kr = kd * dh[2][2]; // distance from center in a.u.
      38    14282828 :     const double kremain = disr_radius * disr_radius - kr * kr;
      39    14282828 :     const int jgmin = ceil(-1e-8 - sqrt(fmax(0.0, kremain)) * dh_inv[1][1]);
      40    14282828 :     if (bounds != NULL) {
      41     7141414 :       bounds[ibound] = jgmin;
      42             :     }
      43    14282828 :     ibound++;
      44   149443282 :     for (int jg = jgmin; jg <= 0; jg++) {
      45   135160454 :       const int jd = (2 * jg - 1) / 2; // distance from center in grid points
      46   135160454 :       const double jr = jd * dh[1][1]; // distance from center in a.u.
      47   135160454 :       const double jremain = kremain - jr * jr;
      48   135160454 :       const int igmin = ceil(-1e-8 - sqrt(fmax(0.0, jremain)) * dh_inv[0][0]);
      49   135160454 :       if (bounds != NULL) {
      50    67580227 :         bounds[ibound] = igmin;
      51             :       }
      52   135160454 :       ibound++;
      53             :     }
      54             :   }
      55     1613240 :   return ibound; // Number of bounds - needed to allocate array.
      56             : }
      57             : 
      58             : /*******************************************************************************
      59             :  * \brief Rebuild a cache entry for a given cell and max radius.
      60             :  * \author Ole Schuett
      61             :  ******************************************************************************/
      62       64270 : static void rebuild_cache_entry(const int max_imr, const double drmin,
      63             :                                 const double dh[3][3],
      64             :                                 const double dh_inv[3][3],
      65             :                                 grid_sphere_cache_entry *entry) {
      66       64270 :   if (entry->max_imr > 0) {
      67       50403 :     free(entry->offsets);
      68       50403 :     free(entry->storage);
      69             :   }
      70       64270 :   entry->max_imr = max_imr;
      71             : 
      72             :   // Compute required storage size.
      73       64270 :   entry->offsets = malloc(max_imr * sizeof(int));
      74       64270 :   assert(entry->offsets != NULL);
      75             :   int nbounds_total = 0;
      76      870890 :   for (int imr = 1; imr <= max_imr; imr++) {
      77      806620 :     const double radius = imr * drmin;
      78      806620 :     const int nbounds = single_sphere_bounds(radius, dh, dh_inv, NULL);
      79      806620 :     entry->offsets[imr - 1] = nbounds_total;
      80      806620 :     nbounds_total += nbounds;
      81             :   }
      82             : 
      83             :   // Allocate and fill storage.
      84       64270 :   entry->storage = malloc(nbounds_total * sizeof(int));
      85       64270 :   assert(entry->storage != NULL);
      86      870890 :   for (int imr = 1; imr <= max_imr; imr++) {
      87      806620 :     const double radius = imr * drmin;
      88      806620 :     const int offset = entry->offsets[imr - 1];
      89      806620 :     single_sphere_bounds(radius, dh, dh_inv, &entry->storage[offset]);
      90             :   }
      91       64270 : }
      92             : 
      93             : /*******************************************************************************
      94             :  * \brief Lookup the sphere bound from cache and compute them as needed.
      95             :  *        See grid_sphere_cache.h for details.
      96             :  * \author Ole Schuett
      97             :  ******************************************************************************/
      98   122068868 : void grid_sphere_cache_lookup(const double radius, const double dh[3][3],
      99             :                               const double dh_inv[3][3], int **sphere_bounds,
     100             :                               double *discr_radius) {
     101             : 
     102             :   // Prepare the cache.
     103   122068868 :   grid_sphere_cache *cache = grid_library_get_sphere_cache();
     104             : 
     105             :   // Find or create cache entry for given grid.
     106   122068868 :   const double dr0 = dh[0][0], dr1 = dh[1][1], dr2 = dh[2][2];
     107   122068868 :   grid_sphere_cache_entry *entry = NULL;
     108   122068868 :   bool found = false;
     109             : 
     110             :   // Fast path: check prev match.
     111   122068868 :   if (cache->prev_match < cache->size) {
     112   122064299 :     entry = &cache->entries[cache->prev_match];
     113   122064299 :     if (entry->dr[0] == dr0 && entry->dr[1] == dr1 && entry->dr[2] == dr2) {
     114   120487236 :       found = true;
     115             :     }
     116             :   }
     117             : 
     118             :   // Full search.
     119   122068868 :   if (!found) {
     120     4142778 :     for (int i = 0; i < cache->size; i++) {
     121     4128911 :       entry = &cache->entries[i];
     122     4128911 :       if (entry->dr[0] == dr0 && entry->dr[1] == dr1 && entry->dr[2] == dr2) {
     123     1567765 :         cache->prev_match = i;
     124     1567765 :         found = true;
     125     1567765 :         break;
     126             :       }
     127             :     }
     128             :   }
     129             : 
     130             :   // If no existing cache entry was found then create a new one.
     131   122068868 :   if (!found) {
     132       13867 :     cache->size++;
     133       13867 :     grid_sphere_cache_entry *old_entries = cache->entries;
     134       13867 :     const size_t entry_size = sizeof(grid_sphere_cache_entry);
     135       13867 :     cache->entries = malloc(cache->size * entry_size);
     136       13867 :     assert(cache->entries != NULL);
     137       13867 :     memcpy(cache->entries, old_entries, (cache->size - 1) * entry_size);
     138       13867 :     free(old_entries);
     139       13867 :     cache->prev_match = cache->size - 1;
     140       13867 :     entry = &cache->entries[cache->size - 1];
     141             :     // Initialize new cache entry
     142       13867 :     entry->max_imr = 0;
     143       13867 :     entry->dr[0] = dr0;
     144       13867 :     entry->dr[1] = dr1;
     145       13867 :     entry->dr[2] = dr2;
     146       13867 :     entry->drmin = fmin(dr0, fmin(dr1, dr2));
     147       13867 :     entry->drmin_inv = 1.0 / entry->drmin;
     148             :   }
     149             : 
     150             :   // Discretize the radius.
     151   122068868 :   const int imr = imax(1, (int)ceil(radius * entry->drmin_inv));
     152   122068868 :   *discr_radius = entry->drmin * imr;
     153             : 
     154             :   // Rebuild cache entry if requested radius is too large.
     155   122068868 :   if (entry->max_imr < imr) {
     156       64270 :     rebuild_cache_entry(imr, entry->drmin, dh, dh_inv, entry);
     157             :   }
     158   122068868 :   const int offset = entry->offsets[imr - 1];
     159   122068868 :   *sphere_bounds = &entry->storage[offset];
     160   122068868 : }
     161             : 
     162             : /*******************************************************************************
     163             :  * \brief Free the memory of the sphere cache.
     164             :  * \author Ole Schuett
     165             :  ******************************************************************************/
     166        9176 : void grid_sphere_cache_free(grid_sphere_cache *cache) {
     167       23043 :   for (int i = 0; i < cache->size; i++) {
     168       13867 :     if (cache->entries[i].max_imr > 0) {
     169       13867 :       free(cache->entries[i].offsets);
     170       13867 :       free(cache->entries[i].storage);
     171             :     }
     172             :   }
     173        9176 :   free(cache->entries);
     174        9176 :   cache->size = 0;
     175        9176 : }
     176             : 
     177             : // EOF