BioCMAMC-ST
post_process.hpp
1#ifndef __CORE_POST_PROCESS_PUBLIC_HPP__
2#define __CORE_POST_PROCESS_PUBLIC_HPP__
3#include "Kokkos_Atomic.hpp"
4#include "Kokkos_Core_fwd.hpp"
5#include "common/common.hpp"
6#include "mc/alias.hpp"
7#include "mc/traits.hpp"
8#include <Kokkos_Core.hpp>
9#include <cstdint>
10#include <mc/particles_container.hpp>
11
12template <typename MemorySpace>
13using ParticlePropertyViewType = Kokkos::View<double**, Kokkos::LayoutRight, MemorySpace>;
14
15using SubViewtype =
16 Kokkos::Subview<ParticlePropertyViewType<ComputeSpace>, decltype(Kokkos::ALL), std::size_t>;
17namespace PostProcessing
18{
20 {
21 ParticlePropertyViewType<HostSpace> particle_values;
22 ParticlePropertyViewType<HostSpace> spatial_values;
23 std::vector<std::string> vnames;
24 };
25
26 template <HasExportPropertiesFull Model, typename ExecutionSpace>
27 void inner(std::size_t n_p,
28 const MC::ParticlePositions& position,
29 const typename Model::SelfParticle& model,
30 ParticlePropertyViewType<ComputeSpace>& particle_values,
31 ParticlePropertyViewType<ComputeSpace>& spatial_values,
32 const MC::ParticleStatus& status)
33 {
34 Kokkos::Experimental::ScatterView<double**, Kokkos::LayoutRight, ComputeSpace>
35 scatter_spatial_values(spatial_values);
36
37 Kokkos::parallel_for(
38 "kernel_get_properties",
39 Kokkos::RangePolicy<ExecutionSpace>(0, n_p),
40 KOKKOS_LAMBDA(const int i_particle) {
41 if (status(i_particle) != MC::Status::Idle)
42 {
43 return;
44 }
45 auto access = scatter_spatial_values.access();
46
47 for (std::size_t i = 0; i < Model::n_var; ++i)
48 {
49 access(i, position(i_particle)) += model(i_particle, i);
50 particle_values(i, i_particle) = model(i_particle, i);
51 }
52 auto mass = Model::mass(i_particle, model);
53 access(Model::n_var, position(i_particle)) += mass;
54 particle_values(Model::n_var, i_particle) = mass;
55 });
56 Kokkos::fence();
57 Kokkos::Experimental::contribute(spatial_values, scatter_spatial_values);
58 }
59
60 template <HasExportPropertiesPartial Model, typename ExecutionSpace>
61 void inner_partial(const std::size_t n_p,
62 const MC::ParticlePositions& position,
63 const typename Model::SelfParticle& model,
64 ParticlePropertyViewType<ComputeSpace>& particle_values,
65 ParticlePropertyViewType<ComputeSpace>& spatial_values,
66 const MC::ParticleStatus& status)
67 {
68 Kokkos::Experimental::ScatterView<double**, Kokkos::LayoutRight, ComputeSpace>
69 scatter_spatial_values(spatial_values);
70 static const auto indices = Model::get_number();
71
72 static Kokkos::View<size_t*, HostSpace> host_index("host_index", indices.size());
73
74 for (std::size_t i = 0; i < indices.size(); ++i)
75 {
76 host_index(i) = indices[i];
77 }
78
79 const Kokkos::View<const size_t*, ComputeSpace> kindices =
80 Kokkos::create_mirror_view_and_copy(ComputeSpace(), host_index);
81 Kokkos::parallel_for(
82 "kernel_get_properties",
83 Kokkos::RangePolicy<ExecutionSpace>(0, n_p),
84 KOKKOS_LAMBDA(const int i_particle) {
85
86 if(status(i_particle)!=MC::Status::Idle)
87 {
88 return;
89 }
90
91 auto access = scatter_spatial_values.access();
92
93 for (size_t k_var = 0; k_var < kindices.extent(0); ++k_var)
94 {
95 const auto index_export = kindices(k_var);
96 const auto current = model(i_particle, index_export);
97
98 access(k_var, position(i_particle)) += current;
99 particle_values(k_var, i_particle) = current;
100 }
101 const auto mass = Model::mass(i_particle, model);
102 access(kindices.extent(0), position(i_particle)) += mass;
103 particle_values(kindices.extent(0), i_particle) = mass;
104 });
105 Kokkos::fence();
106 Kokkos::Experimental::contribute(spatial_values, scatter_spatial_values);
107 }
108
109 template <ModelType M>
110 std::optional<PostProcessing::BonceBuffer>
111 get_properties(MC::ParticlesContainer<M>& container, const std::size_t n_compartment)
112 {
113 if constexpr (HasExportProperties<M>)
114 {
115 container.clean_dead(container.counter);
116 container.counter = 0;
117 BonceBuffer properties;
118 const std::size_t n_p =
119 container.n_particles(); // USE list size not Kokkos View size. ParticleList
120 // allocates more particles than needed
121 auto ar = M::names();
122 properties.vnames = std::vector<std::string>(ar.begin(), ar.end());
123 properties.vnames.emplace_back("mass");
124
125 std::size_t n_var = M::n_var + 1;
126 if constexpr (HasExportPropertiesPartial<M>)
127 {
128 n_var = ar.size() + 1;
129 }
130 ParticlePropertyViewType<ComputeSpace> spatial_values(
131 "property_spatial", n_var, n_compartment);
132 ParticlePropertyViewType<ComputeSpace> particle_values("property_values", n_var, n_p);
133
134 if constexpr (HasExportPropertiesPartial<M>)
135 {
137 container.position,
138 container.model,
139 particle_values,
140 spatial_values,
141 container.status);
142 }
143 else
144 {
146 container.position,
147 container.model,
148 particle_values,
149 spatial_values,
150 container.status);
151 }
152
153 properties.particle_values =
154 Kokkos::create_mirror_view_and_copy(Kokkos::HostSpace(), particle_values);
155 properties.spatial_values =
156 Kokkos::create_mirror_view_and_copy(Kokkos::HostSpace(), spatial_values);
157 return properties;
158 }
159 else
160 {
161 return std::nullopt;
162 }
163 }
164
165} // namespace PostProcessing
166#endif
Main owning object for Monte-Carlo particles.
Definition particles_container.hpp:135
Model::SelfParticle model
Definition particles_container.hpp:148
KOKKOS_INLINE_FUNCTION std::size_t n_particles() const
Gets the number of particles in the container.
Definition particles_container.hpp:171
MC::ParticlePositions position
Definition particles_container.hpp:149
std::size_t counter
Definition particles_container.hpp:177
void clean_dead(std::size_t to_remove)
Definition particles_container.hpp:395
MC::ParticleStatus status
Definition particles_container.hpp:150
SFNIAE way to check whether model allow partial value saving.
Definition traits.hpp:152
Model that can export properties.
Definition traits.hpp:159
Kokkos::View< Status *, ComputeSpace > ParticleStatus
Definition alias.hpp:20
Kokkos::View< uint64_t *, ComputeSpace > ParticlePositions
Definition alias.hpp:19
Definition impl_post_process.hpp:17
void inner(std::size_t n_p, const MC::ParticlePositions &position, const typename Model::SelfParticle &model, ParticlePropertyViewType< ComputeSpace > &particle_values, ParticlePropertyViewType< ComputeSpace > &spatial_values, const MC::ParticleStatus &status)
Definition post_process.hpp:27
std::optional< PostProcessing::BonceBuffer > get_properties(MC::ParticlesContainer< M > &container, const std::size_t n_compartment)
Definition post_process.hpp:111
void inner_partial(const std::size_t n_p, const MC::ParticlePositions &position, const typename Model::SelfParticle &model, ParticlePropertyViewType< ComputeSpace > &particle_values, ParticlePropertyViewType< ComputeSpace > &spatial_values, const MC::ParticleStatus &status)
Definition post_process.hpp:61
Definition post_process.hpp:20
ParticlePropertyViewType< HostSpace > spatial_values
Definition post_process.hpp:22
std::vector< std::string > vnames
Definition post_process.hpp:23
ParticlePropertyViewType< HostSpace > particle_values
Definition post_process.hpp:21