mirror of https://github.com/QMCPACK/qmcpack.git
remove use of deprecated functions
This commit is contained in:
parent
3a9aad1da9
commit
fe957ad06a
|
@ -99,9 +99,9 @@ inline void calculate_energy(EMat&& locV, const MatA& Gc, MatB&& Gcloc, const Sp
|
|||
// W[nwalk][2][NMO][NAEA]
|
||||
|
||||
assert(locV.dimensionality == 2);
|
||||
assert(Gc.size(1) == Gcloc.size(1));
|
||||
assert(Vakbl.size(0) == Gcloc.size(0));
|
||||
assert(Gc.size(0) == Vakbl.size(1));
|
||||
assert(std::get<1>(Gc.sizes()) == std::get<1>(Gcloc.sizes()));
|
||||
assert(Vakbl.size(0) == std::get<0>(Gcloc.sizes()));
|
||||
assert(std::get<0>(Gc.sizes()) == Vakbl.size(1));
|
||||
|
||||
using Type = typename std::decay<EMat>::type::element;
|
||||
const Type half = Type(0.5);
|
||||
|
|
|
@ -213,10 +213,10 @@ template<class MultiArray3D,
|
|||
typename = typename std::enable_if<std::decay<MultiArray2D>::type::dimensionality == 2>>
|
||||
void get_diagonal_strided(MultiArray3D const& B, MultiArray2D&& A)
|
||||
{
|
||||
if (A.size(0) != B.size(0) || A.size(1) != B.size(1) || A.size(1) != B.size(2) || A.stride(1) != 1 ||
|
||||
if (std::get<0>(A.sizes()) != std::get<0>(B.sizes()) || std::get<1>(A.sizes()) != std::get<1>(B.sizes()) || std::get<1>(A.sizes()) != std::get<2>(B.sizes()) || A.stride(1) != 1 ||
|
||||
B.stride(2) != 1)
|
||||
throw std::runtime_error(" Error: Inconsistent matrix dimensions in get_diagonal_strided.\n");
|
||||
get_diagonal_strided(A.size(0), A.size(1), pointer_dispatch(B.origin()), B.stride(1), B.stride(0),
|
||||
get_diagonal_strided(std::get<0>(A.sizes()), std::get<1>(A.sizes()), pointer_dispatch(B.origin()), B.stride(1), B.stride(0),
|
||||
pointer_dispatch(A.origin()), A.stride(0));
|
||||
}
|
||||
|
||||
|
|
|
@ -225,7 +225,7 @@ MultiArray2D&& gesvd(char jobU,
|
|||
// in F: At = (U * S * VT)t = VTt * S * Ut
|
||||
// so I need to switch U <--> VT when calling fortran interface
|
||||
int status = -1;
|
||||
gesvd(jobVT, jobU, A.size(1), A.size(0), pointer_dispatch(A.origin()), A.stride(0), pointer_dispatch(S.origin()),
|
||||
gesvd(jobVT, jobU, std::get<1>(A.sizes()), std::get<0>(A.sizes()), pointer_dispatch(A.origin()), A.stride(0), pointer_dispatch(S.origin()),
|
||||
pointer_dispatch(VT.origin()), VT.stride(0), // !!!
|
||||
pointer_dispatch(U.origin()), U.stride(0), // !!!
|
||||
pointer_dispatch(WORK.data()), WORK.size(), pointer_dispatch(RWORK.origin()), status);
|
||||
|
|
|
@ -82,8 +82,8 @@ public:
|
|||
template<class MatA, class MatB, class MatC>
|
||||
T MixedDensityMatrix(const MatA& hermA, const MatB& B, MatC&& C, T LogOverlapFactor, bool compact, bool herm = true)
|
||||
{
|
||||
int NMO = (herm ? hermA.size(1) : hermA.size(0));
|
||||
int NAEA = (herm ? hermA.size(0) : hermA.size(1));
|
||||
int NMO = (herm ? std::get<1>(hermA.sizes()) : std::get<0>(hermA.sizes()));
|
||||
int NAEA = (herm ? std::get<0>(hermA.sizes()) : std::get<1>(hermA.sizes()));
|
||||
TMatrix TNN({NAEA, NAEA}, buffer_manager.get_generator().template get_allocator<T>());
|
||||
TMatrix TNM({NAEA, NMO}, buffer_manager.get_generator().template get_allocator<T>());
|
||||
TVector WORK(iextensions<1u>{work_size}, buffer_manager.get_generator().template get_allocator<T>());
|
||||
|
|
|
@ -233,10 +233,10 @@ public:
|
|||
static_assert(pointedType<MatB>::dimensionality == 2, "Wrong dimensionality");
|
||||
static_assert(std::decay<MatC>::type::dimensionality == 3, "Wrong dimensionality");
|
||||
static_assert(std::decay<TVec>::type::dimensionality == 1, "Wrong dimensionality");
|
||||
int NMO = (herm ? (*hermA[0]).size(1) : (*hermA[0]).size(0));
|
||||
int NAEA = (herm ? (*hermA[0]).size(0) : (*hermA[0]).size(1));
|
||||
int NMO = (herm ? std::get<1>((*hermA[0]).sizes()) : std::get<0>((*hermA[0]).sizes()));
|
||||
int NAEA = (herm ? std::get<0>((*hermA[0]).sizes()) : std::get<1>((*hermA[0]).sizes()));
|
||||
int nbatch = Bi.size();
|
||||
assert(C.size(0) == nbatch);
|
||||
assert(C.size() == nbatch);
|
||||
assert(ovlp.size() == nbatch);
|
||||
int n1 = nbatch, n2 = NAEA, n3 = NMO;
|
||||
if (compact)
|
||||
|
|
|
@ -1150,25 +1150,25 @@ void DensityMatrices(std::vector<MatA> const& Left,
|
|||
using ma::T;
|
||||
|
||||
int nbatch = Right.size();
|
||||
int NMO = (herm ? (*Left[0]).size(1) : (*Left[0]).size(0));
|
||||
int NEL = (herm ? (*Left[0]).size(0) : (*Left[0]).size(1));
|
||||
int NMO = (herm ? std::get<1>((*Left[0]).sizes()) : std::get<0>((*Left[0]).sizes()));
|
||||
int NEL = (herm ? std::get<0>((*Left[0]).sizes()) : std::get<1>((*Left[0]).sizes()));
|
||||
|
||||
assert((*Right[0]).size(0) == NMO);
|
||||
assert((*Right[0]).size(1) == NEL);
|
||||
assert(std::get<0>((*Right[0]).sizes()) == NMO);
|
||||
assert(std::get<1>((*Right[0]).sizes()) == NEL);
|
||||
assert(G.size() == nbatch);
|
||||
assert((*G[0]).size(1) == NMO);
|
||||
assert(std::get<1>((*G[0]).sizes()) == NMO);
|
||||
if (compact)
|
||||
assert((*G[0]).size(0) == NEL);
|
||||
assert((*G[0]).size() == NEL);
|
||||
else
|
||||
assert((*G[0]).size(0) == NMO);
|
||||
assert((*G[0]).size() == NMO);
|
||||
assert(ovlp.size() == nbatch);
|
||||
assert(TNN3D.size(1) == NEL);
|
||||
assert(TNN3D.size(2) == NEL);
|
||||
assert(std::get<1>(TNN3D.sizes()) == NEL);
|
||||
assert(std::get<2>(TNN3D.sizes()) == NEL);
|
||||
if (not compact)
|
||||
{
|
||||
assert(TNM3D.size(0) == nbatch);
|
||||
assert(TNM3D.size(1) == NEL);
|
||||
assert(TNM3D.size(2) == NMO);
|
||||
assert(std::get<0>(TNM3D.sizes()) == nbatch);
|
||||
assert(std::get<1>(TNM3D.sizes()) == NEL);
|
||||
assert(std::get<2>(TNM3D.sizes()) == NMO);
|
||||
}
|
||||
assert(IWORK.num_elements() >= nbatch * (NEL + 1));
|
||||
|
||||
|
|
Loading…
Reference in New Issue