src/gromacs/gmxlib/nonbonded/nb_kernel_avx_256_single/nb_kernel_ElecCSTab_VdwLJ_GeomW3W3_avx_256_single.c

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