Shamrock 2025.10.0
Astrophysical Code
Loading...
Searching...
No Matches
NodeBiCGSTABLoop.cpp
Go to the documentation of this file.
1// -------------------------------------------------------//
2//
3// SHAMROCK code for hydrodynamics
4// Copyright (c) 2021-2026 Timothée David--Cléris <tim.shamrock@proton.me>
5// SPDX-License-Identifier: CeCILL Free Software License Agreement v2.1
6// Shamrock is licensed under the CeCILL 2.1 License, see LICENSE for more information
7//
8// -------------------------------------------------------//
9
18
20#include "shambase/string.hpp"
21#include "shamcomm/logs.hpp"
24#include <cmath>
25
27
28 template<class Tvec, class TgridVec>
30 StackEntry stack_loc{};
31 auto edges = get_edges();
32
33 edges.spans_block_cell_sizes.check_sizes(edges.sizes.indexes);
34 edges.spans_phi.check_sizes(edges.sizes.indexes);
35 edges.spans_rho.check_sizes(edges.sizes.indexes);
36 edges.spans_phi_res.ensure_sizes(edges.sizes.indexes);
37 edges.spans_phi_res_bis.ensure_sizes(edges.sizes.indexes);
38 edges.spans_phi_p.ensure_sizes(edges.sizes.indexes);
39 edges.spans_phi_Ap.ensure_sizes(edges.sizes.indexes);
40 edges.spans_phi_s.ensure_sizes(edges.sizes.indexes);
41 edges.spans_phi_As.ensure_sizes(edges.sizes.indexes);
42 edges.spans_phi_hadamard_prod.ensure_sizes(edges.sizes.indexes);
43
44 edges.spans_rhs.ensure_sizes(edges.sizes.indexes);
45
46 // r_0 = b - A phi_0, r'_0 = r_0 / 2, p_0 = r_0
47 node_init.evaluate();
48
49 // <b, b>
50 node_ddot_rhs.evaluate();
51
52 // <r'_0, r'_0>
53 node_ddot_rstarj_rstarj.evaluate();
54
55 shamlog_debug_ln(
56 "Ramses::BiCGSTAB",
57 sham::format(
58 "k = 0, <b,b> = {}, |r'_0| / |b| = {}",
59 edges.rhs_norm_value.data,
60 std::sqrt(edges.shadow_res_norm.data / edges.rhs_norm_value.data)));
61
62 // a breakdown is detected when the denominator is exactly 0
63 const Tscal breakdown_tol = 0;
64
65 u32 k = 0;
66 bool converged = false;
67 Tscal last_residual_norm2 = 0;
68 while (k < Niter_max) {
69
70 // <r_k, r'_0>
71 node_had_prod_rj_rp0.evaluate();
72 node_ddot_rj_rp0.evaluate();
73
74 // exchange the ghost blocks of p_k
75 node_gz_p.evaluate();
76 node_exch_gz_p.evaluate();
77 node_replace_gz_p.evaluate();
78
79 // A p_k
80 node_Apj.evaluate();
81
82 // <A p_k, r'_0>
83 node_had_Apj_rp0.evaluate();
84 node_ddot_Apj_rp0.evaluate();
85
86 // alpha_k = <r_k, r'_0> / <A p_k, r'_0>
87 const Tscal sigma = edges.e_norm.data;
88 if (std::abs(sigma) <= breakdown_tol) {
89 // TODO: (kept from new_amr_plus_grav) restart instead of stopping
92 "Ramses::BiCGSTAB", sham::format("breakdown: <A p_k, r'_0> = {}", sigma)));
93 break;
94 }
95 edges.alpha.data = edges.old_values.data / sigma;
96
97 const Tscal alp_saved = edges.alpha.data;
98
99 // s_k = r_k - alpha_k A p_k
100 edges.e_norm.data = 0;
101 edges.beta.data = 1;
102 edges.alpha.data = -alp_saved;
103 node_sj_vec.evaluate();
104
105 // <s_k, s_k>
106 node_ddot_sj_sj.evaluate();
107
108 const Tscal rel_sj_sqr = edges.e_norm.data / edges.rhs_norm_value.data;
109 last_residual_norm2 = rel_sj_sqr;
110 if (rel_sj_sqr < tol_cvg * tol_cvg) {
111 // phi_{k+1} = phi_k + alpha_k p_k
112 edges.alpha.data = alp_saved;
113 node_new_phi_happy_break.evaluate();
114 shamlog_debug_ln(
115 "Ramses::BiCGSTAB",
116 sham::format("k = {}, converged on <s,s> / <b,b> = {}", k, rel_sj_sqr));
117 converged = true;
118 break;
119 }
120
121 // exchange the ghost blocks of s_k
122 node_gz_s.evaluate();
123 node_exch_gz_s.evaluate();
124 node_replace_gz_s.evaluate();
125
126 // A s_k
127 node_Asj.evaluate();
128
129 // <A s_k, s_k>
130 node_had_Asj_sj.evaluate();
131 node_ddot_Asj_sj.evaluate();
132
133 // <A s_k, A s_k>
134 node_ddot_Asj_Asj.evaluate();
135
136 // w_k = <A s_k, s_k> / <A s_k, A s_k>
137 if (edges.new_values.data <= breakdown_tol) {
138 // TODO: (kept from new_amr_plus_grav) restart instead of stopping
139 ON_RANK_0(
141 "Ramses::BiCGSTAB",
142 sham::format("breakdown: <A s_k, A s_k> = {}", edges.new_values.data)));
143 break;
144 }
145 edges.w_stab.data = edges.e_norm.data / edges.new_values.data;
146
147 const Tscal w_saved = edges.w_stab.data;
148 if (std::abs(w_saved) <= breakdown_tol) {
149 // TODO: (kept from new_amr_plus_grav) restart instead of stopping
150 ON_RANK_0(
152 "Ramses::BiCGSTAB", sham::format("breakdown: omega = {}", w_saved)));
153 break;
154 }
155
156 // phi_{k+1} = phi_k + alpha_k p_k + w_k s_k
157 edges.alpha.data = alp_saved;
158 node_new_phi.evaluate();
159
160 // r_{k+1} = s_k - w_k A s_k
161 edges.w_stab.data = -w_saved;
162 edges.e_norm.data = 0;
163 edges.new_values.data = 1;
164 node_new_res.evaluate();
165
166 // <r_{k+1}, r_{k+1}>
167 node_ddot_rj_rj.evaluate();
168
169 const Tscal rel_rj_sqr = edges.e_norm.data / edges.rhs_norm_value.data;
170 last_residual_norm2 = rel_rj_sqr;
171
172 shamlog_debug_ln(
173 "Ramses::BiCGSTAB",
174 sham::format("k = {}, |r| / |b| = {}", k + 1, std::sqrt(rel_rj_sqr)));
175
176 if (rel_rj_sqr < tol_cvg * tol_cvg) {
177 converged = true;
178 break;
179 }
180
181 // rho_{k+1} = <r_{k+1}, r'_0>
182 node_had_rjnew_rp0.evaluate();
183 node_ddot_rjnew_rp0.evaluate();
184
185 const Tscal rho_new = edges.new_values.data;
186 if ((rho_new * rho_new)
187 < (tol_happy_bk * tol_happy_bk) * edges.e_norm.data * edges.shadow_res_norm.data) {
188 // lucky breakdown: restart with r'_0 = p_{k+1} = r_{k+1}
189 shamlog_debug_ln("Ramses::BiCGSTAB", sham::format("k = {}, restart", k + 1));
190 node_overwrite_rp0.evaluate();
191 node_overwrite_p.evaluate();
192
193 // <r'_0, r'_0>
194 node_ddot_rstarj_rstarj.evaluate();
195 } else {
196 // beta_k = (alpha_k / w_k) (<r_{k+1}, r'_0> / <r_k, r'_0>)
197 edges.beta.data = (alp_saved / w_saved) * (rho_new / edges.old_values.data);
198
199 // p_{k+1} = r_{k+1} + beta_k (p_k - w_k A p_k)
200 edges.e_norm.data = 1;
201 edges.alpha.data = -w_saved * edges.beta.data;
202 node_new_p_vec.evaluate();
203 }
204
205 k = k + 1;
206 }
207
208 // exchange the ghost blocks of phi, needed to compute the gravitational acceleration
209 node_gz_phi.evaluate();
210 node_exch_gz_phi.evaluate();
211 node_replace_gz_phi.evaluate();
212
213 last_iteration_count = k;
214
215 if (shamcomm::world_rank() == 0) {
216 Tscal rel_res = std::sqrt(last_residual_norm2);
217 if (converged) {
219 "Ramses::BiCGSTAB",
220 sham::format("converged after {} iterations, |r|/|b| = {}", k, rel_res));
221 } else {
223 "Ramses::BiCGSTAB",
224 sham::format(
225 "not converged after {} iterations, |r|/|b| = {} (tol = {})",
226 k,
227 rel_res,
228 tol_cvg));
229 }
230 }
231 }
232
233 template<class Tvec, class TgridVec>
235 std::string tex = R"tex(
236 BiCGSTAB solve of the Poisson equation
237 \begin{equation}
238 -\Delta x^3 \Delta {spans_phi} = -4 \pi G ({spans_rho} - {mean_rho}) \Delta x^3
239 \end{equation}
240 )tex";
241
242 replace_edges_tex_symbols(tex);
243
244 return tex;
245 }
246
247} // namespace shammodels::basegodunov::modules
248
BiCGSTAB solver of the Poisson equation for the self-gravity.
std::uint32_t u32
32 bit unsigned integer
Solve with the BiCGSTAB method, starting from the current content of spans_phi.
virtual std::string _impl_get_tex() const
get the tex of the node
i32 world_rank()
Gives the rank of the current process in the MPI communicator.
Definition worldInfo.cpp:41
namespace for the basegodunov model modules
void info_ln(std::string module_name, Types... var2)
Prints a log message with multiple arguments followed by a newline.
Definition logs.hpp:132
void warn_ln(std::string module_name, Types... var2)
Prints a log message with multiple arguments followed by a newline.
Definition logs.hpp:132
This file contains the definition for the stacktrace related functionality.
shambase::details::BasicStackEntry StackEntry
Alias for shambase::details::BasicStackEntry.
Functions related to the MPI communicator.
#define ON_RANK_0(x)
Macro to execute code only on rank 0.
Definition worldInfo.hpp:73