/*
void SpinAdapted::operatorfunctions::TensorMultiply(const SpinBlock *ablock, const Baseoperator<Matrix>& a, const Baseoperator<Matrix>& b, const SpinBlock *cblock, Wavefunction& c, Wavefunction& v, const SpinQuantum opQ, double scale)
{
// can be used for situation with different bra and ket
const int leftBraOpSz = cblock->get_leftBlock()->get_braStateInfo().quanta.size ();
const int leftKetOpSz = cblock->get_leftBlock()->get_ketStateInfo().quanta.size ();
const int rightBraOpSz = cblock->get_rightBlock()->get_braStateInfo().quanta.size ();
const int rightKetOpSz = cblock->get_rightBlock()->get_ketStateInfo().quanta.size ();
const StateInfo* lbraS = cblock->get_braStateInfo().leftStateInfo, *rbraS = cblock->get_braStateInfo().rightStateInfo;
const StateInfo* lketS = cblock->get_ketStateInfo().leftStateInfo, *rketS = cblock->get_ketStateInfo().rightStateInfo;
const char conjC = (cblock->get_leftBlock() == ablock) ? 'n' : 't';
const Baseoperator<Matrix>& leftOp = (conjC == 'n') ? a : b; // an ugly hack to support the release memory optimisation
const Baseoperator<Matrix>& rightOp = (conjC == 'n') ? b : a;
const char leftConj = (conjC == 'n') ? a.conjugacy() : b.conjugacy();
const char rightConj = (conjC == 'n') ? b.conjugacy() : a.conjugacy();
Wavefunction u;
u.resize(leftBraOpSz*leftKetOpSz, rightKetOpSz);
int totalmem =0;
{
for (int lQrQPrime = 0; lQrQPrime<leftBraOpSz*rightKetOpSz; ++lQrQPrime)
{
int rQPrime = lQrQPrime%rightKetOpSz, lQ = lQrQPrime/rightKetOpSz;
for (int lQPrime = 0; lQPrime < leftKetOpSz; lQPrime++)
if (leftOp.allowed(lQ, lQPrime) && c.allowed(lQPrime, rQPrime))
{
int lindex = lQ*leftKetOpSz+lQPrime;
u.allowed(lindex, rQPrime) = true;
u(lindex,rQPrime).ReSize(lbraS->getquantastates(lQ), rketS->getquantastates(rQPrime));
double factor = leftOp.get_scaling(lbraS->quanta[lQ], lketS->quanta[lQPrime]);
MatrixMultiply (leftOp.operator_element(lQ, lQPrime), leftConj, c.operator_element(lQPrime, rQPrime), 'n',
u.operator_element(lindex, rQPrime), factor, 0.);
}
}
}
pout << "after first step in tensormultiply"<<endl;
mcheck("before davidson but after all blocks are built");
{
for (int lQrQ = 0; lQrQ<leftBraOpSz*rightBraOpSz; ++lQrQ)
{
int rQ = lQrQ%rightBraOpSz, lQ=lQrQ/rightBraOpSz;
if (v.allowed(lQ, rQ))
for (int rQPrime = 0; rQPrime < rightKetOpSz; rQPrime++)
if (rightOp.allowed(rQ, rQPrime))
for (int lQPrime = 0; lQPrime < leftKetOpSz; lQPrime++)
if (leftOp.allowed(lQ, lQPrime) && u.allowed(lQ*leftKetOpSz+lQPrime, rQPrime))
{
int lindex = lQ*leftKetOpSz+lQPrime;
double factor = scale;
factor *= dmrginp.get_ninej()(lketS->quanta[lQPrime].get_s().getirrep(), rketS->quanta[rQPrime].get_s().getirrep() , c.get_deltaQuantum(0).get_s().getirrep(),
leftOp.get_spin().getirrep(), rightOp.get_spin().getirrep(), opQ.get_s().getirrep(),
lbraS->quanta[lQ].get_s().getirrep(), rbraS->quanta[rQ].get_s().getirrep() , v.get_deltaQuantum(0).get_s().getirrep());
factor *= Symmetry::spatial_ninej(lketS->quanta[lQPrime].get_symm().getirrep() , rketS->quanta[rQPrime].get_symm().getirrep(), c.get_symm().getirrep(),
leftOp.get_symm().getirrep(), rightOp.get_symm().getirrep(), opQ.get_symm().getirrep(),
lbraS->quanta[lQ].get_symm().getirrep() , rbraS->quanta[rQ].get_symm().getirrep(), v.get_symm().getirrep());
int parity = rightOp.get_fermion() && IsFermion(lketS->quanta[lQPrime]) ? -1 : 1;
factor *= rightOp.get_scaling(rbraS->quanta[rQ], rketS->quanta[rQPrime]);
MatrixMultiply (u.operator_element(lindex, rQPrime), 'n',
rightOp(rQ, rQPrime), TransposeOf(rightOp.conjugacy()), v.operator_element(lQ, rQ), factor*parity);
}
}
}
}
*/
void SpinAdapted::operatorfunctions::OperatorScaleAdd(double scaleV, const SpinBlock& b, const Baseoperator<Matrix>& op1, Baseoperator<Matrix>& op2)
{
const StateInfo& s = b.get_stateInfo();
for (int lQ = 0; lQ< op2.nrows(); lQ++)
for (int rQ = 0; rQ<op2.ncols(); rQ++)
if (op2.allowed(lQ, rQ) && op1.allowed(lQ,rQ))
{
double factor = op1.get_scaling(s.quanta[lQ], s.quanta[rQ]);
if (op1.conjugacy() == 't')
MatrixScaleAdd(scaleV*factor, op1.operator_element(lQ,rQ).t(), op2.operator_element(lQ,rQ));
else
MatrixScaleAdd(scaleV*factor, op1.operator_element(lQ,rQ), op2.operator_element(lQ,rQ));
}
}
SparseMatrix& SparseMatrix::operator+=(const SparseMatrix& other)
{
for (int i = 0; i < nrows(); ++i)
for (int j = 0; j < ncols(); ++j)
if (allowed(i, j))
{
assert(other.allowed(i, j));
MatrixScaleAdd(1., other.operator_element(i, j), operator_element(i, j));
}
return *this;
}
void ScaleAdd(double d, const SparseMatrix& a, SparseMatrix& b)
{
for (int lQ = 0; lQ < a.nrows(); ++lQ)
for (int rQ = 0; rQ < a.ncols(); ++rQ)
if (a.allowed(lQ, rQ))
{
if (!b.allowed(lQ, rQ))
cout <<"Not a valid addition"<<endl;
assert(b.allowed(lQ, rQ));
MatrixScaleAdd(d, a.operator_element(lQ, rQ), b.operator_element(lQ, rQ));
}
}
