Update for PluginPlay #396

cxx/include/scf/scf_mm.hpp

@@ -18,26 +18,18 @@
 #include <pluginplay/pluginplay.hpp>
 
 namespace scf {
-/** @brief Loads the modules contained in the SCF module collection into the
- *         provided ModuleManager instance.
- */
-void load_modules(pluginplay::ModuleManager& mm);
-
-/** @brief Connects SCF's modules to the modules other plugins provide.
+/** @brief The SCF plugin.
+ *
+ *  Load it into a ModuleManager with `mm.load_plugin<scf::SCF>()`
+ *  (`mm.load_plugin(scf.SCF())` from Python). The plugin's name is "scf".
  *
  *  Several SCF modules need a submodule that SCF itself does not provide (the
  *  Hamiltonian, the AO integrals, the overlap matrix, and the SAD density).
- *  This function sets those submodules to the default implementations from
- *  the NUX, Integrals, and ChemCache plugins.
- *
- *  Each submodule is only set if the module providing it has been loaded into
- *  @p mm, so this function must be called after those plugins' load_modules.
- *  Submodules whose provider is missing are left unset, and SCF does not
- *  depend on any of those plugins.
- *
- *  @param[in,out] mm The ModuleManager to set the submodules in. Must already
- *                    contain SCF's modules (see load_modules).
+ *  The plugin records defaults for those submodules from the NUX, Integrals,
+ *  and ChemCache plugins, which ModuleManager::wire_defaults sets once the
+ *  plugins are loaded. Submodules whose provider is not loaded are left unset,
+ *  and SCF does not depend on any of those plugins.
  */
-void set_defaults(pluginplay::ModuleManager& mm);
+DECLARE_PLUGIN(SCF);
 
 } // namespace scf

cxx/src/scf/driver/driver.hpp

