src/gromacs/mdlib/nbnxn_kernels/nbnxn_kernel_ref.c

   1 /*
   2  * This file is part of the GROMACS molecular simulation package.
   3  *
   4  * Copyright (c) 2012,2013, by the GROMACS development team, led by
   5  * Mark Abraham, David van der Spoel, Berk Hess, and Erik Lindahl,
   6  * and including many others, as listed in the AUTHORS file in the
   7  * top-level source directory and at http://www.gromacs.org.
   8  *
   9  * GROMACS is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU Lesser General Public License
  11  * as published by the Free Software Foundation; either version 2.1
  12  * of the License, or (at your option) any later version.
  13  *
  14  * GROMACS is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17  * Lesser General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU Lesser General Public
  20  * License along with GROMACS; if not, see
  21  * http://www.gnu.org/licenses, or write to the Free Software Foundation,
  22  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA.
  23  *
  24  * If you want to redistribute modifications to GROMACS, please
  25  * consider that scientific software is very special. Version
  26  * control is crucial - bugs must be traceable. We will be happy to
  27  * consider code for inclusion in the official distribution, but
  28  * derived work must not be called official GROMACS. Details are found
  29  * in the README & COPYING files - if they are missing, get the
  30  * official version at http://www.gromacs.org.
  31  *
  32  * To help us fund GROMACS development, we humbly ask that you cite
  33  * the research papers on the package. Check out http://www.gromacs.org.
  34  */
  35 #ifdef HAVE_CONFIG_H
  36 #include <config.h>
  37 #endif
  38
  39 #include <math.h>
  40
  41 #include "typedefs.h"
  42 #include "vec.h"
  43 #include "smalloc.h"
  44 #include "force.h"
  45 #include "gmx_omp_nthreads.h"
  46 #include "nbnxn_kernel_ref.h"
  47 #include "../nbnxn_consts.h"
  48 #include "nbnxn_kernel_common.h"
  49
  50 /*! \brief Typedefs for declaring lookup tables of kernel functions.
  51  */
  52 typedef void (*p_nbk_func_ener)(const nbnxn_pairlist_t     *nbl,
  53                                 const nbnxn_atomdata_t     *nbat,
  54                                 const interaction_const_t  *ic,
  55                                 rvec                       *shift_vec,
  56                                 real                       *f,
  57                                 real                       *fshift,
  58                                 real                       *Vvdw,
  59                                 real                       *Vc);
  60
  61 typedef void (*p_nbk_func_noener)(const nbnxn_pairlist_t     *nbl,
  62                                   const nbnxn_atomdata_t     *nbat,
  63                                   const interaction_const_t  *ic,
  64                                   rvec                       *shift_vec,
  65                                   real                       *f,
  66                                   real                       *fshift);
  67
  68 /* Analytical reaction-field kernels */
  69 #define CALC_COUL_RF
  70
  71 /* Include the force+energy kernels */
  72 #define CALC_ENERGIES
  73 #include "nbnxn_kernel_ref_outer.h"
  74 #undef CALC_ENERGIES
  75
  76 /* Include the force+energygroups kernels */
  77 #define CALC_ENERGIES
  78 #define ENERGY_GROUPS
  79 #include "nbnxn_kernel_ref_outer.h"
  80 #undef ENERGY_GROUPS
  81 #undef CALC_ENERGIES
  82
  83 /* Include the force only kernels */
  84 #include "nbnxn_kernel_ref_outer.h"
  85
  86 #undef CALC_COUL_RF
  87
  88
  89 /* Tabulated exclusion interaction electrostatics kernels */
  90 #define CALC_COUL_TAB
  91
  92 /* Include the force+energy kernels */
  93 #define CALC_ENERGIES
  94 #include "nbnxn_kernel_ref_outer.h"
  95 #undef CALC_ENERGIES
  96
  97 /* Include the force+energygroups kernels */
  98 #define CALC_ENERGIES
  99 #define ENERGY_GROUPS
 100 #include "nbnxn_kernel_ref_outer.h"
 101 #undef ENERGY_GROUPS
 102 #undef CALC_ENERGIES
 103
 104 /* Include the force only kernels */
 105 #include "nbnxn_kernel_ref_outer.h"
 106
 107 /* Twin-range cut-off kernels */
 108 #define VDW_CUTOFF_CHECK
 109
 110 /* Include the force+energy kernels */
 111 #define CALC_ENERGIES
 112 #include "nbnxn_kernel_ref_outer.h"
 113 #undef CALC_ENERGIES
 114
 115 /* Include the force+energygroups kernels */
 116 #define CALC_ENERGIES
 117 #define ENERGY_GROUPS
 118 #include "nbnxn_kernel_ref_outer.h"
 119 #undef ENERGY_GROUPS
 120 #undef CALC_ENERGIES
 121
 122 /* Include the force only kernels */
 123 #include "nbnxn_kernel_ref_outer.h"
 124
 125 #undef VDW_CUTOFF_CHECK
 126
 127 #undef CALC_COUL_TAB
 128
 129
 130 enum {
 131     coultRF, coultTAB, coultTAB_TWIN, coultNR
 132 };
 133
 134 p_nbk_func_ener p_nbk_c_ener[coultNR] =
 135 {
 136     nbnxn_kernel_ref_rf_ener,
 137     nbnxn_kernel_ref_tab_ener,
 138     nbnxn_kernel_ref_tab_twin_ener
 139 };
 140
 141 p_nbk_func_ener p_nbk_c_energrp[coultNR] =
 142 {
 143     nbnxn_kernel_ref_rf_energrp,
 144     nbnxn_kernel_ref_tab_energrp,
 145     nbnxn_kernel_ref_tab_twin_energrp
 146 };
 147
 148 p_nbk_func_noener p_nbk_c_noener[coultNR] =
 149 {
 150     nbnxn_kernel_ref_rf_noener,
 151     nbnxn_kernel_ref_tab_noener,
 152     nbnxn_kernel_ref_tab_twin_noener
 153 };
 154
 155 void
 156 nbnxn_kernel_ref(const nbnxn_pairlist_set_t *nbl_list,
 157                  const nbnxn_atomdata_t     *nbat,
 158                  const interaction_const_t  *ic,
 159                  rvec                       *shift_vec,
 160                  int                         force_flags,
 161                  int                         clearF,
 162                  real                       *fshift,
 163                  real                       *Vc,
 164                  real                       *Vvdw)
 165 {
 166     int                nnbl;
 167     nbnxn_pairlist_t **nbl;
 168     int                coult;
 169     int                nb;
 170
 171     nnbl = nbl_list->nnbl;
 172     nbl  = nbl_list->nbl;
 173
 174     if (EEL_RF(ic->eeltype) || ic->eeltype == eelCUT)
 175     {
 176         coult = coultRF;
 177     }
 178     else
 179     {
 180         if (ic->rcoulomb == ic->rvdw)
 181         {
 182             coult = coultTAB;
 183         }
 184         else
 185         {
 186             coult = coultTAB_TWIN;
 187         }
 188     }
 189
 190 #pragma omp parallel for schedule(static) num_threads(gmx_omp_nthreads_get(emntNonbonded))
 191     for (nb = 0; nb < nnbl; nb++)
 192     {
 193         nbnxn_atomdata_output_t *out;
 194         real                    *fshift_p;
 195
 196         out = &nbat->out[nb];
 197
 198         if (clearF == enbvClearFYes)
 199         {
 200             clear_f(nbat, nb, out->f);
 201         }
 202
 203         if ((force_flags & GMX_FORCE_VIRIAL) && nnbl == 1)
 204         {
 205             fshift_p = fshift;
 206         }
 207         else
 208         {
 209             fshift_p = out->fshift;
 210
 211             if (clearF == enbvClearFYes)
 212             {
 213                 clear_fshift(fshift_p);
 214             }
 215         }
 216
 217         if (!(force_flags & GMX_FORCE_ENERGY))
 218         {
 219             /* Don't calculate energies */
 220             p_nbk_c_noener[coult](nbl[nb], nbat,
 221                                   ic,
 222                                   shift_vec,
 223                                   out->f,
 224                                   fshift_p);
 225         }
 226         else if (out->nV == 1)
 227         {
 228             /* No energy groups */
 229             out->Vvdw[0] = 0;
 230             out->Vc[0]   = 0;
 231
 232             p_nbk_c_ener[coult](nbl[nb], nbat,
 233                                 ic,
 234                                 shift_vec,
 235                                 out->f,
 236                                 fshift_p,
 237                                 out->Vvdw,
 238                                 out->Vc);
 239         }
 240         else
 241         {
 242             /* Calculate energy group contributions */
 243             int i;
 244
 245             for (i = 0; i < out->nV; i++)
 246             {
 247                 out->Vvdw[i] = 0;
 248             }
 249             for (i = 0; i < out->nV; i++)
 250             {
 251                 out->Vc[i] = 0;
 252             }
 253
 254             p_nbk_c_energrp[coult](nbl[nb], nbat,
 255                                    ic,
 256                                    shift_vec,
 257                                    out->f,
 258                                    fshift_p,
 259                                    out->Vvdw,
 260                                    out->Vc);
 261         }
 262     }
 263
 264     if (force_flags & GMX_FORCE_ENERGY)
 265     {
 266         reduce_energies_over_lists(nbat, nnbl, Vvdw, Vc);
 267     }
 268 }