/usr/include/c++/14/bits/stl_algobase.h: 939 - 1152
--------------------------------------------------------------------------------

939:       for (; __first != __last; ++__first)
940: 	*__first = __value;
[...]
952: 	*__first = __tmp;
[...]
1146:       if (__n <= 0)
1147: 	return __first;
1148: 
1149:       __glibcxx_requires_can_increment(__first, __n);
1150: 
1151:       std::__fill_a(__first, __first + __n, __value);
1152:       return __first + __n;
/home/eoseret/qaas/qaas_runs/178-547-6790/intel/miniqmc/build/miniqmc/src/Utilities/NewTimer.h: 242 - 249
--------------------------------------------------------------------------------

242:   ScopeGuard(TIMER& t) : timer(t) { timer.start(); }
[...]
249:   ~ScopeGuard() { timer.stop(); }
/usr/include/c++/14/bits/stl_construct.h: 119 - 119
--------------------------------------------------------------------------------

119:       ::new((void*)__p) _Tp(std::forward<_Args>(__args)...);
/home/eoseret/qaas/qaas_runs/178-547-6790/intel/miniqmc/build/miniqmc/src/Numerics/OhmmsPETE/TinyVectorTensorOps.h: 77 - 79
--------------------------------------------------------------------------------

77:     return TinyVector<Type_t, 3>(lhs[0] * rhs[0] + lhs[1] * rhs[1] + lhs[2] * rhs[2],
78:                                  lhs[3] * rhs[0] + lhs[4] * rhs[1] + lhs[5] * rhs[2],
79:                                  lhs[6] * rhs[0] + lhs[7] * rhs[1] + lhs[8] * rhs[2]);
/usr/include/c++/14/bits/refwrap.h: 351 - 351
--------------------------------------------------------------------------------

351:       { return *_M_data; }
/home/eoseret/qaas/qaas_runs/178-547-6790/intel/miniqmc/build/miniqmc/src/Utilities/RandomGenerator.h: 51 - 60
--------------------------------------------------------------------------------

