diff --git a/CMakeLists.txt b/CMakeLists.txt index a6fa3a49..59753883 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -46,6 +46,7 @@ cmaize_find_or_build_dependency( BUILD_TARGET simde FIND_TARGET nwx::simde CMAKE_ARGS BUILD_TESTING=OFF + NWX_PLUGINPLAY_VERSION="cache_access" ) cmaize_find_or_build_dependency( @@ -88,11 +89,6 @@ if("${BUILD_TESTING}") INCLUDE_DIRS "${project_src_dir}/${PROJECT_NAME}" DEPENDS Catch2::Catch2 ${PROJECT_NAME} ) - nwx_pybind11_tests( - py_ghostfragment - ${python_tests_dir}/integration_tests/test_ghostfragment.py - SUBMODULES simde chemist pluginplay parallelzone - ) if("${INTEGRATION_TESTING}") cmaize_find_or_build_dependency( @@ -102,5 +98,13 @@ if("${BUILD_TESTING}") FIND_TARGET nwx::nwchemex CMAKE_ARGS BUILD_TESTING=OFF ) + + nwx_pybind11_tests( + py_ghostfragment + ${python_tests_dir}/integration_tests/test_ghostfragment.py + DEPENDS nwchemex + SUBMODULES simde chemist pluginplay parallelzone friendzone chemcache nwchemex + ) + endif() endif() diff --git a/src/ghostfragment/drivers/drivers.hpp b/src/ghostfragment/drivers/drivers.hpp index aa519b99..3fc02717 100644 --- a/src/ghostfragment/drivers/drivers.hpp +++ b/src/ghostfragment/drivers/drivers.hpp @@ -40,11 +40,24 @@ inline void set_defaults(pluginplay::ModuleManager& mm) { mm.change_submod("Fragment Driver", "Find broken bonds", "Broken bonds"); mm.change_submod("Fragment Driver", "Cap broken bonds", "Weighted distance"); + + mm.copy_module("Fragment Driver", "N-mer Driver"); + mm.change_submod("N-mer Driver", "Molecular graph to fragments", + "All nmers"); + mm.change_submod("FragmentedChemicalSystem Driver", "Fragmenter", "Fragment Driver"); + + mm.copy_module("FragmentedChemicalSystem Driver", "N-mer System Driver"); + mm.change_submod("N-mer System Driver", "Fragmenter", "N-mer Driver"); + mm.change_submod("Fragment Based Method", "Subsystem former", "FragmentedChemicalSystem Driver"); mm.change_submod("Fragment Based Method", "Weighter", "GMBE Weights"); + + mm.copy_module("Fragment Based Method", "N-mer Based Method"); + mm.change_submod("N-mer Based Method", "Subsystem former", + "N-mer System Driver"); } } // namespace ghostfragment::drivers diff --git a/src/ghostfragment/drivers/fragment.cpp b/src/ghostfragment/drivers/fragment.cpp index 13478cde..89c88063 100644 --- a/src/ghostfragment/drivers/fragment.cpp +++ b/src/ghostfragment/drivers/fragment.cpp @@ -58,22 +58,42 @@ MODULE_CTOR(Fragment) { MODULE_RUN(Fragment) { const auto& [mol] = frags_pt::unwrap_inputs(inputs); - - auto& graph_mod = submods.at("Molecular Graph"); - const auto& graph = graph_mod.run_as(mol); - - auto& frags_mod = submods.at("Molecular graph to fragments"); + auto& runtime = get_runtime(); + + // Step 1: Form the molecular graph + auto& graph_mod = submods.at("Molecular Graph"); + const auto& graph = graph_mod.run_as(mol); + const auto n_nodes = graph.nodes_size(); + const auto n_edges = graph.edges_size(); + runtime.logger().debug("Created a graph with " + std::to_string(n_nodes) + + " nodes and " + std::to_string(n_edges) + " edges."); + + // Step 2: Use the graph to make fragments + auto& frags_mod = submods.at("Molecular graph to fragments"); const auto& frags_no_ints = frags_mod.run_as(graph); + const auto n_frags = frags_no_ints.size(); + runtime.logger().debug("Created " + std::to_string(n_frags) + + " fragments."); + // Step 3: Analyze the fragments for intersections auto& intersect_mod = submods.at("Intersection finder"); - const auto& frags = intersect_mod.run_as(frags_no_ints); + const auto& frags = intersect_mod.run_as(frags_no_ints); + const auto n_ints = frags.size() - n_frags; + runtime.logger().debug("Added " + std::to_string(n_ints) + + " intersections."); + // Step 4: Did forming fragments (or intersections) break bonds? auto& bonds_mod = submods.at("Find broken bonds"); const auto& conns = graph.edges(); const auto& broken_bonds = bonds_mod.run_as(frags, conns); + runtime.logger().debug("Found " + std::to_string(broken_bonds.size()) + + " broken bonds."); + // Step 5: Fix those broken bonds!!!! auto& cap_mod = submods.at("Cap broken bonds"); const auto& capped_frags = cap_mod.run_as(frags, broken_bonds); + const auto n_caps = capped_frags.cap_set().size(); + runtime.logger().debug("Added " + std::to_string(n_caps) + " caps."); auto rv = results(); return frags_pt::wrap_results(rv, capped_frags); diff --git a/src/ghostfragment/drivers/fragment_based_method.cpp b/src/ghostfragment/drivers/fragment_based_method.cpp index 5ff4a939..7dc0cf9d 100644 --- a/src/ghostfragment/drivers/fragment_based_method.cpp +++ b/src/ghostfragment/drivers/fragment_based_method.cpp @@ -44,11 +44,12 @@ MODULE_CTOR(FragmentBasedMethod) { add_submodule("Subsystem former"); add_submodule("Weighter"); - add_submodule("Apply basis set"); - add_submodule("Energy method"); + add_submodule("Energy method"); } MODULE_RUN(FragmentBasedMethod) { + auto& logger = get_runtime().logger(); + // Step 0: Unpack input const auto& [sys] = my_pt::unwrap_inputs(inputs); @@ -60,19 +61,25 @@ MODULE_RUN(FragmentBasedMethod) { auto& weight_mod = submods.at("weighter"); const auto& weights = weight_mod.run_as(subsystems); - auto& basis_mod = submods.at("Apply basis set"); auto& energy_mod = submods.at("Energy method"); double energy = 0.0; + + auto n_subsystems = subsystems.size(); + decltype(n_subsystems) counter = 0; + auto msg = [](auto counter, auto n_subsystems, auto egy) { + return "Energy of subsystem " + std::to_string(counter) + " of " + + std::to_string(n_subsystems) + " : " + std::to_string(egy); + }; for(auto&& [c_i, sys_i] : iter::zip(weights, subsystems)) { - auto mol_i = sys_i.molecule().as_molecule(); - const auto& basis = basis_mod.run_as(mol_i); + auto mol_i = sys_i.molecule().as_molecule(); // This is a hack until views work with values chemical_system_type sys_i_copy(mol_i); - const auto e_i = energy_mod.run_as(basis, sys_i_copy); + const auto e_i = energy_mod.run_as(sys_i_copy); energy += c_i * e_i; + logger.info(msg(counter++, n_subsystems, e_i)); } auto rv = results(); diff --git a/src/ghostfragment/fragmenting/fragmenting.hpp b/src/ghostfragment/fragmenting/fragmenting.hpp index 216d1ded..5ebffc4e 100644 --- a/src/ghostfragment/fragmenting/fragmenting.hpp +++ b/src/ghostfragment/fragmenting/fragmenting.hpp @@ -37,6 +37,7 @@ inline void load_modules(pluginplay::ModuleManager& mm) { inline void set_defaults(pluginplay::ModuleManager& mm) { mm.change_submod("Heavy Atom Partition", "Connectivity", "Covalent Radius"); + mm.change_submod("All nmers", "Monomer maker", "Bond-Based Fragmenter"); } } // namespace ghostfragment::fragmenting diff --git a/src/ghostfragment/fragmenting/heavy_atom.cpp b/src/ghostfragment/fragmenting/heavy_atom.cpp index 338d1e31..35bfebd0 100644 --- a/src/ghostfragment/fragmenting/heavy_atom.cpp +++ b/src/ghostfragment/fragmenting/heavy_atom.cpp @@ -56,12 +56,14 @@ MODULE_CTOR(HeavyAtom) { MODULE_RUN(HeavyAtom) { using fragmented_nuclei = typename pt::FragmentedNucleiTraits::result_type; using size_type = typename fragmented_nuclei::size_type; + auto& logger = get_runtime().logger(); const auto& [system] = frags_pt::unwrap_inputs(inputs); const auto& mol = system.molecule(); auto& con_mod = submods.at("Connectivity"); const auto& conns = con_mod.run_as(mol); + logger.debug("Found " + std::to_string(conns.nbonds()) + " bonds."); fragmented_nuclei frags(mol.nuclei().as_nuclei()); @@ -69,6 +71,8 @@ MODULE_RUN(HeavyAtom) { std::vector fragment; const auto Zi = mol[atom_i].Z(); const auto conn_i = conns.bonded_atoms(atom_i); + logger.trace("Atom " + std::to_string(atom_i) + + " has Z == " + std::to_string(Zi)); if(Zi > 1) { fragment.push_back(atom_i); diff --git a/src/ghostfragment/fragmenting/intersections_by_recursion.cpp b/src/ghostfragment/fragmenting/intersections_by_recursion.cpp index f1088915..bf3015d4 100644 --- a/src/ghostfragment/fragmenting/intersections_by_recursion.cpp +++ b/src/ghostfragment/fragmenting/intersections_by_recursion.cpp @@ -26,17 +26,18 @@ using nuclear_index_set = typename fragments_type::nucleus_index_set; using size_type = typename nuclear_index_set::size_type; using index_set = std::set; using intersection_set = std::set; +using frag_set = std::vector; namespace { -template -void compute_intersection(const index_set& curr_frag, BeginItr&& starting_frag, - EndItr&& end_itr, intersection_set& ints_so_far) { - while(starting_frag != end_itr) { +void compute_intersection(const index_set& curr_frag, std::size_t starting_frag, + const frag_set& frag_indices, + intersection_set& ints_so_far) { + while(starting_frag < frag_indices.size()) { index_set intersection; + const index_set& next_frag = frag_indices[starting_frag]; auto itr = std::inserter(intersection, intersection.begin()); std::set_intersection(curr_frag.begin(), curr_frag.end(), - starting_frag->begin(), starting_frag->end(), - itr); + next_frag.begin(), next_frag.end(), itr); ++starting_frag; // If it's empty and/or we've seen it befor just move on if(intersection.empty() || ints_so_far.count(intersection)) continue; @@ -44,9 +45,8 @@ void compute_intersection(const index_set& curr_frag, BeginItr&& starting_frag, // Add the intersection ints_so_far.insert(intersection); - // Copy iterator so we leave starting_frag unchanged when we recurse - decltype(starting_frag) new_begin(starting_frag); - compute_intersection(intersection, new_begin, end_itr, ints_so_far); + compute_intersection(intersection, starting_frag + 1, frag_indices, + ints_so_far); } } @@ -65,6 +65,7 @@ MODULE_CTOR(IntersectionsByRecursion) { } MODULE_RUN(IntersectionsByRecursion) { + auto& logger = get_runtime().logger(); auto [frags] = property_type::unwrap_inputs(inputs); // It's much easier to work with nuclear indices @@ -72,23 +73,27 @@ MODULE_RUN(IntersectionsByRecursion) { for(size_type i = 0; i < frags.size(); ++i) { const auto frag_i = frags.nuclear_indices(i); + std::string frag_str; + for(auto x : frag_i) frag_str += std::to_string(x) + ","; + frag_str.pop_back(); + logger.debug("Input fragment: " + frag_str); frag_indices.emplace_back(frag_i.begin(), frag_i.end()); } std::set intersections; - auto begin = frag_indices.begin(); - auto end = frag_indices.end(); - - while(begin != end) { - index_set frag = *begin; - ++begin; - decltype(begin) begin_copy(begin); - compute_intersection(frag, begin_copy, end, intersections); + for(decltype(frags.size()) begin = 0; begin < frags.size(); ++begin) { + const index_set& frag = frag_indices[begin]; + compute_intersection(frag, begin + 1, frag_indices, intersections); } - for(const auto& intersection_i : intersections) + for(const auto& intersection_i : intersections) { + std::string int_str; + for(auto x : intersection_i) int_str += std::to_string(x) + ","; + int_str.pop_back(); + logger.debug("Found intersection: " + int_str); frags.insert(intersection_i.begin(), intersection_i.end()); + } auto rv = results(); return property_type::wrap_results(rv, frags); diff --git a/src/ghostfragment/fragmenting/nmers.cpp b/src/ghostfragment/fragmenting/nmers.cpp index 49ec7bc3..b39a9113 100644 --- a/src/ghostfragment/fragmenting/nmers.cpp +++ b/src/ghostfragment/fragmenting/nmers.cpp @@ -45,14 +45,21 @@ MODULE_CTOR(NMers) { description(mod_desc); satisfies_property_type(); - add_input("n").set_description("The maximum n-mer size"); + add_input("n") + .set_description("The maximum n-mer size") + .set_default(n_type(1)); add_submodule("Monomer maker"); } MODULE_RUN(NMers) { + auto& logger = get_runtime().logger(); + const auto& [graph] = my_pt::unwrap_inputs(inputs); auto n = inputs.at("n").value(); + auto nmer_str = std::to_string(n) + "-mers"; + logger.debug("Will be making " + nmer_str + "."); + auto& monomer_mod = submods.at("Monomer maker"); const auto& frags = monomer_mod.run_as(graph); @@ -110,7 +117,7 @@ MODULE_RUN(NMers) { } if(i_is_good[i]) nmers.insert(nmer_i.begin(), nmer_i.end()); } - + logger.debug("Made " + std::to_string(nmers.size()) + " " + nmer_str + "."); auto rv = results(); return my_pt::wrap_results(rv, nmers); } diff --git a/src/ghostfragment/topology/covradii.cpp b/src/ghostfragment/topology/covradii.cpp index fd4a3370..dd942fe7 100644 --- a/src/ghostfragment/topology/covradii.cpp +++ b/src/ghostfragment/topology/covradii.cpp @@ -55,6 +55,7 @@ MODULE_CTOR(CovRadii) { } MODULE_RUN(CovRadii) { + auto& logger = get_runtime().logger(); const auto& [mol] = my_pt::unwrap_inputs(inputs); const auto tau = inputs.at("tau").value(); const auto tau_plus_1 = tau + 1.0; @@ -66,13 +67,21 @@ MODULE_RUN(CovRadii) { for(size_type i = 0; i < natoms; ++i) { const auto atom_i = mol[i]; const auto sigma_i = covalent_radius(atom_i.Z()); + logger.trace("Atom " + std::to_string(i) + " has covalent radius " + + std::to_string(sigma_i) + " (a.u.)."); for(size_type j = i + 1; j < natoms; ++j) { const auto atom_j = mol[j].as_nucleus(); const auto sigma_j = covalent_radius(atom_j.Z()); + logger.trace("Atom " + std::to_string(j) + " has covalent radius " + + std::to_string(sigma_j) + " (a.u.)."); const auto rij = (atom_i.as_nucleus() - atom_j).magnitude(); const auto max_bond = tau_plus_1 * (sigma_i + sigma_j); + + logger.trace(std::to_string(i) + "-" + std::to_string(j) + + " distance is: " + std::to_string(rij)); + if(rij <= max_bond) ct.add_bond(i, j); } } diff --git a/src/ghostfragment/topology/nuclear_graph_from_connectivity.cpp b/src/ghostfragment/topology/nuclear_graph_from_connectivity.cpp index 6696c7d8..23601893 100644 --- a/src/ghostfragment/topology/nuclear_graph_from_connectivity.cpp +++ b/src/ghostfragment/topology/nuclear_graph_from_connectivity.cpp @@ -46,13 +46,22 @@ MODULE_CTOR(NuclearGraphFromConnectivity) { MODULE_RUN(NuclearGraphFromConnectivity) { using traits_type = pt::NuclearGraphTraits; using result_type = traits_type::result_type; + auto& logger = get_runtime().logger(); const auto& [chem_sys] = my_pt::unwrap_inputs(inputs); - auto& pseudo_atom_mod = submods.at("Nodes"); - const auto& frags = pseudo_atom_mod.run_as(chem_sys); + + auto& pseudo_atom_mod = submods.at("Nodes"); + const auto& frags = pseudo_atom_mod.run_as(chem_sys); + const auto n_atoms = chem_sys.molecule().size(); + const auto n_pas = frags.size(); + logger.debug("The " + std::to_string(n_atoms) + + " atoms of the system were converted into " + + std::to_string(n_pas) + " pseudoatoms."); auto& conn_mod = submods.at("Connectivity"); const auto& atom_conns = conn_mod.run_as(chem_sys.molecule()); + const auto n_bonds = atom_conns.nbonds(); + logger.debug("System has " + std::to_string(n_bonds) + " bonds."); const auto nnodes = frags.size(); std::decay_t edges(nnodes); diff --git a/tests/cxx/unit_tests/ghostfragment/drivers/fragment_based_method.cpp b/tests/cxx/unit_tests/ghostfragment/drivers/fragment_based_method.cpp index f2810f4d..b5b0255a 100644 --- a/tests/cxx/unit_tests/ghostfragment/drivers/fragment_based_method.cpp +++ b/tests/cxx/unit_tests/ghostfragment/drivers/fragment_based_method.cpp @@ -47,14 +47,11 @@ using namespace ghostfragment; using namespace testing; using my_pt = simde::TotalEnergy; -using ao_energy_pt = simde::AOEnergy; using frag_sys_pt = pt::FragmentedChemicalSystem; using frag_sys_traits = pt::FragmentedChemicalSystemTraits; using chemical_system_type = typename frag_sys_traits::system_type; using frag_sys_type = typename frag_sys_traits::result_type; using frag_mol_type = typename frag_sys_type::fragmented_molecule_type; -using basis_set_pt = simde::MolecularBasisSet; -using basis_set_type = chemist::basis_set::AOBasisSetD; using weights_pt = pt::FragmentWeights; // Checks that we pass in the correct system, returns a set of fragments @@ -73,23 +70,13 @@ auto weight_mod(const frag_sys_type& frags) { }); } -// Checks it was passed one of the frags -auto basis_mod(const chemical_system_type& sys, const basis_set_type& aos) { - return pluginplay::make_lambda([=](auto&& sys_in) { - REQUIRE(sys_in == sys.molecule()); - return aos; +auto energy_mod(const chemical_system_type& sys) { + return pluginplay::make_lambda([=](auto&& sys_in) { + REQUIRE(sys == sys_in); + return -75.123456; // Just make up an energy... }); } -auto energy_mod(const chemical_system_type& sys, const basis_set_type& aos) { - return pluginplay::make_lambda( - [=](auto&& aos_in, auto&& sys_in) { - REQUIRE(sys == sys_in); - REQUIRE(aos == aos_in); - return -75.123456; // Just make up an energy... - }); -} - TEST_CASE("FragmentBasedMethod") { auto mm = initialize(); auto& mod = mm.at("Fragment Based Method"); @@ -97,12 +84,10 @@ TEST_CASE("FragmentBasedMethod") { chemical_system_type water(testing::water(1)); frag_mol_type frag_mol(testing::water_fragmented_nuclei(1), 0, 1); frag_sys_type frags(std::move(frag_mol)); - basis_set_type aos; mod.change_submod("Subsystem former", frag_mod(water, frags)); mod.change_submod("Weighter", weight_mod(frags)); - mod.change_submod("Apply basis set", basis_mod(water, aos)); - mod.change_submod("Energy method", energy_mod(water, aos)); + mod.change_submod("Energy method", energy_mod(water)); auto energy = mod.run_as(water); auto corr = 2.0 * -75.123456; diff --git a/tests/cxx/unit_tests/ghostfragment/fragmenting/intersections_by_recursion.cpp b/tests/cxx/unit_tests/ghostfragment/fragmenting/intersections_by_recursion.cpp index 55e15a8b..fc84e8e3 100644 --- a/tests/cxx/unit_tests/ghostfragment/fragmenting/intersections_by_recursion.cpp +++ b/tests/cxx/unit_tests/ghostfragment/fragmenting/intersections_by_recursion.cpp @@ -123,6 +123,20 @@ TEST_CASE("Intersection Finder") { auto intersects = mod.run_as(fragmented_nuclei); REQUIRE(intersects == corr); } + + SECTION("Alternative three Overlaps") { + fragmented_nuclei.insert({0, 1, 2, 3, 4}); + fragmented_nuclei.insert({0, 1, 2, 5, 6, 7}); + fragmented_nuclei.insert({3, 4, 5, 6, 7}); + + fragments_type corr(fragmented_nuclei); + corr.insert({0, 1, 2}); + corr.insert({3, 4}); + corr.insert({5, 6, 7}); + + auto intersects = mod.run_as(fragmented_nuclei); + REQUIRE(intersects == corr); + } } SECTION("Four Fragments") { diff --git a/tests/python/integration_tests/drivers/__init__.py b/tests/python/integration_tests/drivers/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/tests/python/integration_tests/drivers/test_fragment_based_method.py b/tests/python/integration_tests/drivers/test_fragment_based_method.py new file mode 100644 index 00000000..7506f3e3 --- /dev/null +++ b/tests/python/integration_tests/drivers/test_fragment_based_method.py @@ -0,0 +1,91 @@ +# Copyright 2024 GhostFragment +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import nwchemex as nwx +import parallelzone as pz +import simde +import chemist +import pluginplay +import ghostfragment +import unittest +import ctypes + + +class TestFragmentBasedMethod(unittest.TestCase): + + def test_1b_water_dimer_hf_aug_cc_pvdz(self): + mod_key = 'Fragment Based Method' + method = 'NWChem : SCF' + basis = 'aug-cc-pvdz' + self.mm.change_input(method, 'basis set', basis) + sys = chemist.ChemicalSystem(self.water2) + + self.mm.change_submod(mod_key, 'Energy method', method) + egy = self.mm.run_as(simde.TotalEnergy(), mod_key, sys) + self.assertAlmostEqual(egy, -152.084758403538) + + def test_1b_water_trimer_hf_sto_3g(self): + mod_key = 'Fragment Based Method' + method = 'NWChem : SCF' + basis = 'sto-3g' + self.mm.change_input(method, 'basis set', basis) + sys = chemist.ChemicalSystem(self.water3) + + self.mm.change_submod(mod_key, 'Energy method', method) + egy = self.mm.run_as(simde.TotalEnergy(), mod_key, sys) + self.assertAlmostEqual(egy, -224.881189393868) + + def test_2b_water_trimer_hf_sto_3g(self): + mod_key = 'N-mer Based Method' + method = 'NWChem : SCF' + basis = 'sto-3g' + trunc_order = 2 + self.mm.change_input(method, 'basis set', basis) + self.mm.change_input('All nmers', 'n', trunc_order) + sys = chemist.ChemicalSystem(self.water3) + + self.mm.change_submod(mod_key, 'Energy method', method) + egy = self.mm.run_as(simde.TotalEnergy(), mod_key, sys) + self.assertAlmostEqual(egy, -224.90189366802105) + + def setUp(self): + self.mm = pluginplay.ModuleManager() + nwx.load_modules(self.mm) + ghostfragment.load_modules(self.mm) + + mol_pt = simde.MoleculeFromString() + sys_maker_key = 'ChemicalSystem via QCElemental' + + mol_str = """ + H -1.958940 -0.032063 0.725554 + H -0.607485 0.010955 0.056172 + O -1.538963 0.004548 -0.117331 + H 1.727607 0.762122 -0.351887 + H 1.704312 -0.747744 -0.399151 + O 1.430776 -0.003706 0.113495 + """ + self.water2 = self.mm.run_as(mol_pt, sys_maker_key, mol_str) + + mol_str = """ + O -0.167787 1.645761 0.108747 + H 0.613411 1.102620 0.113724 + H -0.093821 2.209720 -0.643619 + O 1.517569 -0.667424 -0.080674 + H 1.989645 -1.098799 0.612047 + H 0.668397 -1.091798 -0.139744 + O -1.350388 -0.964879 -0.092208 + H -1.908991 -1.211298 0.626207 + H -1.263787 -0.018107 -0.055536 + """ + self.water3 = self.mm.run_as(mol_pt, sys_maker_key, mol_str) diff --git a/tests/python/integration_tests/test_cap.py b/tests/python/integration_tests/test_cap.py deleted file mode 100644 index 4ea63cca..00000000 --- a/tests/python/integration_tests/test_cap.py +++ /dev/null @@ -1,27 +0,0 @@ -# Copyright 2024 GhostFragment -# -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. - -#import nwchemex as nwx -import simde -import pluginplay -import ghostfragment -import unittest - - -class TestCapping(unittest.TestCase): - - def setUp(self): - mm = pluginplay.ModuleManager() - ghostfragment.load_modules(mm) - # nwx.load_modules()