#pragma once #include "common.hpp" namespace kel { namespace lbm { template kel::lbm::error_or init( const converter& conv, kel::lbm::data>& fields, kel::lbm::data>& macros, kel::lbm::data>& particles ){ (void) conv; auto& info_f = fields.template get<"info">(); auto& porous_f = macros.template get<"porosity">(); // Set everything as walls iterator::apply( [&](auto& index){ info_f.at(index).set(1u); }, {}, info_f.get_dims(), {} ); // Fluid iterator::apply( [&](auto& index){ info_f.at(index).set(2u); }, {}, info_f.get_dims(), {{1u,1u}} ); auto dims = info_f.get_dims(); auto width = dims.at({{0u}}); auto height = dims.at({{1u}}); // auto w = width.template cast_to(); auto h = height.template cast_to(); auto w2 = w * 0.5; auto h4 = h * 0.25; kel::lbm::data e{0.1}; kel::lbm::data c = w * (kel::lbm::data{1.0} - e) * 0.5; kel::lbm::data d{0.2}; auto b = h * (kel::lbm::data{1.0} - d) * 0.5; auto p_r = (c*c + b*b) / (b*2); auto p_r_2 = p_r * p_r; std::cout<<"p²_r: "<> top_pos; { top_pos.at({0u}) = w2.get(); top_pos.at({1u}) = (h + p_i).get(); } // Circle Bot kel::lbm::data> bot_pos; { bot_pos.at({0u}) = w2.get(); bot_pos.at({1u}) = -p_i.get(); } iterator::apply( [&](auto& index){ auto& info = info_f.at(index); auto tp_diff = top_pos; auto bp_diff = bot_pos; for(uint64_t i{0u}; i < Desc::D; ++i){ tp_diff.at(i) = top_pos.at(i) - index.at(i).template cast_to(); bp_diff.at(i) = bot_pos.at(i) - index.at(i).template cast_to(); } auto tpd_v = kel::lbm::math::vectorize_data(tp_diff); auto tpd_dot = kel::lbm::math::dot(tpd_v,tpd_v); auto bpd_v = kel::lbm::math::vectorize_data(bp_diff); auto bpd_dot = kel::lbm::math::dot(bpd_v,bpd_v); if( (tpd_dot.at({}).template cast_to() <= p_r_2 ) or (bpd_dot.at({}).template cast_to() <= p_r_2 ) ){ info.set({1u}); } }, {}, info_f.get_dims(), {} ); // Inflow iterator::apply( [&](auto& index){ info_f.at(index).set(3u); }, {{0u,0u}}, {{1u,dim_y}}, {{0u,1u}} ); // Outflow iterator::apply( [&](auto& index){ info_f.at(index).set(4u); }, {{dim_x-1u,0u}}, {{dim_x, dim_y}}, {{0u,1u}} ); // auto& df_f = fields.template get<"dfs_old">(); auto& rho_f = macros.template get<"density">(); auto& vel_f = macros.template get<"velocity">(); auto& por_f = macros.template get<"porosity">(); iterator::apply( [&](auto& index){ auto& df = df_f.at(index); auto& rho = rho_f.at(index); por_f.at(index).at({}) = {1}; rho.at({}) = {1}; auto& vel = vel_f.at(index); auto eq = equilibrium(rho,vel); df = eq; }, {},// 0-index df_f.get_dims() ); iterator::apply( [&](auto& index){ auto& df = df_f.at(index); auto& rho = rho_f.at(index); rho.at({}) = {1}; auto& vel = vel_f.at(index); if(info_f.at(index).get() == 2u){ vel.at({{0u}}) = 0.0; } auto eq = equilibrium(rho,vel); df = eq; }, {},// 0-index df_f.get_dims(), {{1u,1u}} ); { kel::lbm::data>> radius_p; radius_p.at({}).set(conv.meter_si_to_lbm({0.05}).handle().get()); std::cout<<"RADIUS: "<> dense_p; dense_p.at({}).set(1); particles = create_spheroid_particle_group(radius_p, dense_p, {{64u}}); auto& parts = particles.template get<"particles">(); /** * Seed the particles upstream of the throat on a staggered grid. * * Spacing is 2.4 radii, so they start clear of one another -- any * initial overlap would be resolved as a contact on the first step and * fire them apart. */ const auto radius = radius_p.at({}).get(); const auto pitch = radius * 2.4; const auto x0 = conv.meter_si_to_lbm({0.10}).handle().get(); const auto y_mid = conv.meter_si_to_lbm({0.25}).handle().get(); constexpr uint64_t per_column = 4ul; for(uint64_t i = 0u; i < particle_amount; ++i){ auto col = i / per_column; auto row = i % per_column; // Offset alternate columns by half a pitch so they interleave. auto y_off = (static_cast(row) - (per_column - 1u) * 0.5) * pitch + ((col % 2u == 1u) ? pitch * 0.5 : 0.0); auto& p = parts.at({i}); auto& prb = p.template get<"rigid_body">(); auto& p_pos = prb.template get<"position">(); auto& p_pos_old = prb.template get<"position_old">(); p_pos.at({{0u}}).set(x0 + static_cast(col) * pitch); p_pos.at({{1u}}).set(y_mid + y_off); // Start at rest: position_old defaults to zero, which would read // as an enormous velocity. p_pos_old = p_pos; } } return kel::lbm::make_void(); } } }