int main(int, char **argv) {
const double myT = hughes_water_prop.kT; // room temperature in Hartree
const double R = 2.7;
Functional x(Identity());
Grid n(gd);
n = 0.001*VectorXd::Ones(gd.NxNyNz) + 0.001*(-10*r2(gd)).cwise().exp();
compare_functionals(NiceSum(), x + kT(), myT, n, 4e-13);
compare_functionals(NiceQuad(), sqr(x + kT()) - x + 2*kT(), myT, n, 3e-12);
compare_functionals(NiceSqrt(), sqrt(x) , myT, n, 1e-12);
compare_functionals(NiceSqrtandMore(), sqrt(x) - x + 2*kT(), myT, n, 1e-12);
compare_functionals(NiceLog(), log(x), myT, n, 7e-14);
compare_functionals(NiceLogandSqr(), log(x) + sqr(x), myT, n, 6e-13);
compare_functionals(NiceLogandSqrandInverse(), log(x) + (sqr(x)-Pow(3)) + Functional(1)/x, myT, n, 3e-10);
compare_functionals(NiceLogOneMinusX(), log(1-x), myT, n, 1e-12);
compare_functionals(NiceNbar(R), StepConvolve(R), myT, n, 3e-13);
compare_functionals(NiceLogOneMinusNbar(R), log(1 - StepConvolve(R)), myT, n, 3e-13);
Functional n2 = ShellConvolve(R);
Functional n3 = StepConvolve(R);
compare_functionals(NiceN2(R), n2, myT, n, 1e-14);
const double four_pi_r2 = 4*M_PI*R*R;
Functional one_minus_n3 = 1 - n3;
Functional phi1 = (-1/four_pi_r2)*n2*log(one_minus_n3);
compare_functionals(NicePhi1(R), phi1, myT, n, 1e-6);
const double four_pi_r = 4*M_PI*R;
Functional n2x = xShellConvolve(R);
Functional n2y = yShellConvolve(R);
Functional n2z = zShellConvolve(R);
Functional phi2 = (sqr(n2) - sqr(n2x) - sqr(n2y) - sqr(n2z))/(four_pi_r*one_minus_n3);
compare_functionals(NiceN2xsqr(R), sqr(n2x), myT, n, 3e-14);
compare_functionals(NicePhi2(R), phi2, myT, n, 1e-13);
Functional phi3 = (n3 + sqr(one_minus_n3)*log(one_minus_n3))/(36*M_PI*sqr(n3)*sqr(one_minus_n3))
*n2*(sqr(n2) - 3*(sqr(n2x) + sqr(n2y) + sqr(n2z)));
compare_functionals(NicePhi3(R), phi3, myT, n, 1e-13, 0.001, 1e-14);
compare_functionals(TensorWhiteBear(R), HardSpheresWB(R), myT, n, 1e-13, 0.0001, 1e-13);
compare_functionals(gSigmaA_by_hand(R), gSigmaA_automagic(R), myT, n, 1e-13, 0.0001, 1e-13);
if (errors == 0) printf("\n%s passes!\n", argv[0]);
else printf("\n%s fails %d tests!\n", argv[0], errors);
return errors;
}
int main(int, char **argv) {
const double myT = water_prop.kT; // room temperature in Hartree
const double R = 2.7;
Functional x(Identity());
Grid n(gd);
n = 0.001*VectorXd::Ones(gd.NxNyNz) + 0.001*(-10*r2(gd)).cwise().exp();
compare_functionals(Sum(), x + kT, myT, n, 2e-13);
compare_functionals(Quadratic(), sqr(x + kT) - x + 2*kT, myT, n, 2e-12);
compare_functionals(Sqrt(), sqrt(x), myT, n, 1e-12);
compare_functionals(SqrtAndMore(), sqrt(x) - x + 2*kT, myT, n, 1e-12);
compare_functionals(Log(), log(x), myT, n, 3e-14);
compare_functionals(LogAndSqr(), log(x) + sqr(x), myT, n, 3e-14);
compare_functionals(LogAndSqrAndInverse(), log(x) + (sqr(x)-Pow(3)) + Functional(1)/x, myT, n, 3e-10);
compare_functionals(LogOneMinusX(), log(1-x), myT, n, 1e-12);
compare_functionals(LogOneMinusNbar(R), log(1-StepConvolve(R)), myT, n, 1e-13);
compare_functionals(SquareXshell(R), sqr(xShellConvolve(R)), myT, n);
Functional n2 = ShellConvolve(R);
Functional n3 = StepConvolve(R);
compare_functionals(n2_and_n3(R), sqr(n2) + sqr(n3), myT, n, 1e-14);
const double four_pi_r2 = 4*M_PI*R*R;
Functional one_minus_n3 = 1 - n3;
Functional phi1 = (-1/four_pi_r2)*n2*log(one_minus_n3);
compare_functionals(Phi1(R), phi1, myT, n, 1e-13);
const double four_pi_r = 4*M_PI*R;
Functional n2x = xShellConvolve(R);
Functional n2y = yShellConvolve(R);
Functional n2z = zShellConvolve(R);
Functional phi2 = (sqr(n2) - sqr(n2x) - sqr(n2y) - sqr(n2z))/(four_pi_r*one_minus_n3);
compare_functionals(Phi2(R), phi2, myT, n, 1e-14);
Functional phi3rf = n2*(sqr(n2) - 3*(sqr(n2x) + sqr(n2y) + sqr(n2z)))/(24*M_PI*sqr(one_minus_n3));
compare_functionals(Phi3rf(R), phi3rf, myT, n, 1e-13);
compare_functionals(AlmostRF(R), myT*(phi1 + phi2 + phi3rf), myT, n, 2e-14);
Functional veff = EffectivePotentialToDensity();
compare_functionals(SquareVeff(R), sqr(veff), myT, Grid(gd, -myT*n.cwise().log()), 1e-12);
compare_functionals(AlmostRFnokT(R), phi1 + phi2 + phi3rf, myT, n, 3e-14);
compare_functionals(AlmostRF(R),
(myT*phi1).set_name("phi1") + (myT*phi2).set_name("phi2") + (myT*phi3rf).set_name("phi3"),
myT, n, 4e-14);
compare_functionals(Phi1Veff(R), phi1(veff), myT, Grid(gd, -myT*n.cwise().log()), 1e-13);
compare_functionals(Phi2Veff(R), phi2(veff), myT, Grid(gd, -myT*n.cwise().log()), 1e-14);
compare_functionals(Phi3rfVeff(R), phi3rf(veff), myT, Grid(gd, -myT*n.cwise().log()), 1e-13);
compare_functionals(IdealGasFast(), IdealGasOfVeff, myT, Grid(gd, -myT*n.cwise().log()),
1e-12);
double mu = -1;
compare_functionals(Phi1plus(R, mu),
phi1(veff) + IdealGasOfVeff + ChemicalPotential(mu)(veff),
myT, Grid(gd, -myT*n.cwise().log()), 1e-12);
if (errors == 0) printf("\n%s passes!\n", argv[0]);
else printf("\n%s fails %d tests!\n", argv[0], errors);
return errors;
}
int main(int, char **argv) {
const double kT = 1e-3;
Lattice lat(Cartesian(0,5,5), Cartesian(5,0,5), Cartesian(5,5,0));
Cartesian plotcorner(-5, -5, 0), plotx(10,0,0), ploty(0,10,0);
int resolution = 200;
GridDescription gd(lat, resolution, resolution, resolution);
Grid foo(gd), bar(gd), ref(gd);
printf("Running Set(gaussian)...\n");
foo.Set(gaussian);
const double integrate_foo = Identity().integral(kT, foo);
printf("Original integrates to %.15g\n", integrate_foo);
printf("Original Maximum is %g\n", foo.maxCoeff());
int retval = 0;
if (integrate_foo < 0) {
printf("Integral of original is negative (which may throw off tests): %g\n", integrate_foo);
retval++;
}
//mkdir("tests/vis", 0777);
//foo.epsNativeSlice("tests/vis/unblurred.eps", plotx, ploty, plotcorner);
printf("Running Gaussian(10)...\n");
bar = Gaussian(10)(kT, foo);
printf("Gaussian(10) integrates to %.15g\n", Identity().integral(kT, bar));
if (fabs(Identity().integral(kT, bar)/integrate_foo-1) > 1e-6) {
printf("Error in Gaussian(10) is too large: %g\n", Identity().integral(kT, bar)/integrate_foo-1);
retval++;
}
//bar.epsNativeSlice("tests/vis/gaussian-width-10.eps", plotx, ploty, plotcorner);
printf("Gaussian(1) integrates to %g\n", Identity().integral(kT, bar));
printf("Running Gaussian(1)...\n");
bar = Gaussian(1)(kT, foo);
if (fabs(Identity().integral(kT, bar)/integrate_foo-1) > 1e-6) {
printf("Error in Gaussian(1) is too large: %g\n", Identity().integral(kT, bar)/integrate_foo-1);
retval++;
}
//bar.epsNativeSlice("tests/vis/gaussian-width-1.eps", plotx, ploty, plotcorner);
printf("Running StepConvolve(1)...\n");
bar = StepConvolve(1)(kT, foo);
printf("StepConvolve(1) integrates to %.15g\n", Identity().integral(kT, bar));
printf("StepConvolve(1) Maximum is %g\n", bar.maxCoeff());
if (fabs(bar.maxCoeff()/integrate_foo-1) > 1e-6) {
printf("FAIL: Max of StepConvolve(1) is wrong: %g\n", bar.maxCoeff()/integrate_foo - 1);
retval++;
}
printf("StepConvolve(1) Minimum is %g\n", bar.minCoeff());
if (bar.minCoeff()/integrate_foo < -1e-9) {
printf("Min of StepConvolve(1) is wrong: %g\n", bar.minCoeff()/integrate_foo);
retval++;
}
const double fourpiover3 = 4*M_PI/3;
if (fabs((Identity().integral(kT, bar)/integrate_foo-fourpiover3)/fourpiover3) > 1e-6) {
printf("Integral of StepConvolve(1) is wrong: %g\n",
(Identity().integral(kT, bar)/integrate_foo-fourpiover3)/fourpiover3);
retval++;
}
//bar.epsNativeSlice("tests/vis/step-1.eps", plotx, ploty, plotcorner);
printf("Running StepConvolve(2)...\n");
bar = StepConvolve(2)(kT, foo);
printf("StepConvolve(2) Maximum is %g\n", bar.maxCoeff());
printf("StepConvolve(2) integrates to %.15g\n", Identity().integral(kT, bar));
if (fabs((Identity().integral(kT, bar)/integrate_foo-fourpiover3*8)/fourpiover3/8) > 1e-6) {
printf("Integral of StepConvolve(2) is wrong: %g\n", (Identity().integral(kT, bar)/integrate_foo-fourpiover3*8)/fourpiover3/8);
retval++;
}
if (fabs((bar.maxCoeff()-integrate_foo)/integrate_foo) > 1e-6) {
printf("Max of StepConvolve(2) is wrong: %g\n", (bar.maxCoeff()-integrate_foo)/integrate_foo);
retval++;
}
printf("StepConvolve(2) Minimum is %g\n", bar.minCoeff());
if (bar.minCoeff()/integrate_foo < -1e-9) {
printf("Min of StepConvolve(2) is wrong: %g\n", bar.minCoeff()/integrate_foo);
retval++;
}
//bar.epsNativeSlice("tests/vis/step-2.eps", plotx, ploty, plotcorner);
printf("Running StepConvolve(3)...\n");
bar = StepConvolve(3)(kT, foo);
printf("StepConvolve(3) Maximum is %g\n", bar.maxCoeff());
printf("StepConvolve(3) integrates to %.15g\n", Identity().integral(kT, bar));
if (fabs((Identity().integral(kT, bar)/integrate_foo-fourpiover3*27)/fourpiover3/27) > 1e-6) {
printf("Integral of StepConvolve(3) is wrong: %g\n",
(Identity().integral(kT, bar)/integrate_foo-fourpiover3*27)/fourpiover3/27);
retval++;
}
if (fabs((bar.maxCoeff()-integrate_foo)/integrate_foo) > 1e-6) {
printf("Max of StepConvolve(3) is wrong: %g\n", (bar.maxCoeff()-integrate_foo)/integrate_foo);
retval++;
}
printf("StepConvolve(3) Minimum is %g\n", bar.minCoeff());
if (fabs(bar.minCoeff()/integrate_foo) < -1e-9) {
printf("Min of StepConvolve(3) is wrong: %g\n", bar.minCoeff()/integrate_foo);
retval++;
}
//bar.epsNativeSlice("tests/vis/step-3.eps", plotx, ploty, plotcorner);
const double fourpi = 4*M_PI;
printf("Running ShellConvolve(1)...\n");
bar = ShellConvolve(1)(kT, foo);
printf("ShellConvolve(1) integrates to %.15g\n", Identity().integral(kT, bar));
printf("ShellConvolve(1) Maximum is %g\n", bar.maxCoeff());
if (fabs((Identity().integral(kT, bar)/integrate_foo-fourpi)/fourpi) > 1e-6) {
printf("Integral of ShellConvolve(1) is wrong: %g\n",
(Identity().integral(kT, bar)/integrate_foo-fourpi)/fourpi);
retval++;
}
printf("ShellConvolve(1) Minimum is %g\n", bar.minCoeff());
if (bar.minCoeff()/integrate_foo < -1e-9) {
printf("Min of ShellConvolve(1) is wrong: %g\n", bar.minCoeff()/integrate_foo);
retval++;
}
//bar.epsNativeSlice("tests/vis/shell-1.eps", plotx, ploty, plotcorner);
printf("Running ShellPrimeConvolve(1)...\n");
bar = ShellPrimeConvolve(1)(kT, foo);
printf("ShellPrimeConvolve(1) integrates to %.15g\n", Identity().integral(kT, bar));
printf("ShellPrimeConvolve(1) Maximum is %g\n", bar.maxCoeff());
//bar.epsNativeSlice("tests/vis/shellPrime-1.eps", plotx, ploty, plotcorner);
printf("Running ShellConvolve(3)...\n");
bar = ShellConvolve(3)(kT, foo);
printf("ShellConvolve(3) Maximum is %g\n", bar.maxCoeff());
printf("ShellConvolve(3) integrates to %.15g\n", Identity().integral(kT, bar));
if (fabs((Identity().integral(kT, bar)/integrate_foo-fourpi*9)/fourpi/9) > 1e-6) {
printf("Integral of ShellConvolve(3) is wrong: %g\n",
(Identity().integral(kT, bar)/integrate_foo-fourpi*9)/fourpi/9);
retval++;
}
printf("ShellConvolve(3) Minimum is %g\n", bar.minCoeff());
if (bar.minCoeff()/integrate_foo < -1e-9) {
printf("Min of ShellConvolve(3) is wrong: %g\n", bar.minCoeff()/integrate_foo);
retval++;
}
//bar.epsNativeSlice("tests/vis/shell-3.eps", plotx, ploty, plotcorner);
printf("Running yShellConvolve(1)...\n");
bar = yShellConvolve(1)(kT, foo);
printf("yShellConvolve(1) integrates to %.15g\n", Identity().integral(kT, bar));
printf("yShellConvolve(1) Maximum is %g\n", bar.maxCoeff());
printf("yShellConvolve(1) Minimum is %g\n", bar.minCoeff());
if (fabs(Identity().integral(kT, bar)/integrate_foo) > 1e-6) {
printf("Integral of yShellConvolve(1) is wrong: %g\n",
Identity().integral(kT, bar)/integrate_foo-fourpi);
retval++;
}
//bar.epsNativeSlice("tests/vis/y-shell-1.eps", plotx, ploty, plotcorner);
Functional ysh = yShellConvolve(1), sh = ShellConvolve(1);
{
Grid scalarsh(gd, ShellConvolve(1)(kT, foo));
if (bar.maxCoeff() > scalarsh.maxCoeff()) {
printf("FAIL: max of vector shell greater than scalar shell!\n");
retval++;
}
if (-bar.minCoeff() > scalarsh.maxCoeff()) {
printf("FAIL: min of vector shell greater in magnitude than scalar shell!\n");
retval++;
}
}
printf("Running xShellConvolve(3)...\n");
ref = ShellConvolve(3)(kT, foo);
bar = xShellConvolve(3)(kT, foo);
printf("xShellConvolve(3) Maximum is %g\n", bar.maxCoeff());
printf("xShellConvolve(3) integrates to %.15g\n", Identity().integral(kT, bar));
if (fabs(Identity().integral(kT, bar)/integrate_foo) > 1e-6) {
printf("Integral of xShellConvolve(3) is wrong: %g\n",
Identity().integral(kT, bar)/integrate_foo);
retval++;
}
double mymax = ref.maxCoeff();
if (fabs(bar.maxCoeff() - mymax)/mymax > 2e-3) {
printf("problem with xShellConvolve max: %g != %g (error of %g)\n",
bar.maxCoeff(), mymax, (bar.maxCoeff() - mymax)/mymax);
retval++;
exit(1);
}
if (fabs((bar.minCoeff() + mymax)/mymax) > 2e-3) {
printf("problem with xShellConvolve min: %g != minus %g (error of %g)\n",
bar.minCoeff(), mymax, (bar.minCoeff() + mymax)/mymax);
retval++;
exit(1);
}
//bar.epsNativeSlice("tests/vis/x-shell-3.eps", plotx, ploty, plotcorner);
for (int i=0;i<gd.NxNyNz;i++) {
if ((fabs(bar[i]) - fabs(ref[i]))/mymax > 1e-11) {
printf("FAIL: x shell is bigger in magnitude than shell by %g out of %g compared with %g!\n",
fabs(bar[i]) - fabs(ref[i]), fabs(ref[i]), mymax);
retval++;
}
}
printf("Running VectorDensityX(3)...\n");
ref = n2Density(3)(kT, foo);
bar = VectorDensityX(3)(kT, foo);
printf("VectorDensityX(3) Maximum is %g\n", bar.maxCoeff());
printf("VectorDensityX(3) integrates to %.15g\n", Identity().integral(kT, bar));
if (fabs(Identity().integral(kT, bar)/integrate_foo) > 1e-6) {
printf("Integral of VectorDensityX(3) is wrong: %g\n",
Identity().integral(kT, bar)/integrate_foo);
retval++;
}
//bar.epsNativeSlice("tests/vis/x-vector-3.eps", plotx, ploty, plotcorner);
mymax = ref.maxCoeff();
if (fabs(bar.maxCoeff() - mymax)/mymax > 2e-3) {
printf("problem with VectorDensityX max: %g != %g (error of %g)\n",
bar.maxCoeff(), mymax, (bar.maxCoeff() - mymax)/mymax);
retval++;
exit(1);
}
if (fabs((bar.minCoeff() + mymax)/mymax) > 2e-3) {
printf("problem with VectorDensityX min: %g != minus %g (error of %g)\n",
bar.minCoeff(), mymax, (bar.minCoeff() + mymax)/mymax);
retval++;
exit(1);
}
for (int i=0;i<gd.NxNyNz;i++) {
if ((fabs(bar[i]) - fabs(ref[i]))/mymax > 1e-11) {
printf("FAIL: x shell is bigger in magnitude than shell by %g out of %g compared with %g!\n",
fabs(bar[i]) - fabs(ref[i]), fabs(ref[i]), mymax);
retval++;
}
}
printf("Running xyShellConvolve(1)...\n");
ref = xShellConvolve(1)(kT, foo);
bar = xyShellConvolve(1)(kT, foo);
printf("xyShellConvolve(1) integrates to %.15g\n", Identity().integral(kT, bar));
printf("xyShellConvolve(1) Maximum is %g\n", bar.maxCoeff());
if (fabs(Identity().integral(kT, bar)/integrate_foo) > 1e-6) {
printf("Integral of xyShellConvolve(1) is wrong: %g\n",
Identity().integral(kT, bar)/integrate_foo-fourpi);
retval++;
}
//bar.epsNativeSlice("tests/vis/xy-shell-1.eps", plotx, ploty, plotcorner);
mymax = ref.maxCoeff();
for (int i=0;i<gd.NxNyNz;i++) {
if ((fabs(bar[i]) - fabs(ref[i]))/mymax > 1e-11) {
printf("FAIL: xy shell is bigger in magnitude than x shell by %g out of %g!\n",
fabs(bar[i]) - fabs(ref[i]), fabs(ref[i]));
retval++;
}
}
printf("Running xxShellConvolve(2)...\n");
ref = xShellConvolve(2)(kT, foo).cwise().abs() + 1./3*ShellConvolve(2)(kT, foo);
bar = xxShellConvolve(2)(kT, foo);
printf("xxShellConvolve(2) integrates to %.15g\n", Identity().integral(kT, bar));
printf("xxShellConvolve(2) Maximum is %g\n", bar.maxCoeff());
if (fabs(Identity().integral(kT, bar)/integrate_foo) > 1e-14) {
printf("FAIL: Integral of xxShellConvolve(2) is wrong: %g\n",
Identity().integral(kT, bar)/integrate_foo);
retval++;
}
//bar.epsNativeSlice("tests/vis/xx-shell-2.eps", plotx, ploty, plotcorner);
//bar.epsNativeSlice("tests/vis/xx-shell-2.eps", Cartesian(0,10,0), Cartesian(0,0,10), Cartesian(0,0,0));
mymax = ref.maxCoeff();
for (int i=0;i<gd.NxNyNz;i++) {
if ((fabs(bar[i]) - fabs(ref[i]))/mymax > 1e-12) {
printf("FAIL: xx shell is bigger in magnitude than x shell by %g out of %g compared with %g!\n",
fabs(bar[i]) - fabs(ref[i]), fabs(ref[i]), mymax);
retval++;
}
}
printf("Running TensorDensityXX(2)...\n");
ref = VectorDensityX(2)(kT, foo).cwise().abs() + 1./3*n2Density(2)(kT, foo);
bar = TensorDensityXX(2)(kT, foo);
printf("TensorDensityXX(2) integrates to %.15g\n", Identity().integral(kT, bar));
printf("TensorDensityXX(2) Maximum is %g\n", bar.maxCoeff());
if (fabs(Identity().integral(kT, bar)/integrate_foo) > 1e-14) {
printf("FAIL: Integral of xxShellConvolve(2) is wrong: %g\n",
Identity().integral(kT, bar)/integrate_foo);
retval++;
}
//bar.epsNativeSlice("tests/vis/xx-tensor-2.eps", plotx, ploty, plotcorner);
mymax = ref.maxCoeff();
double shellmax = n2Density(3)(kT, foo).maxCoeff();
if (fabs(bar.maxCoeff() - 2*shellmax/3)/(2*shellmax/3) > 1e-2) {
printf("problem with TensorDensityXX max: %g != %g (error of %g)\n",
bar.maxCoeff(), 2*shellmax/3, (bar.maxCoeff() - 2*shellmax/3)/(2*shellmax/3));
retval++;
exit(1);
}
for (int i=0;i<gd.NxNyNz;i++) {
if ((fabs(bar[i]) - fabs(ref[i]))/mymax > 1e-12) {
printf("FAIL: xx shell is bigger in magnitude than x shell by %g out of %g compared with %g!\n",
fabs(bar[i]) - fabs(ref[i]), fabs(ref[i]), mymax);
retval++;
}
}
printf("Running zxShellConvolve(3)...\n");
Functional zxsh = zxShellConvolve(3);
bar = zxsh(kT, foo);
printf("zxShellConvolve(3) Maximum is %g\n", bar.maxCoeff());
printf("zxShellConvolve(3) integrates to %.15g\n", Identity().integral(kT, bar));
if (fabs(Identity().integral(kT, bar)/integrate_foo) > 1e-6) {
printf("Integral of zxShellConvolve(3) is wrong: %g\n",
Identity().integral(kT, bar)/integrate_foo);
retval++;
}
//bar.epsNativeSlice("tests/vis/zx-shell-3.eps", plotx, ploty, Cartesian(-5,-5,0.5));
if (retval == 0) printf("\n%s passes!\n", argv[0]);
else printf("\n%s fails %d tests!\n", argv[0], retval);
return retval;
}