void SpinAdapted::Csf::applyRowminus(Csf& output, int irrep)
{
map<Slater, double>::iterator itout, it = det_rep.begin();
map<Slater, double> detsout;
for ( ; it!= det_rep.end(); it++)
for (int i=0; i<dmrginp.last_site(); i++) {
if (SymmetryOfSpatialOrb(i).getirrep() != irrep)
continue;
int I = dmrginp.spatial_to_spin()[i];
for (int j=0; j<2; j++) {
Slater s = (*it).first;
int sign = s.getSign();
s.d(I+2+j).c(I+j);
s.setSign(sign); //This is a hack.
if ( !s.isempty()) {
itout = detsout.find(s);
if (itout == detsout.end())
detsout[s] = (*it).second;
else
detsout[s] += (*it).second;
}
}
}
output.set_det_rep(detsout, S, IrrepVector(this->irrep.getirrep(), 0));
}
void test2() {
std::cout << "newSlaterTest test 2" << std::endl;
double errorThreshold = 1e-5;
int dim = 2;
int nParticles = 6;
double alpha = 0.987;
double w = 1.0;
long idum = -1;
int cycles = 1000;
mat rInit = randu(nParticles, dim);
mat rNew = rInit;
//--------------------------------------------------------------------------
// Analytic
Orbital *orbital = new QDOrbital(dim, alpha, w);
Slater *slater = new Slater(dim, nParticles, orbital);
slater->setPosition(rInit, 0);
slater->init();
slater->acceptPosition();
//--------------------------------------------------------------------------
// Moving one particle
for (int n = 0; n < cycles; n++) {
for (int i = 0; i < nParticles; i++) {
for (int d = 0; d < dim; d++)
rNew(i, d) = 2 * (ran3(&idum) - 0.5);
slater->setPosition(rNew, i);
slater->updateMatrix();
slater->updateInverse();
slater->acceptPosition();
// Sum over Laplace elements
double laplace = 0;
double laplaceNumeric = 0;
for (int j = 0; j < nParticles; j++) {
laplace += slater->getLaplacian(j);
laplaceNumeric += slater->getLaplacianNumerical(j);
}
if (abs(laplace - laplaceNumeric) > errorThreshold)
std::cout << "%TEST_FAILED% time=0 testname=test2 (newSlaterTest) message=Analytic solution not matching numeric." << endl
<< "Differeance = " << abs(laplace - laplaceNumeric) << " "
<< "\t laplace = " << laplace << " "
<< "\t laplaceNumeric = " << laplaceNumeric << " "
<< std::endl;
}
}
}
double SpinAdapted::det_energy (const Slater& s)
{
// energy of a single slater determinant, used in truncation
double energy = 0;
Slater bra;
Slater ket;
for (int i = 0; i < s.size (); ++i)
{
ket = s;
bra = s;
energy += ket.trace (bra.d(i).c(i)) *
v_1 (i,i);
}
// diagonal
for (int i = 0; i < s.size (); ++i)
for (int j = 0; j < s.size (); ++j)
{
ket = s;
bra = s;
energy += .5 * ket.trace (bra.d(j).d(i).c(j).c(i))
* (v_2 (i,j,j,i) - v_2 (i,j,i,j));
}
return energy;
}
void SpinAdapted::Csf::applySminus(Csf& output)
{
map<Slater, double>::iterator itout, it = det_rep.begin();
map<Slater, double> detsout;
for ( ; it!= det_rep.end(); it++)
for (int i=0; i<Slater().size(); i+=2) {
Slater s = (*it).first;
s.d(i).c(i+1);
if ( !s.isempty()) {
itout = detsout.find(s);
if (itout == detsout.end())
detsout[s] = (*it).second;
else
detsout[s] += (*it).second;
}
}
output.set_det_rep(detsout, S, irrep);
output.set_S(S);
output.set_Sz(Sz-2);
output.set_n(n);
output.normalize();
}
bool Slater::operator== (const Slater& b) const
{
if (this->size() != b.size())
{
return 0;
}
for (int i = 0; i < this->size(); ++i)
{
if ((*this)[i] != b[i])
{
return 0;
}
}
return 1;
}
void testingInverse() {
std::cout << "newSlaterTest test 1" << std::endl;
double errorThreshold = 1e-4;
int dim = 2;
int nParticles = 12;
double alpha = 0.987;
double w = 1.0;
long idum = -1;
int cycles = 20;
mat rInit = randu(nParticles, dim);
mat rNew = rInit;
mat rOld = rInit;
//--------------------------------------------------------------------------
// Analytic
Orbital *orbital = new QDOrbital(dim, alpha, w);
Slater *slater = new Slater(dim, nParticles, orbital);
slater->setPosition(rInit, 0);
slater->init();
slater->acceptPosition();
//--------------------------------------------------------------------------
// Numeric
Orbital *orbitalNumeric = new QDOrbital(dim, alpha, w);
Slater *slaterNumeric = new Slater(dim, nParticles, orbitalNumeric);
slaterNumeric->setPosition(rInit, 0);
slaterNumeric->init();
slaterNumeric->acceptPosition();
//--------------------------------------------------------------------------
// Moving one particle
for (int n = 0; n < cycles; n++) {
for (int i = 0; i < nParticles; i++) {
for (int d = 0; d < dim; d++)
rNew(i, d) = 2 * (ran3(&idum) - 0.5);
// Updating analytic
slater->setPosition(rNew, i);
slater->updateMatrix();
// Updating numeric
slaterNumeric->setPosition(rNew, i);
slaterNumeric->updateMatrix();
// 50 percent chance of acceptance
if (ran3(&idum) >= 0.5) {
slater->updateInverse();
slater->acceptPosition();
slaterNumeric->updateInverseNumeric();
slaterNumeric->acceptPosition();
for (int d = 0; d < dim; d++)
rOld(i, d) = rNew(i, d);
} else {
slater->rejectPosition();
slaterNumeric->rejectPosition();
for (int d = 0; d < dim; d++)
rNew(i, d) = rOld(i, d);
}
mat DpInv = slater->DpInv;
mat DmInv = slater->DmInv;
mat Dp = slater->Dp;
mat Dm = slater->Dm;
mat DpInvNumeric = slaterNumeric->DpInv;
mat DmInvNumeric = slaterNumeric->DmInv;
// Printing difference
if (abs(det(DpInv * Dp) - 1) > errorThreshold)
std::cout << "%TEST_FAILED% time=0 testname=test2 (newSlaterTest) message=Analytic solution not matching numeric. " << endl
<< DpInv * Dp << std::endl;
}
}
}
