PBC fix bundle

.github/workflows/cmake.yml

@@ -44,7 +44,7 @@ jobs:
         -DMADNESS_BUILD_LIBRARIES_ONLY=${{ matrix.build_type != 'Debug' }}
 
     steps:
-    - uses: actions/checkout@v2
+    - uses: actions/checkout@v4
 
     - name: Create Build Environment
       # Some projects don't allow in-source building, so create a separate build directory
@@ -105,7 +105,7 @@ jobs:
         message("::set-output name=timestamp::${current_date}")
 
     - name: Setup ccache cache files
-      uses: actions/cache@v1.1.0
+      uses: actions/cache@v4
       with:
         path: ${{github.workspace}}/build/.ccache
         key: ${{ matrix.config.name }}-ccache-${{ steps.ccache_cache_timestamp.outputs.timestamp }}

cmake/modules/FindLibxc.cmake

@@ -13,7 +13,7 @@ include(FindPackageHandleStandardArgs)
 
 if(NOT LIBXC_FOUND)
 
-  # Set default sarch paths for libxc
+  # Set default search paths for libxc
   if(LIBXC_ROOT_DIR)
     set(LIBXC_INCLUDE_DIR ${LIBXC_ROOT_DIR}/include CACHE PATH "The include directory for libxc")
     if(CMAKE_SIZEOF_VOID_P EQUAL 8 AND CMAKE_SYSTEM_NAME STREQUAL "Linux")

doc/index.rst

@@ -5,9 +5,8 @@
 
 Welcome to MADNESS
 ==================
-Multiresolution Adaptive Numerical Environment for Scientific Simulation
 
-MADNESS provides a high-level environment for the solution of integral and differential equations in many dimensions using adaptive, fast methods with guaranteed precision based on multi-resolution analysis and novel separated representations. There are three main components to MADNESS. At the lowest level is a new petascale parallel programming environment that increases programmer productivity and code performance/scalability while maintaining backward compatibility with current programming tools such as MPI and Global Arrays. The numerical capabilities built upon the parallel tools provide a high-level environment for composing and solving numerical problems in many (1-6+) dimensions. Finally, built upon the numerical tools are new applications with initial focus upon chemistry, atomic and molecular physics, material science, and nuclear structure.
+MADNESS (**M**\ ultiresolution **AD**\ aptive **N**\ umerical **E**\ nvironment for **S**\ cientific **S**\ imulation) provides a high-level environment for the solution of integral and differential equations in many dimensions using adaptive, fast methods with guaranteed precision based on multi-resolution analysis and novel separated representations. There are three main components to MADNESS. At the lowest level is a new petascale parallel programming environment that increases programmer productivity and code performance/scalability while maintaining backward compatibility with current programming tools such as MPI and Global Arrays. The numerical capabilities built upon the parallel tools provide a high-level environment for composing and solving numerical problems in many (1-6+) dimensions. Finally, built upon the numerical tools are new applications with initial focus upon chemistry, atomic and molecular physics, material science, and nuclear structure.
 
 
 

src/apps/moldft/preal.cc

@@ -96,27 +96,6 @@ class AtomicBasisFunctor : public FunctionFunctorInterface<Q,3> {
     }
 };
 
