def heat_transfer(net):
max_iter, nonlinear_method, tol_p, tol_v, tol_t, tol_res = get_net_options(
net, "iter", "nonlinear_method", "tol_p", "tol_v", "tol_T", "tol_res")
# Start of nonlinear loop
# ---------------------------------------------------------------------------------------------
if net.fluid.is_gas:
logger.info("Caution! Temperature calculation does currently not affect hydraulic "
"properties!")
error_t, error_t_out, residual_norm = [], [], None
set_net_option(net, "converged", False)
niter = 0
# This loop is left as soon as the solver converged
while not get_net_option(net, "converged") and niter <= max_iter:
logger.info("niter %d" % niter)
# solve_hydraulics is where the calculation takes place
t_out, t_out_old, t_init, t_init_old, epsilon = solve_temperature(net)
# Error estimation & convergence plot
delta_t_init = np.abs(t_init - t_init_old)
delta_t_out = np.abs(t_out - t_out_old)
residual_norm = (linalg.norm(epsilon) / (len(epsilon)))
error_t.append(linalg.norm(delta_t_init) / (len(delta_t_init)))
error_t_out.append(linalg.norm(delta_t_out) / (len(delta_t_out)))
# Control of damping factor
if nonlinear_method == "automatic":
error_x0_increased, error_x1_increased = set_damping_factor(net, niter,
[error_t, error_t_out])
if error_x0_increased:
net["_active_pit"]["node"][:, TINIT] = t_init_old
if error_x1_increased:
net["_active_pit"]["branch"][:, T_OUT] = t_out_old
elif nonlinear_method != "constant":
logger.warning("No proper nonlinear method chosen. Using constant settings.")
# Setting convergence flag
if error_t[niter] <= tol_t and error_t_out[niter] <= tol_t \
and residual_norm < tol_res:
if nonlinear_method != "automatic":
set_net_option(net, "converged", True)
elif get_net_option(net, "alpha") == 1:
set_net_option(net, "converged", True)
logger.debug("errorT: %s" % error_t[niter])
logger.debug("alpha: %s" % get_net_option(net, "alpha"))
niter += 1
logger.debug("F: %s" % epsilon.round(4))
logger.debug("T_init_: %s" % t_init.round(4))
logger.debug("T_out_: %s" % t_out.round(4))
write_internal_results(net, iterations_T=niter, error_T=error_t[niter - 1],
residual_norm_T=residual_norm)
logger.info("---------------------------------------------------------------------------------")
if get_net_option(net, "converged") is False:
logger.warning("Maximum number of iterations reached but heat transfer solver did not "
"converge.")
logger.info("Norm of residual: %s" % residual_norm)
else:
logger.info("Calculation completed. Preparing results...")
logger.info("Converged after %d iterations." % niter)
logger.info("Norm of residual: %s" % residual_norm)
logger.info("tol_T: %s" % get_net_option(net, "tol_T"))
net['converged'] = True
return niter
def hydraulics(net):
max_iter, nonlinear_method, tol_p, tol_v, tol_t, tol_res = get_net_options(
net, "iter", "nonlinear_method", "tol_p", "tol_v", "tol_T", "tol_res")
# Start of nonlinear loop
# ---------------------------------------------------------------------------------------------
niter = 0
create_internal_results(net)
net["_internal_data"] = dict()
# This branch is used to stop the solver after a specified error tolerance is reached
error_v, error_p, residual_norm = [], [], None
# This loop is left as soon as the solver converged
while not get_net_option(net, "converged") and niter <= max_iter:
logger.info("niter %d" % niter)
# solve_hydraulics is where the calculation takes place
v_init, p_init, v_init_old, p_init_old, epsilon = solve_hydraulics(net)
# Error estimation & convergence plot
dv_init = np.abs(v_init - v_init_old)
dp_init = np.abs(p_init - p_init_old)
residual_norm = (linalg.norm(epsilon) / (len(epsilon)))
error_v.append(linalg.norm(dv_init) / (len(dv_init)))
error_p.append(linalg.norm(dp_init / (len(dp_init))))
# Control of damping factor
if nonlinear_method == "automatic":
error_x0_increased, error_x1_increased = set_damping_factor(net, niter,
[error_p, error_v])
if error_x0_increased:
net["_active_pit"]["node"][:, PINIT] = p_init_old
if error_x1_increased:
net["_active_pit"]["branch"][:, VINIT] = v_init_old
elif nonlinear_method != "constant":
logger.warning("No proper nonlinear method chosen. Using constant settings.")
# Setting convergence flag
if error_v[niter] <= tol_v and error_p[niter] <= tol_p and residual_norm < tol_res:
if nonlinear_method != "automatic":
set_net_option(net, "converged", True)
elif get_net_option(net, "alpha") == 1:
set_net_option(net, "converged", True)
logger.debug("errorv: %s" % error_v[niter])
logger.debug("errorp: %s" % error_p[niter])
logger.debug("alpha: %s" % get_net_option(net, "alpha"))
niter += 1
write_internal_results(net, iterations=niter, error_p=error_p[niter - 1],
error_v=error_v[niter - 1], residual_norm=residual_norm)
logger.info("---------------------------------------------------------------------------------")
if get_net_option(net, "converged") is False:
logger.warning("Maximum number of iterations reached but hydraulics solver did not "
"converge.")
logger.info("Norm of residual: %s" % residual_norm)
else:
logger.info("Calculation completed. Preparing results...")
logger.info("Converged after %d iterations." % niter)
logger.info("Norm of residual: %s" % residual_norm)
logger.info("tol_p: %s" % get_net_option(net, "tol_p"))
logger.info("tol_v: %s" % get_net_option(net, "tol_v"))
net['converged'] = True
net.pop("_internal_data", None)
set_user_pf_options(net, hyd_flag=True)
return niter