From e8a27e1d580a4c6eaed7311d8db9bba105cc1b83 Mon Sep 17 00:00:00 2001 From: Xavier Andrade Date: Mon, 14 Oct 2024 15:15:11 -0700 Subject: [PATCH] Make the poisson solve a free function instead of using an empty class. --- python/_pinq.cpp | 6 ++-- src/hamiltonian/exchange_operator.hpp | 3 +- src/hamiltonian/self_consistency.hpp | 8 ++--- src/observables/forces_stress.hpp | 4 +-- src/solvers/poisson.hpp | 49 ++++++++++++--------------- 5 files changed, 28 insertions(+), 42 deletions(-) diff --git a/python/_pinq.cpp b/python/_pinq.cpp index f61d1e071..f5824d167 100644 --- a/python/_pinq.cpp +++ b/python/_pinq.cpp @@ -136,10 +136,8 @@ struct calculator { electrons_.emplace(systems::electrons(ions, els_)); ground_state::initial_guess(ions, *electrons_); } - - solvers::poisson poisson_solver; - - auto ionic_long_range = poisson_solver(electrons_->atomic_pot().ionic_density(electrons_->kpin_states_comm(), electrons_->density_basis(), ions)); + + auto ionic_long_range = solvers::poisson::solve(electrons_->atomic_pot().ionic_density(electrons_->kpin_states_comm(), electrons_->density_basis(), ions)); auto ionic_short_range = electrons_->atomic_pot().local_potential(electrons_->kpin_states_comm(), electrons_->density_basis(), ions); auto vion = operations::add(ionic_long_range, ionic_short_range); diff --git a/src/hamiltonian/exchange_operator.hpp b/src/hamiltonian/exchange_operator.hpp index 1a3681c45..e73264a0f 100644 --- a/src/hamiltonian/exchange_operator.hpp +++ b/src/hamiltonian/exchange_operator.hpp @@ -34,7 +34,6 @@ namespace hamiltonian { gpu::array kpoint_indices_; std::optional> orbitals_; std::vector> ace_orbitals_; - solvers::poisson poisson_solver_; double exchange_coefficient_; bool use_ace_; singularity_correction sing_; @@ -142,7 +141,7 @@ namespace hamiltonian { }); } - poisson_solver_.in_place(rhoij, -phi.kpoint() + kpt[jj], sing_(idx[jj])); + solvers::poisson::in_place(rhoij, -phi.kpoint() + kpt[jj], sing_(idx[jj])); { CALI_CXX_MARK_SCOPE("exchange_operator::mulitplication"); gpu::run(nst, exxphi.basis().local_size(), diff --git a/src/hamiltonian/self_consistency.hpp b/src/hamiltonian/self_consistency.hpp index 72e7e1514..6ad803823 100644 --- a/src/hamiltonian/self_consistency.hpp +++ b/src/hamiltonian/self_consistency.hpp @@ -74,9 +74,7 @@ class self_consistency { CALI_CXX_MARK_FUNCTION; - solvers::poisson poisson_solver; - - auto ionic_long_range = poisson_solver(atomic_pot.ionic_density(comm, density_basis_, ions)); + auto ionic_long_range = solvers::poisson::solve(atomic_pot.ionic_density(comm, density_basis_, ions)); auto ionic_short_range = atomic_pot.local_potential(comm, density_basis_, ions); vion_ = operations::add(ionic_long_range, ionic_short_range); @@ -97,8 +95,6 @@ class self_consistency { energy.external(operations::integral_product(total_density, vion_)); - solvers::poisson poisson_solver; - //IONIC POTENTIAL auto vscalar = vion_; @@ -117,7 +113,7 @@ class self_consistency { // Hartree if(theory_.hartree_potential()){ - auto vhartree = poisson_solver(total_density); + auto vhartree = solvers::poisson::solve(total_density); energy.hartree(0.5*operations::integral_product(total_density, vhartree)); operations::increment(vscalar, vhartree); } else { diff --git a/src/observables/forces_stress.hpp b/src/observables/forces_stress.hpp index f7a7f3dc2..b31ee3ec1 100644 --- a/src/observables/forces_stress.hpp +++ b/src/observables/forces_stress.hpp @@ -81,11 +81,9 @@ struct forces_stress { { CALI_CXX_MARK_SCOPE("forces_local"); - solvers::poisson poisson_solver; - //the force from the local potential for(int iatom = 0; iatom < ions.size(); iatom++){ - auto ionic_long_range = poisson_solver(electrons.atomic_pot().ionic_density(electrons.states_comm(), electrons.density_basis(), ions, iatom)); + auto ionic_long_range = solvers::poisson::solve(electrons.atomic_pot().ionic_density(electrons.states_comm(), electrons.density_basis(), ions, iatom)); auto ionic_short_range = electrons.atomic_pot().local_potential(electrons.states_comm(), electrons.density_basis(), ions, iatom); auto force_cov = -gpu::run(gpu::reduce(electrons.density_basis().local_size()), diff --git a/src/solvers/poisson.hpp b/src/solvers/poisson.hpp index 5348a3f98..2466b406f 100644 --- a/src/solvers/poisson.hpp +++ b/src/solvers/poisson.hpp @@ -26,6 +26,8 @@ class poisson { public: + poisson() = delete; + struct poisson_kernel_3d { GPU_FUNCTION auto operator()(vector3 gg, double const zeroterm) const { auto g2 = norm(gg); @@ -67,7 +69,7 @@ class poisson { /////////////////////////////////////////////////////////////////////////////////////////////////// template - void poisson_apply_kernel(KernelType const kernel, FieldSetType & density, vector3 const & gshift = {0.0, 0.0, 0.0}, double const zeroterm = 0.0) const { + static void poisson_apply_kernel(KernelType const kernel, FieldSetType & density, vector3 const & gshift = {0.0, 0.0, 0.0}, double const zeroterm = 0.0) { static_assert(std::is_same_v, "Only makes sense in fourier_space"); @@ -87,7 +89,7 @@ class poisson { private: - auto poisson_solve_3d(basis::field const & density) const { + static auto poisson_solve_3d(basis::field const & density) { CALI_CXX_MARK_FUNCTION; @@ -98,7 +100,7 @@ class poisson { /////////////////////////////////////////////////////////////////////////////////////////////////// - void poisson_solve_in_place_3d(basis::field_set & density, vector3 const & gshift, double const zeroterm) const { + static void poisson_solve_in_place_3d(basis::field_set & density, vector3 const & gshift, double const zeroterm) { CALI_CXX_MARK_FUNCTION; @@ -109,7 +111,7 @@ class poisson { /////////////////////////////////////////////////////////////////////////////////////////////////// - basis::field poisson_solve_2d(basis::field const & density) const { + static basis::field poisson_solve_2d(basis::field const & density) { CALI_CXX_MARK_FUNCTION; @@ -127,7 +129,7 @@ class poisson { /////////////////////////////////////////////////////////////////////////////////////////////////// - void poisson_solve_in_place_2d(basis::field_set & density, vector3 const & gshift, double const zeroterm) const { + static void poisson_solve_in_place_2d(basis::field_set & density, vector3 const & gshift, double const zeroterm) { CALI_CXX_MARK_FUNCTION; @@ -143,7 +145,7 @@ class poisson { /////////////////////////////////////////////////////////////////////////////////////////////////// - basis::field poisson_solve_0d(basis::field const & density) const { + static basis::field poisson_solve_0d(basis::field const & density) { CALI_CXX_MARK_FUNCTION; @@ -161,7 +163,7 @@ class poisson { /////////////////////////////////////////////////////////////////////////////////////////////////// - void poisson_solve_in_place_0d(basis::field_set & density, vector3 const & gshift, double const zeroterm) const { + static void poisson_solve_in_place_0d(basis::field_set & density, vector3 const & gshift, double const zeroterm) { CALI_CXX_MARK_FUNCTION; @@ -179,7 +181,7 @@ class poisson { public: - auto operator()(const basis::field & density) const { + static auto solve(const basis::field & density) { CALI_CXX_MARK_SCOPE("poisson(complex)"); @@ -195,7 +197,7 @@ class poisson { /////////////////////////////////////////////////////////////////////////////////////////////////// template - void in_place(basis::field_set & density, vector3 const & gshift = {0.0, 0.0, 0.0}, double const zeroterm = 0.0) const { + static void in_place(basis::field_set & density, vector3 const & gshift = {0.0, 0.0, 0.0}, double const zeroterm = 0.0) { CALI_CXX_MARK_SCOPE("poisson(complex)"); @@ -212,11 +214,11 @@ class poisson { /////////////////////////////////////////////////////////////////////////////////////////////////// - basis::field operator()(const basis::field & density) const { + static basis::field solve(const basis::field & density) { CALI_CXX_MARK_SCOPE("poisson(real)"); - auto complex_potential = operator()(complex_field(density)); + auto complex_potential = solve(complex_field(density)); return real_field(complex_potential); } @@ -234,8 +236,6 @@ class poisson { #include TEST_CASE(INQ_TEST_FILE, INQ_TEST_TAG) { - - using namespace inq; using namespace inq::magnitude; using namespace Catch::literals; @@ -262,7 +262,6 @@ TEST_CASE(INQ_TEST_FILE, INQ_TEST_TAG) { field density(rs); field_set density_set(rs, nst); - solvers::poisson psolver; SECTION("Point charge"){ @@ -284,8 +283,8 @@ TEST_CASE(INQ_TEST_FILE, INQ_TEST_TAG) { } } - auto potential = psolver(density); - psolver.in_place(density_set); + auto potential = solvers::poisson::solve(density); + solvers::poisson::in_place(density_set); double sum[2] = {0.0, 0.0}; for(int ix = 0; ix < rs.local_sizes()[0]; ix++){ @@ -332,8 +331,8 @@ TEST_CASE(INQ_TEST_FILE, INQ_TEST_TAG) { } } - auto potential = psolver(density); - psolver.in_place(density_set); + auto potential = solvers::poisson::solve(density); + solvers::poisson::in_place(density_set); double diff = 0.0; for(int ix = 0; ix < rs.local_sizes()[0]; ix++){ @@ -372,7 +371,7 @@ TEST_CASE(INQ_TEST_FILE, INQ_TEST_TAG) { } } - auto rpotential = psolver(rdensity); + auto rpotential = solvers::poisson::solve(rdensity); double diff = 0.0; for(int ix = 0; ix < rs.local_sizes()[0]; ix++){ @@ -396,8 +395,6 @@ TEST_CASE(INQ_TEST_FILE, INQ_TEST_TAG) { { basis::real_space rs(systems::cell::cubic(8.0_b).finite(), /*spacing =*/ 0.09, comm); - solvers::poisson psolver; - SECTION("Grid finite"){ CHECK(rs.cell().periodicity() == 0); @@ -430,8 +427,8 @@ TEST_CASE(INQ_TEST_FILE, INQ_TEST_TAG) { CHECK(real(operations::integral(density)) == -1.0_a); - auto potential = psolver(density); - psolver.in_place(density_set); + auto potential = solvers::poisson::solve(density); + solvers::poisson::in_place(density_set); for(int ix = 0; ix < rs.local_sizes()[0]; ix++){ for(int iy = 0; iy < rs.local_sizes()[1]; iy++){ @@ -476,8 +473,6 @@ TEST_CASE(INQ_TEST_FILE, INQ_TEST_TAG) { basis::real_space rs(systems::cell::orthorhombic(6.0_b, 6.0_b, 9.0_b).periodicity(2), /*spacing =*/ 0.12, comm); - solvers::poisson psolver; - CHECK(rs.cell().periodicity() == 2); CHECK(rs.sizes()[0] == 50); @@ -504,8 +499,8 @@ TEST_CASE(INQ_TEST_FILE, INQ_TEST_TAG) { CHECK(real(operations::integral(density)) == -1.0_a); - auto potential = psolver(density); - psolver.in_place(density_set); + auto potential = solvers::poisson::solve(density); + solvers::poisson::in_place(density_set); auto & part = potential.basis().part();