void SpinAdapted::operatorfunctions::TensorProduct (const SpinBlock *ablock, const Baseoperator<Matrix>& a, const Baseoperator<Matrix>& b, const SpinBlock* cblock, const StateInfo* cstateinfo, DiagonalMatrix& cDiagonal, double scale)
{
if (fabs(scale) < TINY) return;
const int aSz = a.nrows();
const int bSz = b.nrows();
const char conjC = (cblock->get_leftBlock() == ablock) ? 'n' : 't';
const SpinBlock* bblock = (cblock->get_leftBlock() == ablock) ? cblock->get_rightBlock() : cblock->get_leftBlock();
const StateInfo& s = cblock->get_stateInfo();
const StateInfo* lS = s.leftStateInfo, *rS = s.rightStateInfo;
for (int aQ = 0; aQ < aSz; ++aQ)
if (a.allowed(aQ, aQ))
for (int bQ = 0; bQ < bSz; ++bQ)
if (b.allowed(bQ, bQ))
if (s.allowedQuanta (aQ, bQ, conjC))
{
int cQ = s.quantaMap (aQ, bQ, conjC)[0];
Real scaleA = scale;
Real scaleB = 1;
if (conjC == 'n')
{
scaleB *= dmrginp.get_ninej()(lS->quanta[aQ].get_s().getirrep() , rS->quanta[bQ].get_s().getirrep(), cstateinfo->quanta[cQ].get_s().getirrep(),
a.get_spin().getirrep(), b.get_spin().getirrep(), 0,
lS->quanta[aQ].get_s().getirrep() , rS->quanta[bQ].get_s().getirrep(), cstateinfo->quanta[cQ].get_s().getirrep());
scaleB *= Symmetry::spatial_ninej(lS->quanta[aQ].get_symm().getirrep() , rS->quanta[bQ].get_symm().getirrep(), cstateinfo->quanta[cQ].get_symm().getirrep(),
a.get_symm().getirrep(), b.get_symm().getirrep(), 0,
lS->quanta[aQ].get_symm().getirrep() , rS->quanta[bQ].get_symm().getirrep(), cstateinfo->quanta[cQ].get_symm().getirrep());
if (b.get_fermion() && IsFermion (lS->quanta [aQ])) scaleB *= -1.0;
for (int aQState = 0; aQState < lS->quantaStates[aQ] ; aQState++)
MatrixDiagonalScale(a.operator_element(aQ, aQ)(aQState+1, aQState+1)*scaleA*scaleB, b.operator_element(bQ, bQ),
cDiagonal.Store()+s.unBlockedIndex[cQ]+aQState*rS->quantaStates[bQ]);
}
else
{
scaleB *= dmrginp.get_ninej()(lS->quanta[bQ].get_s().getirrep() , rS->quanta[aQ].get_s().getirrep(), cstateinfo->quanta[cQ].get_s().getirrep(),
b.get_spin().getirrep(), a.get_spin().getirrep(), 0,
lS->quanta[bQ].get_s().getirrep() , rS->quanta[aQ].get_s().getirrep(), cstateinfo->quanta[cQ].get_s().getirrep());
scaleB *= Symmetry::spatial_ninej(lS->quanta[bQ].get_symm().getirrep() , rS->quanta[aQ].get_symm().getirrep(), cstateinfo->quanta[cQ].get_symm().getirrep(),
b.get_symm().getirrep(), a.get_symm().getirrep(), 0,
lS->quanta[bQ].get_symm().getirrep() , rS->quanta[aQ].get_symm().getirrep(), cstateinfo->quanta[cQ].get_symm().getirrep());
if (a.get_fermion()&& IsFermion(lS->quanta[bQ])) scaleB *= -1.0;
for (int bQState = 0; bQState < lS->quantaStates[bQ] ; bQState++)
MatrixDiagonalScale(b.operator_element(bQ, bQ)(bQState+1, bQState+1)*scaleA*scaleB, a.operator_element(aQ, aQ),
cDiagonal.Store()+s.unBlockedIndex[cQ]+bQState*rS->quantaStates[aQ]);
}
}
}
void SpinAdapted::diagonalise(Matrix& sym, DiagonalMatrix& d, Matrix& vec)
{
int nrows = sym.Nrows();
int ncols = sym.Ncols();
assert(nrows == ncols);
d.ReSize(nrows);
vec.ReSize(nrows, nrows);
Matrix workmat;
workmat = sym;
vector<double> workquery(1);
int info = 0;
double* dptr = d.Store();
int query = -1;
DSYEV('V', 'L', nrows, workmat.Store(), nrows, dptr, &(workquery[0]), query, info); // do query to find best size
int optlength = static_cast<int>(workquery[0]);
vector<double> workspace(optlength);
DSYEV('V', 'U', nrows, workmat.Store(), nrows, dptr, &(workspace[0]), optlength, info); // do query to find best size
if (info > 0)
{
pout << "failed to converge " << endl;
abort();
}
for (int i = 0; i < nrows; ++i)
for (int j = 0; j < ncols; ++j)
vec(j+1,i+1) = workmat(i+1,j+1);
}
void SpinAdapted::svd(Matrix& M, DiagonalMatrix& d, Matrix& U, Matrix& V)
{
int nrows = M.Nrows();
int ncols = M.Ncols();
assert(nrows >= ncols);
int minmn = min(nrows, ncols);
int maxmn = max(nrows, ncols);
int eigenrows = min(minmn, minmn);
d.ReSize(minmn);
Matrix Ut;
Ut.ReSize(nrows, nrows);
V.ReSize(ncols, ncols);
int lwork = maxmn * maxmn + 100;
double* workspace = new double[lwork];
// first transpose matrix
Matrix Mt;
Mt = M.t();
int info = 0;
DGESVD('A', 'A', nrows, ncols, Mt.Store(), nrows, d.Store(),
Ut.Store(), nrows, V.Store(), ncols, workspace, lwork, info);
U.ReSize(nrows, ncols);
SpinAdapted::Clear(U);
for (int i = 0; i < nrows; ++i)
for (int j = 0; j < ncols; ++j)
U(i+1,j+1) = Ut(j+1,i+1);
delete[] workspace;
}
static void tred3(const SymmetricMatrix& X, DiagonalMatrix& D,
DiagonalMatrix& E, SymmetricMatrix& A)
{
Tracer et("Evalue(tred3)");
Real tol =
FloatingPointPrecision::Minimum()/FloatingPointPrecision::Epsilon();
int n = X.Nrows(); A = X; D.ReSize(n); E.ReSize(n);
Real* ei = E.Store() + n;
for (int i = n-1; i >= 0; i--)
{
Real h = 0.0; Real f;
Real* d = D.Store(); Real* a = A.Store() + (i*(i+1))/2; int k = i;
while (k--) { f = *a++; *d++ = f; h += square(f); }
if (h <= tol) { *(--ei) = 0.0; h = 0.0; }
else
{
Real g = sign(-sqrt(h), f); *(--ei) = g; h -= f*g;
f -= g; *(d-1) = f; *(a-1) = f; f = 0.0;
Real* dj = D.Store(); Real* ej = E.Store(); int j;
for (j = 0; j < i; j++)
{
Real* dk = D.Store(); Real* ak = A.Store()+(j*(j+1))/2;
Real g = 0.0; k = j;
while (k--) g += *ak++ * *dk++;
k = i-j; int l = j;
while (k--) { g += *ak * *dk++; ak += ++l; }
g /= h; *ej++ = g; f += g * *dj++;
}
Real hh = f / (2 * h); Real* ak = A.Store();
dj = D.Store(); ej = E.Store();
for (j = 0; j < i; j++)
{
f = *dj++; g = *ej - hh * f; *ej++ = g;
Real* dk = D.Store(); Real* ek = E.Store(); k = j+1;
while (k--) { *ak++ -= (f * *ek++ + g * *dk++); }
}
}
*d = *a; *a = h;
}
}
static void tred2(const SymmetricMatrix& A, DiagonalMatrix& D,
DiagonalMatrix& E, Matrix& Z)
{
Tracer et("Evalue(tred2)");
Real tol =
FloatingPointPrecision::Minimum()/FloatingPointPrecision::Epsilon();
int n = A.Nrows(); Z.ReSize(n,n); Z.Inject(A);
D.ReSize(n); E.ReSize(n);
Real* z = Z.Store(); int i;
for (i=n-1; i > 0; i--) // i=0 is excluded
{
Real f = Z.element(i,i-1); Real g = 0.0;
int k = i-1; Real* zik = z + i*n;
while (k--) g += square(*zik++);
Real h = g + square(f);
if (g <= tol) { E.element(i) = f; h = 0.0; }
else
{
g = sign(-sqrt(h), f); E.element(i) = g; h -= f*g;
Z.element(i,i-1) = f-g; f = 0.0;
Real* zji = z + i; Real* zij = z + i*n; Real* ej = E.Store();
int j;
for (j=0; j<i; j++)
{
*zji = (*zij++)/h; g = 0.0;
Real* zjk = z + j*n; zik = z + i*n;
k = j; while (k--) g += *zjk++ * (*zik++);
k = i-j; while (k--) { g += *zjk * (*zik++); zjk += n; }
*ej++ = g/h; f += g * (*zji); zji += n;
}
Real hh = f / (h + h); zij = z + i*n; ej = E.Store();
for (j=0; j<i; j++)
{
f = *zij++; g = *ej - hh * f; *ej++ = g;
Real* zjk = z + j*n; Real* zik = z + i*n;
Real* ek = E.Store(); k = j+1;
while (k--) *zjk++ -= ( f*(*ek++) + g*(*zik++) );
}
}
D.element(i) = h;
}
D.element(0) = 0.0; E.element(0) = 0.0;
for (i=0; i<n; i++)
{
if (D.element(i) != 0.0)
{
for (int j=0; j<i; j++)
{
Real g = 0.0;
Real* zik = z + i*n; Real* zkj = z + j;
int k = i; while (k--) { g += *zik++ * (*zkj); zkj += n; }
Real* zki = z + i; zkj = z + j;
k = i; while (k--) { *zkj -= g * (*zki); zkj += n; zki += n; }
}
}
Real* zij = z + i*n; Real* zji = z + i;
int j = i; while (j--) { *zij++ = 0.0; *zji = 0.0; zji += n; }
D.element(i) = *zij; *zij = 1.0;
}
}