/beegfs/hackathon/users/eoseret/qaas_runs_test/178-654-5599/intel/miniqmc/build/miniqmc/src/Numerics/Spline2/MultiBsplineRef.hpp: 188 - 286
--------------------------------------------------------------------------------

188:   y -= spline_m->y_grid.start;
189:   z -= spline_m->z_grid.start;
190:   spline2::getSplineBound(x * spline_m->x_grid.delta_inv, tx, ix, spline_m->x_grid.num - 1);
191:   spline2::getSplineBound(y * spline_m->y_grid.delta_inv, ty, iy, spline_m->y_grid.num - 1);
192:   spline2::getSplineBound(z * spline_m->z_grid.delta_inv, tz, iz, spline_m->z_grid.num - 1);
[...]
198:   const intptr_t xs = spline_m->x_stride;
199:   const intptr_t ys = spline_m->y_stride;
200:   const intptr_t zs = spline_m->z_stride;
201: 
202:   const size_t out_offset = spline_m->num_splines;
[...]
215:   std::fill(vals, vals + num_splines, T());
[...]
226:   for (int i = 0; i < 4; i++)
227:     for (int j = 0; j < 4; j++)
228:     {
229:       const T* restrict coefs    = spline_m->coefs + (ix + i) * xs + (iy + j) * ys + iz * zs;
230:       const T* restrict coefszs  = coefs + zs;
231:       const T* restrict coefs2zs = coefs + 2 * zs;
232:       const T* restrict coefs3zs = coefs + 3 * zs;
233: 
234:       const T pre20 = d2a[i] * b[j];
235:       const T pre10 = da[i] * b[j];
236:       const T pre00 = a[i] * b[j];
237:       const T pre11 = da[i] * db[j];
238:       const T pre01 = a[i] * db[j];
239:       const T pre02 = a[i] * d2b[j];
240: 
241:       const int iSplitPoint = num_splines;
242:       for (int n = 0; n < iSplitPoint; n++)
243:       {
244:         T coefsv    = coefs[n];
245:         T coefsvzs  = coefszs[n];
246:         T coefsv2zs = coefs2zs[n];
247:         T coefsv3zs = coefs3zs[n];
248: 
249:         T sum0 = c[0] * coefsv + c[1] * coefsvzs + c[2] * coefsv2zs + c[3] * coefsv3zs;
250:         T sum1 = dc[0] * coefsv + dc[1] * coefsvzs + dc[2] * coefsv2zs + dc[3] * coefsv3zs;
251:         T sum2 = d2c[0] * coefsv + d2c[1] * coefsvzs + d2c[2] * coefsv2zs + d2c[3] * coefsv3zs;
252: 
253:         hxx[n] += pre20 * sum0;
254:         hxy[n] += pre11 * sum0;
255:         hxz[n] += pre10 * sum1;
256:         hyy[n] += pre02 * sum0;
257:         hyz[n] += pre01 * sum1;
258:         hzz[n] += pre00 * sum2;
259:         gx[n] += pre10 * sum0;
260:         gy[n] += pre01 * sum0;
261:         gz[n] += pre00 * sum1;
262:         vals[n] += pre00 * sum0;
[...]
269:   const T dxx   = dxInv * dxInv;
270:   const T dyy   = dyInv * dyInv;
271:   const T dzz   = dzInv * dzInv;
272:   const T dxy   = dxInv * dyInv;
273:   const T dxz   = dxInv * dzInv;
274:   const T dyz   = dyInv * dzInv;
275: 
276:   for (int n = 0; n < num_splines; n++)
277:   {
278:     gx[n] *= dxInv;
279:     gy[n] *= dyInv;
280:     gz[n] *= dzInv;
281:     hxx[n] *= dxx;
282:     hyy[n] *= dyy;
283:     hzz[n] *= dzz;
284:     hxy[n] *= dxy;
285:     hxz[n] *= dxz;
286:     hyz[n] *= dyz;
/beegfs/hackathon/users/eoseret/qaas_runs_test/178-654-5599/intel/miniqmc/build/miniqmc/src/Numerics/OhmmsPETE/TinyVector.h: 61 - 145
--------------------------------------------------------------------------------

61:     for (size_t d = 0; d < D; ++d)
[...]
145:       X[i] = base[i * offset];
/beegfs/hackathon/users/eoseret/qaas_runs_test/178-654-5599/intel/miniqmc/build/miniqmc/src/Numerics/OhmmsPETE/VectorSoAContainer.h: 231 - 271
--------------------------------------------------------------------------------

231:   inline const AoSElement_t operator[](size_t i) const { return AoSElement_t(myData + i, nGhosts); }
[...]
265:   inline T* data() { return myData; }
[...]
271:   inline T* restrict data(size_t i) { return myData + i * nGhosts; }
/beegfs/hackathon/users/eoseret/qaas_runs_test/178-654-5599/intel/miniqmc/build/miniqmc/src/Particle/Lattice/CrystalLattice.h: 170 - 170
--------------------------------------------------------------------------------

170:       if (-std::numeric_limits<T1>::epsilon() < val_dot[i] && val_dot[i] < 0)
/beegfs/hackathon/users/eoseret/qaas_runs_test/178-654-5599/intel/miniqmc/build/miniqmc/src/Numerics/OhmmsPETE/TinyVectorTensorOps.h: 150 - 152
--------------------------------------------------------------------------------

150:     return TinyVector<Type_t, 3>(lhs[0] * rhs[0] + lhs[1] * rhs[3] + lhs[2] * rhs[6],
151:                                  lhs[0] * rhs[1] + lhs[1] * rhs[4] + lhs[2] * rhs[7],
152:                                  lhs[0] * rhs[2] + lhs[1] * rhs[5] + lhs[2] * rhs[8]);
/beegfs/hackathon/users/eoseret/qaas_runs_test/178-654-5599/intel/miniqmc/build/miniqmc/src/Utilities/NewTimer.h: 242 - 249
--------------------------------------------------------------------------------

242:   ScopeGuard(TIMER& t) : timer(t) { timer.start(); }
[...]
249:   ~ScopeGuard() { timer.stop(); }
/beegfs/hackathon/users/eoseret/qaas_runs_test/178-654-5599/intel/miniqmc/build/miniqmc/src/QMCWaveFunctions/einspline_spo_ref.hpp: 203 - 230
--------------------------------------------------------------------------------

203:     ScopedTimer local_timer(timer);
204: 
205:     auto u = Lattice.toUnit_floor(P.activeR(iat));
206:     for (int i = 0; i < nBlocks; ++i)
207:       MultiBsplineEvalRef::evaluate_vgh(einsplines[i], u[0], u[1], u[2], psi[i].data(), grad[i].data(), hess[i].data(),
208:                                         nSplinesPerBlock);
[...]
216:   {
217:     evaluate_vgh(P, iat);
218: 
219:     for (int i = 0; i < nBlocks; ++i)
220:     {
221:       // in real simulation, phase needs to be applied. Here just fake computation
222:       const int first = i * nBlocks;
223:       for (int j = first; j < std::min((i + 1) * nSplinesPerBlock, OrbitalSetSize); j++)
224:       {
225:         psi_v[j]   = psi[i][j - first];
226:         dpsi_v[j]  = grad[i][j - first];
227:         d2psi_v[j] = hess[i].data(0)[j - first];
228:       }
229:     }
230:   }
/usr/lib/gcc/x86_64-redhat-linux/11/../../../../include/c++/11/bits/stl_vector.h: 1046 - 1046
--------------------------------------------------------------------------------

/usr/lib/gcc/x86_64-redhat-linux/11/../../../../include/c++/11/bits/stl_vector.h: 1169 - 1169
--------------------------------------------------------------------------------

/beegfs/hackathon/users/eoseret/qaas_runs_test/178-654-5599/intel/miniqmc/build/miniqmc/src/Numerics/OhmmsPETE/OhmmsVector.h: 223 - 223
--------------------------------------------------------------------------------

223:     return X[i];
/usr/lib/gcc/x86_64-redhat-linux/11/../../../../include/c++/11/bits/stl_algobase.h: 235 - 235
--------------------------------------------------------------------------------

/usr/lib/gcc/x86_64-redhat-linux/11/../../../../include/c++/11/bits/stl_algobase.h: 923 - 924
--------------------------------------------------------------------------------

/beegfs/hackathon/users/eoseret/qaas_runs_test/178-654-5599/intel/miniqmc/build/miniqmc/src/Numerics/Spline2/MultiBsplineEvalHelper.hpp: 45 - 47
--------------------------------------------------------------------------------

45:   T sf = std::floor(x);
46:   T dx2 = x - sf;
47:   int ind2 = std::min(std::max(0, static_cast<int>(sf)), nmax);
/beegfs/hackathon/users/eoseret/qaas_runs_test/178-654-5599/intel/miniqmc/build/miniqmc/src/Particle/ParticleSet.h: 143 - 143
--------------------------------------------------------------------------------

143:     return (active_ptcl_ == iat) ? active_pos_ : R[iat];
/beegfs/hackathon/users/eoseret/qaas_runs_test/178-654-5599/intel/miniqmc/build/miniqmc/src/Numerics/Spline2/MultiBsplineData.hpp: 68 - 79
--------------------------------------------------------------------------------

68:     a[0]   = ((A00 * tx + A01) * tx + A02) * tx + A03;
69:     a[1]   = ((A10 * tx + A11) * tx + A12) * tx + A13;
70:     a[2]   = ((A20 * tx + A21) * tx + A22) * tx + A23;
71:     a[3]   = ((A30 * tx + A31) * tx + A32) * tx + A33;
72:     da[0]  = (dA01 * tx + dA02) * tx + dA03;
73:     da[1]  = (dA11 * tx + dA12) * tx + dA13;
74:     da[2]  = (dA21 * tx + dA22) * tx + dA23;
75:     da[3]  = (dA31 * tx + dA32) * tx + dA33;
76:     d2a[0] = d2A02 * tx + d2A03;
77:     d2a[1] = d2A12 * tx + d2A13;
78:     d2a[2] = d2A22 * tx + d2A23;
79:     d2a[3] = d2A32 * tx + d2A33;
/beegfs/hackathon/users/eoseret/qaas_runs_test/178-654-5599/intel/miniqmc/build/miniqmc/src/Numerics/OhmmsPETE/Tensor.h: 213 - 213
--------------------------------------------------------------------------------

213:   inline Type_t operator[](unsigned int i) const { return X[i]; }
