/beegfs/hackathon/users/eoseret/qaas_runs_test/178-654-6841/intel/miniqmc/build/miniqmc/src/QMCWaveFunctions/DeterminantHelper.h: 40 - 47
--------------------------------------------------------------------------------

40:   if (psi < 0.0)
41:   {
42:     phase = M_PI;
43:     return std::log(-psi);
44:   }
45:   else
46:   {
47:     phase = 0.0;
/beegfs/hackathon/users/eoseret/qaas_runs_test/178-654-6841/intel/miniqmc/build/miniqmc/src/Numerics/PETE/OperatorTags.h: 63 - 94
--------------------------------------------------------------------------------

63:     return (a * b);
[...]
94:     (const_cast<T1&>(a) += b);
/beegfs/hackathon/users/eoseret/qaas_runs_test/178-654-6841/intel/miniqmc/build/miniqmc/src/QMCWaveFunctions/DiracMatrix.h: 29 - 121
--------------------------------------------------------------------------------

29:   T logdet(0);
30:   int sign_det = 1;
31:   for (size_t i = 0; i < n; i++)
32:   {
33:     sign_det *= (pivot[i] == i + 1) ? 1 : -1;
34:     sign_det *= (diag[i] > 0) ? 1 : -1;
35:     logdet += std::log(std::abs(diag[i]));
36:   }
37:   phase = (sign_det > 0) ? T(0) : M_PI;
[...]
76:     m_pivot.resize(lda);
77:     Lwork = -1;
[...]
83:     Lwork = static_cast<int>(lw);
84:     m_work.resize(Lwork);
[...]
96:     BlasThreadingEnv knob(getNextLevelNumThreads());
97:     const int n   = invMat.rows();
98:     const int lda = invMat.cols();
99:     T_FP* invMat_ptr(nullptr);
100: #if !defined(MIXED_PRECISION)
101:     simd::transpose(amat.data(), n, amat.cols(), invMat.data(), n, invMat.cols());
[...]
108:     if (Lwork < lda)
109:       reset(invMat_ptr, lda);
110:     int status;
111:     LAPACK::getrf(n, n, invMat_ptr, lda, m_pivot.data(), status);
112:     for (int i = 0; i < n; i++)
113:       LU_diag[i] = invMat_ptr[i * lda + i];
114:     real_type_fp Phase_tmp;
115:     LogDet = computeLogDet(LU_diag.data(), n, m_pivot.data(), Phase_tmp);
116:     Phase  = Phase_tmp;
117:     LAPACK::getri(n, invMat_ptr, lda, m_pivot.data(), m_work.data(), Lwork, status);
118: #if defined(MIXED_PRECISION)
119:     invMat = psiM_fp;
120: #endif
121:   }
/cluster/comp/gcc/15.1.0/include/c++/15.1.0/bits/unique_ptr.h: 193 - 193
--------------------------------------------------------------------------------

193:       pointer    _M_ptr() const noexcept { return std::get<0>(_M_t); }
/beegfs/hackathon/users/eoseret/qaas_runs_test/178-654-6841/intel/miniqmc/build/miniqmc/src/Utilities/OpenMP.h: 38 - 38
--------------------------------------------------------------------------------

38: #pragma omp parallel
/beegfs/hackathon/users/eoseret/qaas_runs_test/178-654-6841/intel/miniqmc/build/miniqmc/src/Numerics/OhmmsPETE/OhmmsMatrix.h: 78 - 217
--------------------------------------------------------------------------------

78:   inline size_type cols() const { return D2; }
[...]
217:   inline Type_t* operator[](size_type i) { return X.data() + i * D2; }
/cluster/comp/gcc/15.1.0/include/c++/15.1.0/bits/vector.tcc: 763 - 841
--------------------------------------------------------------------------------