@@ -22,25 +22,25 @@ namespace scf::driver {
 DECLARE_MODULE(SCFDriver);
 DECLARE_MODULE(SCFLoop);
 
-inline void load_modules(pluginplay::ModuleManager& mm) {
-    mm.add_module<SCFDriver>("SCF Driver");
-    mm.add_module<SCFLoop>("Loop");
+inline void load_modules(pluginplay::ModuleMap& modules) {
+    modules.add_module<SCFDriver>("SCF Driver");
+    modules.add_module<SCFLoop>("Loop");
 }
 
-inline void set_defaults(pluginplay::ModuleManager& mm) {
-    mm.change_submod("Loop", "Electronic energy", "Electronic energy");
-    mm.change_submod("Loop", "Density matrix", "Density matrix builder");
-    mm.change_submod("Loop", "Diagonalizer",
-                     "Generalized eigensolve via Eigen");
-    mm.change_submod("Loop", "Fock matrix builder", "Fock matrix builder");
-    mm.change_submod("Loop", "One-electron Fock operator",
-                     "Restricted One-Electron Fock op");
-    mm.change_submod("Loop", "Fock operator", "Restricted Fock Op");
-    mm.change_submod("Loop", "Charge-charge", "Coulomb's Law");
-    mm.change_submod("Loop", "Fock matrix builder", "Fock matrix builder");
+inline void set_defaults(pluginplay::ModuleMap& modules) {
+    modules.change_submod("Loop", "Electronic energy", "Electronic energy");
+    modules.change_submod("Loop", "Density matrix", "Density matrix builder");
+    modules.change_submod("Loop", "Diagonalizer",
+                          "Generalized eigensolve via Eigen");
+    modules.change_submod("Loop", "Fock matrix builder", "Fock matrix builder");
+    modules.change_submod("Loop", "One-electron Fock operator",
+                          "Restricted One-Electron Fock op");
+    modules.change_submod("Loop", "Fock operator", "Restricted Fock Op");
+    modules.change_submod("Loop", "Charge-charge", "Coulomb's Law");
+    modules.change_submod("Loop", "Fock matrix builder", "Fock matrix builder");
 
-    mm.change_submod("SCF Driver", "Guess", "Core guess");
-    mm.change_submod("SCF Driver", "Optimizer", "Loop");
+    modules.change_submod("SCF Driver", "Guess", "Core guess");
+    modules.change_submod("SCF Driver", "Optimizer", "Loop");
 }
 
 } // namespace scf::driver

cxx/src/scf/eigen_solver/eigen_solver.hpp

@@ -25,20 +25,20 @@ DECLARE_MODULE(EigenGeneralized);
 DECLARE_MODULE(EigenNormal);
 DECLARE_MODULE(JacobiNormal);
 
-inline void set_defaults(pluginplay::ModuleManager& mm) {
-    mm.change_submod("Eigen Solve", "none", "Eigen Solve via Eigen");
-    mm.change_submod("Eigen Solve", "uncertain", "Eigen Solve via Jacobi");
-    mm.change_submod("Eigen Solve", "interval", "Eigen Solve via Jacobi");
-    mm.change_submod("Generalized eigensolve", "Eigen Solve", "Eigen Solve");
+inline void set_defaults(pluginplay::ModuleMap& modules) {
+    modules.change_submod("Eigen Solve", "none", "Eigen Solve via Eigen");
+    modules.change_submod("Eigen Solve", "uncertain", "Eigen Solve via Jacobi");
+    modules.change_submod("Eigen Solve", "interval", "Eigen Solve via Jacobi");
+    modules.change_submod("Generalized eigensolve", "Eigen Solve",
+                          "Eigen Solve");
 }
 
-inline void load_modules(pluginplay::ModuleManager& mm) {
-    mm.add_module<EigenSolveDriver>("Eigen Solve");
-    mm.add_module<EigenNormal>("Eigen Solve via Eigen");
-    mm.add_module<JacobiNormal>("Eigen Solve via Jacobi");
-    mm.add_module<EigenGeneralized>("Generalized eigensolve via Eigen");
-    mm.add_module<GeneralizedEigenSolver>("Generalized eigensolve");
-    set_defaults(mm);
+inline void load_modules(pluginplay::ModuleMap& modules) {
+    modules.add_module<EigenSolveDriver>("Eigen Solve");
+    modules.add_module<EigenNormal>("Eigen Solve via Eigen");
+    modules.add_module<JacobiNormal>("Eigen Solve via Jacobi");
+    modules.add_module<EigenGeneralized>("Generalized eigensolve via Eigen");
+    modules.add_module<GeneralizedEigenSolver>("Generalized eigensolve");
 }
 
 } // namespace scf::eigen_solver

cxx/src/scf/export_scf.cpp

@@ -20,7 +20,7 @@
 
 namespace scf {
 
-EXPORT_PLUGIN(scf, m) {
+EXPORT_PLUGIN(scf, SCF, m) {
     pybind11::module::import("parallelzone");
     m.def("initialize", [](pybind11::list py_args) {
         std::vector<std::string> args;
@@ -34,7 +34,6 @@ EXPORT_PLUGIN(scf, m) {
         return scf::initialize(argc, argv.data());
     });
     m.def("finalize", []() { scf::finalize(); });
-    m.def("set_defaults", &set_defaults);
 }
 
 } // namespace scf

cxx/src/scf/fock_operator/fock_operator.hpp

@@ -25,7 +25,7 @@ DECLARE_MODULE(Restricted);
 template<typename DensityType, typename ElectronType>
 DECLARE_MODULE(RKohnSham);
 
-inline void load_modules(pluginplay::ModuleManager& mm) {
+inline void load_modules(pluginplay::ModuleMap& modules) {
     using simde::type::decomposable_e_density;
     using simde::type::e_density;
     using simde::type::electron;
@@ -38,14 +38,14 @@ inline void load_modules(pluginplay::ModuleManager& mm) {
     using e_ks_e    = RKohnSham<e_density, electron>;
     using d_ks_many = RKohnSham<decomposable_e_density, many_electrons>;
     using d_ks_e    = RKohnSham<decomposable_e_density, electron>;
-    mm.add_module<e_many>("AO Restricted Fock Op");
-    mm.add_module<d_many>("Restricted Fock Op");
-    mm.add_module<e_e>("AO Restricted One-Electron Fock Op");
-    mm.add_module<d_e>("Restricted One-Electron Fock Op");
-    mm.add_module<e_ks_many>("AO Restricted Kohn-Sham Op");
-    mm.add_module<d_ks_many>("Restricted Kohn-Sham Op");
-    mm.add_module<e_ks_e>("AO Restricted One-Electron Kohn-Sham Op");
-    mm.add_module<d_ks_e>("Restricted One-Electron Kohn-Sham Op");
+    modules.add_module<e_many>("AO Restricted Fock Op");
+    modules.add_module<d_many>("Restricted Fock Op");
+    modules.add_module<e_e>("AO Restricted One-Electron Fock Op");
+    modules.add_module<d_e>("Restricted One-Electron Fock Op");
+    modules.add_module<e_ks_many>("AO Restricted Kohn-Sham Op");
+    modules.add_module<d_ks_many>("Restricted Kohn-Sham Op");
+    modules.add_module<e_ks_e>("AO Restricted One-Electron Kohn-Sham Op");
+    modules.add_module<d_ks_e>("Restricted One-Electron Kohn-Sham Op");
 }
 
 #define EXTERN_RESTRICTED(density)                                           \

cxx/src/scf/guess/guess.hpp

@@ -22,21 +22,21 @@ namespace scf::guess {
 DECLARE_MODULE(Core);
 DECLARE_MODULE(SAD);
 
-inline void load_modules(pluginplay::ModuleManager& mm) {
-    mm.add_module<Core>("Core guess");
-    mm.add_module<SAD>("SAD guess");
+inline void load_modules(pluginplay::ModuleMap& modules) {
+    modules.add_module<Core>("Core guess");
+    modules.add_module<SAD>("SAD guess");
 }
 
-inline void set_defaults(pluginplay::ModuleManager& mm) {
-    mm.change_submod("Core guess", "Build Fock operator",
-                     "Restricted One-Electron Fock Op");
-    mm.change_submod("Core guess", "Guess updater",
-                     "Diagonalization Fock update");
+inline void set_defaults(pluginplay::ModuleMap& modules) {
+    modules.change_submod("Core guess", "Build Fock operator",
+                          "Restricted One-Electron Fock Op");
+    modules.change_submod("Core guess", "Guess updater",
+                          "Diagonalization Fock update");
 
-    mm.change_submod("SAD guess", "Build Fock operator",
-                     "Restricted One-Electron Fock Op");
-    mm.change_submod("SAD guess", "Guess updater",
-                     "Diagonalization Fock update");
+    modules.change_submod("SAD guess", "Build Fock operator",
+                          "Restricted One-Electron Fock Op");
+    modules.change_submod("SAD guess", "Guess updater",
+                          "Diagonalization Fock update");
 }
 
 } // namespace scf::guess

cxx/src/scf/matrix_builder/matrix_builder.hpp

@@ -25,43 +25,46 @@ DECLARE_MODULE(DeterminantDriver);
 DECLARE_MODULE(ElectronicEnergy);
 DECLARE_MODULE(Fock);
 
-inline void load_modules(pluginplay::ModuleManager& mm) {
-    mm.add_module<SCFIntegralsDriver>("SCF integral driver");
-    mm.add_module<DensityMatrix>("Density matrix builder");
-    mm.add_module<DeterminantDriver>("Determinant driver");
-    mm.add_module<ElectronicEnergy>("Electronic energy");
-    mm.add_module<Fock>("Fock matrix builder");
+inline void load_modules(pluginplay::ModuleMap& modules) {
+    modules.add_module<SCFIntegralsDriver>("SCF integral driver");
+    modules.add_module<DensityMatrix>("Density matrix builder");
+    modules.add_module<DeterminantDriver>("Determinant driver");
+    modules.add_module<ElectronicEnergy>("Electronic energy");
+    modules.add_module<Fock>("Fock matrix builder");
 }
 
-inline void set_defaults(pluginplay::ModuleManager& mm) {
+inline void set_defaults(pluginplay::ModuleMap& modules) {
     const auto ao_driver = "SCF integral driver";
-    // mm.change_submod(ao_driver, "Fock matrix", "Fock Matrix Builder");
-    mm.change_submod(ao_driver, "Density matrix", "Density matrix builder");
+    // modules.change_submod(ao_driver, "Fock matrix", "Fock Matrix Builder");
+    modules.change_submod(ao_driver, "Density matrix",
+                          "Density matrix builder");
 // GauXC and LibXC's "XC Potential"/"XC Energy" modules satisfy the same
 // property types (see scf::xc::gauxc::xc_potential.cpp/xc_energy.cpp and
 // scf::xc::libxc::libxc_potential.cpp/libxc_energy.cpp), so either is a
 // valid default; GauXC is preferred when both are available. Neither module
-// exists in the ModuleManager when its BUILD_* option is off, and
-// mm.change_submod throws if pointed at a key that isn't registered, so
+// exists in the plugin when its BUILD_* option is off, and
+// ModuleMap::change_submod throws if pointed at a key that isn't registered, so
 // this must mirror the same guards scf::xc::set_defaults uses (see xc.cpp)
 // rather than unconditionally defaulting to GauXC.
 #ifdef BUILD_GAUXC
-    mm.change_submod(ao_driver, "XC Potential", "GauXC XC Potential");
+    modules.change_submod(ao_driver, "XC Potential", "GauXC XC Potential");
 #elif defined(BUILD_LIBXC)
-    mm.change_submod(ao_driver, "XC Potential", "LibXC Potential");
+    modules.change_submod(ao_driver, "XC Potential", "LibXC Potential");
 #endif
 
-    mm.change_submod("Fock Matrix Builder", "Two center evaluator", ao_driver);
+    modules.change_submod("Fock Matrix Builder", "Two center evaluator",
+                          ao_driver);
 
     const auto det_driver = "Determinant driver";
-    mm.change_submod(det_driver, "Two center evaluator", ao_driver);
-    mm.change_submod(det_driver, "Fock matrix", "Fock matrix builder");
+    modules.change_submod(det_driver, "Two center evaluator", ao_driver);
+    modules.change_submod(det_driver, "Fock matrix", "Fock matrix builder");
 
-    mm.change_submod("Electronic energy", "determinant driver", det_driver);
+    modules.change_submod("Electronic energy", "determinant driver",
+                          det_driver);
 #ifdef BUILD_GAUXC
-    mm.change_submod("Electronic energy", "XC Energy", "GauXC XC Energy");
+    modules.change_submod("Electronic energy", "XC Energy", "GauXC XC Energy");
 #elif defined(BUILD_LIBXC)
-    mm.change_submod("Electronic energy", "XC Energy", "LibXC Energy");
+    modules.change_submod("Electronic energy", "XC Energy", "LibXC Energy");
 #endif
 }
 

cxx/src/scf/scf_mm.cpp

@@ -26,50 +26,47 @@
 
 namespace scf {
 
-void load_modules(pluginplay::ModuleManager& mm) {
-    driver::load_modules(mm);
-    eigen_solver::load_modules(mm);
-    fock_operator::load_modules(mm);
-    guess::load_modules(mm);
-    matrix_builder::load_modules(mm);
-    update::load_modules(mm);
-    xc::load_modules(mm);
+PLUGIN_CTOR(SCF) {
+    set_name("scf");
 
-    mm.add_module<CoulombsLaw>("Coulomb's Law");
+    // The defaults refer to modules from more than one subdirectory, so all
+    // modules are added before any defaults are set
+    driver::load_modules(modules());
+    eigen_solver::load_modules(modules());
+    fock_operator::load_modules(modules());
+    guess::load_modules(modules());
+    matrix_builder::load_modules(modules());
+    update::load_modules(modules());
+    xc::load_modules(modules());
+
+    add_module<CoulombsLaw>("Coulomb's Law");
 
-    // mm.add_module<SCFDriver>("Driver");
 #ifdef BUILD_TAMM_SCF
-    mm.add_module<TAMMEnergy>("SCF Energy via TAMM");
+    add_module<TAMMEnergy>("SCF Energy via TAMM");
 #endif
 
-    driver::set_defaults(mm);
-    guess::set_defaults(mm);
-    matrix_builder::set_defaults(mm);
-    update::set_defaults(mm);
-    xc::set_defaults(mm);
-}
+    driver::set_defaults(modules());
+    eigen_solver::set_defaults(modules());
+    guess::set_defaults(modules());
+    matrix_builder::set_defaults(modules());
+    update::set_defaults(modules());
+    xc::set_defaults(modules());
 
-void set_defaults(pluginplay::ModuleManager& mm) {
-    // Sets submod of module to provider, but only if provider is loaded
-    auto set_if_loaded = [&mm](const std::string& module,
-                               const std::string& submod,
-                               const std::string& provider) {
-        if(mm.count(provider)) mm.change_submod(module, submod, provider);
-    };
+    // Submodules SCF does not provide come from these plugins, if loaded
+    set_preferred_providers("nux", "integrals", "chemcache");
 
-    // From NUX
-    set_if_loaded("SCF Driver", "Hamiltonian",
-                  "Born-Oppenheimer approximation");
+    default_submod_from("nux", "SCF Driver", "Hamiltonian",
+                        "Born-Oppenheimer approximation");
 
-    // From Integrals
-    set_if_loaded("SCF integral driver", "Fundamental matrices",
-                  "AO integral driver");
-    set_if_loaded("Diagonalization Fock update", "Overlap matrix builder",
-                  "Overlap");
-    set_if_loaded("Loop", "Overlap matrix builder", "Overlap");
+    default_submod_from("integrals", "SCF integral driver",
+                        "Fundamental matrices", "AO integral driver");
+    default_submod_from("integrals", "Diagonalization Fock update",
+                        "Overlap matrix builder", "Overlap");
+    default_submod_from("integrals", "Loop", "Overlap matrix builder",
+                        "Overlap");
 
-    // From ChemCache
-    set_if_loaded("SAD guess", "SAD Density", "sto-3g SAD density");
+    default_submod_from("chemcache", "SAD guess", "SAD Density",
+                        "sto-3g SAD density");
 }
 
 } // namespace scf

cxx/src/scf/update/update.hpp

@@ -21,15 +21,15 @@ namespace scf::update {
 
 DECLARE_MODULE(Diagonalization);
 
-inline void load_modules(pluginplay::ModuleManager& mm) {
-    mm.add_module<Diagonalization>("Diagonalization Fock update");
+inline void load_modules(pluginplay::ModuleMap& modules) {
+    modules.add_module<Diagonalization>("Diagonalization Fock update");
 }
 
-inline void set_defaults(pluginplay::ModuleManager& mm) {
-    mm.change_submod("Diagonalization Fock update", "Diagonalizer",
-                     "Generalized eigensolve via Eigen");
-    mm.change_submod("Diagonalization Fock update", "Fock matrix builder",
-                     "Fock matrix builder");
+inline void set_defaults(pluginplay::ModuleMap& modules) {
+    modules.change_submod("Diagonalization Fock update", "Diagonalizer",
+                          "Generalized eigensolve via Eigen");
+    modules.change_submod("Diagonalization Fock update", "Fock matrix builder",
+                          "Fock matrix builder");
 }
 
 } // namespace scf::update