1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
|
#include <kel/lbm/sycl/lbm.hpp>
#include <kel/lbm/lbm.hpp>
#include <kel/lbm/particle.hpp>
#include <fstream>
#include <forstio/io/io.hpp>
#include <forstio/remote/filesystem/easy.hpp>
#include <forstio/codec/json/json.hpp>
#include <forstio/codec/simple.hpp>
namespace kel {
namespace lbm {
// Deliberately tiny: 32 x 32 x 32 = 32768 cells, so a full run finishes in
// seconds. Square in y/z so the channel cross section is symmetric about the
// particle, which makes a stray transverse force obvious.
constexpr uint64_t dim_x = 32ul;
constexpr uint64_t dim_y = 32ul;
constexpr uint64_t dim_z = 32ul;
constexpr uint64_t particle_amount = 1ul;
/**
* The particle lives in lattice space, exactly like the fluid: the radius is a
* number of cells, the density is relative to the fluid's rho = 1, and the
* mass, inertia, force and torque that follow are all lattice quantities. The
* converter handles the fluid's SI <-> LBM bookkeeping and is deliberately not
* applied to any of this -- so every column of particle.csv is in cells,
* steps, and lattice mass.
*/
constexpr double particle_radius = 0.15 * static_cast<double>(dim_y);
constexpr double particle_density = 1.0;
namespace sch {
/**
* The spin axis is an arbitrary fixed vector, not a lattice direction. It is
* normalised by the integrator, so these three need not be a unit vector.
*
* Defaults to +y: flow along x, axis vertical and perpendicular to it, blades
* sweeping the x-z plane -- the vertical-axis turbine arrangement.
*/
using LbmArgs = Args<
Struct<
Member<String, "name">,
Member<UInt64, "time_steps">,
Member<UInt64, "sub_steps">,
Member<Float64, "axis_x">,
Member<Float64, "axis_y">,
Member<Float64, "axis_z">
>,
Tuple<>
>;
using InfoChunk = Chunk<UInt8, 0u, dim_x, dim_y, dim_z>;
template<typename T, typename Desc>
using DfChunk = Chunk<FixedArray<T,Desc::Q>, 1u, dim_x, dim_y, dim_z>;
template<typename T, typename Desc>
using ScalarChunk = Chunk<Scalar<T>, 0u, dim_x, dim_y, dim_z>;
template<typename T, typename Desc>
using VectorChunk = Chunk<Vector<T,Desc::D>, 0u, dim_x, dim_y, dim_z>;
template<typename T, typename Desc>
using ChunkStruct = Struct<
Member<InfoChunk, "info">,
Member<DfChunk<T,Desc>, "dfs">,
Member<DfChunk<T,Desc>, "dfs_old">,
Member<VectorChunk<T,Desc>, "particle_N">,
Member<ScalarChunk<T,Desc>, "particle_D">
>;
template<typename T, typename Desc>
using MomChunk = Chunk<Vector<T,Desc::D>, 0u, dim_x, dim_y, dim_z>;
template<typename T>
using RhoChunk = Chunk<Scalar<T>, 0u, dim_x, dim_y, dim_z>;
/**
* "force" is not optional here: HlbmOneParticleGather reads it, so the 3D
* macro struct needs it the moment a particle is carried.
*/
template<typename T, typename Desc>
using MacroStruct = Struct<
Member<MomChunk<T,Desc>, "velocity">,
Member<RhoChunk<T>, "density">,
Member<MomChunk<T,Desc>, "force">,
Member<ScalarChunk<T,Desc>, "porosity">
>;
/**
* particle_aabb is specialised only on ParticleGroup, so a bare
* FixedArray<Particle<...>> hits its always_false primary template.
*/
template<typename T, typename Desc>
using ParticleSpheroidGroup = ParticleGroup<T,Desc::D,particle_amount,coll::Spheroid<T>>;
}
template<typename T, typename Desc>
kel::lbm::error_or<void> setup_initial_conditions(
converter<T>& conv,
kel::lbm::data<sch::ChunkStruct<T,Desc>>& fields,
kel::lbm::data<sch::MacroStruct<T,Desc>>& macros,
kel::lbm::data<sch::ParticleSpheroidGroup<T,Desc>>& particles
){
// Unit conversion is not exercised in this reduced case.
(void) conv;
auto& info_f = fields.template get<"info">();
// Set everything as walls
iterator<Desc::D>::apply(
[&](auto& index){
info_f.at(index).set(1u);
},
{},
info_f.get_dims(),
{}
);
// Fluid
iterator<Desc::D>::apply(
[&](auto& index){
info_f.at(index).set(2u);
},
{},
info_f.get_dims(),
{{1u,1u,1u}}
);
// Inflow
iterator<Desc::D>::apply(
[&](auto& index){
info_f.at(index).set(3u);
},
{{0u,0u,0u}},
{{1u,dim_y,dim_z}},
{{0u,1u,1u}}
);
// Outflow
iterator<Desc::D>::apply(
[&](auto& index){
info_f.at(index).set(4u);
},
{{dim_x-1u,0u,0u}},
{{dim_x,dim_y,dim_z}},
{{0u,1u,1u}}
);
//
auto& df_f = fields.template get<"dfs_old">();
auto& rho_f = macros.template get<"density">();
auto& mom_f = macros.template get<"velocity">();
auto& por_f = macros.template get<"porosity">();
auto& force_f = macros.template get<"force">();
iterator<Desc::D>::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& mom = mom_f.at(index);
auto eq = equilibrium<T,Desc>(rho,mom);
df = eq;
auto& force = force_f.at(index);
for(uint64_t i{0u}; i < Desc::D; ++i){
force.at({{i}}).set(0);
}
},
{},// 0-index
df_f.get_dims()
);
iterator<Desc::D>::apply(
[&](auto& index){
auto& df = df_f.at(index);
auto& rho = rho_f.at(index);
rho.at({}) = {1};
auto& mom = mom_f.at(index);
mom.at({{0u}}) = 0.01;
auto eq = equilibrium<T,Desc>(rho,mom);
df = eq;
},
{},// 0-index
df_f.get_dims(),
{{1u,1u,1u}}
);
kel::lbm::data<sch::LbmMeter<sch::Scalar<T>>> rad;
rad.at({}).set(particle_radius);
kel::lbm::data<sch::Scalar<T>> dense;
dense.at({}).set(particle_density);
// Mask resolution 16 in 3D is 16^3 = 4096 voxels. The analytic spheroid
// porosity is what HLBM actually calls, but the mask is still filled.
particles = create_spheroid_particle_group<T,Desc::D,particle_amount>(rad,dense,{16u});
{
auto& rb = particles.template get<"particles">().at({0u}).template get<"rigid_body">();
auto& rbp = rb.template get<"position">();
rbp.at({{0u}}) = 0.3 * dim_x;
rbp.at({{1u}}) = 0.5 * dim_y;
rbp.at({{2u}}) = 0.5 * dim_z;
// position_old == position means the body starts at rest. It also
// makes a pinned body exact later: 2x - x_old + 0 == x.
rb.template get<"position_old">() = rbp;
kel::lbm::data<sch::Vector<T,Desc::D>> zero;
for(uint64_t i{0u}; i < Desc::D; ++i){
zero.at({{i}}).set(0);
}
// Acceleration is unit typed now, so its zero has to be too.
kel::lbm::data<sch::LbmAcceleration<sch::Vector<T,Desc::D>>> zero_acc;
for(uint64_t i{0u}; i < Desc::D; ++i){
zero_acc.at({{i}}).set(0);
}
rb.template get<"acceleration">() = zero_acc;
// In 3D these are Vector<T,3> (a rotation vector), not a scalar angle.
rb.template get<"rotation">() = zero;
rb.template get<"rotation_old">() = zero;
rb.template get<"angular_acceleration">() = zero;
}
return kel::lbm::make_void();
}
template<typename T, typename Desc>
kel::lbm::error_or<void> step(
converter<T>& conv,
kel::lbm::data<sch::Ptr<sch::ChunkStruct<T,Desc>>,encode::Sycl<kel::lbm::enc::Native>>& fields,
kel::lbm::data<sch::Ptr<sch::MacroStruct<T,Desc>>,encode::Sycl<kel::lbm::enc::Native>>& macros,
kel::lbm::data<sch::Ptr<sch::ParticleSpheroidGroup<T,Desc>>,encode::Sycl<kel::lbm::enc::Native>>& particles,
kel::lbm::data<sch::UInt64> t_i,
kel::lbm::data<sch::UInt64> sub_steps,
const kel::lbm::data<sch::Vector<T,3u>>& spin_axis,
device& dev
){
auto& q = dev.get_handle();
auto& info_f = fields.template get<"info">();
// Porosity back to 1 (all fluid) before the particle restamps itself.
q.submit([&](acpp::sycl::handler& h){
component<T,Desc,cmpt::HlbmReset,encode::Sycl<kel::lbm::enc::Native>> hlbm_reset;
h.parallel_for(acpp::sycl::range<Desc::D>{dim_x,dim_y,dim_z}, [=](acpp::sycl::id<Desc::D> idx){
kel::lbm::data<sch::FixedArray<sch::UInt64,Desc::D>> index;
for(uint64_t i = 0u; i < Desc::D; ++i){
index.at({{i}}).set(idx[i]);
}
hlbm_reset.apply(fields,macros,index,t_i);
});
}).wait();
/**
* One work item per particle. The stamp has to come after the integrate:
* it writes the post-integration surface velocity back onto the lattice.
*/
q.submit([&](acpp::sycl::handler& h){
component<T,Desc,cmpt::ParticleForceReset,encode::Sycl<kel::lbm::enc::Native>> p_reset;
component<T,Desc,cmpt::HlbmOneParticleGather,encode::Sycl<kel::lbm::enc::Native>> p_gather;
component<T,Desc,cmpt::HlbmOneParticleStamp,encode::Sycl<kel::lbm::enc::Native>> p_stamp;
/**
* The rotor replaces the free-body integrator. No contact pass: the
* body is pinned, so it cannot reach a wall or another particle.
*/
component<T,Desc,cmpt::ParticleAxisIntegrate,encode::Sycl<kel::lbm::enc::Native>> p_integrate{spin_axis};
h.parallel_for(acpp::sycl::range<1u>{particle_amount}, [=](acpp::sycl::id<1u> idx){
kel::lbm::data<sch::FixedArray<sch::UInt64,1u>> index;
for(uint64_t i = 0u; i < 1u; ++i){
index.at({{i}}).set(idx[i]);
}
p_reset.apply(particles,index,t_i);
p_gather.apply(fields,macros,particles,index,t_i,sub_steps);
p_integrate.apply(particles,index,t_i,sub_steps);
p_stamp.apply(fields,macros,particles,index,t_i,sub_steps);
});
}).wait();
// auto coll_ev =
q.submit([&](acpp::sycl::handler& h){
/**
* Hlbm rather than BGK: it is the collision that consumes the
* porosity and particle_N/particle_D the stamp pass writes.
*/
component<T,Desc,cmpt::Hlbm, encode::Sycl<kel::lbm::enc::Native>> collision{conv.template kinematic_viscosity_si_to_tau<Desc>({0.1})};
component<T,Desc,cmpt::BounceBack,encode::Sycl<kel::lbm::enc::Native>> bb;
component<T,Desc,cmpt::ZouHeHorizontal<true>,encode::Sycl<kel::lbm::enc::Native>> flow_in{
[&](){
uint64_t target_t_i = 256u;
if(t_i.get() < target_t_i){
return 1.0 + (0.001 / target_t_i) * t_i.get();
}
return 1.001;
}()
};
component<T,Desc,cmpt::ZouHeHorizontal<false>,encode::Sycl<kel::lbm::enc::Native>> flow_out{1.0};
h.parallel_for(acpp::sycl::range<Desc::D>{dim_x,dim_y,dim_z}, [=](acpp::sycl::id<Desc::D> idx){
kel::lbm::data<sch::FixedArray<sch::UInt64,Desc::D>> index;
for(uint64_t i = 0u; i < Desc::D; ++i){
index.at({{i}}).set(idx[i]);
}
auto info = info_f.at(index);
switch(info.get()){
case 0u:
break;
case 1u:
bb.apply(fields,index,t_i);
break;
case 2u:
collision.apply(fields,macros,index,t_i);
break;
case 3u:
flow_in.apply(fields,index,t_i);
collision.apply(fields,macros,index,t_i);
break;
case 4u:
flow_out.apply(fields,index,t_i);
collision.apply(fields,macros,index,t_i);
break;
default:
break;
}
});
}).wait();
q.submit([&](acpp::sycl::handler& h){
component<T,Desc,cmpt::Stream,encode::Sycl<kel::lbm::enc::Native>> stream;
h.parallel_for(acpp::sycl::range<Desc::D>{dim_x,dim_y,dim_z}, [=](acpp::sycl::id<Desc::D> idx){
kel::lbm::data<sch::FixedArray<sch::UInt64,Desc::D>> index;
for(uint64_t i = 0u; i < Desc::D; ++i){
index.at({{i}}).set(idx[i]);
}
auto info = info_f.at(index);
if(info.get() > 0u){
stream.apply(fields,index,t_i);
}
});
}).wait();
// Step
/*
q.submit([&](acpp::sycl::handler& h){
// h.depends_on(collision_ev);
}).wait();
*/
return kel::lbm::make_void();
}
}
}
template<typename T, typename Desc>
kel::lbm::error_or<void> lbm_main(int argc, char** argv){
using namespace kel::lbm;
kel::lbm::data<sch::LbmArgs> args;
{
auto& args_n = args.template get<"args">();
auto& name = args_n.template get<"name">();
name.set("vawt_3d_hlbm_gpu");
auto& steps_arg = args_n.template get<"time_steps">();
steps_arg.set(256u);
auto& sub_arg = args_n.template get<"sub_steps">();
sub_arg.set(16u);
// +y by default: flow along x, axis perpendicular to it.
args_n.template get<"axis_x">().set(0.0);
args_n.template get<"axis_y">().set(1.0);
args_n.template get<"axis_z">().set(0.0);
}
{
auto eov = kel::lbm::parse_args(args,argc,argv);
if(eov.is_error()){
return eov;
}
}
auto eo_lbm_env = init_lbm_env(args);
if(eo_lbm_env.is_error()){
return std::move(eo_lbm_env.get_error());
}
const auto& lbm_env = eo_lbm_env.get_value();
auto& out_dir = lbm_env.name_dir;
{
std::error_code ec;
std::filesystem::create_directories(out_dir,ec);
if(ec != std::errc{}){
return kel::lbm::make_error<kel::lbm::err::critical>("Could not create output directory");
}
}
converter<T> conv {
// delta_x
{1.0},
// delta_t
{1.0}
};
// Characteristic length is the body diameter -- the scale that sets Re here.
print_lbm_meta<T,Desc>(conv,{0.1},{0.01},{2.0 * particle_radius});
auto lbm_data_ptr = kel::lbm::heap<kel::lbm::data<sch::ChunkStruct<T,Desc>>>();
auto lbm_macro_data_ptr = kel::lbm::heap<kel::lbm::data<sch::MacroStruct<T,Desc>>>();
auto lbm_particle_data_ptr = kel::lbm::heap<kel::lbm::data<sch::ParticleSpheroidGroup<T,Desc>>>();
std::cout<<"Estimated Bytes: "<<memory_estimate<sch::ChunkStruct<T,Desc>,sch::MacroStruct<T,Desc>>().get()<<std::endl;
auto eo_aio = saw::setup_async_io();
if(eo_aio.is_error()){
return kel::lbm::make_error<kel::lbm::err::critical>(
std::string{eo_aio.get_error().get_message()});
}
auto& aio = eo_aio.get_value();
saw::wait_scope wait{aio.event_loop};
bool krun = true;
bool print_status = false;
aio.event_port.on_signal(saw::Signal::Terminate).then([&](){
krun = false;
}).detach();
aio.event_port.on_signal(saw::Signal::User1).then([&](){
print_status = true;
}).detach();
device dev;
auto& sycl_q = dev.get_handle();
sycl_q.wait();
{
auto eov = setup_initial_conditions<T,Desc>(conv,*lbm_data_ptr,*lbm_macro_data_ptr,*lbm_particle_data_ptr);
if(eov.is_error()){
return eov;
}
}
kel::lbm::data<sch::ChunkStruct<T,Desc>, encode::Sycl<kel::lbm::enc::Native>> lbm_sycl_data{sycl_q};
kel::lbm::data<sch::MacroStruct<T,Desc>, encode::Sycl<kel::lbm::enc::Native>> lbm_sycl_macro_data{sycl_q};
kel::lbm::data<sch::ParticleSpheroidGroup<T,Desc>, encode::Sycl<kel::lbm::enc::Native>> lbm_sycl_particle_data{sycl_q};
sycl_q.wait();
auto lsd_view = make_view(lbm_sycl_data);
auto lsdm_view = make_view(lbm_sycl_macro_data);
auto lsdp_view = make_view(lbm_sycl_particle_data);
{
auto eov = dev.copy_to_device(*lbm_data_ptr,lbm_sycl_data);
if(eov.is_error()){
return eov;
}
}
{
auto eov = dev.copy_to_device(*lbm_macro_data_ptr,lbm_sycl_macro_data);
if(eov.is_error()){
return eov;
}
}
{
auto eov = dev.copy_to_device(*lbm_particle_data_ptr,lbm_sycl_particle_data);
if(eov.is_error()){
return eov;
}
}
sycl_q.wait();
kel::lbm::data<sch::UInt64> time_steps = args.template get<"args">().template get<"time_steps">();
kel::lbm::data<sch::UInt64> sub_steps = args.template get<"args">().template get<"sub_steps">();
kel::lbm::data<sch::Vector<T,3u>> spin_axis;
{
auto& args_n = args.template get<"args">();
spin_axis.at({{0u}}).set(args_n.template get<"axis_x">().get());
spin_axis.at({{1u}}).set(args_n.template get<"axis_y">().get());
spin_axis.at({{2u}}).set(args_n.template get<"axis_z">().get());
}
// Unit axis, for projecting the rotation and torque onto it below.
auto axis_hat = kel::lbm::math::normalize(spin_axis);
/**
* Particle time series. write_vtk_file only accepts a struct of chunks, so
* a particle group cannot go through it -- a CSV beside the VTK output is
* the simpler answer, and it is what you actually plot.
*
* Velocity and angular velocity are not stored on the body: the scheme is
* position-Verlet, so both are recovered as (now - previous) * steps.
*/
std::ofstream particle_csv{out_dir / "particle.csv"};
if(not particle_csv.is_open()){
return kel::lbm::make_error<kel::lbm::err::critical>("Could not open particle.csv");
}
/**
* theta/omega/alpha/tau are the rotation, angular velocity, angular
* acceleration and torque projected onto the spin axis -- the rotor
* numbers. drag is the streamwise force. The raw vectors follow so a
* stray off-axis component is still visible rather than hidden by the
* projection.
*/
particle_csv
<<"step,theta,omega,alpha,tau,drag,"
<<"x,y,z,vx,vy,vz,fx,fy,fz,"
<<"rot_x,rot_y,rot_z,omega_x,omega_y,omega_z,"
<<"alpha_x,alpha_y,alpha_z,tau_x,tau_y,tau_z\n";
auto write_particle_row = [&](uint64_t step_i){
auto& rb = lbm_particle_data_ptr->template get<"particles">()
.at({0u}).template get<"rigid_body">();
auto& pos = rb.template get<"position">();
auto& pos_old = rb.template get<"position_old">();
auto& force = rb.template get<"force">();
auto& rot = rb.template get<"rotation">();
auto& rot_old = rb.template get<"rotation_old">();
auto& ang_acc = rb.template get<"angular_acceleration">();
auto& torque = rb.template get<"torque">();
const auto steps = static_cast<double>(particle_sub_steps(sub_steps));
// Project onto the spin axis.
double theta = 0.0, omega = 0.0, alpha = 0.0, tau = 0.0;
for(uint64_t k{0u}; k < 3u; ++k){
const double a = axis_hat.at({{k}}).get();
theta += rot.at({{k}}).get() * a;
omega += (rot.at({{k}}).get() - rot_old.at({{k}}).get()) * steps * a;
alpha += ang_acc.at({{k}}).get() * a;
tau += torque.at({{k}}).get() * a;
}
particle_csv
<<step_i
<<","<<theta
<<","<<omega
<<","<<alpha
<<","<<tau
<<","<<force.at({{0u}}).get();
particle_csv<<"";
for(uint64_t k{0u}; k < Desc::D; ++k){
particle_csv<<","<<pos.at({{k}}).get();
}
for(uint64_t k{0u}; k < Desc::D; ++k){
particle_csv<<","<<(pos.at({{k}}).get() - pos_old.at({{k}}).get()) * steps;
}
for(uint64_t k{0u}; k < Desc::D; ++k){
particle_csv<<","<<force.at({{k}}).get();
}
for(uint64_t k{0u}; k < 3u; ++k){
particle_csv<<","<<rot.at({{k}}).get();
}
for(uint64_t k{0u}; k < 3u; ++k){
particle_csv<<","<<(rot.at({{k}}).get() - rot_old.at({{k}}).get()) * steps;
}
for(uint64_t k{0u}; k < 3u; ++k){
particle_csv<<","<<ang_acc.at({{k}}).get();
}
for(uint64_t k{0u}; k < 3u; ++k){
particle_csv<<","<<torque.at({{k}}).get();
}
particle_csv<<"\n";
};
for(kel::lbm::data<sch::UInt64> i{0u}; i < time_steps and krun; ++i){
{
{
auto eov = write_vtk_file(out_dir,"t",i.get(),*lbm_macro_data_ptr);
if(eov.is_error()){
return eov;
}
}
}
{
auto eov = step<T,Desc>(conv,lsd_view,lsdm_view,lsdp_view,i,sub_steps,spin_axis,dev);
if(eov.is_error()){
return eov;
}
}
{
auto eov = dev.copy_to_host(lbm_sycl_particle_data,*lbm_particle_data_ptr);
if(eov.is_error()){
return eov;
}
}
write_particle_row(i.get());
{
auto eov = dev.copy_to_host(lbm_sycl_macro_data,*lbm_macro_data_ptr);
if(eov.is_error()){
return eov;
}
}
{
auto eov = dev.copy_to_host(lbm_sycl_data,*lbm_data_ptr);
if(eov.is_error()){
return eov;
}
}
wait.poll();
if(print_status){
std::cout<<"Status: "<<i.get()<<" of "<<time_steps.get()<<" - "<<(i.template cast_to<sch::Float64>().get() * 100 / time_steps.get())<<"%"<<std::endl;
print_status = false;
}
}
sycl_q.wait();
{
auto eov = write_vtk_file(out_dir,"t",time_steps.get(),*lbm_macro_data_ptr);
if(eov.is_error()){
return eov;
}
}
/*
iterator<Desc::D>::apply(
[&](auto& index){
std::cout<<index.at({0u}).get()<<" "<<index.at({1u}).get()<<" "<<lbm_data.get<"info">().at(index).template cast_to<sch::UInt16>().get()<<"\n";
},
{{0u,0u}},
{{dim_x, dim_y}}
);
*/
sycl_q.wait();
return kel::lbm::make_void();
}
using FloatT = kel::lbm::sch::Float32;
int main(int argc, char** argv){
auto eov = lbm_main<FloatT,kel::lbm::sch::D3Q27>(argc, argv);
if(eov.is_error()){
auto& err = eov.get_error();
std::cerr<<"[Error] "<<err.get_category();
auto err_msg = err.get_message();
if(err_msg.size() > 0u){
std::cerr<<" - "<<err_msg;
}
std::cerr<<std::endl;
return err.get_id();
}
return 0;
}
|