-// Functor for the nuclear charge density
-class NuclearDensityFunctor : public FunctionFunctorInterface<double,3> {
-  Molecule molecule;
-  std::vector<coord_3d> specialpts;
-public:
-  NuclearDensityFunctor(const Molecule& molecule) : 
-    molecule(molecule), specialpts(molecule.get_all_coords_vec()) {}
-
-  double operator()(const Vector<double,3>& r) const {
-    return molecule.mol_nuclear_charge_density(r[0], r[1], r[2]);
-  }
-
-  std::vector<coord_3d> special_points() const{
-    return specialpts;
-  }
-
-  Level special_level() {
-    return 15;
-  }
-};
-
 // Functor for the nuclear potential
 class MolecularPotentialFunctor : public FunctionFunctorInterface<double,3> {
 private:

src/apps/moldft/testperiodicdft.cc

@@ -12,6 +12,7 @@
 #include <madness/tensor/solvers.h>
 #include<madness/chem/molecule.h>
 #include<madness/chem/molecularbasis.h>
+#include<madness/chem/potentialmanager.h>
 #include<madness/chem/xcfunctional.h>
 
 using namespace madness;
@@ -178,46 +179,6 @@ class AtomicOrbitalFunctor: public FunctionFunctorInterface<double,3> {
     std::vector<coord_3d> special_points() const {return specialpt;}
 };
 
-class NuclearDensityFunctor : public FunctionFunctorInterface<double,3> {
-private:
-    const Molecule& molecule;
-    const double R;
-    std::vector<coord_3d> specialpt;
-    const int maxR = 1;
-public:
-    NuclearDensityFunctor(const Molecule& molecule, double R)
-        : molecule(molecule), R(R), specialpt(molecule.get_all_coords_vec())
-    {}
-
-    double operator()(const coord_3d& x) const {
-        double big = 2*R + 6.0*molecule.smallest_length_scale();
-        double sum = 0.0;
-        for (int i=-maxR; i<=+maxR; i++) {
-            double xx = x[0]+i*R;
-            if (xx < big && xx > -big) {
-                for (int j=-maxR; j<=+maxR; j++) {
-                    double yy = x[1]+j*R;
-                    if (yy < big && yy > -big) {
-                        for (int k=-maxR; k<=+maxR; k++) {
-                            double zz = x[2]+k*R;
-                            if (zz < big && zz > -big)
-                                sum += molecule.nuclear_charge_density(x[0]+i*R, x[1]+j*R, x[2]+k*R);
-                        }
-                    }
-                }
-            }
-        }
-        return sum;
-    }
-
-    std::vector<coord_3d> special_points() const {return specialpt;}
-
-    Level special_level() {
-        return 10;
-    }
-
-};
-
 class KPeriodicBSHOperator {
 private:
     double kx, ky, kz;
@@ -979,7 +940,7 @@ int main(int argc, char** argv) {
     aobasis.read_file("sto-3g");
 
     // Nuclear potential
-    real_function_3d vnuc = real_factory_3d(world).functor(real_functor_3d(new NuclearDensityFunctor(molecule, L))).truncate_mode(0).truncate_on_project();
+    real_function_3d vnuc = real_factory_3d(world).functor(real_functor_3d(new NuclearDensityFunctor(molecule))).truncate_mode(0).truncate_on_project();
     double nuclear_charge=vnuc.trace();
     if (world.rank() == 0) print("total nuclear charge", nuclear_charge);
     vnuc = -1.0*make_coulomb_potential(world, vnuc);

src/apps/plot/plot2cube.cpp

@@ -35,7 +35,7 @@ int main(int argc, char** argv) {
     	std::cout << std::setw(25) << std::left << "\tsilent<bool> " << "silence output - default=false\n";
     	std::cout << "--------------------------\n";
     	std::cout << "necessary files:\n";
-    	std::cout << "\tinputfile" << std::setw(25) << "the inputfile for madnesss that should hold the molecular geometry\n";
+    	std::cout << "\tinputfile" << std::setw(25) << "the inputfile for madness that should hold the molecular geometry\n";
     	std::cout << "\tname.00000" << std::setw(25) << "the madness function file - filename given by plot2cube file=name\n";
     	std::cout << "--------------------------\n";
     }

src/apps/plot/plot2plane.cpp

@@ -33,7 +33,7 @@ int main(int argc, char** argv) {
     	std::cout << std::setw(25) << std::left << "\tsilent<bool> " << "silence output - default=false\n";
     	std::cout << "--------------------------\n";
     	std::cout << "necessary files:\n";
-    	std::cout << std::setw(25) << std::left << "\tinputfile" << "the inputfile for madnesss that should hold plot parameters.\nE\t\texample:\n";
+    	std::cout << std::setw(25) << std::left << "\tinputfile" << "the inputfile for madness that should hold plot parameters.\nE\t\texample:\n";
     	std::cout << "\n";
     	std::cout << "\t\tplot\n";
     	std::cout << "\t\tplane=x1,x2\n";

src/examples/periodic/CMakeLists.txt

@@ -1,7 +1,9 @@
 # src/examples/periodic
 
 set(EXAMPLE_SOURCES
-    testpercoul)
+    testpercoul
+    erfcr
+    testfilter)
 
 # Create executables for example applications
 foreach(example ${EXAMPLE_SOURCES})

src/examples/periodic/erfcr.cc

@@ -3,7 +3,7 @@
 #include <vector>
 #include <cmath>
 
-#include "/home/rjh/Devel/madtran/madness/src/madness/misc/gnuplot.h"
+#include <madness/misc/gnuplot.h>
 
 // Gaussian expansion of erfc(a*r)/r accurate to epsilon over [rlo,inf]
 // Returns pair [coeffs,expnts]

src/examples/periodic/testfilter.cc

@@ -0,0 +1,126 @@
+#include <madness/mra/mra.h>
+#include <madness/mra/operator.h>
+
+const double L = 10;
+
+static double gaussian_3d(const madness::coord_3d& r, const double expnt) {
+    const double x=r[0], y=r[1], z=r[2];
+    const double coeff = pow(expnt/M_PI, 1.5);
+    return coeff * exp(-expnt * (x*x + y*y + z*z));
+}
+
+static double rho_electronic_3d(const madness::coord_3d& r) { return gaussian_3d(r, 1); }
+static double rho_nuclear_3d(const madness::coord_3d& r) { return -gaussian_3d(r, 10000); }
+
+static double rho_gaussian_func_3d(const madness::coord_3d& r) {
+    return rho_electronic_3d(r) + rho_nuclear_3d(r);
+}
+
+// filter out leading order moments up to order k by zeroing out the corresponding coefficients in compressed representation
+template<typename T, std::size_t NDIM>
+void filter_moments_inplace(madness::Function<T,NDIM>& f, const int k, const bool fence=true) {
+
+    // can only filter in compressed representation
+    if (!f.is_compressed()) {
+        f.compress(fence);
+    }
+
+    auto filter_op = [&](madness::Tensor<T> &coeff) {
+        if constexpr (NDIM == 3) {
+            if (k >= 0) {
+                coeff(0, 0, 0) = 0.;
+            }
+            if (k >= 1) {
+                coeff(1, 0, 0) = 0.;
+                coeff(0, 1, 0) = 0.;
+                coeff(0, 0, 1) = 0.;
+            }
+            if (k >= 2) {
+                coeff(2, 0, 0) = 0.;
+                coeff(0, 2, 0) = 0.;
+                coeff(0, 0, 2) = 0.;
+                coeff(1, 1, 0) = 0.;
+                coeff(1, 0, 1) = 0.;
+                coeff(0, 1, 1) = 0.;
+            }
+            if (k >= 3)
+                abort();// TODO implement support for higher moments
+        } else
+            static_assert("filter_moments_inplace at the moment is implemented for NDIM=3");
+    };
+
+    // on [-L,L] normalized scaling function k is Sqrt[(2 k + 1)/(2 L)] LegendreP[k, x/L]
+    // the coefficient of x^k in LegendreP[k, x] is 2^(-k) Binomial[2 k, k], hence
+    // coefficient of x^k in scaling function k is Sqrt[(2 k + 1)/(2 L)] Binomial[2 k, k]/(2 L)^k
+    // thus if all moments of up to k-1 vanish, k-th moment (=expectation value of x^k) of
+    // scaling function k is its coefficient times Sqrt[(2 L)/ (2 k + 1)] (2 L)^k / Binomial[2 k, k]
+    f.unaryop_coeff([&](const madness::Key<NDIM> &key, madness::Tensor<T> &coeff) {
+        MADNESS_ASSERT(f.is_compressed());
+        // for compressed form only need 1 node, but public interface does not allow mutable access to the data
+        if (key == f.get_impl()->key0()) {
+            filter_op(coeff);
+        }
+    },
+                    fence);
+}
+
+int main(int argc, char**argv) {
+    using namespace madness;
+    {
+      auto &world = initialize(argc, argv);
+      startup(world, argc, argv, true);
+
+      // Function defaults
+      int k = 11;
+      double thresh = 1e-9;
+      double eps = 1e-9;
+      FunctionDefaults<3>::set_k(k);
+      FunctionDefaults<3>::set_cubic_cell(-L / 2, L / 2);
+      FunctionDefaults<3>::set_thresh(thresh);
+      FunctionDefaults<3>::set_refine(true);
+      FunctionDefaults<3>::set_initial_level(2);
+      FunctionDefaults<3>::set_truncate_mode(1);
+
+      Function<double, 3> rho, rhoE, rhoN, V_periodic, V_periodicE, V_periodicN;
+
+      {
+        // moments to filter out (0 = charge, 1 = dipoles, 2 = quadrupoles, >=3 not supported yet)
+        constexpr int filter_level = 0;
+	printf("building gaussian diff charge distribution ...\n\n");
+	std::vector<coord_3d> special_pt{coord_3d(std::array<double,3>{0.0, 0.0, 0.0})};
+	rho = FunctionFactory<double, 3>(world).special_points(special_pt).initial_level(4).f(rho_gaussian_func_3d);
+        // rho[E+N] is neutral, so no need to filter out the leading moment, but does not hurt
+        filter_moments_inplace(rho, filter_level);
+	rho.truncate();
+	rhoE = FunctionFactory<double, 3>(world).special_points(special_pt).initial_level(4).f(rho_electronic_3d);
+        filter_moments_inplace(rhoE, filter_level);
+	rhoE.truncate();
+	rhoN = FunctionFactory<double, 3>(world).special_points(special_pt).initial_level(4).f(rho_nuclear_3d);
+        filter_moments_inplace(rhoN, filter_level);
+	rhoN.truncate();
+
+	BoundaryConditions<3> bc_periodic(BC_PERIODIC);
+	SeparatedConvolution<double, 3> pop = CoulombOperator(world, 1e-4, eps, bc_periodic.is_periodic());
+	printf("applying periodic operator ...\n\n");
+	V_periodic = apply(pop, rho);
+	V_periodic.truncate();
+	V_periodicE = apply(pop, rhoE);
+	V_periodicE.truncate();
+	V_periodicN = apply(pop, rhoN);
+	V_periodicN.truncate();
+
+	V_periodic.reconstruct();
+	V_periodicE.reconstruct();
+	V_periodicN.reconstruct();
+      }
+
+      double bstep = L / 1000.0;
+      printf("   z\t\tV_(E+N)[z]\tV_E[z]\t\tV_N[z]\t\tV_E[z]+V_n[z]\trho\t\terror\n");
+      for (int i = 0; i < 1001; i++) {
+	double x = -L / 2 + i * bstep;
+        coord_3d p(std::array<double, 3>{0,0,x});
+        printf("%.3f\t\t%.8f\t%.8f\t%.8f\t%.8f\t%.8f\t%.8f\n", p[2], V_periodic(p), V_periodicE(p), V_periodicN(p), V_periodicE(p) + V_periodicN(p), rho(p), V_periodic(p) - V_periodicN(p) - V_periodicE(p));
+      }
+    }
+    madness::finalize();
+}

src/examples/periodic/testpercoul.cc

@@ -51,7 +51,7 @@ int main(int argc, char**argv) {
 	rho.truncate();
 
 	BoundaryConditions<3> bc_periodic(BC_PERIODIC);
-	SeparatedConvolution<double, 3> pop = CoulombOperator(world, 1e-4, eps, bc_periodic);
+	SeparatedConvolution<double, 3> pop = CoulombOperator(world, 1e-4, eps, bc_periodic.is_periodic());
 	printf("applying periodic operator ...\n\n");
 	V_periodic = apply(pop, rho);
 	V_periodic.truncate();

src/madness/chem/CMakeLists.txt

@@ -88,6 +88,7 @@ set(MADCHEM_SOURCES
     oep.cc
     pcm.cc
     pointgroupsymmetry.cc
+    potentialmanager.cc
     polynomial.cc
     SCF.cc
     SCFOperators.cc

src/madness/chem/SCFOperators.cc

@@ -366,6 +366,19 @@ XCOperator<T, NDIM>::XCOperator(World &world, std::string xc_data, const bool sp
     xc_args = prep_xc_args(arho, brho);
 }
 
+/// custom ctor with the XC functional
+template<typename T, std::size_t NDIM>
+XCOperator<T, NDIM>::XCOperator(World& world, std::shared_ptr<XCfunctional> xc,
+           const bool spin_polarized,
+           const int ispin,
+           const int nbeta,
+           const real_function_3d& arho, const real_function_3d& brho,
+           std::string deriv)
+    : world(world), dft_deriv(deriv), xc(xc), nbeta(nbeta), ispin(ispin),
+      extra_truncation(FunctionDefaults<3>::get_thresh() * 0.01) {
+  xc_args = prep_xc_args(arho, brho);
+}
+
 template<typename T, std::size_t NDIM>
 XCOperator<T, NDIM>::XCOperator(World &world, const SCF *calc, int ispin, std::string deriv)
         : world(world), dft_deriv(deriv), ispin(ispin), extra_truncation(FunctionDefaults<3>::get_thresh() * 0.01) {

src/madness/chem/SCFOperators.h

@@ -650,6 +650,14 @@ class XCOperator : public SCFOperatorBase<T,NDIM> {
             const real_function_3d& arho, const real_function_3d& brho,
             std::string deriv="abgv");
 
+    /// custom ctor with the XC functional
+    XCOperator(World& world, std::shared_ptr<XCfunctional> xc,
+               const bool spin_polarized,
+               int ispin,
+               int nbeta,
+               const real_function_3d& arho, const real_function_3d& brho,
+               std::string deriv="abgv");
+
     /// ctor with an SCF calculation, will initialize the necessary intermediates
     XCOperator(World& world, const SCF* scf, int ispin=0, std::string deriv="abgv");
 

src/madness/chem/atomutil.cc

@@ -468,14 +468,20 @@ double d2smoothed_potential(double r) {
 }
 
 
-/// Charge density corresponding to smoothed 1/r potential
+/// Charge density corresponding to smoothed `1/r` potential
 
-/// Invoke as \c rho(r/c)/c^3 where \c c is the radius of the
+/// To obtain the desired density as a function of `r`,
+///// \f$
+/////  \frac{\exp(-\frac{r^2}{c^2}) \left(\frac{5}{2}-\frac{r^2}{c^2}\right)}{\pi ^{3/2} c^3}
+///// \f$,
+/// invoke as \c smoothed_density(r/c)/c^3 where \c c is the radius of the
 /// smoothed volume.
-double smoothed_density(double r) {
+/// \param rs effective distance, \f$ r_s \equiv r/c \f$ , from the origin of the density
+/// \return \f$ \frac{\exp(-r_s^2) \left(\frac{5}{2}- r_s^2 \right)}{\pi^{3/2}} \f$
+double smoothed_density(double rs) {
     static const double rpithreehalf = std::pow(madness::constants::pi, -1.5);
-    double rsq = r*r;
-    return exp(-rsq)*(2.5 - rsq) * rpithreehalf;
+    double rs2 = rs*rs;
+    return exp(-rs2)*(2.5 - rs2) * rpithreehalf;
 }