763: 	  size_type __navail = size_type(this->_M_impl._M_end_of_storage
764: 					 - this->_M_impl._M_finish);
765: 
766: 	  if (__size > max_size() || __navail > max_size() - __size)
767: 	    __builtin_unreachable();
768: 
769: 	  if (__navail >= __n)
[...]
775: 	      this->_M_impl._M_finish =
[...]
794: 		std::__uninitialized_default_n_a(__new_start + __size, __n,
[...]
839: 	      this->_M_impl._M_start = __new_start;
840: 	      this->_M_impl._M_finish = __new_start + __size + __n;
841: 	      this->_M_impl._M_end_of_storage = __new_start + __len;
/cluster/comp/gcc/15.1.0/include/c++/15.1.0/bits/new_allocator.h: 104 - 172
--------------------------------------------------------------------------------

104:       ~__new_allocator() _GLIBCXX_USE_NOEXCEPT { }
[...]
172: 	_GLIBCXX_OPERATOR_DELETE(_GLIBCXX_SIZED_DEALLOC(__p, __n));
/cluster/comp/gcc/15.1.0/include/c++/15.1.0/bits/basic_string.h: 896 - 3963
--------------------------------------------------------------------------------

896:       { _M_dispose(); }
[...]
3963:     { return std::move(__rhs.insert(0, __lhs)); }
/beegfs/hackathon/users/eoseret/qaas_runs_test/178-654-6841/intel/miniqmc/build/miniqmc/src/Numerics/OhmmsPETE/TinyVectorOps.h: 129 - 131
--------------------------------------------------------------------------------

129:     Type_t res = lhs[0] * rhs[0];
130:     for (unsigned d = 1; d < D; ++d)
131:       res += lhs[d] * rhs[d];
/cluster/comp/gcc/15.1.0/include/c++/15.1.0/bits/std_abs.h: 78 - 78
--------------------------------------------------------------------------------

78:   { return __builtin_fabs(__x); }
/beegfs/hackathon/users/eoseret/qaas_runs_test/178-654-6841/intel/miniqmc/build/miniqmc/src/Platforms/CPU/SIMD/Mallocator.hpp: 50 - 79
--------------------------------------------------------------------------------

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);
79:   }
/beegfs/hackathon/users/eoseret/qaas_runs_test/178-654-6841/intel/miniqmc/build/miniqmc/src/Numerics/OhmmsPETE/OhmmsVector.h: 56 - 248
--------------------------------------------------------------------------------