51:     for (int i = 0; i + 1 < n; i += 2)
52:     {
53:       double temp1 = 1.0 - 0.9999999999 * rng(), temp2 = rng();
54:       a[i]     = sqrt(-2.0 * log(temp1)) * cos(6.283185306 * temp2);
55:       a[i + 1] = sqrt(-2.0 * log(temp1)) * sin(6.283185306 * temp2);
56:     }
57:     if (n % 2 == 1)
58:     {
59:       double temp1 = 1 - 0.9999999999 * rng(), temp2 = rng();
60:       a[n - 1] = sqrt(-2.0 * log(temp1)) * cos(6.283185306 * temp2);
/home/eoseret/qaas/qaas_runs/178-547-6790/intel/miniqmc/build/miniqmc/src/Platforms/CPU/SIMD/Mallocator.hpp: 50 - 78
--------------------------------------------------------------------------------

50:     std::size_t asize = n * sizeof(T);
51:     std::size_t amod  = asize % ALIGN;
52:     if (amod != 0)
53:       asize += ALIGN - amod;
[...]
61:     pt = aligned_alloc(ALIGN, asize);
[...]
68:     if (pt == nullptr)
69:       throw std::runtime_error("Allocation failed in Mallocator, requested size in bytes = " +
70:                                std::to_string(n * sizeof(T)));
[...]
76:     if (n == 0)
77:       throw std::runtime_error("Mallocator::deallocate does not accept size 0 allocations.");
78:     free(p);
/usr/include/c++/14/bits/stl_uninitialized.h: 639 - 660
--------------------------------------------------------------------------------

639: 	  _ForwardIterator __cur = __first;
640: 	  __try
641: 	    {
642: 	      for (; __n > 0; --__n, (void) ++__cur)
[...]
660:         __uninit_default_n(_ForwardIterator __first, _Size __n)
/home/eoseret/qaas/qaas_runs/178-547-6790/intel/miniqmc/build/miniqmc/src/Numerics/OhmmsPETE/VectorSoAContainer.h: 231 - 231
--------------------------------------------------------------------------------

231:   inline const AoSElement_t operator[](size_t i) const { return AoSElement_t(myData + i, nGhosts); }
/usr/include/c++/14/bits/basic_string.h: 809 - 3721
--------------------------------------------------------------------------------

809:       { _M_dispose(); }
[...]
3721:     { return std::move(__rhs.insert(0, __lhs)); }
/usr/include/c++/14/bits/stl_vector.h: 98 - 1920
--------------------------------------------------------------------------------

98: 	_Vector_impl_data() _GLIBCXX_NOEXCEPT
99: 	: _M_start(), _M_finish(), _M_end_of_storage()
[...]
366:       ~_Vector_base() _GLIBCXX_NOEXCEPT
367:       {
368: 	_M_deallocate(_M_impl._M_start,
369: 		      _M_impl._M_end_of_storage - _M_impl._M_start);
[...]
380: 	return __n != 0 ? _Tr::allocate(_M_impl, __n) : pointer();
[...]
388: 	if (__p)
[...]
398: 	this->_M_impl._M_start = this->_M_allocate(__n);
399: 	this->_M_impl._M_finish = this->_M_impl._M_start;
400: 	this->_M_impl._M_end_of_storage = this->_M_impl._M_start + __n;
[...]
992:       size() const _GLIBCXX_NOEXCEPT
993:       { return size_type(this->_M_impl._M_finish - this->_M_impl._M_start); }
[...]
1131: 	return *(this->_M_impl._M_start + __n);
[...]
1150: 	return *(this->_M_impl._M_start + __n);
[...]
1719: 	this->_M_impl._M_finish =
[...]
1919: 	if (__n > _S_max_size(_Tp_alloc_type(__a)))
1920: 	  __throw_length_error(
/home/eoseret/qaas/qaas_runs/178-547-6790/intel/miniqmc/build/miniqmc/src/Drivers/NonLocalPP.hpp: 97 - 135
--------------------------------------------------------------------------------

97:   inline int size() const { return sgridxyz_m.size(); }
[...]
104:     RealType phi(TWOPI * (myRNG())), psi(TWOPI * (myRNG())), cth((myRNG()) - 0.5);
105:     RealType sph(std::sin(phi)), cph(std::cos(phi)), sth(std::sqrt(1.0 - cth * cth)), sps(std::sin(psi)),
106:         cps(std::cos(psi));
107:     TensorType rmat(cph * cth * cps - sph * sps, sph * cth * cps + cph * sps, -sth * cps, -cph * cth * sps - sph * cps,
108:                     -sph * cth * sps + cph * cps, sth * sps, cph * sth, sph * sth, cth);
109:     const int n = sgridxyz_m.size();
110:     for (int i = 0; i < n; ++i)
111:       rrotsgrid[i] = dot(rmat, sgridxyz_m[i]);
112:   }
113: 
114:   void evaluate(const ParticleSet& els, WaveFunction& wf)
115:   {
116:     ParticlePos rOnSphere(size());
117:     std::vector<QMCTraits::PosType> virtualPos(size());
118:     std::vector<QMCTraits::ValueType> ratios(size());
119:     randomize(rOnSphere); // pick random sphere
120:     const auto& d_ie = els.getDistTableAB(wf.get_ei_TableID());
121: 
122:     for (int jel = 0; jel < els.getTotalNum(); ++jel)
123:     {
124:       const auto& dist  = d_ie.getDistRow(jel);
125:       const auto& displ = d_ie.getDisplRow(jel);
126:       for (int iat = 0; iat < ions_ref.getTotalNum(); ++iat)
127:       {
128:         //due to < Rmax condition, the actually iteration iat is [0,2] in a real simulation
129:         if (dist[iat] < Rmax)
130:         {
131:           for (int k = 0; k < size(); k++)
132:             virtualPos[k] = dist[iat] * rOnSphere[k] + displ[iat] + els.R[jel];
133:           auto& VP = *VPs[ions_ref.GroupID[iat]];
134:           VP.makeMoves(els, jel, virtualPos, true, iat);
135:           wf.evaluateRatios(VP, ratios);
/home/eoseret/qaas/qaas_runs/178-547-6790/intel/miniqmc/build/miniqmc/src/Numerics/OhmmsPETE/TinyVector.h: 61 - 145
--------------------------------------------------------------------------------

61:     for (size_t d = 0; d < D; ++d)
62:       X[d] = T(0);
[...]
145:       X[i] = base[i * offset];
/usr/include/c++/14/bits/random.h: 1906 - 2011
--------------------------------------------------------------------------------

1906: 	{ return _M_a; }
[...]
2011: 	  return (__aurng() * (__p.b() - __p.a())) + __p.a();
/usr/include/c++/14/bits/unique_ptr.h: 193 - 193
--------------------------------------------------------------------------------

193:       pointer    _M_ptr() const noexcept { return std::get<0>(_M_t); }
/usr/include/c++/14/bits/new_allocator.h: 88 - 172
--------------------------------------------------------------------------------

88:       __new_allocator() _GLIBCXX_USE_NOEXCEPT { }
[...]
104:       ~__new_allocator() _GLIBCXX_USE_NOEXCEPT { }
[...]
134: 	if (__builtin_expect(__n > this->_M_max_size(), false))
135: 	  {
136: 	    // _GLIBCXX_RESOLVE_LIB_DEFECTS
137: 	    // 3190. allocator::allocate sometimes returns too little storage
138: 	    if (__n > (std::size_t(-1) / sizeof(_Tp)))
139: 	      std::__throw_bad_array_new_length();
[...]
151: 	return static_cast<_Tp*>(_GLIBCXX_OPERATOR_NEW(__n * sizeof(_Tp)));
[...]
172: 	_GLIBCXX_OPERATOR_DELETE(_GLIBCXX_SIZED_DEALLOC(__p, __n));
/home/eoseret/qaas/qaas_runs/178-547-6790/intel/miniqmc/build/miniqmc/src/Numerics/PETE/OperatorTags.h: 43 - 63
--------------------------------------------------------------------------------

43:     return (a + b);
[...]
63:     return (a * b);
/home/eoseret/qaas/qaas_runs/178-547-6790/intel/miniqmc/build/miniqmc/src/Drivers/miniqmc.cpp: 411 - 469
--------------------------------------------------------------------------------

411: #pragma omp parallel for reduction(+ : my_accepted)
412:     for (int iw = 0; iw < nmovers; iw++)
413:     {
414:       auto& els          = *mover_list[iw]->els_ptr;
415:       auto& random_th    = mover_list[iw]->rng;
416:       auto& wavefunction = mover_list[iw]->wavefunction;
417:       auto& ecp          = mover_list[iw]->nlpp;
418: 
419:       ParticlePos delta(nels);
420:       ParticlePos rOnSphere(nknots);
421: 
422:       aligned_vector<RealType> ur(nels);
423: 
424:       Timers[Timer_Diffusion].get().start();
425:       for (int l = 0; l < nsubsteps; ++l) // drift-and-diffusion
426:       {
427:         random_th.generate_uniform(ur.data(), nels);
428:         random_th.generate_normal(&delta[0][0], nels3);
429:         for (int iel = 0; iel < nels; ++iel)
430:         {
431:           // Compute gradient at the current position
432:           Timers[Timer_evalGrad].get().start();
433:           PosType grad_now = wavefunction.evalGrad(els, iel);
434:           Timers[Timer_evalGrad].get().stop();
435: 
436:           // Construct trial move
437:           els.makeMove(iel, delta[iel]);
438: 
439:           // Compute gradient at the trial position
440:           Timers[Timer_ratioGrad].get().start();
441:           PosType grad_new;
442:           wavefunction.ratioGrad(els, iel, grad_new);
443:           Timers[Timer_ratioGrad].get().stop();
444: 
445:           // Accept/reject the trial move
446:           if (ur[iel] < accept) // MC
447:           {
448:             // Update position, and update temporary storage
449:             Timers[Timer_Update].get().start();
450:             wavefunction.acceptMove(els, iel);
451:             Timers[Timer_Update].get().stop();
452:             els.acceptMove(iel);
453:             my_accepted++;
454:           }
455:           else
456:           {
457:             els.rejectMove(iel);
458:             wavefunction.restore(iel);
459:           }
460:         } // iel
461:         wavefunction.completeUpdates();
462:       }   // substeps
463: 
464:       els.donePbyP();
465: 
466:       // evaluate Kinetic Energy
467:       wavefunction.evaluateGL(els);
468: 
469:       Timers[Timer_Diffusion].get().stop();
/home/eoseret/qaas/qaas_runs/178-547-6790/intel/miniqmc/build/miniqmc/src/Utilities/StdRandom.h: 102 - 103
--------------------------------------------------------------------------------

102:     for (int i = 0; i < n; ++i)
103:       d[i] = uniform(myRNG);
/usr/include/c++/14/bits/random.tcc: 404 - 3374
--------------------------------------------------------------------------------

404:       for (size_t __k = 0; __k < (__n - __m); ++__k)
405:         {
406: 	  _UIntType __y = ((_M_x[__k] & __upper_mask)
407: 			   | (_M_x[__k + 1] & __lower_mask));
408: 	  _M_x[__k] = (_M_x[__k + __m] ^ (__y >> 1)
409: 		       ^ ((__y & 0x01) ? __a : 0));
410:         }
411: 
412:       for (size_t __k = (__n - __m); __k < (__n - 1); ++__k)
413: 	{
414: 	  _UIntType __y = ((_M_x[__k] & __upper_mask)
415: 			   | (_M_x[__k + 1] & __lower_mask));
416: 	  _M_x[__k] = (_M_x[__k + (__m - __n)] ^ (__y >> 1)
417: 		       ^ ((__y & 0x01) ? __a : 0));
418: 	}
419: 
420:       _UIntType __y = ((_M_x[__n - 1] & __upper_mask)
421: 		       | (_M_x[0] & __lower_mask));
422:       _M_x[__n - 1] = (_M_x[__m - 1] ^ (__y >> 1)
423: 		       ^ ((__y & 0x01) ? __a : 0));
424:       _M_p = 0;
425:     }
[...]
453:     mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d,
454: 			    __s, __b, __t, __c, __l, __f>::
455:     operator()()
456:     {
457:       // Reload the vector - cost is O(n) amortized over n calls.
458:       if (_M_p >= state_size)
459: 	_M_gen_rand();
460: 
461:       // Calculate o(x(i)).
462:       result_type __z = _M_x[_M_p++];
463:       __z ^= (__z >> __u) & __d;
464:       __z ^= (__z << __s) & __b;
465:       __z ^= (__z << __t) & __c;
466:       __z ^= (__z >> __l);
[...]
3363:       _RealType __sum = _RealType(0);
3364:       _RealType __tmp = _RealType(1);
3365:       for (size_t __k = __m; __k != 0; --__k)
3366: 	{
3367: 	  __sum += _RealType(__urng() - __urng.min()) * __tmp;
3368: 	  __tmp *= __r;
3369: 	}
3370:       __ret = __sum / __tmp;
3371:       if (__builtin_expect(__ret >= _RealType(1), 0))
3372: 	{
3373: #if _GLIBCXX_USE_C99_MATH_FUNCS
3374: 	  __ret = std::nextafter(_RealType(1), _RealType(0));
/home/eoseret/qaas/qaas_runs/178-547-6790/intel/miniqmc/build/miniqmc/src/Numerics/OhmmsPETE/OhmmsVector.h: 46 - 229
--------------------------------------------------------------------------------

46:   explicit inline Vector(size_t n = 0, Type_t val = Type_t()) : nLocal(n)
47:   {
48:     if (n)
[...]
210:     if (nAllocated)
[...]
229:     return X[i];
/home/eoseret/qaas/qaas_runs/178-547-6790/intel/miniqmc/build/miniqmc/src/Particle/ParticleSet.h: 277 - 277
--------------------------------------------------------------------------------

277:   inline size_t getTotalNum() const { return TotalNum; }
