src/gromacs/gmxlib/nonbonded/nb_kernel_avx_128_fma_double/nb_kernel_ElecEwSh_VdwLJEwSh_GeomW4W4_avx_128_fma_double.c

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