56:   explicit inline Vector(T* ref, size_t n) : nLocal(n), X(ref) {}
[...]
210:     if (nAllocated)
[...]
221:   inline Type_t& operator[](size_t i)
222:   {
223:     return X[i];
[...]
248:   inline pointer data() { return X; }
/beegfs/hackathon/users/eoseret/qaas_runs_test/178-654-6841/intel/miniqmc/build/miniqmc/src/QMCWaveFunctions/DiracDeterminantRef.cpp: 53 - 269
--------------------------------------------------------------------------------

53:   InverseTimer->start();
54:   updateEng.invert_transpose(logdetT, invMat, LogValue, PhaseValue);
55:   InverseTimer->stop();
[...]
231: typename DiracDeterminantRef<DU_TYPE>::RealType DiracDeterminantRef<DU_TYPE>::evaluateLog(
[...]
238:   if (NumPtcls == 1)
239:   {
240:     ValueType y = psiM(0, 0);
241:     GradType rv = y * dpsiM(0, 0);
242:     G[FirstIndex] += rv;
243:     L[FirstIndex] += y * d2psiM(0, 0) - dot(rv, rv);
244:   }
245:   else
246:   {
247:     for (int i = 0, iat = FirstIndex; i < NumPtcls; i++, iat++)
248:     {
249:       mGradType rv   = simd::dot(psiM[i], dpsiM[i], NumOrbitals);
250:       mValueType lap = simd::dot(psiM[i], d2psiM[i], NumOrbitals);
251:       G[iat] += rv;
252:       L[iat] += lap - dot(rv, rv);
253:     }
254:   }
255:   return LogValue;
256: }
257: 
258: template<typename DU_TYPE>
259: void DiracDeterminantRef<DU_TYPE>::recompute(ParticleSet& P)
260: {
261:   SPOVGLTimer->start();
262:   Phi->evaluate_notranspose(P, FirstIndex, LastIndex, psiM_temp, dpsiM, d2psiM);
263:   SPOVGLTimer->stop();
264:   if (NumPtcls == 1)
265:   {
266:     //CurrentDet=psiM(0,0);
267:     ValueType det = psiM_temp(0, 0);
268:     psiM(0, 0)    = RealType(1) / det;
269:     LogValue      = evaluateLogAndPhase(det, PhaseValue);
/cluster/comp/gcc/15.1.0/include/c++/15.1.0/bits/stl_construct.h: 133 - 133
--------------------------------------------------------------------------------

133:       ::new(static_cast<void*>(__p)) _Tp(std::forward<_Args>(__args)...);
/beegfs/hackathon/users/eoseret/qaas_runs_test/178-654-6841/intel/miniqmc/build/miniqmc/src/Platforms/CPU/BLAS.hpp: 790 - 828
--------------------------------------------------------------------------------

790:     dgetrf(n, m, a, n0, piv, st);
[...]
827:     dgetri(n, a, n0, piv, work, n1, status);
828:   }
/beegfs/hackathon/users/eoseret/qaas_runs_test/178-654-6841/intel/miniqmc/build/miniqmc/src/Platforms/CPU/SIMD/inner_product.hpp: 82 - 212
--------------------------------------------------------------------------------

82:   for (int i = 0; i < n; i++)
83:     res += a[i] * b[i];
[...]
155:   for (int i = 0; i < n; i++)
[...]
210:   for (size_t i = 0; i < n; ++i)
211:     for (size_t j = 0; j < m; ++j)
212:       B[i * ldb + j] = A[j * lda + i];
/beegfs/hackathon/users/eoseret/qaas_runs_test/178-654-6841/intel/miniqmc/build/miniqmc/src/Numerics/OhmmsPETE/TinyVector.h: 62 - 62
--------------------------------------------------------------------------------

62:       X[d] = T(0);
/cluster/comp/gcc/15.1.0/include/c++/15.1.0/bits/stl_vector.h: 1119 - 2239
--------------------------------------------------------------------------------

1119: 	ptrdiff_t __dif = this->_M_impl._M_finish - this->_M_impl._M_start;
[...]
1145: 	if (__new_size > size())
1146: 	  _M_default_append(__new_size - size());
1147: 	else if (__new_size < size())
1148: 	  _M_erase_at_end(this->_M_impl._M_start + __new_size);
[...]
1396:       { return _M_data_ptr(this->_M_impl._M_start); }
[...]
1880: 	~_Guard_alloc()
1881: 	{
1882: 	  if (_M_storage)
[...]
2198: 	if (max_size() - size() < __n)
2199: 	  __throw_length_error(__N(__s));
2200: 
2201: 	const size_type __len = size() + (std::max)(size(), __n);
[...]
2235: 	if (size_type __n = this->_M_impl._M_finish - __pos)
2236: 	  {
2237: 	    std::_Destroy(__pos, this->_M_impl._M_finish,
2238: 			  _M_get_Tp_allocator());
2239: 	    this->_M_impl._M_finish = __pos;
/beegfs/hackathon/users/eoseret/qaas_runs_test/178-654-6841/intel/miniqmc/build/miniqmc/src/QMCWaveFunctions/DelayedUpdate.h: 79 - 79
--------------------------------------------------------------------------------

79:     delay_count = 0;
/cluster/comp/gcc/15.1.0/include/c++/15.1.0/bits/stl_uninitialized.h: 1309 - 1310
--------------------------------------------------------------------------------

1309:       _ForwardIterator __cur = __result;
1310:       for (; __first != __last; ++__first, (void)++__cur)
/cluster/comp/gcc/15.1.0/include/c++/15.1.0/bits/stl_algobase.h: 263 - 263
--------------------------------------------------------------------------------

263:       if (__a < __b)
/beegfs/hackathon/users/eoseret/qaas_runs_test/178-654-6841/intel/miniqmc/build/miniqmc/src/QMCWaveFunctions/SPOSet.h: 106 - 111
--------------------------------------------------------------------------------

106:     for (int iat = first, i = 0; iat < last; ++iat, ++i)
107:     {
108:       ValueVector_t v(logdet[i], OrbitalSetSize);
109:       GradVector_t g(dlogdet[i], OrbitalSetSize);
110:       ValueVector_t l(d2logdet[i], OrbitalSetSize);
111:       evaluate(P, iat, v, g, l);
