src/gromacs/gmxlib/nonbonded/nb_kernel_avx_256_double/nb_kernel_ElecCSTab_VdwLJ_GeomW4W4_avx_256_double.c

   1 /*
   2  * This file is part of the GROMACS molecular simulation package.
   3  *
   4  * Copyright (c) 2012,2013,2014, 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 /*
  36  * Note: this file was generated by the GROMACS avx_256_double kernel generator.
  37  */
  38 #include "gmxpre.h"
  39
  40 #include "config.h"
  41
  42 #include <math.h>
  43
  44 #include "../nb_kernel.h"
  45 #include "gromacs/legacyheaders/types/simple.h"
  46 #include "gromacs/math/vec.h"
  47 #include "gromacs/legacyheaders/nrnb.h"
  48
  49 #include "gromacs/simd/math_x86_avx_256_double.h"
  50 #include "kernelutil_x86_avx_256_double.h"
  51
  52 /*
  53  * Gromacs nonbonded kernel:   nb_kernel_ElecCSTab_VdwLJ_GeomW4W4_VF_avx_256_double
  54  * Electrostatics interaction: CubicSplineTable
  55  * VdW interaction:            LennardJones
  56  * Geometry:                   Water4-Water4
  57  * Calculate force/pot:        PotentialAndForce
  58  */
  59 void
  60 nb_kernel_ElecCSTab_VdwLJ_GeomW4W4_VF_avx_256_double
  61                     (t_nblist                    * gmx_restrict       nlist,
  62                      rvec                        * gmx_restrict          xx,
  63                      rvec                        * gmx_restrict          ff,
  64                      t_forcerec                  * gmx_restrict          fr,
  65                      t_mdatoms                   * gmx_restrict     mdatoms,
  66                      nb_kernel_data_t gmx_unused * gmx_restrict kernel_data,
  67                      t_nrnb                      * gmx_restrict        nrnb)
  68 {
  69     /* Suffixes 0,1,2,3 refer to particle indices for waters in the inner or outer loop, or
  70      * just 0 for non-waters.
  71      * Suffixes A,B,C,D refer to j loop unrolling done with AVX, e.g. for the four different
  72      * jnr indices corresponding to data put in the four positions in the SIMD register.
  73      */
  74     int              i_shift_offset,i_coord_offset,outeriter,inneriter;
  75     int              j_index_start,j_index_end,jidx,nri,inr,ggid,iidx;
  76     int              jnrA,jnrB,jnrC,jnrD;
  77     int              jnrlistA,jnrlistB,jnrlistC,jnrlistD;
  78     int              jnrlistE,jnrlistF,jnrlistG,jnrlistH;
  79     int              j_coord_offsetA,j_coord_offsetB,j_coord_offsetC,j_coord_offsetD;
  80     int              *iinr,*jindex,*jjnr,*shiftidx,*gid;
  81     real             rcutoff_scalar;
  82     real             *shiftvec,*fshift,*x,*f;
  83     real             *fjptrA,*fjptrB,*fjptrC,*fjptrD;
  84     real             scratch[4*DIM];
  85     __m256d          tx,ty,tz,fscal,rcutoff,rcutoff2,jidxall;
  86     real *           vdwioffsetptr0;
  87     __m256d          ix0,iy0,iz0,fix0,fiy0,fiz0,iq0,isai0;
  88     real *           vdwioffsetptr1;
  89     __m256d          ix1,iy1,iz1,fix1,fiy1,fiz1,iq1,isai1;
  90     real *           vdwioffsetptr2;
  91     __m256d          ix2,iy2,iz2,fix2,fiy2,fiz2,iq2,isai2;
  92     real *           vdwioffsetptr3;
  93     __m256d          ix3,iy3,iz3,fix3,fiy3,fiz3,iq3,isai3;
  94     int              vdwjidx0A,vdwjidx0B,vdwjidx0C,vdwjidx0D;
  95     __m256d          jx0,jy0,jz0,fjx0,fjy0,fjz0,jq0,isaj0;
  96     int              vdwjidx1A,vdwjidx1B,vdwjidx1C,vdwjidx1D;
  97     __m256d          jx1,jy1,jz1,fjx1,fjy1,fjz1,jq1,isaj1;
  98     int              vdwjidx2A,vdwjidx2B,vdwjidx2C,vdwjidx2D;
  99     __m256d          jx2,jy2,jz2,fjx2,fjy2,fjz2,jq2,isaj2;
 100     int              vdwjidx3A,vdwjidx3B,vdwjidx3C,vdwjidx3D;
 101     __m256d          jx3,jy3,jz3,fjx3,fjy3,fjz3,jq3,isaj3;
 102     __m256d          dx00,dy00,dz00,rsq00,rinv00,rinvsq00,r00,qq00,c6_00,c12_00;
 103     __m256d          dx11,dy11,dz11,rsq11,rinv11,rinvsq11,r11,qq11,c6_11,c12_11;
 104     __m256d          dx12,dy12,dz12,rsq12,rinv12,rinvsq12,r12,qq12,c6_12,c12_12;
 105     __m256d          dx13,dy13,dz13,rsq13,rinv13,rinvsq13,r13,qq13,c6_13,c12_13;
 106     __m256d          dx21,dy21,dz21,rsq21,rinv21,rinvsq21,r21,qq21,c6_21,c12_21;
 107     __m256d          dx22,dy22,dz22,rsq22,rinv22,rinvsq22,r22,qq22,c6_22,c12_22;
 108     __m256d          dx23,dy23,dz23,rsq23,rinv23,rinvsq23,r23,qq23,c6_23,c12_23;
 109     __m256d          dx31,dy31,dz31,rsq31,rinv31,rinvsq31,r31,qq31,c6_31,c12_31;
 110     __m256d          dx32,dy32,dz32,rsq32,rinv32,rinvsq32,r32,qq32,c6_32,c12_32;
 111     __m256d          dx33,dy33,dz33,rsq33,rinv33,rinvsq33,r33,qq33,c6_33,c12_33;
 112     __m256d          velec,felec,velecsum,facel,crf,krf,krf2;
 113     real             *charge;
 114     int              nvdwtype;
 115     __m256d          rinvsix,rvdw,vvdw,vvdw6,vvdw12,fvdw,fvdw6,fvdw12,vvdwsum,sh_vdw_invrcut6;
 116     int              *vdwtype;
 117     real             *vdwparam;
 118     __m256d          one_sixth   = _mm256_set1_pd(1.0/6.0);
 119     __m256d          one_twelfth = _mm256_set1_pd(1.0/12.0);
 120     __m128i          vfitab;
 121     __m128i          ifour       = _mm_set1_epi32(4);
 122     __m256d          rt,vfeps,vftabscale,Y,F,G,H,Heps,Fp,VV,FF;
 123     real             *vftab;
 124     __m256d          dummy_mask,cutoff_mask;
 125     __m128           tmpmask0,tmpmask1;
 126     __m256d          signbit = _mm256_castsi256_pd( _mm256_set1_epi32(0x80000000) );
 127     __m256d          one     = _mm256_set1_pd(1.0);
 128     __m256d          two     = _mm256_set1_pd(2.0);
 129     x                = xx[0];
 130     f                = ff[0];
 131
 132     nri              = nlist->nri;
 133     iinr             = nlist->iinr;
 134     jindex           = nlist->jindex;
 135     jjnr             = nlist->jjnr;
 136     shiftidx         = nlist->shift;
 137     gid              = nlist->gid;
 138     shiftvec         = fr->shift_vec[0];
 139     fshift           = fr->fshift[0];
 140     facel            = _mm256_set1_pd(fr->epsfac);
 141     charge           = mdatoms->chargeA;
 142     nvdwtype         = fr->ntype;
 143     vdwparam         = fr->nbfp;
 144     vdwtype          = mdatoms->typeA;
 145
 146     vftab            = kernel_data->table_elec->data;
 147     vftabscale       = _mm256_set1_pd(kernel_data->table_elec->scale);
 148
 149     /* Setup water-specific parameters */
 150     inr              = nlist->iinr[0];
 151     iq1              = _mm256_mul_pd(facel,_mm256_set1_pd(charge[inr+1]));
 152     iq2              = _mm256_mul_pd(facel,_mm256_set1_pd(charge[inr+2]));
 153     iq3              = _mm256_mul_pd(facel,_mm256_set1_pd(charge[inr+3]));
 154     vdwioffsetptr0   = vdwparam+2*nvdwtype*vdwtype[inr+0];
 155
 156     jq1              = _mm256_set1_pd(charge[inr+1]);
 157     jq2              = _mm256_set1_pd(charge[inr+2]);
 158     jq3              = _mm256_set1_pd(charge[inr+3]);
 159     vdwjidx0A        = 2*vdwtype[inr+0];
 160     c6_00            = _mm256_set1_pd(vdwioffsetptr0[vdwjidx0A]);
 161     c12_00           = _mm256_set1_pd(vdwioffsetptr0[vdwjidx0A+1]);
 162     qq11             = _mm256_mul_pd(iq1,jq1);
 163     qq12             = _mm256_mul_pd(iq1,jq2);
 164     qq13             = _mm256_mul_pd(iq1,jq3);
 165     qq21             = _mm256_mul_pd(iq2,jq1);
 166     qq22             = _mm256_mul_pd(iq2,jq2);
 167     qq23             = _mm256_mul_pd(iq2,jq3);
 168     qq31             = _mm256_mul_pd(iq3,jq1);
 169     qq32             = _mm256_mul_pd(iq3,jq2);
 170     qq33             = _mm256_mul_pd(iq3,jq3);
 171
 172     /* Avoid stupid compiler warnings */
 173     jnrA = jnrB = jnrC = jnrD = 0;
 174     j_coord_offsetA = 0;
 175     j_coord_offsetB = 0;
 176     j_coord_offsetC = 0;
 177     j_coord_offsetD = 0;
 178
 179     outeriter        = 0;
 180     inneriter        = 0;
 181
 182     for(iidx=0;iidx<4*DIM;iidx++)
 183     {
 184         scratch[iidx] = 0.0;
 185     }
 186
 187     /* Start outer loop over neighborlists */
 188     for(iidx=0; iidx<nri; iidx++)
 189     {
 190         /* Load shift vector for this list */
 191         i_shift_offset   = DIM*shiftidx[iidx];
 192
 193         /* Load limits for loop over neighbors */
 194         j_index_start    = jindex[iidx];
 195         j_index_end      = jindex[iidx+1];
 196
 197         /* Get outer coordinate index */
 198         inr              = iinr[iidx];
 199         i_coord_offset   = DIM*inr;
 200
 201         /* Load i particle coords and add shift vector */
 202         gmx_mm256_load_shift_and_4rvec_broadcast_pd(shiftvec+i_shift_offset,x+i_coord_offset,
 203                                                     &ix0,&iy0,&iz0,&ix1,&iy1,&iz1,&ix2,&iy2,&iz2,&ix3,&iy3,&iz3);
 204
 205         fix0             = _mm256_setzero_pd();
 206         fiy0             = _mm256_setzero_pd();
 207         fiz0             = _mm256_setzero_pd();
 208         fix1             = _mm256_setzero_pd();
 209         fiy1             = _mm256_setzero_pd();
 210         fiz1             = _mm256_setzero_pd();
 211         fix2             = _mm256_setzero_pd();
 212         fiy2             = _mm256_setzero_pd();
 213         fiz2             = _mm256_setzero_pd();
 214         fix3             = _mm256_setzero_pd();
 215         fiy3             = _mm256_setzero_pd();
 216         fiz3             = _mm256_setzero_pd();
 217
 218         /* Reset potential sums */
 219         velecsum         = _mm256_setzero_pd();
 220         vvdwsum          = _mm256_setzero_pd();
 221
 222         /* Start inner kernel loop */
 223         for(jidx=j_index_start; jidx<j_index_end && jjnr[jidx+3]>=0; jidx+=4)
 224         {
 225
 226             /* Get j neighbor index, and coordinate index */
 227             jnrA             = jjnr[jidx];
 228             jnrB             = jjnr[jidx+1];
 229             jnrC             = jjnr[jidx+2];
 230             jnrD             = jjnr[jidx+3];
 231             j_coord_offsetA  = DIM*jnrA;
 232             j_coord_offsetB  = DIM*jnrB;
 233             j_coord_offsetC  = DIM*jnrC;
 234             j_coord_offsetD  = DIM*jnrD;
 235
 236             /* load j atom coordinates */
 237             gmx_mm256_load_4rvec_4ptr_swizzle_pd(x+j_coord_offsetA,x+j_coord_offsetB,
 238                                                  x+j_coord_offsetC,x+j_coord_offsetD,
 239                                                  &jx0,&jy0,&jz0,&jx1,&jy1,&jz1,&jx2,
 240                                                  &jy2,&jz2,&jx3,&jy3,&jz3);
 241
 242             /* Calculate displacement vector */
 243             dx00             = _mm256_sub_pd(ix0,jx0);
 244             dy00             = _mm256_sub_pd(iy0,jy0);
 245             dz00             = _mm256_sub_pd(iz0,jz0);
 246             dx11             = _mm256_sub_pd(ix1,jx1);
 247             dy11             = _mm256_sub_pd(iy1,jy1);
 248             dz11             = _mm256_sub_pd(iz1,jz1);
 249             dx12             = _mm256_sub_pd(ix1,jx2);
 250             dy12             = _mm256_sub_pd(iy1,jy2);
 251             dz12             = _mm256_sub_pd(iz1,jz2);
 252             dx13             = _mm256_sub_pd(ix1,jx3);
 253             dy13             = _mm256_sub_pd(iy1,jy3);
 254             dz13             = _mm256_sub_pd(iz1,jz3);
 255             dx21             = _mm256_sub_pd(ix2,jx1);
 256             dy21             = _mm256_sub_pd(iy2,jy1);
 257             dz21             = _mm256_sub_pd(iz2,jz1);
 258             dx22             = _mm256_sub_pd(ix2,jx2);
 259             dy22             = _mm256_sub_pd(iy2,jy2);
 260             dz22             = _mm256_sub_pd(iz2,jz2);
 261             dx23             = _mm256_sub_pd(ix2,jx3);
 262             dy23             = _mm256_sub_pd(iy2,jy3);
 263             dz23             = _mm256_sub_pd(iz2,jz3);
 264             dx31             = _mm256_sub_pd(ix3,jx1);
 265             dy31             = _mm256_sub_pd(iy3,jy1);
 266             dz31             = _mm256_sub_pd(iz3,jz1);
 267             dx32             = _mm256_sub_pd(ix3,jx2);
 268             dy32             = _mm256_sub_pd(iy3,jy2);
 269             dz32             = _mm256_sub_pd(iz3,jz2);
 270             dx33             = _mm256_sub_pd(ix3,jx3);
 271             dy33             = _mm256_sub_pd(iy3,jy3);
 272             dz33             = _mm256_sub_pd(iz3,jz3);
 273
 274             /* Calculate squared distance and things based on it */
 275             rsq00            = gmx_mm256_calc_rsq_pd(dx00,dy00,dz00);
 276             rsq11            = gmx_mm256_calc_rsq_pd(dx11,dy11,dz11);
 277             rsq12            = gmx_mm256_calc_rsq_pd(dx12,dy12,dz12);
 278             rsq13            = gmx_mm256_calc_rsq_pd(dx13,dy13,dz13);
 279             rsq21            = gmx_mm256_calc_rsq_pd(dx21,dy21,dz21);
 280             rsq22            = gmx_mm256_calc_rsq_pd(dx22,dy22,dz22);
 281             rsq23            = gmx_mm256_calc_rsq_pd(dx23,dy23,dz23);
 282             rsq31            = gmx_mm256_calc_rsq_pd(dx31,dy31,dz31);
 283             rsq32            = gmx_mm256_calc_rsq_pd(dx32,dy32,dz32);
 284             rsq33            = gmx_mm256_calc_rsq_pd(dx33,dy33,dz33);
 285
 286             rinv11           = gmx_mm256_invsqrt_pd(rsq11);
 287             rinv12           = gmx_mm256_invsqrt_pd(rsq12);
 288             rinv13           = gmx_mm256_invsqrt_pd(rsq13);
 289             rinv21           = gmx_mm256_invsqrt_pd(rsq21);
 290             rinv22           = gmx_mm256_invsqrt_pd(rsq22);
 291             rinv23           = gmx_mm256_invsqrt_pd(rsq23);
 292             rinv31           = gmx_mm256_invsqrt_pd(rsq31);
 293             rinv32           = gmx_mm256_invsqrt_pd(rsq32);
 294             rinv33           = gmx_mm256_invsqrt_pd(rsq33);
 295
 296             rinvsq00         = gmx_mm256_inv_pd(rsq00);
 297
 298             fjx0             = _mm256_setzero_pd();
 299             fjy0             = _mm256_setzero_pd();
 300             fjz0             = _mm256_setzero_pd();
 301             fjx1             = _mm256_setzero_pd();
 302             fjy1             = _mm256_setzero_pd();
 303             fjz1             = _mm256_setzero_pd();
 304             fjx2             = _mm256_setzero_pd();
 305             fjy2             = _mm256_setzero_pd();
 306             fjz2             = _mm256_setzero_pd();
 307             fjx3             = _mm256_setzero_pd();
 308             fjy3             = _mm256_setzero_pd();
 309             fjz3             = _mm256_setzero_pd();
 310
 311             /**************************
 312              * CALCULATE INTERACTIONS *
 313              **************************/
 314
 315             /* LENNARD-JONES DISPERSION/REPULSION */
 316
 317             rinvsix          = _mm256_mul_pd(_mm256_mul_pd(rinvsq00,rinvsq00),rinvsq00);
 318             vvdw6            = _mm256_mul_pd(c6_00,rinvsix);
 319             vvdw12           = _mm256_mul_pd(c12_00,_mm256_mul_pd(rinvsix,rinvsix));
 320             vvdw             = _mm256_sub_pd( _mm256_mul_pd(vvdw12,one_twelfth) , _mm256_mul_pd(vvdw6,one_sixth) );
 321             fvdw             = _mm256_mul_pd(_mm256_sub_pd(vvdw12,vvdw6),rinvsq00);
 322
 323             /* Update potential sum for this i atom from the interaction with this j atom. */
 324             vvdwsum          = _mm256_add_pd(vvdwsum,vvdw);
 325
 326             fscal            = fvdw;
 327
 328             /* Calculate temporary vectorial force */
 329             tx               = _mm256_mul_pd(fscal,dx00);
 330             ty               = _mm256_mul_pd(fscal,dy00);
 331             tz               = _mm256_mul_pd(fscal,dz00);
 332
 333             /* Update vectorial force */
 334             fix0             = _mm256_add_pd(fix0,tx);
 335             fiy0             = _mm256_add_pd(fiy0,ty);
 336             fiz0             = _mm256_add_pd(fiz0,tz);
 337
 338             fjx0             = _mm256_add_pd(fjx0,tx);
 339             fjy0             = _mm256_add_pd(fjy0,ty);
 340             fjz0             = _mm256_add_pd(fjz0,tz);
 341
 342             /**************************
 343              * CALCULATE INTERACTIONS *
 344              **************************/
 345
 346             r11              = _mm256_mul_pd(rsq11,rinv11);
 347
 348             /* Calculate table index by multiplying r with table scale and truncate to integer */
 349             rt               = _mm256_mul_pd(r11,vftabscale);
 350             vfitab           = _mm256_cvttpd_epi32(rt);
 351             vfeps            = _mm256_sub_pd(rt,_mm256_round_pd(rt, _MM_FROUND_FLOOR));
 352             vfitab           = _mm_slli_epi32(vfitab,2);
 353
 354             /* CUBIC SPLINE TABLE ELECTROSTATICS */
 355             Y                = _mm256_load_pd( vftab + _mm_extract_epi32(vfitab,0) );
 356             F                = _mm256_load_pd( vftab + _mm_extract_epi32(vfitab,1) );
 357             G                = _mm256_load_pd( vftab + _mm_extract_epi32(vfitab,2) );
 358             H                = _mm256_load_pd( vftab + _mm_extract_epi32(vfitab,3) );
 359             GMX_MM256_FULLTRANSPOSE4_PD(Y,F,G,H);
 360             Heps             = _mm256_mul_pd(vfeps,H);
 361             Fp               = _mm256_add_pd(F,_mm256_mul_pd(vfeps,_mm256_add_pd(G,Heps)));
 362             VV               = _mm256_add_pd(Y,_mm256_mul_pd(vfeps,Fp));
 363             velec            = _mm256_mul_pd(qq11,VV);
 364             FF               = _mm256_add_pd(Fp,_mm256_mul_pd(vfeps,_mm256_add_pd(G,_mm256_add_pd(Heps,Heps))));
 365             felec            = _mm256_xor_pd(signbit,_mm256_mul_pd(_mm256_mul_pd(qq11,FF),_mm256_mul_pd(vftabscale,rinv11)));
 366
 367             /* Update potential sum for this i atom from the interaction with this j atom. */
 368             velecsum         = _mm256_add_pd(velecsum,velec);
 369
 370             fscal            = felec;
 371
 372             /* Calculate temporary vectorial force */
 373             tx               = _mm256_mul_pd(fscal,dx11);
 374             ty               = _mm256_mul_pd(fscal,dy11);
 375             tz               = _mm256_mul_pd(fscal,dz11);
 376
 377             /* Update vectorial force */
 378             fix1             = _mm256_add_pd(fix1,tx);
 379             fiy1             = _mm256_add_pd(fiy1,ty);
 380             fiz1             = _mm256_add_pd(fiz1,tz);
 381
 382             fjx1             = _mm256_add_pd(fjx1,tx);
 383             fjy1             = _mm256_add_pd(fjy1,ty);
 384             fjz1             = _mm256_add_pd(fjz1,tz);
 385
 386             /**************************
 387              * CALCULATE INTERACTIONS *
 388              **************************/
 389
 390             r12              = _mm256_mul_pd(rsq12,rinv12);
 391
 392             /* Calculate table index by multiplying r with table scale and truncate to integer */
 393             rt               = _mm256_mul_pd(r12,vftabscale);
 394             vfitab           = _mm256_cvttpd_epi32(rt);
 395             vfeps            = _mm256_sub_pd(rt,_mm256_round_pd(rt, _MM_FROUND_FLOOR));
 396             vfitab           = _mm_slli_epi32(vfitab,2);
 397
 398             /* CUBIC SPLINE TABLE ELECTROSTATICS */
 399             Y                = _mm256_load_pd( vftab + _mm_extract_epi32(vfitab,0) );
 400             F                = _mm256_load_pd( vftab + _mm_extract_epi32(vfitab,1) );
 401             G                = _mm256_load_pd( vftab + _mm_extract_epi32(vfitab,2) );
 402             H                = _mm256_load_pd( vftab + _mm_extract_epi32(vfitab,3) );
 403             GMX_MM256_FULLTRANSPOSE4_PD(Y,F,G,H);
 404             Heps             = _mm256_mul_pd(vfeps,H);
 405             Fp               = _mm256_add_pd(F,_mm256_mul_pd(vfeps,_mm256_add_pd(G,Heps)));
 406             VV               = _mm256_add_pd(Y,_mm256_mul_pd(vfeps,Fp));
 407             velec            = _mm256_mul_pd(qq12,VV);
 408             FF               = _mm256_add_pd(Fp,_mm256_mul_pd(vfeps,_mm256_add_pd(G,_mm256_add_pd(Heps,Heps))));
 409             felec            = _mm256_xor_pd(signbit,_mm256_mul_pd(_mm256_mul_pd(qq12,FF),_mm256_mul_pd(vftabscale,rinv12)));
 410
 411             /* Update potential sum for this i atom from the interaction with this j atom. */
 412             velecsum         = _mm256_add_pd(velecsum,velec);
 413
 414             fscal            = felec;
 415
 416             /* Calculate temporary vectorial force */
 417             tx               = _mm256_mul_pd(fscal,dx12);
 418             ty               = _mm256_mul_pd(fscal,dy12);
 419             tz               = _mm256_mul_pd(fscal,dz12);
 420
 421             /* Update vectorial force */
 422             fix1             = _mm256_add_pd(fix1,tx);
 423             fiy1             = _mm256_add_pd(fiy1,ty);
 424             fiz1             = _mm256_add_pd(fiz1,tz);
 425
 426             fjx2             = _mm256_add_pd(fjx2,tx);
 427             fjy2             = _mm256_add_pd(fjy2,ty);
 428             fjz2             = _mm256_add_pd(fjz2,tz);
 429
 430             /**************************
 431              * CALCULATE INTERACTIONS *
 432              **************************/
 433
 434             r13              = _mm256_mul_pd(rsq13,rinv13);
 435
 436             /* Calculate table index by multiplying r with table scale and truncate to integer */
 437             rt               = _mm256_mul_pd(r13,vftabscale);
 438             vfitab           = _mm256_cvttpd_epi32(rt);
 439             vfeps            = _mm256_sub_pd(rt,_mm256_round_pd(rt, _MM_FROUND_FLOOR));
 440             vfitab           = _mm_slli_epi32(vfitab,2);
 441
 442             /* CUBIC SPLINE TABLE ELECTROSTATICS */
 443             Y                = _mm256_load_pd( vftab + _mm_extract_epi32(vfitab,0) );
 444             F                = _mm256_load_pd( vftab + _mm_extract_epi32(vfitab,1) );
 445             G                = _mm256_load_pd( vftab + _mm_extract_epi32(vfitab,2) );
 446             H                = _mm256_load_pd( vftab + _mm_extract_epi32(vfitab,3) );
 447             GMX_MM256_FULLTRANSPOSE4_PD(Y,F,G,H);
 448             Heps             = _mm256_mul_pd(vfeps,H);
 449             Fp               = _mm256_add_pd(F,_mm256_mul_pd(vfeps,_mm256_add_pd(G,Heps)));
 450             VV               = _mm256_add_pd(Y,_mm256_mul_pd(vfeps,Fp));
 451             velec            = _mm256_mul_pd(qq13,VV);
 452             FF               = _mm256_add_pd(Fp,_mm256_mul_pd(vfeps,_mm256_add_pd(G,_mm256_add_pd(Heps,Heps))));
 453             felec            = _mm256_xor_pd(signbit,_mm256_mul_pd(_mm256_mul_pd(qq13,FF),_mm256_mul_pd(vftabscale,rinv13)));
 454
 455             /* Update potential sum for this i atom from the interaction with this j atom. */
 456             velecsum         = _mm256_add_pd(velecsum,velec);
 457
 458             fscal            = felec;
 459
 460             /* Calculate temporary vectorial force */
 461             tx               = _mm256_mul_pd(fscal,dx13);
 462             ty               = _mm256_mul_pd(fscal,dy13);
 463             tz               = _mm256_mul_pd(fscal,dz13);
 464
 465             /* Update vectorial force */
 466             fix1             = _mm256_add_pd(fix1,tx);
 467             fiy1             = _mm256_add_pd(fiy1,ty);
 468             fiz1             = _mm256_add_pd(fiz1,tz);
 469
 470             fjx3             = _mm256_add_pd(fjx3,tx);
 471             fjy3             = _mm256_add_pd(fjy3,ty);
 472             fjz3             = _mm256_add_pd(fjz3,tz);
 473
 474             /**************************
 475              * CALCULATE INTERACTIONS *
 476              **************************/
 477
 478             r21              = _mm256_mul_pd(rsq21,rinv21);
 479
 480             /* Calculate table index by multiplying r with table scale and truncate to integer */
 481             rt               = _mm256_mul_pd(r21,vftabscale);
 482             vfitab           = _mm256_cvttpd_epi32(rt);
 483             vfeps            = _mm256_sub_pd(rt,_mm256_round_pd(rt, _MM_FROUND_FLOOR));
 484             vfitab           = _mm_slli_epi32(vfitab,2);
 485
 486             /* CUBIC SPLINE TABLE ELECTROSTATICS */
 487             Y                = _mm256_load_pd( vftab + _mm_extract_epi32(vfitab,0) );
 488             F                = _mm256_load_pd( vftab + _mm_extract_epi32(vfitab,1) );
 489             G                = _mm256_load_pd( vftab + _mm_extract_epi32(vfitab,2) );
 490             H                = _mm256_load_pd( vftab + _mm_extract_epi32(vfitab,3) );
 491             GMX_MM256_FULLTRANSPOSE4_PD(Y,F,G,H);
 492             Heps             = _mm256_mul_pd(vfeps,H);
 493             Fp               = _mm256_add_pd(F,_mm256_mul_pd(vfeps,_mm256_add_pd(G,Heps)));
 494             VV               = _mm256_add_pd(Y,_mm256_mul_pd(vfeps,Fp));
 495             velec            = _mm256_mul_pd(qq21,VV);
 496             FF               = _mm256_add_pd(Fp,_mm256_mul_pd(vfeps,_mm256_add_pd(G,_mm256_add_pd(Heps,Heps))));
 497             felec            = _mm256_xor_pd(signbit,_mm256_mul_pd(_mm256_mul_pd(qq21,FF),_mm256_mul_pd(vftabscale,rinv21)));
 498
 499             /* Update potential sum for this i atom from the interaction with this j atom. */
 500             velecsum         = _mm256_add_pd(velecsum,velec);
 501
 502             fscal            = felec;
 503
 504             /* Calculate temporary vectorial force */
 505             tx               = _mm256_mul_pd(fscal,dx21);
 506             ty               = _mm256_mul_pd(fscal,dy21);
 507             tz               = _mm256_mul_pd(fscal,dz21);
 508
 509             /* Update vectorial force */
 510             fix2             = _mm256_add_pd(fix2,tx);
 511             fiy2             = _mm256_add_pd(fiy2,ty);
 512             fiz2             = _mm256_add_pd(fiz2,tz);
 513
 514             fjx1             = _mm256_add_pd(fjx1,tx);
 515             fjy1             = _mm256_add_pd(fjy1,ty);
 516             fjz1             = _mm256_add_pd(fjz1,tz);
 517
 518             /**************************
 519              * CALCULATE INTERACTIONS *
 520              **************************/
 521
 522             r22              = _mm256_mul_pd(rsq22,rinv22);
 523
 524             /* Calculate table index by multiplying r with table scale and truncate to integer */
 525             rt               = _mm256_mul_pd(r22,vftabscale);
 526             vfitab           = _mm256_cvttpd_epi32(rt);
 527             vfeps            = _mm256_sub_pd(rt,_mm256_round_pd(rt, _MM_FROUND_FLOOR));
 528             vfitab           = _mm_slli_epi32(vfitab,2);
 529
 530             /* CUBIC SPLINE TABLE ELECTROSTATICS */
 531             Y                = _mm256_load_pd( vftab + _mm_extract_epi32(vfitab,0) );
 532             F                = _mm256_load_pd( vftab + _mm_extract_epi32(vfitab,1) );
 533             G                = _mm256_load_pd( vftab + _mm_extract_epi32(vfitab,2) );
 534             H                = _mm256_load_pd( vftab + _mm_extract_epi32(vfitab,3) );
 535             GMX_MM256_FULLTRANSPOSE4_PD(Y,F,G,H);
 536             Heps             = _mm256_mul_pd(vfeps,H);
 537             Fp               = _mm256_add_pd(F,_mm256_mul_pd(vfeps,_mm256_add_pd(G,Heps)));
 538             VV               = _mm256_add_pd(Y,_mm256_mul_pd(vfeps,Fp));
 539             velec            = _mm256_mul_pd(qq22,VV);
 540             FF               = _mm256_add_pd(Fp,_mm256_mul_pd(vfeps,_mm256_add_pd(G,_mm256_add_pd(Heps,Heps))));
 541             felec            = _mm256_xor_pd(signbit,_mm256_mul_pd(_mm256_mul_pd(qq22,FF),_mm256_mul_pd(vftabscale,rinv22)));
 542
 543             /* Update potential sum for this i atom from the interaction with this j atom. */
 544             velecsum         = _mm256_add_pd(velecsum,velec);
 545
 546             fscal            = felec;
 547
 548             /* Calculate temporary vectorial force */
 549             tx               = _mm256_mul_pd(fscal,dx22);
 550             ty               = _mm256_mul_pd(fscal,dy22);
 551             tz               = _mm256_mul_pd(fscal,dz22);
 552
 553             /* Update vectorial force */
 554             fix2             = _mm256_add_pd(fix2,tx);
 555             fiy2             = _mm256_add_pd(fiy2,ty);
 556             fiz2             = _mm256_add_pd(fiz2,tz);
 557
 558             fjx2             = _mm256_add_pd(fjx2,tx);
 559             fjy2             = _mm256_add_pd(fjy2,ty);
 560             fjz2             = _mm256_add_pd(fjz2,tz);
 561
 562             /**************************
 563              * CALCULATE INTERACTIONS *
 564              **************************/
 565
 566             r23              = _mm256_mul_pd(rsq23,rinv23);
 567
 568             /* Calculate table index by multiplying r with table scale and truncate to integer */
 569             rt               = _mm256_mul_pd(r23,vftabscale);
 570             vfitab           = _mm256_cvttpd_epi32(rt);
 571             vfeps            = _mm256_sub_pd(rt,_mm256_round_pd(rt, _MM_FROUND_FLOOR));
 572             vfitab           = _mm_slli_epi32(vfitab,2);
 573
 574             /* CUBIC SPLINE TABLE ELECTROSTATICS */
 575             Y                = _mm256_load_pd( vftab + _mm_extract_epi32(vfitab,0) );
 576             F                = _mm256_load_pd( vftab + _mm_extract_epi32(vfitab,1) );
 577             G                = _mm256_load_pd( vftab + _mm_extract_epi32(vfitab,2) );
 578             H                = _mm256_load_pd( vftab + _mm_extract_epi32(vfitab,3) );
 579             GMX_MM256_FULLTRANSPOSE4_PD(Y,F,G,H);
 580             Heps             = _mm256_mul_pd(vfeps,H);
 581             Fp               = _mm256_add_pd(F,_mm256_mul_pd(vfeps,_mm256_add_pd(G,Heps)));
 582             VV               = _mm256_add_pd(Y,_mm256_mul_pd(vfeps,Fp));
 583             velec            = _mm256_mul_pd(qq23,VV);
 584             FF               = _mm256_add_pd(Fp,_mm256_mul_pd(vfeps,_mm256_add_pd(G,_mm256_add_pd(Heps,Heps))));
 585             felec            = _mm256_xor_pd(signbit,_mm256_mul_pd(_mm256_mul_pd(qq23,FF),_mm256_mul_pd(vftabscale,rinv23)));
 586
 587             /* Update potential sum for this i atom from the interaction with this j atom. */
 588             velecsum         = _mm256_add_pd(velecsum,velec);
 589
 590             fscal            = felec;
 591
 592             /* Calculate temporary vectorial force */
 593             tx               = _mm256_mul_pd(fscal,dx23);
 594             ty               = _mm256_mul_pd(fscal,dy23);
 595             tz               = _mm256_mul_pd(fscal,dz23);
 596
 597             /* Update vectorial force */
 598             fix2             = _mm256_add_pd(fix2,tx);
 599             fiy2             = _mm256_add_pd(fiy2,ty);
 600             fiz2             = _mm256_add_pd(fiz2,tz);
 601
 602             fjx3             = _mm256_add_pd(fjx3,tx);
 603             fjy3             = _mm256_add_pd(fjy3,ty);
 604             fjz3             = _mm256_add_pd(fjz3,tz);
 605
 606             /**************************
 607              * CALCULATE INTERACTIONS *
 608              **************************/
 609
 610             r31              = _mm256_mul_pd(rsq31,rinv31);
 611
 612             /* Calculate table index by multiplying r with table scale and truncate to integer */
 613             rt               = _mm256_mul_pd(r31,vftabscale);
 614             vfitab           = _mm256_cvttpd_epi32(rt);
 615             vfeps            = _mm256_sub_pd(rt,_mm256_round_pd(rt, _MM_FROUND_FLOOR));
 616             vfitab           = _mm_slli_epi32(vfitab,2);
 617
 618             /* CUBIC SPLINE TABLE ELECTROSTATICS */
 619             Y                = _mm256_load_pd( vftab + _mm_extract_epi32(vfitab,0) );
 620             F                = _mm256_load_pd( vftab + _mm_extract_epi32(vfitab,1) );
 621             G                = _mm256_load_pd( vftab + _mm_extract_epi32(vfitab,2) );
 622             H                = _mm256_load_pd( vftab + _mm_extract_epi32(vfitab,3) );
 623             GMX_MM256_FULLTRANSPOSE4_PD(Y,F,G,H);
 624             Heps             = _mm256_mul_pd(vfeps,H);
 625             Fp               = _mm256_add_pd(F,_mm256_mul_pd(vfeps,_mm256_add_pd(G,Heps)));
 626             VV               = _mm256_add_pd(Y,_mm256_mul_pd(vfeps,Fp));
 627             velec            = _mm256_mul_pd(qq31,VV);
 628             FF               = _mm256_add_pd(Fp,_mm256_mul_pd(vfeps,_mm256_add_pd(G,_mm256_add_pd(Heps,Heps))));
 629             felec            = _mm256_xor_pd(signbit,_mm256_mul_pd(_mm256_mul_pd(qq31,FF),_mm256_mul_pd(vftabscale,rinv31)));
 630
 631             /* Update potential sum for this i atom from the interaction with this j atom. */
 632             velecsum         = _mm256_add_pd(velecsum,velec);
 633
 634             fscal            = felec;
 635
 636             /* Calculate temporary vectorial force */
 637             tx               = _mm256_mul_pd(fscal,dx31);
 638             ty               = _mm256_mul_pd(fscal,dy31);
 639             tz               = _mm256_mul_pd(fscal,dz31);
 640
 641             /* Update vectorial force */
 642             fix3             = _mm256_add_pd(fix3,tx);
 643             fiy3             = _mm256_add_pd(fiy3,ty);
 644             fiz3             = _mm256_add_pd(fiz3,tz);
 645
 646             fjx1             = _mm256_add_pd(fjx1,tx);
 647             fjy1             = _mm256_add_pd(fjy1,ty);
 648             fjz1             = _mm256_add_pd(fjz1,tz);
 649
 650             /**************************
 651              * CALCULATE INTERACTIONS *
 652              **************************/
 653
 654             r32              = _mm256_mul_pd(rsq32,rinv32);
 655
 656             /* Calculate table index by multiplying r with table scale and truncate to integer */
 657             rt               = _mm256_mul_pd(r32,vftabscale);
 658             vfitab           = _mm256_cvttpd_epi32(rt);
 659             vfeps            = _mm256_sub_pd(rt,_mm256_round_pd(rt, _MM_FROUND_FLOOR));
 660             vfitab           = _mm_slli_epi32(vfitab,2);
 661
 662             /* CUBIC SPLINE TABLE ELECTROSTATICS */
 663             Y                = _mm256_load_pd( vftab + _mm_extract_epi32(vfitab,0) );
 664             F                = _mm256_load_pd( vftab + _mm_extract_epi32(vfitab,1) );
 665             G                = _mm256_load_pd( vftab + _mm_extract_epi32(vfitab,2) );
 666             H                = _mm256_load_pd( vftab + _mm_extract_epi32(vfitab,3) );
 667             GMX_MM256_FULLTRANSPOSE4_PD(Y,F,G,H);
 668             Heps             = _mm256_mul_pd(vfeps,H);
 669             Fp               = _mm256_add_pd(F,_mm256_mul_pd(vfeps,_mm256_add_pd(G,Heps)));
 670             VV               = _mm256_add_pd(Y,_mm256_mul_pd(vfeps,Fp));
 671             velec            = _mm256_mul_pd(qq32,VV);
 672             FF               = _mm256_add_pd(Fp,_mm256_mul_pd(vfeps,_mm256_add_pd(G,_mm256_add_pd(Heps,Heps))));
 673             felec            = _mm256_xor_pd(signbit,_mm256_mul_pd(_mm256_mul_pd(qq32,FF),_mm256_mul_pd(vftabscale,rinv32)));
 674
 675             /* Update potential sum for this i atom from the interaction with this j atom. */
 676             velecsum         = _mm256_add_pd(velecsum,velec);
 677
 678             fscal            = felec;
 679
 680             /* Calculate temporary vectorial force */
 681             tx               = _mm256_mul_pd(fscal,dx32);
 682             ty               = _mm256_mul_pd(fscal,dy32);
 683             tz               = _mm256_mul_pd(fscal,dz32);
 684
 685             /* Update vectorial force */
 686             fix3             = _mm256_add_pd(fix3,tx);
 687             fiy3             = _mm256_add_pd(fiy3,ty);
 688             fiz3             = _mm256_add_pd(fiz3,tz);
 689
 690             fjx2             = _mm256_add_pd(fjx2,tx);
 691             fjy2             = _mm256_add_pd(fjy2,ty);
 692             fjz2             = _mm256_add_pd(fjz2,tz);
 693
 694             /**************************
 695              * CALCULATE INTERACTIONS *
 696              **************************/
 697
 698             r33              = _mm256_mul_pd(rsq33,rinv33);
 699
 700             /* Calculate table index by multiplying r with table scale and truncate to integer */
 701             rt               = _mm256_mul_pd(r33,vftabscale);
 702             vfitab           = _mm256_cvttpd_epi32(rt);
 703             vfeps            = _mm256_sub_pd(rt,_mm256_round_pd(rt, _MM_FROUND_FLOOR));
 704             vfitab           = _mm_slli_epi32(vfitab,2);
 705
 706             /* CUBIC SPLINE TABLE ELECTROSTATICS */
 707             Y                = _mm256_load_pd( vftab + _mm_extract_epi32(vfitab,0) );
 708             F                = _mm256_load_pd( vftab + _mm_extract_epi32(vfitab,1) );
 709             G                = _mm256_load_pd( vftab + _mm_extract_epi32(vfitab,2) );
 710             H                = _mm256_load_pd( vftab + _mm_extract_epi32(vfitab,3) );
 711             GMX_MM256_FULLTRANSPOSE4_PD(Y,F,G,H);
 712             Heps             = _mm256_mul_pd(vfeps,H);
 713             Fp               = _mm256_add_pd(F,_mm256_mul_pd(vfeps,_mm256_add_pd(G,Heps)));
 714             VV               = _mm256_add_pd(Y,_mm256_mul_pd(vfeps,Fp));
 715             velec            = _mm256_mul_pd(qq33,VV);
 716             FF               = _mm256_add_pd(Fp,_mm256_mul_pd(vfeps,_mm256_add_pd(G,_mm256_add_pd(Heps,Heps))));
 717             felec            = _mm256_xor_pd(signbit,_mm256_mul_pd(_mm256_mul_pd(qq33,FF),_mm256_mul_pd(vftabscale,rinv33)));
 718
 719             /* Update potential sum for this i atom from the interaction with this j atom. */
 720             velecsum         = _mm256_add_pd(velecsum,velec);
 721
 722             fscal            = felec;
 723
 724             /* Calculate temporary vectorial force */
 725             tx               = _mm256_mul_pd(fscal,dx33);
 726             ty               = _mm256_mul_pd(fscal,dy33);
 727             tz               = _mm256_mul_pd(fscal,dz33);
 728
 729             /* Update vectorial force */
 730             fix3             = _mm256_add_pd(fix3,tx);
 731             fiy3             = _mm256_add_pd(fiy3,ty);
 732             fiz3             = _mm256_add_pd(fiz3,tz);
 733
 734             fjx3             = _mm256_add_pd(fjx3,tx);
 735             fjy3             = _mm256_add_pd(fjy3,ty);
 736             fjz3             = _mm256_add_pd(fjz3,tz);
 737
 738             fjptrA             = f+j_coord_offsetA;
 739             fjptrB             = f+j_coord_offsetB;
 740             fjptrC             = f+j_coord_offsetC;
 741             fjptrD             = f+j_coord_offsetD;
 742
 743             gmx_mm256_decrement_4rvec_4ptr_swizzle_pd(fjptrA,fjptrB,fjptrC,fjptrD,
 744                                                       fjx0,fjy0,fjz0,fjx1,fjy1,fjz1,
 745                                                       fjx2,fjy2,fjz2,fjx3,fjy3,fjz3);
 746
 747             /* Inner loop uses 422 flops */
 748         }
 749
 750         if(jidx<j_index_end)
 751         {
 752
 753             /* Get j neighbor index, and coordinate index */
 754             jnrlistA         = jjnr[jidx];
 755             jnrlistB         = jjnr[jidx+1];
 756             jnrlistC         = jjnr[jidx+2];
 757             jnrlistD         = jjnr[jidx+3];
 758             /* Sign of each element will be negative for non-real atoms.
 759              * This mask will be 0xFFFFFFFF for dummy entries and 0x0 for real ones,
 760              * so use it as val = _mm_andnot_pd(mask,val) to clear dummy entries.
 761              */
 762             tmpmask0 = gmx_mm_castsi128_ps(_mm_cmplt_epi32(_mm_loadu_si128((const __m128i *)(jjnr+jidx)),_mm_setzero_si128()));
 763
 764             tmpmask1 = _mm_permute_ps(tmpmask0,_GMX_MM_PERMUTE(3,3,2,2));
 765             tmpmask0 = _mm_permute_ps(tmpmask0,_GMX_MM_PERMUTE(1,1,0,0));
 766             dummy_mask = _mm256_castps_pd(gmx_mm256_set_m128(tmpmask1,tmpmask0));
 767
 768             jnrA       = (jnrlistA>=0) ? jnrlistA : 0;
 769             jnrB       = (jnrlistB>=0) ? jnrlistB : 0;
 770             jnrC       = (jnrlistC>=0) ? jnrlistC : 0;
 771             jnrD       = (jnrlistD>=0) ? jnrlistD : 0;
 772             j_coord_offsetA  = DIM*jnrA;
 773             j_coord_offsetB  = DIM*jnrB;
 774             j_coord_offsetC  = DIM*jnrC;
 775             j_coord_offsetD  = DIM*jnrD;
 776
 777             /* load j atom coordinates */
 778             gmx_mm256_load_4rvec_4ptr_swizzle_pd(x+j_coord_offsetA,x+j_coord_offsetB,
 779                                                  x+j_coord_offsetC,x+j_coord_offsetD,
 780                                                  &jx0,&jy0,&jz0,&jx1,&jy1,&jz1,&jx2,
 781                                                  &jy2,&jz2,&jx3,&jy3,&jz3);
 782
 783             /* Calculate displacement vector */
 784             dx00             = _mm256_sub_pd(ix0,jx0);
 785             dy00             = _mm256_sub_pd(iy0,jy0);
 786             dz00             = _mm256_sub_pd(iz0,jz0);
 787             dx11             = _mm256_sub_pd(ix1,jx1);
 788             dy11             = _mm256_sub_pd(iy1,jy1);
 789             dz11             = _mm256_sub_pd(iz1,jz1);
 790             dx12             = _mm256_sub_pd(ix1,jx2);
 791             dy12             = _mm256_sub_pd(iy1,jy2);
 792             dz12             = _mm256_sub_pd(iz1,jz2);
 793             dx13             = _mm256_sub_pd(ix1,jx3);
 794             dy13             = _mm256_sub_pd(iy1,jy3);
 795             dz13             = _mm256_sub_pd(iz1,jz3);
 796             dx21             = _mm256_sub_pd(ix2,jx1);
 797             dy21             = _mm256_sub_pd(iy2,jy1);
 798             dz21             = _mm256_sub_pd(iz2,jz1);
 799             dx22             = _mm256_sub_pd(ix2,jx2);
 800             dy22             = _mm256_sub_pd(iy2,jy2);
 801             dz22             = _mm256_sub_pd(iz2,jz2);
 802             dx23             = _mm256_sub_pd(ix2,jx3);
 803             dy23             = _mm256_sub_pd(iy2,jy3);
 804             dz23             = _mm256_sub_pd(iz2,jz3);
 805             dx31             = _mm256_sub_pd(ix3,jx1);
 806             dy31             = _mm256_sub_pd(iy3,jy1);
 807             dz31             = _mm256_sub_pd(iz3,jz1);
 808             dx32             = _mm256_sub_pd(ix3,jx2);
 809             dy32             = _mm256_sub_pd(iy3,jy2);
 810             dz32             = _mm256_sub_pd(iz3,jz2);
 811             dx33             = _mm256_sub_pd(ix3,jx3);
 812             dy33             = _mm256_sub_pd(iy3,jy3);
 813             dz33             = _mm256_sub_pd(iz3,jz3);
 814
 815             /* Calculate squared distance and things based on it */
 816             rsq00            = gmx_mm256_calc_rsq_pd(dx00,dy00,dz00);
 817             rsq11            = gmx_mm256_calc_rsq_pd(dx11,dy11,dz11);
 818             rsq12            = gmx_mm256_calc_rsq_pd(dx12,dy12,dz12);
 819             rsq13            = gmx_mm256_calc_rsq_pd(dx13,dy13,dz13);
 820             rsq21            = gmx_mm256_calc_rsq_pd(dx21,dy21,dz21);
 821             rsq22            = gmx_mm256_calc_rsq_pd(dx22,dy22,dz22);
 822             rsq23            = gmx_mm256_calc_rsq_pd(dx23,dy23,dz23);
 823             rsq31            = gmx_mm256_calc_rsq_pd(dx31,dy31,dz31);
 824             rsq32            = gmx_mm256_calc_rsq_pd(dx32,dy32,dz32);
 825             rsq33            = gmx_mm256_calc_rsq_pd(dx33,dy33,dz33);
 826
 827             rinv11           = gmx_mm256_invsqrt_pd(rsq11);
 828             rinv12           = gmx_mm256_invsqrt_pd(rsq12);
 829             rinv13           = gmx_mm256_invsqrt_pd(rsq13);
 830             rinv21           = gmx_mm256_invsqrt_pd(rsq21);
 831             rinv22           = gmx_mm256_invsqrt_pd(rsq22);
 832             rinv23           = gmx_mm256_invsqrt_pd(rsq23);
 833             rinv31           = gmx_mm256_invsqrt_pd(rsq31);
 834             rinv32           = gmx_mm256_invsqrt_pd(rsq32);
 835             rinv33           = gmx_mm256_invsqrt_pd(rsq33);
 836
 837             rinvsq00         = gmx_mm256_inv_pd(rsq00);
 838
 839             fjx0             = _mm256_setzero_pd();
 840             fjy0             = _mm256_setzero_pd();
 841             fjz0             = _mm256_setzero_pd();
 842             fjx1             = _mm256_setzero_pd();
 843             fjy1             = _mm256_setzero_pd();
 844             fjz1             = _mm256_setzero_pd();
 845             fjx2             = _mm256_setzero_pd();
 846             fjy2             = _mm256_setzero_pd();
 847             fjz2             = _mm256_setzero_pd();
 848             fjx3             = _mm256_setzero_pd();
 849             fjy3             = _mm256_setzero_pd();
 850             fjz3             = _mm256_setzero_pd();
 851
 852             /**************************
 853              * CALCULATE INTERACTIONS *
 854              **************************/
 855
 856             /* LENNARD-JONES DISPERSION/REPULSION */
 857
 858             rinvsix          = _mm256_mul_pd(_mm256_mul_pd(rinvsq00,rinvsq00),rinvsq00);
 859             vvdw6            = _mm256_mul_pd(c6_00,rinvsix);
 860             vvdw12           = _mm256_mul_pd(c12_00,_mm256_mul_pd(rinvsix,rinvsix));
 861             vvdw             = _mm256_sub_pd( _mm256_mul_pd(vvdw12,one_twelfth) , _mm256_mul_pd(vvdw6,one_sixth) );
 862             fvdw             = _mm256_mul_pd(_mm256_sub_pd(vvdw12,vvdw6),rinvsq00);
 863
 864             /* Update potential sum for this i atom from the interaction with this j atom. */
 865             vvdw             = _mm256_andnot_pd(dummy_mask,vvdw);
 866             vvdwsum          = _mm256_add_pd(vvdwsum,vvdw);
 867
 868             fscal            = fvdw;
 869
 870             fscal            = _mm256_andnot_pd(dummy_mask,fscal);
 871
 872             /* Calculate temporary vectorial force */
 873             tx               = _mm256_mul_pd(fscal,dx00);
 874             ty               = _mm256_mul_pd(fscal,dy00);
 875             tz               = _mm256_mul_pd(fscal,dz00);
 876
 877             /* Update vectorial force */
 878             fix0             = _mm256_add_pd(fix0,tx);
 879             fiy0             = _mm256_add_pd(fiy0,ty);
 880             fiz0             = _mm256_add_pd(fiz0,tz);
 881
 882             fjx0             = _mm256_add_pd(fjx0,tx);
 883             fjy0             = _mm256_add_pd(fjy0,ty);
 884             fjz0             = _mm256_add_pd(fjz0,tz);
 885
 886             /**************************
 887              * CALCULATE INTERACTIONS *
 888              **************************/
 889
 890             r11              = _mm256_mul_pd(rsq11,rinv11);
 891             r11              = _mm256_andnot_pd(dummy_mask,r11);
 892
 893             /* Calculate table index by multiplying r with table scale and truncate to integer */
 894             rt               = _mm256_mul_pd(r11,vftabscale);
 895             vfitab           = _mm256_cvttpd_epi32(rt);
 896             vfeps            = _mm256_sub_pd(rt,_mm256_round_pd(rt, _MM_FROUND_FLOOR));
 897             vfitab           = _mm_slli_epi32(vfitab,2);
 898
 899             /* CUBIC SPLINE TABLE ELECTROSTATICS */
 900             Y                = _mm256_load_pd( vftab + _mm_extract_epi32(vfitab,0) );
 901             F                = _mm256_load_pd( vftab + _mm_extract_epi32(vfitab,1) );
 902             G                = _mm256_load_pd( vftab + _mm_extract_epi32(vfitab,2) );
 903             H                = _mm256_load_pd( vftab + _mm_extract_epi32(vfitab,3) );
 904             GMX_MM256_FULLTRANSPOSE4_PD(Y,F,G,H);
 905             Heps             = _mm256_mul_pd(vfeps,H);
 906             Fp               = _mm256_add_pd(F,_mm256_mul_pd(vfeps,_mm256_add_pd(G,Heps)));
 907             VV               = _mm256_add_pd(Y,_mm256_mul_pd(vfeps,Fp));
 908             velec            = _mm256_mul_pd(qq11,VV);
 909             FF               = _mm256_add_pd(Fp,_mm256_mul_pd(vfeps,_mm256_add_pd(G,_mm256_add_pd(Heps,Heps))));
 910             felec            = _mm256_xor_pd(signbit,_mm256_mul_pd(_mm256_mul_pd(qq11,FF),_mm256_mul_pd(vftabscale,rinv11)));
 911
 912             /* Update potential sum for this i atom from the interaction with this j atom. */
 913             velec            = _mm256_andnot_pd(dummy_mask,velec);
 914             velecsum         = _mm256_add_pd(velecsum,velec);
 915
 916             fscal            = felec;
 917
 918             fscal            = _mm256_andnot_pd(dummy_mask,fscal);
 919
 920             /* Calculate temporary vectorial force */
 921             tx               = _mm256_mul_pd(fscal,dx11);
 922             ty               = _mm256_mul_pd(fscal,dy11);
 923             tz               = _mm256_mul_pd(fscal,dz11);
 924
 925             /* Update vectorial force */
 926             fix1             = _mm256_add_pd(fix1,tx);
 927             fiy1             = _mm256_add_pd(fiy1,ty);
 928             fiz1             = _mm256_add_pd(fiz1,tz);
 929
 930             fjx1             = _mm256_add_pd(fjx1,tx);
 931             fjy1             = _mm256_add_pd(fjy1,ty);
 932             fjz1             = _mm256_add_pd(fjz1,tz);
 933
 934             /**************************
 935              * CALCULATE INTERACTIONS *
 936              **************************/
 937
 938             r12              = _mm256_mul_pd(rsq12,rinv12);
 939             r12              = _mm256_andnot_pd(dummy_mask,r12);
 940
 941             /* Calculate table index by multiplying r with table scale and truncate to integer */
 942             rt               = _mm256_mul_pd(r12,vftabscale);
 943             vfitab           = _mm256_cvttpd_epi32(rt);
 944             vfeps            = _mm256_sub_pd(rt,_mm256_round_pd(rt, _MM_FROUND_FLOOR));
 945             vfitab           = _mm_slli_epi32(vfitab,2);
 946
 947             /* CUBIC SPLINE TABLE ELECTROSTATICS */
 948             Y                = _mm256_load_pd( vftab + _mm_extract_epi32(vfitab,0) );
 949             F                = _mm256_load_pd( vftab + _mm_extract_epi32(vfitab,1) );
 950             G                = _mm256_load_pd( vftab + _mm_extract_epi32(vfitab,2) );
 951             H                = _mm256_load_pd( vftab + _mm_extract_epi32(vfitab,3) );
 952             GMX_MM256_FULLTRANSPOSE4_PD(Y,F,G,H);
 953             Heps             = _mm256_mul_pd(vfeps,H);
 954             Fp               = _mm256_add_pd(F,_mm256_mul_pd(vfeps,_mm256_add_pd(G,Heps)));
 955             VV               = _mm256_add_pd(Y,_mm256_mul_pd(vfeps,Fp));
 956             velec            = _mm256_mul_pd(qq12,VV);
 957             FF               = _mm256_add_pd(Fp,_mm256_mul_pd(vfeps,_mm256_add_pd(G,_mm256_add_pd(Heps,Heps))));
 958             felec            = _mm256_xor_pd(signbit,_mm256_mul_pd(_mm256_mul_pd(qq12,FF),_mm256_mul_pd(vftabscale,rinv12)));
 959
 960             /* Update potential sum for this i atom from the interaction with this j atom. */
 961             velec            = _mm256_andnot_pd(dummy_mask,velec);
 962             velecsum         = _mm256_add_pd(velecsum,velec);
 963
 964             fscal            = felec;
 965
 966             fscal            = _mm256_andnot_pd(dummy_mask,fscal);
 967
 968             /* Calculate temporary vectorial force */
 969             tx               = _mm256_mul_pd(fscal,dx12);
 970             ty               = _mm256_mul_pd(fscal,dy12);
 971             tz               = _mm256_mul_pd(fscal,dz12);
 972
 973             /* Update vectorial force */
 974             fix1             = _mm256_add_pd(fix1,tx);
 975             fiy1             = _mm256_add_pd(fiy1,ty);
 976             fiz1             = _mm256_add_pd(fiz1,tz);
 977
 978             fjx2             = _mm256_add_pd(fjx2,tx);
 979             fjy2             = _mm256_add_pd(fjy2,ty);
 980             fjz2             = _mm256_add_pd(fjz2,tz);
 981
 982             /**************************
 983              * CALCULATE INTERACTIONS *
 984              **************************/
 985
 986             r13              = _mm256_mul_pd(rsq13,rinv13);
 987             r13              = _mm256_andnot_pd(dummy_mask,r13);
 988
 989             /* Calculate table index by multiplying r with table scale and truncate to integer */
 990             rt               = _mm256_mul_pd(r13,vftabscale);
 991             vfitab           = _mm256_cvttpd_epi32(rt);
 992             vfeps            = _mm256_sub_pd(rt,_mm256_round_pd(rt, _MM_FROUND_FLOOR));
 993             vfitab           = _mm_slli_epi32(vfitab,2);
 994
 995             /* CUBIC SPLINE TABLE ELECTROSTATICS */
 996             Y                = _mm256_load_pd( vftab + _mm_extract_epi32(vfitab,0) );
 997             F                = _mm256_load_pd( vftab + _mm_extract_epi32(vfitab,1) );
 998             G                = _mm256_load_pd( vftab + _mm_extract_epi32(vfitab,2) );
 999             H                = _mm256_load_pd( vftab + _mm_extract_epi32(vfitab,3) );
1000             GMX_MM256_FULLTRANSPOSE4_PD(Y,F,G,H);
1001             Heps             = _mm256_mul_pd(vfeps,H);
1002             Fp               = _mm256_add_pd(F,_mm256_mul_pd(vfeps,_mm256_add_pd(G,Heps)));
1003             VV               = _mm256_add_pd(Y,_mm256_mul_pd(vfeps,Fp));
1004             velec            = _mm256_mul_pd(qq13,VV);
1005             FF               = _mm256_add_pd(Fp,_mm256_mul_pd(vfeps,_mm256_add_pd(G,_mm256_add_pd(Heps,Heps))));
1006             felec            = _mm256_xor_pd(signbit,_mm256_mul_pd(_mm256_mul_pd(qq13,FF),_mm256_mul_pd(vftabscale,rinv13)));
1007
1008             /* Update potential sum for this i atom from the interaction with this j atom. */
1009             velec            = _mm256_andnot_pd(dummy_mask,velec);
1010             velecsum         = _mm256_add_pd(velecsum,velec);
1011
1012             fscal            = felec;
1013
1014             fscal            = _mm256_andnot_pd(dummy_mask,fscal);
1015
1016             /* Calculate temporary vectorial force */
1017             tx               = _mm256_mul_pd(fscal,dx13);
1018             ty               = _mm256_mul_pd(fscal,dy13);
1019             tz               = _mm256_mul_pd(fscal,dz13);
1020
1021             /* Update vectorial force */
1022             fix1             = _mm256_add_pd(fix1,tx);
1023             fiy1             = _mm256_add_pd(fiy1,ty);
1024             fiz1             = _mm256_add_pd(fiz1,tz);
1025
1026             fjx3             = _mm256_add_pd(fjx3,tx);
1027             fjy3             = _mm256_add_pd(fjy3,ty);
1028             fjz3             = _mm256_add_pd(fjz3,tz);
1029
1030             /**************************
1031              * CALCULATE INTERACTIONS *
1032              **************************/
1033
1034             r21              = _mm256_mul_pd(rsq21,rinv21);
1035             r21              = _mm256_andnot_pd(dummy_mask,r21);
1036
1037             /* Calculate table index by multiplying r with table scale and truncate to integer */
1038             rt               = _mm256_mul_pd(r21,vftabscale);
1039             vfitab           = _mm256_cvttpd_epi32(rt);
1040             vfeps            = _mm256_sub_pd(rt,_mm256_round_pd(rt, _MM_FROUND_FLOOR));
1041             vfitab           = _mm_slli_epi32(vfitab,2);
1042
1043             /* CUBIC SPLINE TABLE ELECTROSTATICS */
1044             Y                = _mm256_load_pd( vftab + _mm_extract_epi32(vfitab,0) );
1045             F                = _mm256_load_pd( vftab + _mm_extract_epi32(vfitab,1) );
1046             G                = _mm256_load_pd( vftab + _mm_extract_epi32(vfitab,2) );
1047             H                = _mm256_load_pd( vftab + _mm_extract_epi32(vfitab,3) );
1048             GMX_MM256_FULLTRANSPOSE4_PD(Y,F,G,H);
1049             Heps             = _mm256_mul_pd(vfeps,H);
1050             Fp               = _mm256_add_pd(F,_mm256_mul_pd(vfeps,_mm256_add_pd(G,Heps)));
1051             VV               = _mm256_add_pd(Y,_mm256_mul_pd(vfeps,Fp));
1052             velec            = _mm256_mul_pd(qq21,VV);
1053             FF               = _mm256_add_pd(Fp,_mm256_mul_pd(vfeps,_mm256_add_pd(G,_mm256_add_pd(Heps,Heps))));
1054             felec            = _mm256_xor_pd(signbit,_mm256_mul_pd(_mm256_mul_pd(qq21,FF),_mm256_mul_pd(vftabscale,rinv21)));
1055
1056             /* Update potential sum for this i atom from the interaction with this j atom. */
1057             velec            = _mm256_andnot_pd(dummy_mask,velec);
1058             velecsum         = _mm256_add_pd(velecsum,velec);
1059
1060             fscal            = felec;
1061
1062             fscal            = _mm256_andnot_pd(dummy_mask,fscal);
1063
1064             /* Calculate temporary vectorial force */
1065             tx               = _mm256_mul_pd(fscal,dx21);
1066             ty               = _mm256_mul_pd(fscal,dy21);
1067             tz               = _mm256_mul_pd(fscal,dz21);
1068
1069             /* Update vectorial force */
1070             fix2             = _mm256_add_pd(fix2,tx);
1071             fiy2             = _mm256_add_pd(fiy2,ty);
1072             fiz2             = _mm256_add_pd(fiz2,tz);
1073
1074             fjx1             = _mm256_add_pd(fjx1,tx);
1075             fjy1             = _mm256_add_pd(fjy1,ty);
1076             fjz1             = _mm256_add_pd(fjz1,tz);
1077
1078             /**************************
1079              * CALCULATE INTERACTIONS *
1080              **************************/
1081
1082             r22              = _mm256_mul_pd(rsq22,rinv22);
1083             r22              = _mm256_andnot_pd(dummy_mask,r22);
1084
1085             /* Calculate table index by multiplying r with table scale and truncate to integer */
1086             rt               = _mm256_mul_pd(r22,vftabscale);
1087             vfitab           = _mm256_cvttpd_epi32(rt);
1088             vfeps            = _mm256_sub_pd(rt,_mm256_round_pd(rt, _MM_FROUND_FLOOR));
1089             vfitab           = _mm_slli_epi32(vfitab,2);
1090
1091             /* CUBIC SPLINE TABLE ELECTROSTATICS */
1092             Y                = _mm256_load_pd( vftab + _mm_extract_epi32(vfitab,0) );
1093             F                = _mm256_load_pd( vftab + _mm_extract_epi32(vfitab,1) );
1094             G                = _mm256_load_pd( vftab + _mm_extract_epi32(vfitab,2) );
1095             H                = _mm256_load_pd( vftab + _mm_extract_epi32(vfitab,3) );
1096             GMX_MM256_FULLTRANSPOSE4_PD(Y,F,G,H);
1097             Heps             = _mm256_mul_pd(vfeps,H);
1098             Fp               = _mm256_add_pd(F,_mm256_mul_pd(vfeps,_mm256_add_pd(G,Heps)));
1099             VV               = _mm256_add_pd(Y,_mm256_mul_pd(vfeps,Fp));
1100             velec            = _mm256_mul_pd(qq22,VV);
1101             FF               = _mm256_add_pd(Fp,_mm256_mul_pd(vfeps,_mm256_add_pd(G,_mm256_add_pd(Heps,Heps))));
1102             felec            = _mm256_xor_pd(signbit,_mm256_mul_pd(_mm256_mul_pd(qq22,FF),_mm256_mul_pd(vftabscale,rinv22)));
1103
1104             /* Update potential sum for this i atom from the interaction with this j atom. */
1105             velec            = _mm256_andnot_pd(dummy_mask,velec);
1106             velecsum         = _mm256_add_pd(velecsum,velec);
1107
1108             fscal            = felec;
1109
1110             fscal            = _mm256_andnot_pd(dummy_mask,fscal);
1111
1112             /* Calculate temporary vectorial force */
1113             tx               = _mm256_mul_pd(fscal,dx22);
1114             ty               = _mm256_mul_pd(fscal,dy22);
1115             tz               = _mm256_mul_pd(fscal,dz22);
1116
1117             /* Update vectorial force */
1118             fix2             = _mm256_add_pd(fix2,tx);
1119             fiy2             = _mm256_add_pd(fiy2,ty);
1120             fiz2             = _mm256_add_pd(fiz2,tz);
1121
1122             fjx2             = _mm256_add_pd(fjx2,tx);
1123             fjy2             = _mm256_add_pd(fjy2,ty);
1124             fjz2             = _mm256_add_pd(fjz2,tz);
1125
1126             /**************************
1127              * CALCULATE INTERACTIONS *
1128              **************************/
1129
1130             r23              = _mm256_mul_pd(rsq23,rinv23);
1131             r23              = _mm256_andnot_pd(dummy_mask,r23);
1132
1133             /* Calculate table index by multiplying r with table scale and truncate to integer */
1134             rt               = _mm256_mul_pd(r23,vftabscale);
1135             vfitab           = _mm256_cvttpd_epi32(rt);
1136             vfeps            = _mm256_sub_pd(rt,_mm256_round_pd(rt, _MM_FROUND_FLOOR));
1137             vfitab           = _mm_slli_epi32(vfitab,2);
1138
1139             /* CUBIC SPLINE TABLE ELECTROSTATICS */
1140             Y                = _mm256_load_pd( vftab + _mm_extract_epi32(vfitab,0) );
1141             F                = _mm256_load_pd( vftab + _mm_extract_epi32(vfitab,1) );
1142             G                = _mm256_load_pd( vftab + _mm_extract_epi32(vfitab,2) );
1143             H                = _mm256_load_pd( vftab + _mm_extract_epi32(vfitab,3) );
1144             GMX_MM256_FULLTRANSPOSE4_PD(Y,F,G,H);
1145             Heps             = _mm256_mul_pd(vfeps,H);
1146             Fp               = _mm256_add_pd(F,_mm256_mul_pd(vfeps,_mm256_add_pd(G,Heps)));
1147             VV               = _mm256_add_pd(Y,_mm256_mul_pd(vfeps,Fp));
1148             velec            = _mm256_mul_pd(qq23,VV);
1149             FF               = _mm256_add_pd(Fp,_mm256_mul_pd(vfeps,_mm256_add_pd(G,_mm256_add_pd(Heps,Heps))));
1150             felec            = _mm256_xor_pd(signbit,_mm256_mul_pd(_mm256_mul_pd(qq23,FF),_mm256_mul_pd(vftabscale,rinv23)));
1151
1152             /* Update potential sum for this i atom from the interaction with this j atom. */
1153             velec            = _mm256_andnot_pd(dummy_mask,velec);
1154             velecsum         = _mm256_add_pd(velecsum,velec);
1155
1156             fscal            = felec;
1157
1158             fscal            = _mm256_andnot_pd(dummy_mask,fscal);
1159
1160             /* Calculate temporary vectorial force */
1161             tx               = _mm256_mul_pd(fscal,dx23);
1162             ty               = _mm256_mul_pd(fscal,dy23);
1163             tz               = _mm256_mul_pd(fscal,dz23);
1164
1165             /* Update vectorial force */
1166             fix2             = _mm256_add_pd(fix2,tx);
1167             fiy2             = _mm256_add_pd(fiy2,ty);
1168             fiz2             = _mm256_add_pd(fiz2,tz);
1169
1170             fjx3             = _mm256_add_pd(fjx3,tx);
1171             fjy3             = _mm256_add_pd(fjy3,ty);
1172             fjz3             = _mm256_add_pd(fjz3,tz);
1173
1174             /**************************
1175              * CALCULATE INTERACTIONS *
1176              **************************/
1177
1178             r31              = _mm256_mul_pd(rsq31,rinv31);
1179             r31              = _mm256_andnot_pd(dummy_mask,r31);
1180
1181             /* Calculate table index by multiplying r with table scale and truncate to integer */
1182             rt               = _mm256_mul_pd(r31,vftabscale);
1183             vfitab           = _mm256_cvttpd_epi32(rt);
1184             vfeps            = _mm256_sub_pd(rt,_mm256_round_pd(rt, _MM_FROUND_FLOOR));
1185             vfitab           = _mm_slli_epi32(vfitab,2);
1186
1187             /* CUBIC SPLINE TABLE ELECTROSTATICS */
1188             Y                = _mm256_load_pd( vftab + _mm_extract_epi32(vfitab,0) );
1189             F                = _mm256_load_pd( vftab + _mm_extract_epi32(vfitab,1) );
1190             G                = _mm256_load_pd( vftab + _mm_extract_epi32(vfitab,2) );
1191             H                = _mm256_load_pd( vftab + _mm_extract_epi32(vfitab,3) );
1192             GMX_MM256_FULLTRANSPOSE4_PD(Y,F,G,H);
1193             Heps             = _mm256_mul_pd(vfeps,H);
1194             Fp               = _mm256_add_pd(F,_mm256_mul_pd(vfeps,_mm256_add_pd(G,Heps)));
1195             VV               = _mm256_add_pd(Y,_mm256_mul_pd(vfeps,Fp));
1196             velec            = _mm256_mul_pd(qq31,VV);
1197             FF               = _mm256_add_pd(Fp,_mm256_mul_pd(vfeps,_mm256_add_pd(G,_mm256_add_pd(Heps,Heps))));
1198             felec            = _mm256_xor_pd(signbit,_mm256_mul_pd(_mm256_mul_pd(qq31,FF),_mm256_mul_pd(vftabscale,rinv31)));
1199
1200             /* Update potential sum for this i atom from the interaction with this j atom. */
1201             velec            = _mm256_andnot_pd(dummy_mask,velec);
1202             velecsum         = _mm256_add_pd(velecsum,velec);
1203
1204             fscal            = felec;
1205
1206             fscal            = _mm256_andnot_pd(dummy_mask,fscal);
1207
1208             /* Calculate temporary vectorial force */
1209             tx               = _mm256_mul_pd(fscal,dx31);
1210             ty               = _mm256_mul_pd(fscal,dy31);
1211             tz               = _mm256_mul_pd(fscal,dz31);
1212
1213             /* Update vectorial force */
1214             fix3             = _mm256_add_pd(fix3,tx);
1215             fiy3             = _mm256_add_pd(fiy3,ty);
1216             fiz3             = _mm256_add_pd(fiz3,tz);
1217
1218             fjx1             = _mm256_add_pd(fjx1,tx);
1219             fjy1             = _mm256_add_pd(fjy1,ty);
1220             fjz1             = _mm256_add_pd(fjz1,tz);
1221
1222             /**************************
1223              * CALCULATE INTERACTIONS *
1224              **************************/
1225
1226             r32              = _mm256_mul_pd(rsq32,rinv32);
1227             r32              = _mm256_andnot_pd(dummy_mask,r32);
1228
1229             /* Calculate table index by multiplying r with table scale and truncate to integer */
1230             rt               = _mm256_mul_pd(r32,vftabscale);
1231             vfitab           = _mm256_cvttpd_epi32(rt);
1232             vfeps            = _mm256_sub_pd(rt,_mm256_round_pd(rt, _MM_FROUND_FLOOR));
1233             vfitab           = _mm_slli_epi32(vfitab,2);
1234
1235             /* CUBIC SPLINE TABLE ELECTROSTATICS */
1236             Y                = _mm256_load_pd( vftab + _mm_extract_epi32(vfitab,0) );
1237             F                = _mm256_load_pd( vftab + _mm_extract_epi32(vfitab,1) );
1238             G                = _mm256_load_pd( vftab + _mm_extract_epi32(vfitab,2) );
1239             H                = _mm256_load_pd( vftab + _mm_extract_epi32(vfitab,3) );
1240             GMX_MM256_FULLTRANSPOSE4_PD(Y,F,G,H);
1241             Heps             = _mm256_mul_pd(vfeps,H);
1242             Fp               = _mm256_add_pd(F,_mm256_mul_pd(vfeps,_mm256_add_pd(G,Heps)));
1243             VV               = _mm256_add_pd(Y,_mm256_mul_pd(vfeps,Fp));
1244             velec            = _mm256_mul_pd(qq32,VV);
1245             FF               = _mm256_add_pd(Fp,_mm256_mul_pd(vfeps,_mm256_add_pd(G,_mm256_add_pd(Heps,Heps))));
1246             felec            = _mm256_xor_pd(signbit,_mm256_mul_pd(_mm256_mul_pd(qq32,FF),_mm256_mul_pd(vftabscale,rinv32)));
1247
1248             /* Update potential sum for this i atom from the interaction with this j atom. */
1249             velec            = _mm256_andnot_pd(dummy_mask,velec);
1250             velecsum         = _mm256_add_pd(velecsum,velec);
1251
1252             fscal            = felec;
1253
1254             fscal            = _mm256_andnot_pd(dummy_mask,fscal);
1255
1256             /* Calculate temporary vectorial force */
1257             tx               = _mm256_mul_pd(fscal,dx32);
1258             ty               = _mm256_mul_pd(fscal,dy32);
1259             tz               = _mm256_mul_pd(fscal,dz32);
1260
1261             /* Update vectorial force */
1262             fix3             = _mm256_add_pd(fix3,tx);
1263             fiy3             = _mm256_add_pd(fiy3,ty);
1264             fiz3             = _mm256_add_pd(fiz3,tz);
1265
1266             fjx2             = _mm256_add_pd(fjx2,tx);
1267             fjy2             = _mm256_add_pd(fjy2,ty);
1268             fjz2             = _mm256_add_pd(fjz2,tz);
1269
1270             /**************************
1271              * CALCULATE INTERACTIONS *
1272              **************************/
1273
1274             r33              = _mm256_mul_pd(rsq33,rinv33);
1275             r33              = _mm256_andnot_pd(dummy_mask,r33);
1276
1277             /* Calculate table index by multiplying r with table scale and truncate to integer */
1278             rt               = _mm256_mul_pd(r33,vftabscale);
1279             vfitab           = _mm256_cvttpd_epi32(rt);
1280             vfeps            = _mm256_sub_pd(rt,_mm256_round_pd(rt, _MM_FROUND_FLOOR));
1281             vfitab           = _mm_slli_epi32(vfitab,2);
1282
1283             /* CUBIC SPLINE TABLE ELECTROSTATICS */
1284             Y                = _mm256_load_pd( vftab + _mm_extract_epi32(vfitab,0) );
1285             F                = _mm256_load_pd( vftab + _mm_extract_epi32(vfitab,1) );
1286             G                = _mm256_load_pd( vftab + _mm_extract_epi32(vfitab,2) );
1287             H                = _mm256_load_pd( vftab + _mm_extract_epi32(vfitab,3) );
1288             GMX_MM256_FULLTRANSPOSE4_PD(Y,F,G,H);
1289             Heps             = _mm256_mul_pd(vfeps,H);
1290             Fp               = _mm256_add_pd(F,_mm256_mul_pd(vfeps,_mm256_add_pd(G,Heps)));
1291             VV               = _mm256_add_pd(Y,_mm256_mul_pd(vfeps,Fp));
1292             velec            = _mm256_mul_pd(qq33,VV);
1293             FF               = _mm256_add_pd(Fp,_mm256_mul_pd(vfeps,_mm256_add_pd(G,_mm256_add_pd(Heps,Heps))));
1294             felec            = _mm256_xor_pd(signbit,_mm256_mul_pd(_mm256_mul_pd(qq33,FF),_mm256_mul_pd(vftabscale,rinv33)));
1295
1296             /* Update potential sum for this i atom from the interaction with this j atom. */
1297             velec            = _mm256_andnot_pd(dummy_mask,velec);
1298             velecsum         = _mm256_add_pd(velecsum,velec);
1299
1300             fscal            = felec;
1301
1302             fscal            = _mm256_andnot_pd(dummy_mask,fscal);
1303
1304             /* Calculate temporary vectorial force */
1305             tx               = _mm256_mul_pd(fscal,dx33);
1306             ty               = _mm256_mul_pd(fscal,dy33);
1307             tz               = _mm256_mul_pd(fscal,dz33);
1308
1309             /* Update vectorial force */
1310             fix3             = _mm256_add_pd(fix3,tx);
1311             fiy3             = _mm256_add_pd(fiy3,ty);
1312             fiz3             = _mm256_add_pd(fiz3,tz);
1313
1314             fjx3             = _mm256_add_pd(fjx3,tx);
1315             fjy3             = _mm256_add_pd(fjy3,ty);
1316             fjz3             = _mm256_add_pd(fjz3,tz);
1317
1318             fjptrA             = (jnrlistA>=0) ? f+j_coord_offsetA : scratch;
1319             fjptrB             = (jnrlistB>=0) ? f+j_coord_offsetB : scratch;
1320             fjptrC             = (jnrlistC>=0) ? f+j_coord_offsetC : scratch;
1321             fjptrD             = (jnrlistD>=0) ? f+j_coord_offsetD : scratch;
1322
1323             gmx_mm256_decrement_4rvec_4ptr_swizzle_pd(fjptrA,fjptrB,fjptrC,fjptrD,
1324                                                       fjx0,fjy0,fjz0,fjx1,fjy1,fjz1,
1325                                                       fjx2,fjy2,fjz2,fjx3,fjy3,fjz3);
1326
1327             /* Inner loop uses 431 flops */
1328         }
1329
1330         /* End of innermost loop */
1331
1332         gmx_mm256_update_iforce_4atom_swizzle_pd(fix0,fiy0,fiz0,fix1,fiy1,fiz1,fix2,fiy2,fiz2,fix3,fiy3,fiz3,
1333                                                  f+i_coord_offset,fshift+i_shift_offset);
1334
1335         ggid                        = gid[iidx];
1336         /* Update potential energies */
1337         gmx_mm256_update_1pot_pd(velecsum,kernel_data->energygrp_elec+ggid);
1338         gmx_mm256_update_1pot_pd(vvdwsum,kernel_data->energygrp_vdw+ggid);
1339
1340         /* Increment number of inner iterations */
1341         inneriter                  += j_index_end - j_index_start;
1342
1343         /* Outer loop uses 26 flops */
1344     }
1345
1346     /* Increment number of outer iterations */
1347     outeriter        += nri;
1348
1349     /* Update outer/inner flops */
1350
1351     inc_nrnb(nrnb,eNR_NBKERNEL_ELEC_VDW_W4W4_VF,outeriter*26 + inneriter*431);
1352 }
1353 /*
1354  * Gromacs nonbonded kernel:   nb_kernel_ElecCSTab_VdwLJ_GeomW4W4_F_avx_256_double
1355  * Electrostatics interaction: CubicSplineTable
1356  * VdW interaction:            LennardJones
1357  * Geometry:                   Water4-Water4
1358  * Calculate force/pot:        Force
1359  */
1360 void
1361 nb_kernel_ElecCSTab_VdwLJ_GeomW4W4_F_avx_256_double
1362                     (t_nblist                    * gmx_restrict       nlist,
1363                      rvec                        * gmx_restrict          xx,
1364                      rvec                        * gmx_restrict          ff,
1365                      t_forcerec                  * gmx_restrict          fr,
1366                      t_mdatoms                   * gmx_restrict     mdatoms,
1367                      nb_kernel_data_t gmx_unused * gmx_restrict kernel_data,
1368                      t_nrnb                      * gmx_restrict        nrnb)
1369 {
1370     /* Suffixes 0,1,2,3 refer to particle indices for waters in the inner or outer loop, or
1371      * just 0 for non-waters.
1372      * Suffixes A,B,C,D refer to j loop unrolling done with AVX, e.g. for the four different
1373      * jnr indices corresponding to data put in the four positions in the SIMD register.
1374      */
1375     int              i_shift_offset,i_coord_offset,outeriter,inneriter;
1376     int              j_index_start,j_index_end,jidx,nri,inr,ggid,iidx;
1377     int              jnrA,jnrB,jnrC,jnrD;
1378     int              jnrlistA,jnrlistB,jnrlistC,jnrlistD;
1379     int              jnrlistE,jnrlistF,jnrlistG,jnrlistH;
1380     int              j_coord_offsetA,j_coord_offsetB,j_coord_offsetC,j_coord_offsetD;
1381     int              *iinr,*jindex,*jjnr,*shiftidx,*gid;
1382     real             rcutoff_scalar;
1383     real             *shiftvec,*fshift,*x,*f;
1384     real             *fjptrA,*fjptrB,*fjptrC,*fjptrD;
1385     real             scratch[4*DIM];
1386     __m256d          tx,ty,tz,fscal,rcutoff,rcutoff2,jidxall;
1387     real *           vdwioffsetptr0;
1388     __m256d          ix0,iy0,iz0,fix0,fiy0,fiz0,iq0,isai0;
1389     real *           vdwioffsetptr1;
1390     __m256d          ix1,iy1,iz1,fix1,fiy1,fiz1,iq1,isai1;
1391     real *           vdwioffsetptr2;
1392     __m256d          ix2,iy2,iz2,fix2,fiy2,fiz2,iq2,isai2;
1393     real *           vdwioffsetptr3;
1394     __m256d          ix3,iy3,iz3,fix3,fiy3,fiz3,iq3,isai3;
1395     int              vdwjidx0A,vdwjidx0B,vdwjidx0C,vdwjidx0D;
1396     __m256d          jx0,jy0,jz0,fjx0,fjy0,fjz0,jq0,isaj0;
1397     int              vdwjidx1A,vdwjidx1B,vdwjidx1C,vdwjidx1D;
1398     __m256d          jx1,jy1,jz1,fjx1,fjy1,fjz1,jq1,isaj1;
1399     int              vdwjidx2A,vdwjidx2B,vdwjidx2C,vdwjidx2D;
1400     __m256d          jx2,jy2,jz2,fjx2,fjy2,fjz2,jq2,isaj2;
1401     int              vdwjidx3A,vdwjidx3B,vdwjidx3C,vdwjidx3D;
1402     __m256d          jx3,jy3,jz3,fjx3,fjy3,fjz3,jq3,isaj3;
1403     __m256d          dx00,dy00,dz00,rsq00,rinv00,rinvsq00,r00,qq00,c6_00,c12_00;
1404     __m256d          dx11,dy11,dz11,rsq11,rinv11,rinvsq11,r11,qq11,c6_11,c12_11;
1405     __m256d          dx12,dy12,dz12,rsq12,rinv12,rinvsq12,r12,qq12,c6_12,c12_12;
1406     __m256d          dx13,dy13,dz13,rsq13,rinv13,rinvsq13,r13,qq13,c6_13,c12_13;
1407     __m256d          dx21,dy21,dz21,rsq21,rinv21,rinvsq21,r21,qq21,c6_21,c12_21;
1408     __m256d          dx22,dy22,dz22,rsq22,rinv22,rinvsq22,r22,qq22,c6_22,c12_22;
1409     __m256d          dx23,dy23,dz23,rsq23,rinv23,rinvsq23,r23,qq23,c6_23,c12_23;
1410     __m256d          dx31,dy31,dz31,rsq31,rinv31,rinvsq31,r31,qq31,c6_31,c12_31;
1411     __m256d          dx32,dy32,dz32,rsq32,rinv32,rinvsq32,r32,qq32,c6_32,c12_32;
1412     __m256d          dx33,dy33,dz33,rsq33,rinv33,rinvsq33,r33,qq33,c6_33,c12_33;
1413     __m256d          velec,felec,velecsum,facel,crf,krf,krf2;
1414     real             *charge;
1415     int              nvdwtype;
1416     __m256d          rinvsix,rvdw,vvdw,vvdw6,vvdw12,fvdw,fvdw6,fvdw12,vvdwsum,sh_vdw_invrcut6;
1417     int              *vdwtype;
1418     real             *vdwparam;
1419     __m256d          one_sixth   = _mm256_set1_pd(1.0/6.0);
1420     __m256d          one_twelfth = _mm256_set1_pd(1.0/12.0);
1421     __m128i          vfitab;
1422     __m128i          ifour       = _mm_set1_epi32(4);
1423     __m256d          rt,vfeps,vftabscale,Y,F,G,H,Heps,Fp,VV,FF;
1424     real             *vftab;
1425     __m256d          dummy_mask,cutoff_mask;
1426     __m128           tmpmask0,tmpmask1;
1427     __m256d          signbit = _mm256_castsi256_pd( _mm256_set1_epi32(0x80000000) );
1428     __m256d          one     = _mm256_set1_pd(1.0);
1429     __m256d          two     = _mm256_set1_pd(2.0);
1430     x                = xx[0];
1431     f                = ff[0];
1432
1433     nri              = nlist->nri;
1434     iinr             = nlist->iinr;
1435     jindex           = nlist->jindex;
1436     jjnr             = nlist->jjnr;
1437     shiftidx         = nlist->shift;
1438     gid              = nlist->gid;
1439     shiftvec         = fr->shift_vec[0];
1440     fshift           = fr->fshift[0];
1441     facel            = _mm256_set1_pd(fr->epsfac);
1442     charge           = mdatoms->chargeA;
1443     nvdwtype         = fr->ntype;
1444     vdwparam         = fr->nbfp;
1445     vdwtype          = mdatoms->typeA;
1446
1447     vftab            = kernel_data->table_elec->data;
1448     vftabscale       = _mm256_set1_pd(kernel_data->table_elec->scale);
1449
1450     /* Setup water-specific parameters */
1451     inr              = nlist->iinr[0];
1452     iq1              = _mm256_mul_pd(facel,_mm256_set1_pd(charge[inr+1]));
1453     iq2              = _mm256_mul_pd(facel,_mm256_set1_pd(charge[inr+2]));
1454     iq3              = _mm256_mul_pd(facel,_mm256_set1_pd(charge[inr+3]));
1455     vdwioffsetptr0   = vdwparam+2*nvdwtype*vdwtype[inr+0];
1456
1457     jq1              = _mm256_set1_pd(charge[inr+1]);
1458     jq2              = _mm256_set1_pd(charge[inr+2]);
1459     jq3              = _mm256_set1_pd(charge[inr+3]);
1460     vdwjidx0A        = 2*vdwtype[inr+0];
1461     c6_00            = _mm256_set1_pd(vdwioffsetptr0[vdwjidx0A]);
1462     c12_00           = _mm256_set1_pd(vdwioffsetptr0[vdwjidx0A+1]);
1463     qq11             = _mm256_mul_pd(iq1,jq1);
1464     qq12             = _mm256_mul_pd(iq1,jq2);
1465     qq13             = _mm256_mul_pd(iq1,jq3);
1466     qq21             = _mm256_mul_pd(iq2,jq1);
1467     qq22             = _mm256_mul_pd(iq2,jq2);
1468     qq23             = _mm256_mul_pd(iq2,jq3);
1469     qq31             = _mm256_mul_pd(iq3,jq1);
1470     qq32             = _mm256_mul_pd(iq3,jq2);
1471     qq33             = _mm256_mul_pd(iq3,jq3);
1472
1473     /* Avoid stupid compiler warnings */
1474     jnrA = jnrB = jnrC = jnrD = 0;
1475     j_coord_offsetA = 0;
1476     j_coord_offsetB = 0;
1477     j_coord_offsetC = 0;
1478     j_coord_offsetD = 0;
1479
1480     outeriter        = 0;
1481     inneriter        = 0;
1482
1483     for(iidx=0;iidx<4*DIM;iidx++)
1484     {
1485         scratch[iidx] = 0.0;
1486     }
1487
1488     /* Start outer loop over neighborlists */
1489     for(iidx=0; iidx<nri; iidx++)
1490     {
1491         /* Load shift vector for this list */
1492         i_shift_offset   = DIM*shiftidx[iidx];
1493
1494         /* Load limits for loop over neighbors */
1495         j_index_start    = jindex[iidx];
1496         j_index_end      = jindex[iidx+1];
1497
1498         /* Get outer coordinate index */
1499         inr              = iinr[iidx];
1500         i_coord_offset   = DIM*inr;
1501
1502         /* Load i particle coords and add shift vector */
1503         gmx_mm256_load_shift_and_4rvec_broadcast_pd(shiftvec+i_shift_offset,x+i_coord_offset,
1504                                                     &ix0,&iy0,&iz0,&ix1,&iy1,&iz1,&ix2,&iy2,&iz2,&ix3,&iy3,&iz3);
1505
1506         fix0             = _mm256_setzero_pd();
1507         fiy0             = _mm256_setzero_pd();
1508         fiz0             = _mm256_setzero_pd();
1509         fix1             = _mm256_setzero_pd();
1510         fiy1             = _mm256_setzero_pd();
1511         fiz1             = _mm256_setzero_pd();
1512         fix2             = _mm256_setzero_pd();
1513         fiy2             = _mm256_setzero_pd();
1514         fiz2             = _mm256_setzero_pd();
1515         fix3             = _mm256_setzero_pd();
1516         fiy3             = _mm256_setzero_pd();
1517         fiz3             = _mm256_setzero_pd();
1518
1519         /* Start inner kernel loop */
1520         for(jidx=j_index_start; jidx<j_index_end && jjnr[jidx+3]>=0; jidx+=4)
1521         {
1522
1523             /* Get j neighbor index, and coordinate index */
1524             jnrA             = jjnr[jidx];
1525             jnrB             = jjnr[jidx+1];
1526             jnrC             = jjnr[jidx+2];
1527             jnrD             = jjnr[jidx+3];
1528             j_coord_offsetA  = DIM*jnrA;
1529             j_coord_offsetB  = DIM*jnrB;
1530             j_coord_offsetC  = DIM*jnrC;
1531             j_coord_offsetD  = DIM*jnrD;
1532
1533             /* load j atom coordinates */
1534             gmx_mm256_load_4rvec_4ptr_swizzle_pd(x+j_coord_offsetA,x+j_coord_offsetB,
1535                                                  x+j_coord_offsetC,x+j_coord_offsetD,
1536                                                  &jx0,&jy0,&jz0,&jx1,&jy1,&jz1,&jx2,
1537                                                  &jy2,&jz2,&jx3,&jy3,&jz3);
1538
1539             /* Calculate displacement vector */
1540             dx00             = _mm256_sub_pd(ix0,jx0);
1541             dy00             = _mm256_sub_pd(iy0,jy0);
1542             dz00             = _mm256_sub_pd(iz0,jz0);
1543             dx11             = _mm256_sub_pd(ix1,jx1);
1544             dy11             = _mm256_sub_pd(iy1,jy1);
1545             dz11             = _mm256_sub_pd(iz1,jz1);
1546             dx12             = _mm256_sub_pd(ix1,jx2);
1547             dy12             = _mm256_sub_pd(iy1,jy2);
1548             dz12             = _mm256_sub_pd(iz1,jz2);
1549             dx13             = _mm256_sub_pd(ix1,jx3);
1550             dy13             = _mm256_sub_pd(iy1,jy3);
1551             dz13             = _mm256_sub_pd(iz1,jz3);
1552             dx21             = _mm256_sub_pd(ix2,jx1);
1553             dy21             = _mm256_sub_pd(iy2,jy1);
1554             dz21             = _mm256_sub_pd(iz2,jz1);
1555             dx22             = _mm256_sub_pd(ix2,jx2);
1556             dy22             = _mm256_sub_pd(iy2,jy2);
1557             dz22             = _mm256_sub_pd(iz2,jz2);
1558             dx23             = _mm256_sub_pd(ix2,jx3);
1559             dy23             = _mm256_sub_pd(iy2,jy3);
1560             dz23             = _mm256_sub_pd(iz2,jz3);
1561             dx31             = _mm256_sub_pd(ix3,jx1);
1562             dy31             = _mm256_sub_pd(iy3,jy1);
1563             dz31             = _mm256_sub_pd(iz3,jz1);
1564             dx32             = _mm256_sub_pd(ix3,jx2);
1565             dy32             = _mm256_sub_pd(iy3,jy2);
1566             dz32             = _mm256_sub_pd(iz3,jz2);
1567             dx33             = _mm256_sub_pd(ix3,jx3);
1568             dy33             = _mm256_sub_pd(iy3,jy3);
1569             dz33             = _mm256_sub_pd(iz3,jz3);
1570
1571             /* Calculate squared distance and things based on it */
1572             rsq00            = gmx_mm256_calc_rsq_pd(dx00,dy00,dz00);
1573             rsq11            = gmx_mm256_calc_rsq_pd(dx11,dy11,dz11);
1574             rsq12            = gmx_mm256_calc_rsq_pd(dx12,dy12,dz12);
1575             rsq13            = gmx_mm256_calc_rsq_pd(dx13,dy13,dz13);
1576             rsq21            = gmx_mm256_calc_rsq_pd(dx21,dy21,dz21);
1577             rsq22            = gmx_mm256_calc_rsq_pd(dx22,dy22,dz22);
1578             rsq23            = gmx_mm256_calc_rsq_pd(dx23,dy23,dz23);
1579             rsq31            = gmx_mm256_calc_rsq_pd(dx31,dy31,dz31);
1580             rsq32            = gmx_mm256_calc_rsq_pd(dx32,dy32,dz32);
1581             rsq33            = gmx_mm256_calc_rsq_pd(dx33,dy33,dz33);
1582
1583             rinv11           = gmx_mm256_invsqrt_pd(rsq11);
1584             rinv12           = gmx_mm256_invsqrt_pd(rsq12);
1585             rinv13           = gmx_mm256_invsqrt_pd(rsq13);
1586             rinv21           = gmx_mm256_invsqrt_pd(rsq21);
1587             rinv22           = gmx_mm256_invsqrt_pd(rsq22);
1588             rinv23           = gmx_mm256_invsqrt_pd(rsq23);
1589             rinv31           = gmx_mm256_invsqrt_pd(rsq31);
1590             rinv32           = gmx_mm256_invsqrt_pd(rsq32);
1591             rinv33           = gmx_mm256_invsqrt_pd(rsq33);
1592
1593             rinvsq00         = gmx_mm256_inv_pd(rsq00);
1594
1595             fjx0             = _mm256_setzero_pd();
1596             fjy0             = _mm256_setzero_pd();
1597             fjz0             = _mm256_setzero_pd();
1598             fjx1             = _mm256_setzero_pd();
1599             fjy1             = _mm256_setzero_pd();
1600             fjz1             = _mm256_setzero_pd();
1601             fjx2             = _mm256_setzero_pd();
1602             fjy2             = _mm256_setzero_pd();
1603             fjz2             = _mm256_setzero_pd();
1604             fjx3             = _mm256_setzero_pd();
1605             fjy3             = _mm256_setzero_pd();
1606             fjz3             = _mm256_setzero_pd();
1607
1608             /**************************
1609              * CALCULATE INTERACTIONS *
1610              **************************/
1611
1612             /* LENNARD-JONES DISPERSION/REPULSION */
1613
1614             rinvsix          = _mm256_mul_pd(_mm256_mul_pd(rinvsq00,rinvsq00),rinvsq00);
1615             fvdw             = _mm256_mul_pd(_mm256_sub_pd(_mm256_mul_pd(c12_00,rinvsix),c6_00),_mm256_mul_pd(rinvsix,rinvsq00));
1616
1617             fscal            = fvdw;
1618
1619             /* Calculate temporary vectorial force */
1620             tx               = _mm256_mul_pd(fscal,dx00);
1621             ty               = _mm256_mul_pd(fscal,dy00);
1622             tz               = _mm256_mul_pd(fscal,dz00);
1623
1624             /* Update vectorial force */
1625             fix0             = _mm256_add_pd(fix0,tx);
1626             fiy0             = _mm256_add_pd(fiy0,ty);
1627             fiz0             = _mm256_add_pd(fiz0,tz);
1628
1629             fjx0             = _mm256_add_pd(fjx0,tx);
1630             fjy0             = _mm256_add_pd(fjy0,ty);
1631             fjz0             = _mm256_add_pd(fjz0,tz);
1632
1633             /**************************
1634              * CALCULATE INTERACTIONS *
1635              **************************/
1636
1637             r11              = _mm256_mul_pd(rsq11,rinv11);
1638
1639             /* Calculate table index by multiplying r with table scale and truncate to integer */
1640             rt               = _mm256_mul_pd(r11,vftabscale);
1641             vfitab           = _mm256_cvttpd_epi32(rt);
1642             vfeps            = _mm256_sub_pd(rt,_mm256_round_pd(rt, _MM_FROUND_FLOOR));
1643             vfitab           = _mm_slli_epi32(vfitab,2);
1644
1645             /* CUBIC SPLINE TABLE ELECTROSTATICS */
1646             Y                = _mm256_load_pd( vftab + _mm_extract_epi32(vfitab,0) );
1647             F                = _mm256_load_pd( vftab + _mm_extract_epi32(vfitab,1) );
1648             G                = _mm256_load_pd( vftab + _mm_extract_epi32(vfitab,2) );
1649             H                = _mm256_load_pd( vftab + _mm_extract_epi32(vfitab,3) );
1650             GMX_MM256_FULLTRANSPOSE4_PD(Y,F,G,H);
1651             Heps             = _mm256_mul_pd(vfeps,H);
1652             Fp               = _mm256_add_pd(F,_mm256_mul_pd(vfeps,_mm256_add_pd(G,Heps)));
1653             FF               = _mm256_add_pd(Fp,_mm256_mul_pd(vfeps,_mm256_add_pd(G,_mm256_add_pd(Heps,Heps))));
1654             felec            = _mm256_xor_pd(signbit,_mm256_mul_pd(_mm256_mul_pd(qq11,FF),_mm256_mul_pd(vftabscale,rinv11)));
1655
1656             fscal            = felec;
1657
1658             /* Calculate temporary vectorial force */
1659             tx               = _mm256_mul_pd(fscal,dx11);
1660             ty               = _mm256_mul_pd(fscal,dy11);
1661             tz               = _mm256_mul_pd(fscal,dz11);
1662
1663             /* Update vectorial force */
1664             fix1             = _mm256_add_pd(fix1,tx);
1665             fiy1             = _mm256_add_pd(fiy1,ty);
1666             fiz1             = _mm256_add_pd(fiz1,tz);
1667
1668             fjx1             = _mm256_add_pd(fjx1,tx);
1669             fjy1             = _mm256_add_pd(fjy1,ty);
1670             fjz1             = _mm256_add_pd(fjz1,tz);
1671
1672             /**************************
1673              * CALCULATE INTERACTIONS *
1674              **************************/
1675
1676             r12              = _mm256_mul_pd(rsq12,rinv12);
1677
1678             /* Calculate table index by multiplying r with table scale and truncate to integer */
1679             rt               = _mm256_mul_pd(r12,vftabscale);
1680             vfitab           = _mm256_cvttpd_epi32(rt);
1681             vfeps            = _mm256_sub_pd(rt,_mm256_round_pd(rt, _MM_FROUND_FLOOR));
1682             vfitab           = _mm_slli_epi32(vfitab,2);
1683
1684             /* CUBIC SPLINE TABLE ELECTROSTATICS */
1685             Y                = _mm256_load_pd( vftab + _mm_extract_epi32(vfitab,0) );
1686             F                = _mm256_load_pd( vftab + _mm_extract_epi32(vfitab,1) );
1687             G                = _mm256_load_pd( vftab + _mm_extract_epi32(vfitab,2) );
1688             H                = _mm256_load_pd( vftab + _mm_extract_epi32(vfitab,3) );
1689             GMX_MM256_FULLTRANSPOSE4_PD(Y,F,G,H);
1690             Heps             = _mm256_mul_pd(vfeps,H);
1691             Fp               = _mm256_add_pd(F,_mm256_mul_pd(vfeps,_mm256_add_pd(G,Heps)));
1692             FF               = _mm256_add_pd(Fp,_mm256_mul_pd(vfeps,_mm256_add_pd(G,_mm256_add_pd(Heps,Heps))));
1693             felec            = _mm256_xor_pd(signbit,_mm256_mul_pd(_mm256_mul_pd(qq12,FF),_mm256_mul_pd(vftabscale,rinv12)));
1694
1695             fscal            = felec;
1696
1697             /* Calculate temporary vectorial force */
1698             tx               = _mm256_mul_pd(fscal,dx12);
1699             ty               = _mm256_mul_pd(fscal,dy12);
1700             tz               = _mm256_mul_pd(fscal,dz12);
1701
1702             /* Update vectorial force */
1703             fix1             = _mm256_add_pd(fix1,tx);
1704             fiy1             = _mm256_add_pd(fiy1,ty);
1705             fiz1             = _mm256_add_pd(fiz1,tz);
1706
1707             fjx2             = _mm256_add_pd(fjx2,tx);
1708             fjy2             = _mm256_add_pd(fjy2,ty);
1709             fjz2             = _mm256_add_pd(fjz2,tz);
1710
1711             /**************************
1712              * CALCULATE INTERACTIONS *
1713              **************************/
1714
1715             r13              = _mm256_mul_pd(rsq13,rinv13);
1716
1717             /* Calculate table index by multiplying r with table scale and truncate to integer */
1718             rt               = _mm256_mul_pd(r13,vftabscale);
1719             vfitab           = _mm256_cvttpd_epi32(rt);
1720             vfeps            = _mm256_sub_pd(rt,_mm256_round_pd(rt, _MM_FROUND_FLOOR));
1721             vfitab           = _mm_slli_epi32(vfitab,2);
1722
1723             /* CUBIC SPLINE TABLE ELECTROSTATICS */
1724             Y                = _mm256_load_pd( vftab + _mm_extract_epi32(vfitab,0) );
1725             F                = _mm256_load_pd( vftab + _mm_extract_epi32(vfitab,1) );
1726             G                = _mm256_load_pd( vftab + _mm_extract_epi32(vfitab,2) );
1727             H                = _mm256_load_pd( vftab + _mm_extract_epi32(vfitab,3) );
1728             GMX_MM256_FULLTRANSPOSE4_PD(Y,F,G,H);
1729             Heps             = _mm256_mul_pd(vfeps,H);
1730             Fp               = _mm256_add_pd(F,_mm256_mul_pd(vfeps,_mm256_add_pd(G,Heps)));
1731             FF               = _mm256_add_pd(Fp,_mm256_mul_pd(vfeps,_mm256_add_pd(G,_mm256_add_pd(Heps,Heps))));
1732             felec            = _mm256_xor_pd(signbit,_mm256_mul_pd(_mm256_mul_pd(qq13,FF),_mm256_mul_pd(vftabscale,rinv13)));
1733
1734             fscal            = felec;
1735
1736             /* Calculate temporary vectorial force */
1737             tx               = _mm256_mul_pd(fscal,dx13);
1738             ty               = _mm256_mul_pd(fscal,dy13);
1739             tz               = _mm256_mul_pd(fscal,dz13);
1740
1741             /* Update vectorial force */
1742             fix1             = _mm256_add_pd(fix1,tx);
1743             fiy1             = _mm256_add_pd(fiy1,ty);
1744             fiz1             = _mm256_add_pd(fiz1,tz);
1745
1746             fjx3             = _mm256_add_pd(fjx3,tx);
1747             fjy3             = _mm256_add_pd(fjy3,ty);
1748             fjz3             = _mm256_add_pd(fjz3,tz);
1749
1750             /**************************
1751              * CALCULATE INTERACTIONS *
1752              **************************/
1753
1754             r21              = _mm256_mul_pd(rsq21,rinv21);
1755
1756             /* Calculate table index by multiplying r with table scale and truncate to integer */
1757             rt               = _mm256_mul_pd(r21,vftabscale);
1758             vfitab           = _mm256_cvttpd_epi32(rt);
1759             vfeps            = _mm256_sub_pd(rt,_mm256_round_pd(rt, _MM_FROUND_FLOOR));
1760             vfitab           = _mm_slli_epi32(vfitab,2);
1761
1762             /* CUBIC SPLINE TABLE ELECTROSTATICS */
1763             Y                = _mm256_load_pd( vftab + _mm_extract_epi32(vfitab,0) );
1764             F                = _mm256_load_pd( vftab + _mm_extract_epi32(vfitab,1) );
1765             G                = _mm256_load_pd( vftab + _mm_extract_epi32(vfitab,2) );
1766             H                = _mm256_load_pd( vftab + _mm_extract_epi32(vfitab,3) );
1767             GMX_MM256_FULLTRANSPOSE4_PD(Y,F,G,H);
1768             Heps             = _mm256_mul_pd(vfeps,H);
1769             Fp               = _mm256_add_pd(F,_mm256_mul_pd(vfeps,_mm256_add_pd(G,Heps)));
1770             FF               = _mm256_add_pd(Fp,_mm256_mul_pd(vfeps,_mm256_add_pd(G,_mm256_add_pd(Heps,Heps))));
1771             felec            = _mm256_xor_pd(signbit,_mm256_mul_pd(_mm256_mul_pd(qq21,FF),_mm256_mul_pd(vftabscale,rinv21)));
1772
1773             fscal            = felec;
1774
1775             /* Calculate temporary vectorial force */
1776             tx               = _mm256_mul_pd(fscal,dx21);
1777             ty               = _mm256_mul_pd(fscal,dy21);
1778             tz               = _mm256_mul_pd(fscal,dz21);
1779
1780             /* Update vectorial force */
1781             fix2             = _mm256_add_pd(fix2,tx);
1782             fiy2             = _mm256_add_pd(fiy2,ty);
1783             fiz2             = _mm256_add_pd(fiz2,tz);
1784
1785             fjx1             = _mm256_add_pd(fjx1,tx);
1786             fjy1             = _mm256_add_pd(fjy1,ty);
1787             fjz1             = _mm256_add_pd(fjz1,tz);
1788
1789             /**************************
1790              * CALCULATE INTERACTIONS *
1791              **************************/
1792
1793             r22              = _mm256_mul_pd(rsq22,rinv22);
1794
1795             /* Calculate table index by multiplying r with table scale and truncate to integer */
1796             rt               = _mm256_mul_pd(r22,vftabscale);
1797             vfitab           = _mm256_cvttpd_epi32(rt);
1798             vfeps            = _mm256_sub_pd(rt,_mm256_round_pd(rt, _MM_FROUND_FLOOR));
1799             vfitab           = _mm_slli_epi32(vfitab,2);
1800
1801             /* CUBIC SPLINE TABLE ELECTROSTATICS */
1802             Y                = _mm256_load_pd( vftab + _mm_extract_epi32(vfitab,0) );
1803             F                = _mm256_load_pd( vftab + _mm_extract_epi32(vfitab,1) );
1804             G                = _mm256_load_pd( vftab + _mm_extract_epi32(vfitab,2) );
1805             H                = _mm256_load_pd( vftab + _mm_extract_epi32(vfitab,3) );
1806             GMX_MM256_FULLTRANSPOSE4_PD(Y,F,G,H);
1807             Heps             = _mm256_mul_pd(vfeps,H);
1808             Fp               = _mm256_add_pd(F,_mm256_mul_pd(vfeps,_mm256_add_pd(G,Heps)));
1809             FF               = _mm256_add_pd(Fp,_mm256_mul_pd(vfeps,_mm256_add_pd(G,_mm256_add_pd(Heps,Heps))));
1810             felec            = _mm256_xor_pd(signbit,_mm256_mul_pd(_mm256_mul_pd(qq22,FF),_mm256_mul_pd(vftabscale,rinv22)));
1811
1812             fscal            = felec;
1813
1814             /* Calculate temporary vectorial force */
1815             tx               = _mm256_mul_pd(fscal,dx22);
1816             ty               = _mm256_mul_pd(fscal,dy22);
1817             tz               = _mm256_mul_pd(fscal,dz22);
1818
1819             /* Update vectorial force */
1820             fix2             = _mm256_add_pd(fix2,tx);
1821             fiy2             = _mm256_add_pd(fiy2,ty);
1822             fiz2             = _mm256_add_pd(fiz2,tz);
1823
1824             fjx2             = _mm256_add_pd(fjx2,tx);
1825             fjy2             = _mm256_add_pd(fjy2,ty);
1826             fjz2             = _mm256_add_pd(fjz2,tz);
1827
1828             /**************************
1829              * CALCULATE INTERACTIONS *
1830              **************************/
1831
1832             r23              = _mm256_mul_pd(rsq23,rinv23);
1833
1834             /* Calculate table index by multiplying r with table scale and truncate to integer */
1835             rt               = _mm256_mul_pd(r23,vftabscale);
1836             vfitab           = _mm256_cvttpd_epi32(rt);
1837             vfeps            = _mm256_sub_pd(rt,_mm256_round_pd(rt, _MM_FROUND_FLOOR));
1838             vfitab           = _mm_slli_epi32(vfitab,2);
1839
1840             /* CUBIC SPLINE TABLE ELECTROSTATICS */
1841             Y                = _mm256_load_pd( vftab + _mm_extract_epi32(vfitab,0) );
1842             F                = _mm256_load_pd( vftab + _mm_extract_epi32(vfitab,1) );
1843             G                = _mm256_load_pd( vftab + _mm_extract_epi32(vfitab,2) );
1844             H                = _mm256_load_pd( vftab + _mm_extract_epi32(vfitab,3) );
1845             GMX_MM256_FULLTRANSPOSE4_PD(Y,F,G,H);
1846             Heps             = _mm256_mul_pd(vfeps,H);
1847             Fp               = _mm256_add_pd(F,_mm256_mul_pd(vfeps,_mm256_add_pd(G,Heps)));
1848             FF               = _mm256_add_pd(Fp,_mm256_mul_pd(vfeps,_mm256_add_pd(G,_mm256_add_pd(Heps,Heps))));
1849             felec            = _mm256_xor_pd(signbit,_mm256_mul_pd(_mm256_mul_pd(qq23,FF),_mm256_mul_pd(vftabscale,rinv23)));
1850
1851             fscal            = felec;
1852
1853             /* Calculate temporary vectorial force */
1854             tx               = _mm256_mul_pd(fscal,dx23);
1855             ty               = _mm256_mul_pd(fscal,dy23);
1856             tz               = _mm256_mul_pd(fscal,dz23);
1857
1858             /* Update vectorial force */
1859             fix2             = _mm256_add_pd(fix2,tx);
1860             fiy2             = _mm256_add_pd(fiy2,ty);
1861             fiz2             = _mm256_add_pd(fiz2,tz);
1862
1863             fjx3             = _mm256_add_pd(fjx3,tx);
1864             fjy3             = _mm256_add_pd(fjy3,ty);
1865             fjz3             = _mm256_add_pd(fjz3,tz);
1866
1867             /**************************
1868              * CALCULATE INTERACTIONS *
1869              **************************/
1870
1871             r31              = _mm256_mul_pd(rsq31,rinv31);
1872
1873             /* Calculate table index by multiplying r with table scale and truncate to integer */
1874             rt               = _mm256_mul_pd(r31,vftabscale);
1875             vfitab           = _mm256_cvttpd_epi32(rt);
1876             vfeps            = _mm256_sub_pd(rt,_mm256_round_pd(rt, _MM_FROUND_FLOOR));
1877             vfitab           = _mm_slli_epi32(vfitab,2);
1878
1879             /* CUBIC SPLINE TABLE ELECTROSTATICS */
1880             Y                = _mm256_load_pd( vftab + _mm_extract_epi32(vfitab,0) );
1881             F                = _mm256_load_pd( vftab + _mm_extract_epi32(vfitab,1) );
1882             G                = _mm256_load_pd( vftab + _mm_extract_epi32(vfitab,2) );
1883             H                = _mm256_load_pd( vftab + _mm_extract_epi32(vfitab,3) );
1884             GMX_MM256_FULLTRANSPOSE4_PD(Y,F,G,H);
1885             Heps             = _mm256_mul_pd(vfeps,H);
1886             Fp               = _mm256_add_pd(F,_mm256_mul_pd(vfeps,_mm256_add_pd(G,Heps)));
1887             FF               = _mm256_add_pd(Fp,_mm256_mul_pd(vfeps,_mm256_add_pd(G,_mm256_add_pd(Heps,Heps))));
1888             felec            = _mm256_xor_pd(signbit,_mm256_mul_pd(_mm256_mul_pd(qq31,FF),_mm256_mul_pd(vftabscale,rinv31)));
1889
1890             fscal            = felec;
1891
1892             /* Calculate temporary vectorial force */
1893             tx               = _mm256_mul_pd(fscal,dx31);
1894             ty               = _mm256_mul_pd(fscal,dy31);
1895             tz               = _mm256_mul_pd(fscal,dz31);
1896
1897             /* Update vectorial force */
1898             fix3             = _mm256_add_pd(fix3,tx);
1899             fiy3             = _mm256_add_pd(fiy3,ty);
1900             fiz3             = _mm256_add_pd(fiz3,tz);
1901
1902             fjx1             = _mm256_add_pd(fjx1,tx);
1903             fjy1             = _mm256_add_pd(fjy1,ty);
1904             fjz1             = _mm256_add_pd(fjz1,tz);
1905
1906             /**************************
1907              * CALCULATE INTERACTIONS *
1908              **************************/
1909
1910             r32              = _mm256_mul_pd(rsq32,rinv32);
1911
1912             /* Calculate table index by multiplying r with table scale and truncate to integer */
1913             rt               = _mm256_mul_pd(r32,vftabscale);
1914             vfitab           = _mm256_cvttpd_epi32(rt);
1915             vfeps            = _mm256_sub_pd(rt,_mm256_round_pd(rt, _MM_FROUND_FLOOR));
1916             vfitab           = _mm_slli_epi32(vfitab,2);
1917
1918             /* CUBIC SPLINE TABLE ELECTROSTATICS */
1919             Y                = _mm256_load_pd( vftab + _mm_extract_epi32(vfitab,0) );
1920             F                = _mm256_load_pd( vftab + _mm_extract_epi32(vfitab,1) );
1921             G                = _mm256_load_pd( vftab + _mm_extract_epi32(vfitab,2) );
1922             H                = _mm256_load_pd( vftab + _mm_extract_epi32(vfitab,3) );
1923             GMX_MM256_FULLTRANSPOSE4_PD(Y,F,G,H);
1924             Heps             = _mm256_mul_pd(vfeps,H);
1925             Fp               = _mm256_add_pd(F,_mm256_mul_pd(vfeps,_mm256_add_pd(G,Heps)));
1926             FF               = _mm256_add_pd(Fp,_mm256_mul_pd(vfeps,_mm256_add_pd(G,_mm256_add_pd(Heps,Heps))));
1927             felec            = _mm256_xor_pd(signbit,_mm256_mul_pd(_mm256_mul_pd(qq32,FF),_mm256_mul_pd(vftabscale,rinv32)));
1928
1929             fscal            = felec;
1930
1931             /* Calculate temporary vectorial force */
1932             tx               = _mm256_mul_pd(fscal,dx32);
1933             ty               = _mm256_mul_pd(fscal,dy32);
1934             tz               = _mm256_mul_pd(fscal,dz32);
1935
1936             /* Update vectorial force */
1937             fix3             = _mm256_add_pd(fix3,tx);
1938             fiy3             = _mm256_add_pd(fiy3,ty);
1939             fiz3             = _mm256_add_pd(fiz3,tz);
1940
1941             fjx2             = _mm256_add_pd(fjx2,tx);
1942             fjy2             = _mm256_add_pd(fjy2,ty);
1943             fjz2             = _mm256_add_pd(fjz2,tz);
1944
1945             /**************************
1946              * CALCULATE INTERACTIONS *
1947              **************************/
1948
1949             r33              = _mm256_mul_pd(rsq33,rinv33);
1950
1951             /* Calculate table index by multiplying r with table scale and truncate to integer */
1952             rt               = _mm256_mul_pd(r33,vftabscale);
1953             vfitab           = _mm256_cvttpd_epi32(rt);
1954             vfeps            = _mm256_sub_pd(rt,_mm256_round_pd(rt, _MM_FROUND_FLOOR));
1955             vfitab           = _mm_slli_epi32(vfitab,2);
1956
1957             /* CUBIC SPLINE TABLE ELECTROSTATICS */
1958             Y                = _mm256_load_pd( vftab + _mm_extract_epi32(vfitab,0) );
1959             F                = _mm256_load_pd( vftab + _mm_extract_epi32(vfitab,1) );
1960             G                = _mm256_load_pd( vftab + _mm_extract_epi32(vfitab,2) );
1961             H                = _mm256_load_pd( vftab + _mm_extract_epi32(vfitab,3) );
1962             GMX_MM256_FULLTRANSPOSE4_PD(Y,F,G,H);
1963             Heps             = _mm256_mul_pd(vfeps,H);
1964             Fp               = _mm256_add_pd(F,_mm256_mul_pd(vfeps,_mm256_add_pd(G,Heps)));
1965             FF               = _mm256_add_pd(Fp,_mm256_mul_pd(vfeps,_mm256_add_pd(G,_mm256_add_pd(Heps,Heps))));
1966             felec            = _mm256_xor_pd(signbit,_mm256_mul_pd(_mm256_mul_pd(qq33,FF),_mm256_mul_pd(vftabscale,rinv33)));
1967
1968             fscal            = felec;
1969
1970             /* Calculate temporary vectorial force */
1971             tx               = _mm256_mul_pd(fscal,dx33);
1972             ty               = _mm256_mul_pd(fscal,dy33);
1973             tz               = _mm256_mul_pd(fscal,dz33);
1974
1975             /* Update vectorial force */
1976             fix3             = _mm256_add_pd(fix3,tx);
1977             fiy3             = _mm256_add_pd(fiy3,ty);
1978             fiz3             = _mm256_add_pd(fiz3,tz);
1979
1980             fjx3             = _mm256_add_pd(fjx3,tx);
1981             fjy3             = _mm256_add_pd(fjy3,ty);
1982             fjz3             = _mm256_add_pd(fjz3,tz);
1983
1984             fjptrA             = f+j_coord_offsetA;
1985             fjptrB             = f+j_coord_offsetB;
1986             fjptrC             = f+j_coord_offsetC;
1987             fjptrD             = f+j_coord_offsetD;
1988
1989             gmx_mm256_decrement_4rvec_4ptr_swizzle_pd(fjptrA,fjptrB,fjptrC,fjptrD,
1990                                                       fjx0,fjy0,fjz0,fjx1,fjy1,fjz1,
1991                                                       fjx2,fjy2,fjz2,fjx3,fjy3,fjz3);
1992
1993             /* Inner loop uses 381 flops */
1994         }
1995
1996         if(jidx<j_index_end)
1997         {
1998
1999             /* Get j neighbor index, and coordinate index */
2000             jnrlistA         = jjnr[jidx];
2001             jnrlistB         = jjnr[jidx+1];
2002             jnrlistC         = jjnr[jidx+2];
2003             jnrlistD         = jjnr[jidx+3];
2004             /* Sign of each element will be negative for non-real atoms.
2005              * This mask will be 0xFFFFFFFF for dummy entries and 0x0 for real ones,
2006              * so use it as val = _mm_andnot_pd(mask,val) to clear dummy entries.
2007              */
2008             tmpmask0 = gmx_mm_castsi128_ps(_mm_cmplt_epi32(_mm_loadu_si128((const __m128i *)(jjnr+jidx)),_mm_setzero_si128()));
2009
2010             tmpmask1 = _mm_permute_ps(tmpmask0,_GMX_MM_PERMUTE(3,3,2,2));
2011             tmpmask0 = _mm_permute_ps(tmpmask0,_GMX_MM_PERMUTE(1,1,0,0));
2012             dummy_mask = _mm256_castps_pd(gmx_mm256_set_m128(tmpmask1,tmpmask0));
2013
2014             jnrA       = (jnrlistA>=0) ? jnrlistA : 0;
2015             jnrB       = (jnrlistB>=0) ? jnrlistB : 0;
2016             jnrC       = (jnrlistC>=0) ? jnrlistC : 0;
2017             jnrD       = (jnrlistD>=0) ? jnrlistD : 0;
2018             j_coord_offsetA  = DIM*jnrA;
2019             j_coord_offsetB  = DIM*jnrB;
2020             j_coord_offsetC  = DIM*jnrC;
2021             j_coord_offsetD  = DIM*jnrD;
2022
2023             /* load j atom coordinates */
2024             gmx_mm256_load_4rvec_4ptr_swizzle_pd(x+j_coord_offsetA,x+j_coord_offsetB,
2025                                                  x+j_coord_offsetC,x+j_coord_offsetD,
2026                                                  &jx0,&jy0,&jz0,&jx1,&jy1,&jz1,&jx2,
2027                                                  &jy2,&jz2,&jx3,&jy3,&jz3);
2028
2029             /* Calculate displacement vector */
2030             dx00             = _mm256_sub_pd(ix0,jx0);
2031             dy00             = _mm256_sub_pd(iy0,jy0);
2032             dz00             = _mm256_sub_pd(iz0,jz0);
2033             dx11             = _mm256_sub_pd(ix1,jx1);
2034             dy11             = _mm256_sub_pd(iy1,jy1);
2035             dz11             = _mm256_sub_pd(iz1,jz1);
2036             dx12             = _mm256_sub_pd(ix1,jx2);
2037             dy12             = _mm256_sub_pd(iy1,jy2);
2038             dz12             = _mm256_sub_pd(iz1,jz2);
2039             dx13             = _mm256_sub_pd(ix1,jx3);
2040             dy13             = _mm256_sub_pd(iy1,jy3);
2041             dz13             = _mm256_sub_pd(iz1,jz3);
2042             dx21             = _mm256_sub_pd(ix2,jx1);
2043             dy21             = _mm256_sub_pd(iy2,jy1);
2044             dz21             = _mm256_sub_pd(iz2,jz1);
2045             dx22             = _mm256_sub_pd(ix2,jx2);
2046             dy22             = _mm256_sub_pd(iy2,jy2);
2047             dz22             = _mm256_sub_pd(iz2,jz2);
2048             dx23             = _mm256_sub_pd(ix2,jx3);
2049             dy23             = _mm256_sub_pd(iy2,jy3);
2050             dz23             = _mm256_sub_pd(iz2,jz3);
2051             dx31             = _mm256_sub_pd(ix3,jx1);
2052             dy31             = _mm256_sub_pd(iy3,jy1);
2053             dz31             = _mm256_sub_pd(iz3,jz1);
2054             dx32             = _mm256_sub_pd(ix3,jx2);
2055             dy32             = _mm256_sub_pd(iy3,jy2);
2056             dz32             = _mm256_sub_pd(iz3,jz2);
2057             dx33             = _mm256_sub_pd(ix3,jx3);
2058             dy33             = _mm256_sub_pd(iy3,jy3);
2059             dz33             = _mm256_sub_pd(iz3,jz3);
2060
2061             /* Calculate squared distance and things based on it */
2062             rsq00            = gmx_mm256_calc_rsq_pd(dx00,dy00,dz00);
2063             rsq11            = gmx_mm256_calc_rsq_pd(dx11,dy11,dz11);
2064             rsq12            = gmx_mm256_calc_rsq_pd(dx12,dy12,dz12);
2065             rsq13            = gmx_mm256_calc_rsq_pd(dx13,dy13,dz13);
2066             rsq21            = gmx_mm256_calc_rsq_pd(dx21,dy21,dz21);
2067             rsq22            = gmx_mm256_calc_rsq_pd(dx22,dy22,dz22);
2068             rsq23            = gmx_mm256_calc_rsq_pd(dx23,dy23,dz23);
2069             rsq31            = gmx_mm256_calc_rsq_pd(dx31,dy31,dz31);
2070             rsq32            = gmx_mm256_calc_rsq_pd(dx32,dy32,dz32);
2071             rsq33            = gmx_mm256_calc_rsq_pd(dx33,dy33,dz33);
2072
2073             rinv11           = gmx_mm256_invsqrt_pd(rsq11);
2074             rinv12           = gmx_mm256_invsqrt_pd(rsq12);
2075             rinv13           = gmx_mm256_invsqrt_pd(rsq13);
2076             rinv21           = gmx_mm256_invsqrt_pd(rsq21);
2077             rinv22           = gmx_mm256_invsqrt_pd(rsq22);
2078             rinv23           = gmx_mm256_invsqrt_pd(rsq23);
2079             rinv31           = gmx_mm256_invsqrt_pd(rsq31);
2080             rinv32           = gmx_mm256_invsqrt_pd(rsq32);
2081             rinv33           = gmx_mm256_invsqrt_pd(rsq33);
2082
2083             rinvsq00         = gmx_mm256_inv_pd(rsq00);
2084
2085             fjx0             = _mm256_setzero_pd();
2086             fjy0             = _mm256_setzero_pd();
2087             fjz0             = _mm256_setzero_pd();
2088             fjx1             = _mm256_setzero_pd();
2089             fjy1             = _mm256_setzero_pd();
2090             fjz1             = _mm256_setzero_pd();
2091             fjx2             = _mm256_setzero_pd();
2092             fjy2             = _mm256_setzero_pd();
2093             fjz2             = _mm256_setzero_pd();
2094             fjx3             = _mm256_setzero_pd();
2095             fjy3             = _mm256_setzero_pd();
2096             fjz3             = _mm256_setzero_pd();
2097
2098             /**************************
2099              * CALCULATE INTERACTIONS *
2100              **************************/
2101
2102             /* LENNARD-JONES DISPERSION/REPULSION */
2103
2104             rinvsix          = _mm256_mul_pd(_mm256_mul_pd(rinvsq00,rinvsq00),rinvsq00);
2105             fvdw             = _mm256_mul_pd(_mm256_sub_pd(_mm256_mul_pd(c12_00,rinvsix),c6_00),_mm256_mul_pd(rinvsix,rinvsq00));
2106
2107             fscal            = fvdw;
2108
2109             fscal            = _mm256_andnot_pd(dummy_mask,fscal);
2110
2111             /* Calculate temporary vectorial force */
2112             tx               = _mm256_mul_pd(fscal,dx00);
2113             ty               = _mm256_mul_pd(fscal,dy00);
2114             tz               = _mm256_mul_pd(fscal,dz00);
2115
2116             /* Update vectorial force */
2117             fix0             = _mm256_add_pd(fix0,tx);
2118             fiy0             = _mm256_add_pd(fiy0,ty);
2119             fiz0             = _mm256_add_pd(fiz0,tz);
2120
2121             fjx0             = _mm256_add_pd(fjx0,tx);
2122             fjy0             = _mm256_add_pd(fjy0,ty);
2123             fjz0             = _mm256_add_pd(fjz0,tz);
2124
2125             /**************************
2126              * CALCULATE INTERACTIONS *
2127              **************************/
2128
2129             r11              = _mm256_mul_pd(rsq11,rinv11);
2130             r11              = _mm256_andnot_pd(dummy_mask,r11);
2131
2132             /* Calculate table index by multiplying r with table scale and truncate to integer */
2133             rt               = _mm256_mul_pd(r11,vftabscale);
2134             vfitab           = _mm256_cvttpd_epi32(rt);
2135             vfeps            = _mm256_sub_pd(rt,_mm256_round_pd(rt, _MM_FROUND_FLOOR));
2136             vfitab           = _mm_slli_epi32(vfitab,2);
2137
2138             /* CUBIC SPLINE TABLE ELECTROSTATICS */
2139             Y                = _mm256_load_pd( vftab + _mm_extract_epi32(vfitab,0) );
2140             F                = _mm256_load_pd( vftab + _mm_extract_epi32(vfitab,1) );
2141             G                = _mm256_load_pd( vftab + _mm_extract_epi32(vfitab,2) );
2142             H                = _mm256_load_pd( vftab + _mm_extract_epi32(vfitab,3) );
2143             GMX_MM256_FULLTRANSPOSE4_PD(Y,F,G,H);
2144             Heps             = _mm256_mul_pd(vfeps,H);
2145             Fp               = _mm256_add_pd(F,_mm256_mul_pd(vfeps,_mm256_add_pd(G,Heps)));
2146             FF               = _mm256_add_pd(Fp,_mm256_mul_pd(vfeps,_mm256_add_pd(G,_mm256_add_pd(Heps,Heps))));
2147             felec            = _mm256_xor_pd(signbit,_mm256_mul_pd(_mm256_mul_pd(qq11,FF),_mm256_mul_pd(vftabscale,rinv11)));
2148
2149             fscal            = felec;
2150
2151             fscal            = _mm256_andnot_pd(dummy_mask,fscal);
2152
2153             /* Calculate temporary vectorial force */
2154             tx               = _mm256_mul_pd(fscal,dx11);
2155             ty               = _mm256_mul_pd(fscal,dy11);
2156             tz               = _mm256_mul_pd(fscal,dz11);
2157
2158             /* Update vectorial force */
2159             fix1             = _mm256_add_pd(fix1,tx);
2160             fiy1             = _mm256_add_pd(fiy1,ty);
2161             fiz1             = _mm256_add_pd(fiz1,tz);
2162
2163             fjx1             = _mm256_add_pd(fjx1,tx);
2164             fjy1             = _mm256_add_pd(fjy1,ty);
2165             fjz1             = _mm256_add_pd(fjz1,tz);
2166
2167             /**************************
2168              * CALCULATE INTERACTIONS *
2169              **************************/
2170
2171             r12              = _mm256_mul_pd(rsq12,rinv12);
2172             r12              = _mm256_andnot_pd(dummy_mask,r12);
2173
2174             /* Calculate table index by multiplying r with table scale and truncate to integer */
2175             rt               = _mm256_mul_pd(r12,vftabscale);
2176             vfitab           = _mm256_cvttpd_epi32(rt);
2177             vfeps            = _mm256_sub_pd(rt,_mm256_round_pd(rt, _MM_FROUND_FLOOR));
2178             vfitab           = _mm_slli_epi32(vfitab,2);
2179
2180             /* CUBIC SPLINE TABLE ELECTROSTATICS */
2181             Y                = _mm256_load_pd( vftab + _mm_extract_epi32(vfitab,0) );
2182             F                = _mm256_load_pd( vftab + _mm_extract_epi32(vfitab,1) );
2183             G                = _mm256_load_pd( vftab + _mm_extract_epi32(vfitab,2) );
2184             H                = _mm256_load_pd( vftab + _mm_extract_epi32(vfitab,3) );
2185             GMX_MM256_FULLTRANSPOSE4_PD(Y,F,G,H);
2186             Heps             = _mm256_mul_pd(vfeps,H);
2187             Fp               = _mm256_add_pd(F,_mm256_mul_pd(vfeps,_mm256_add_pd(G,Heps)));
2188             FF               = _mm256_add_pd(Fp,_mm256_mul_pd(vfeps,_mm256_add_pd(G,_mm256_add_pd(Heps,Heps))));
2189             felec            = _mm256_xor_pd(signbit,_mm256_mul_pd(_mm256_mul_pd(qq12,FF),_mm256_mul_pd(vftabscale,rinv12)));
2190
2191             fscal            = felec;
2192
2193             fscal            = _mm256_andnot_pd(dummy_mask,fscal);
2194
2195             /* Calculate temporary vectorial force */
2196             tx               = _mm256_mul_pd(fscal,dx12);
2197             ty               = _mm256_mul_pd(fscal,dy12);
2198             tz               = _mm256_mul_pd(fscal,dz12);
2199
2200             /* Update vectorial force */
2201             fix1             = _mm256_add_pd(fix1,tx);
2202             fiy1             = _mm256_add_pd(fiy1,ty);
2203             fiz1             = _mm256_add_pd(fiz1,tz);
2204
2205             fjx2             = _mm256_add_pd(fjx2,tx);
2206             fjy2             = _mm256_add_pd(fjy2,ty);
2207             fjz2             = _mm256_add_pd(fjz2,tz);
2208
2209             /**************************
2210              * CALCULATE INTERACTIONS *
2211              **************************/
2212
2213             r13              = _mm256_mul_pd(rsq13,rinv13);
2214             r13              = _mm256_andnot_pd(dummy_mask,r13);
2215
2216             /* Calculate table index by multiplying r with table scale and truncate to integer */
2217             rt               = _mm256_mul_pd(r13,vftabscale);
2218             vfitab           = _mm256_cvttpd_epi32(rt);
2219             vfeps            = _mm256_sub_pd(rt,_mm256_round_pd(rt, _MM_FROUND_FLOOR));
2220             vfitab           = _mm_slli_epi32(vfitab,2);
2221
2222             /* CUBIC SPLINE TABLE ELECTROSTATICS */
2223             Y                = _mm256_load_pd( vftab + _mm_extract_epi32(vfitab,0) );
2224             F                = _mm256_load_pd( vftab + _mm_extract_epi32(vfitab,1) );
2225             G                = _mm256_load_pd( vftab + _mm_extract_epi32(vfitab,2) );
2226             H                = _mm256_load_pd( vftab + _mm_extract_epi32(vfitab,3) );
2227             GMX_MM256_FULLTRANSPOSE4_PD(Y,F,G,H);
2228             Heps             = _mm256_mul_pd(vfeps,H);
2229             Fp               = _mm256_add_pd(F,_mm256_mul_pd(vfeps,_mm256_add_pd(G,Heps)));
2230             FF               = _mm256_add_pd(Fp,_mm256_mul_pd(vfeps,_mm256_add_pd(G,_mm256_add_pd(Heps,Heps))));
2231             felec            = _mm256_xor_pd(signbit,_mm256_mul_pd(_mm256_mul_pd(qq13,FF),_mm256_mul_pd(vftabscale,rinv13)));
2232
2233             fscal            = felec;
2234
2235             fscal            = _mm256_andnot_pd(dummy_mask,fscal);
2236
2237             /* Calculate temporary vectorial force */
2238             tx               = _mm256_mul_pd(fscal,dx13);
2239             ty               = _mm256_mul_pd(fscal,dy13);
2240             tz               = _mm256_mul_pd(fscal,dz13);
2241
2242             /* Update vectorial force */
2243             fix1             = _mm256_add_pd(fix1,tx);
2244             fiy1             = _mm256_add_pd(fiy1,ty);
2245             fiz1             = _mm256_add_pd(fiz1,tz);
2246
2247             fjx3             = _mm256_add_pd(fjx3,tx);
2248             fjy3             = _mm256_add_pd(fjy3,ty);
2249             fjz3             = _mm256_add_pd(fjz3,tz);
2250
2251             /**************************
2252              * CALCULATE INTERACTIONS *
2253              **************************/
2254
2255             r21              = _mm256_mul_pd(rsq21,rinv21);
2256             r21              = _mm256_andnot_pd(dummy_mask,r21);
2257
2258             /* Calculate table index by multiplying r with table scale and truncate to integer */
2259             rt               = _mm256_mul_pd(r21,vftabscale);
2260             vfitab           = _mm256_cvttpd_epi32(rt);
2261             vfeps            = _mm256_sub_pd(rt,_mm256_round_pd(rt, _MM_FROUND_FLOOR));
2262             vfitab           = _mm_slli_epi32(vfitab,2);
2263
2264             /* CUBIC SPLINE TABLE ELECTROSTATICS */
2265             Y                = _mm256_load_pd( vftab + _mm_extract_epi32(vfitab,0) );
2266             F                = _mm256_load_pd( vftab + _mm_extract_epi32(vfitab,1) );
2267             G                = _mm256_load_pd( vftab + _mm_extract_epi32(vfitab,2) );
2268             H                = _mm256_load_pd( vftab + _mm_extract_epi32(vfitab,3) );
2269             GMX_MM256_FULLTRANSPOSE4_PD(Y,F,G,H);
2270             Heps             = _mm256_mul_pd(vfeps,H);
2271             Fp               = _mm256_add_pd(F,_mm256_mul_pd(vfeps,_mm256_add_pd(G,Heps)));
2272             FF               = _mm256_add_pd(Fp,_mm256_mul_pd(vfeps,_mm256_add_pd(G,_mm256_add_pd(Heps,Heps))));
2273             felec            = _mm256_xor_pd(signbit,_mm256_mul_pd(_mm256_mul_pd(qq21,FF),_mm256_mul_pd(vftabscale,rinv21)));
2274
2275             fscal            = felec;
2276
2277             fscal            = _mm256_andnot_pd(dummy_mask,fscal);
2278
2279             /* Calculate temporary vectorial force */
2280             tx               = _mm256_mul_pd(fscal,dx21);
2281             ty               = _mm256_mul_pd(fscal,dy21);
2282             tz               = _mm256_mul_pd(fscal,dz21);
2283
2284             /* Update vectorial force */
2285             fix2             = _mm256_add_pd(fix2,tx);
2286             fiy2             = _mm256_add_pd(fiy2,ty);
2287             fiz2             = _mm256_add_pd(fiz2,tz);
2288
2289             fjx1             = _mm256_add_pd(fjx1,tx);
2290             fjy1             = _mm256_add_pd(fjy1,ty);
2291             fjz1             = _mm256_add_pd(fjz1,tz);
2292
2293             /**************************
2294              * CALCULATE INTERACTIONS *
2295              **************************/
2296
2297             r22              = _mm256_mul_pd(rsq22,rinv22);
2298             r22              = _mm256_andnot_pd(dummy_mask,r22);
2299
2300             /* Calculate table index by multiplying r with table scale and truncate to integer */
2301             rt               = _mm256_mul_pd(r22,vftabscale);
2302             vfitab           = _mm256_cvttpd_epi32(rt);
2303             vfeps            = _mm256_sub_pd(rt,_mm256_round_pd(rt, _MM_FROUND_FLOOR));
2304             vfitab           = _mm_slli_epi32(vfitab,2);
2305
2306             /* CUBIC SPLINE TABLE ELECTROSTATICS */
2307             Y                = _mm256_load_pd( vftab + _mm_extract_epi32(vfitab,0) );
2308             F                = _mm256_load_pd( vftab + _mm_extract_epi32(vfitab,1) );
2309             G                = _mm256_load_pd( vftab + _mm_extract_epi32(vfitab,2) );
2310             H                = _mm256_load_pd( vftab + _mm_extract_epi32(vfitab,3) );
2311             GMX_MM256_FULLTRANSPOSE4_PD(Y,F,G,H);
2312             Heps             = _mm256_mul_pd(vfeps,H);
2313             Fp               = _mm256_add_pd(F,_mm256_mul_pd(vfeps,_mm256_add_pd(G,Heps)));
2314             FF               = _mm256_add_pd(Fp,_mm256_mul_pd(vfeps,_mm256_add_pd(G,_mm256_add_pd(Heps,Heps))));
2315             felec            = _mm256_xor_pd(signbit,_mm256_mul_pd(_mm256_mul_pd(qq22,FF),_mm256_mul_pd(vftabscale,rinv22)));
2316
2317             fscal            = felec;
2318
2319             fscal            = _mm256_andnot_pd(dummy_mask,fscal);
2320
2321             /* Calculate temporary vectorial force */
2322             tx               = _mm256_mul_pd(fscal,dx22);
2323             ty               = _mm256_mul_pd(fscal,dy22);
2324             tz               = _mm256_mul_pd(fscal,dz22);
2325
2326             /* Update vectorial force */
2327             fix2             = _mm256_add_pd(fix2,tx);
2328             fiy2             = _mm256_add_pd(fiy2,ty);
2329             fiz2             = _mm256_add_pd(fiz2,tz);
2330
2331             fjx2             = _mm256_add_pd(fjx2,tx);
2332             fjy2             = _mm256_add_pd(fjy2,ty);
2333             fjz2             = _mm256_add_pd(fjz2,tz);
2334
2335             /**************************
2336              * CALCULATE INTERACTIONS *
2337              **************************/
2338
2339             r23              = _mm256_mul_pd(rsq23,rinv23);
2340             r23              = _mm256_andnot_pd(dummy_mask,r23);
2341
2342             /* Calculate table index by multiplying r with table scale and truncate to integer */
2343             rt               = _mm256_mul_pd(r23,vftabscale);
2344             vfitab           = _mm256_cvttpd_epi32(rt);
2345             vfeps            = _mm256_sub_pd(rt,_mm256_round_pd(rt, _MM_FROUND_FLOOR));
2346             vfitab           = _mm_slli_epi32(vfitab,2);
2347
2348             /* CUBIC SPLINE TABLE ELECTROSTATICS */
2349             Y                = _mm256_load_pd( vftab + _mm_extract_epi32(vfitab,0) );
2350             F                = _mm256_load_pd( vftab + _mm_extract_epi32(vfitab,1) );
2351             G                = _mm256_load_pd( vftab + _mm_extract_epi32(vfitab,2) );
2352             H                = _mm256_load_pd( vftab + _mm_extract_epi32(vfitab,3) );
2353             GMX_MM256_FULLTRANSPOSE4_PD(Y,F,G,H);
2354             Heps             = _mm256_mul_pd(vfeps,H);
2355             Fp               = _mm256_add_pd(F,_mm256_mul_pd(vfeps,_mm256_add_pd(G,Heps)));
2356             FF               = _mm256_add_pd(Fp,_mm256_mul_pd(vfeps,_mm256_add_pd(G,_mm256_add_pd(Heps,Heps))));
2357             felec            = _mm256_xor_pd(signbit,_mm256_mul_pd(_mm256_mul_pd(qq23,FF),_mm256_mul_pd(vftabscale,rinv23)));
2358
2359             fscal            = felec;
2360
2361             fscal            = _mm256_andnot_pd(dummy_mask,fscal);
2362
2363             /* Calculate temporary vectorial force */
2364             tx               = _mm256_mul_pd(fscal,dx23);
2365             ty               = _mm256_mul_pd(fscal,dy23);
2366             tz               = _mm256_mul_pd(fscal,dz23);
2367
2368             /* Update vectorial force */
2369             fix2             = _mm256_add_pd(fix2,tx);
2370             fiy2             = _mm256_add_pd(fiy2,ty);
2371             fiz2             = _mm256_add_pd(fiz2,tz);
2372
2373             fjx3             = _mm256_add_pd(fjx3,tx);
2374             fjy3             = _mm256_add_pd(fjy3,ty);
2375             fjz3             = _mm256_add_pd(fjz3,tz);
2376
2377             /**************************
2378              * CALCULATE INTERACTIONS *
2379              **************************/
2380
2381             r31              = _mm256_mul_pd(rsq31,rinv31);
2382             r31              = _mm256_andnot_pd(dummy_mask,r31);
2383
2384             /* Calculate table index by multiplying r with table scale and truncate to integer */
2385             rt               = _mm256_mul_pd(r31,vftabscale);
2386             vfitab           = _mm256_cvttpd_epi32(rt);
2387             vfeps            = _mm256_sub_pd(rt,_mm256_round_pd(rt, _MM_FROUND_FLOOR));
2388             vfitab           = _mm_slli_epi32(vfitab,2);
2389
2390             /* CUBIC SPLINE TABLE ELECTROSTATICS */
2391             Y                = _mm256_load_pd( vftab + _mm_extract_epi32(vfitab,0) );
2392             F                = _mm256_load_pd( vftab + _mm_extract_epi32(vfitab,1) );
2393             G                = _mm256_load_pd( vftab + _mm_extract_epi32(vfitab,2) );
2394             H                = _mm256_load_pd( vftab + _mm_extract_epi32(vfitab,3) );
2395             GMX_MM256_FULLTRANSPOSE4_PD(Y,F,G,H);
2396             Heps             = _mm256_mul_pd(vfeps,H);
2397             Fp               = _mm256_add_pd(F,_mm256_mul_pd(vfeps,_mm256_add_pd(G,Heps)));
2398             FF               = _mm256_add_pd(Fp,_mm256_mul_pd(vfeps,_mm256_add_pd(G,_mm256_add_pd(Heps,Heps))));
2399             felec            = _mm256_xor_pd(signbit,_mm256_mul_pd(_mm256_mul_pd(qq31,FF),_mm256_mul_pd(vftabscale,rinv31)));
2400
2401             fscal            = felec;
2402
2403             fscal            = _mm256_andnot_pd(dummy_mask,fscal);
2404
2405             /* Calculate temporary vectorial force */
2406             tx               = _mm256_mul_pd(fscal,dx31);
2407             ty               = _mm256_mul_pd(fscal,dy31);
2408             tz               = _mm256_mul_pd(fscal,dz31);
2409
2410             /* Update vectorial force */
2411             fix3             = _mm256_add_pd(fix3,tx);
2412             fiy3             = _mm256_add_pd(fiy3,ty);
2413             fiz3             = _mm256_add_pd(fiz3,tz);
2414
2415             fjx1             = _mm256_add_pd(fjx1,tx);
2416             fjy1             = _mm256_add_pd(fjy1,ty);
2417             fjz1             = _mm256_add_pd(fjz1,tz);
2418
2419             /**************************
2420              * CALCULATE INTERACTIONS *
2421              **************************/
2422
2423             r32              = _mm256_mul_pd(rsq32,rinv32);
2424             r32              = _mm256_andnot_pd(dummy_mask,r32);
2425
2426             /* Calculate table index by multiplying r with table scale and truncate to integer */
2427             rt               = _mm256_mul_pd(r32,vftabscale);
2428             vfitab           = _mm256_cvttpd_epi32(rt);
2429             vfeps            = _mm256_sub_pd(rt,_mm256_round_pd(rt, _MM_FROUND_FLOOR));
2430             vfitab           = _mm_slli_epi32(vfitab,2);
2431
2432             /* CUBIC SPLINE TABLE ELECTROSTATICS */
2433             Y                = _mm256_load_pd( vftab + _mm_extract_epi32(vfitab,0) );
2434             F                = _mm256_load_pd( vftab + _mm_extract_epi32(vfitab,1) );
2435             G                = _mm256_load_pd( vftab + _mm_extract_epi32(vfitab,2) );
2436             H                = _mm256_load_pd( vftab + _mm_extract_epi32(vfitab,3) );
2437             GMX_MM256_FULLTRANSPOSE4_PD(Y,F,G,H);
2438             Heps             = _mm256_mul_pd(vfeps,H);
2439             Fp               = _mm256_add_pd(F,_mm256_mul_pd(vfeps,_mm256_add_pd(G,Heps)));
2440             FF               = _mm256_add_pd(Fp,_mm256_mul_pd(vfeps,_mm256_add_pd(G,_mm256_add_pd(Heps,Heps))));
2441             felec            = _mm256_xor_pd(signbit,_mm256_mul_pd(_mm256_mul_pd(qq32,FF),_mm256_mul_pd(vftabscale,rinv32)));
2442
2443             fscal            = felec;
2444
2445             fscal            = _mm256_andnot_pd(dummy_mask,fscal);
2446
2447             /* Calculate temporary vectorial force */
2448             tx               = _mm256_mul_pd(fscal,dx32);
2449             ty               = _mm256_mul_pd(fscal,dy32);
2450             tz               = _mm256_mul_pd(fscal,dz32);
2451
2452             /* Update vectorial force */
2453             fix3             = _mm256_add_pd(fix3,tx);
2454             fiy3             = _mm256_add_pd(fiy3,ty);
2455             fiz3             = _mm256_add_pd(fiz3,tz);
2456
2457             fjx2             = _mm256_add_pd(fjx2,tx);
2458             fjy2             = _mm256_add_pd(fjy2,ty);
2459             fjz2             = _mm256_add_pd(fjz2,tz);
2460
2461             /**************************
2462              * CALCULATE INTERACTIONS *
2463              **************************/
2464
2465             r33              = _mm256_mul_pd(rsq33,rinv33);
2466             r33              = _mm256_andnot_pd(dummy_mask,r33);
2467
2468             /* Calculate table index by multiplying r with table scale and truncate to integer */
2469             rt               = _mm256_mul_pd(r33,vftabscale);
2470             vfitab           = _mm256_cvttpd_epi32(rt);
2471             vfeps            = _mm256_sub_pd(rt,_mm256_round_pd(rt, _MM_FROUND_FLOOR));
2472             vfitab           = _mm_slli_epi32(vfitab,2);
2473
2474             /* CUBIC SPLINE TABLE ELECTROSTATICS */
2475             Y                = _mm256_load_pd( vftab + _mm_extract_epi32(vfitab,0) );
2476             F                = _mm256_load_pd( vftab + _mm_extract_epi32(vfitab,1) );
2477             G                = _mm256_load_pd( vftab + _mm_extract_epi32(vfitab,2) );
2478             H                = _mm256_load_pd( vftab + _mm_extract_epi32(vfitab,3) );
2479             GMX_MM256_FULLTRANSPOSE4_PD(Y,F,G,H);
2480             Heps             = _mm256_mul_pd(vfeps,H);
2481             Fp               = _mm256_add_pd(F,_mm256_mul_pd(vfeps,_mm256_add_pd(G,Heps)));
2482             FF               = _mm256_add_pd(Fp,_mm256_mul_pd(vfeps,_mm256_add_pd(G,_mm256_add_pd(Heps,Heps))));
2483             felec            = _mm256_xor_pd(signbit,_mm256_mul_pd(_mm256_mul_pd(qq33,FF),_mm256_mul_pd(vftabscale,rinv33)));
2484
2485             fscal            = felec;
2486
2487             fscal            = _mm256_andnot_pd(dummy_mask,fscal);
2488
2489             /* Calculate temporary vectorial force */
2490             tx               = _mm256_mul_pd(fscal,dx33);
2491             ty               = _mm256_mul_pd(fscal,dy33);
2492             tz               = _mm256_mul_pd(fscal,dz33);
2493
2494             /* Update vectorial force */
2495             fix3             = _mm256_add_pd(fix3,tx);
2496             fiy3             = _mm256_add_pd(fiy3,ty);
2497             fiz3             = _mm256_add_pd(fiz3,tz);
2498
2499             fjx3             = _mm256_add_pd(fjx3,tx);
2500             fjy3             = _mm256_add_pd(fjy3,ty);
2501             fjz3             = _mm256_add_pd(fjz3,tz);
2502
2503             fjptrA             = (jnrlistA>=0) ? f+j_coord_offsetA : scratch;
2504             fjptrB             = (jnrlistB>=0) ? f+j_coord_offsetB : scratch;
2505             fjptrC             = (jnrlistC>=0) ? f+j_coord_offsetC : scratch;
2506             fjptrD             = (jnrlistD>=0) ? f+j_coord_offsetD : scratch;
2507
2508             gmx_mm256_decrement_4rvec_4ptr_swizzle_pd(fjptrA,fjptrB,fjptrC,fjptrD,
2509                                                       fjx0,fjy0,fjz0,fjx1,fjy1,fjz1,
2510                                                       fjx2,fjy2,fjz2,fjx3,fjy3,fjz3);
2511
2512             /* Inner loop uses 390 flops */
2513         }
2514
2515         /* End of innermost loop */
2516
2517         gmx_mm256_update_iforce_4atom_swizzle_pd(fix0,fiy0,fiz0,fix1,fiy1,fiz1,fix2,fiy2,fiz2,fix3,fiy3,fiz3,
2518                                                  f+i_coord_offset,fshift+i_shift_offset);
2519
2520         /* Increment number of inner iterations */
2521         inneriter                  += j_index_end - j_index_start;
2522
2523         /* Outer loop uses 24 flops */
2524     }
2525
2526     /* Increment number of outer iterations */
2527     outeriter        += nri;
2528
2529     /* Update outer/inner flops */
2530
2531     inc_nrnb(nrnb,eNR_NBKERNEL_ELEC_VDW_W4W4_F,outeriter*24 + inneriter*390);
2532 }