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

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