Branch data Line data Source code
1 : : //
2 : : // Class ParticleBase
3 : : // Base class for all user-defined particle classes.
4 : : //
5 : : // ParticleBase is a container and manager for a set of particles.
6 : : // The user must define a class derived from ParticleBase which describes
7 : : // what specific data attributes the particle has (e.g., mass or charge).
8 : : // Each attribute is an instance of a ParticleAttribute<T> class; ParticleBase
9 : : // keeps a list of pointers to these attributes, and performs particle creation
10 : : // and destruction.
11 : : //
12 : : // ParticleBase is templated on the ParticleLayout mechanism for the particles.
13 : : // This template parameter should be a class derived from ParticleLayout.
14 : : // ParticleLayout-derived classes maintain the info on which particles are
15 : : // located on which processor, and performs the specific communication
16 : : // required between processors for the particles. The ParticleLayout is
17 : : // templated on the type and dimension of the atom position attribute, and
18 : : // ParticleBase uses the same types for these items as the given
19 : : // ParticleLayout.
20 : : //
21 : : // ParticleBase and all derived classes have the following common
22 : : // characteristics:
23 : : // - The spatial positions of the N particles are stored in the
24 : : // particle_position_type variable R
25 : : // - The global index of the N particles are stored in the
26 : : // particle_index_type variable ID
27 : : // - A pointer to an allocated layout class. When you construct a
28 : : // ParticleBase, you must provide a layout instance, and ParticleBase
29 : : // will delete this instance when it (the ParticleBase) is deleted.
30 : : //
31 : : // To use this class, the user defines a derived class with the same
32 : : // structure as in this example:
33 : : //
34 : : // class UserParticles :
35 : : // public ParticleBase< ParticleSpatialLayout<double,3> > {
36 : : // public:
37 : : // // attributes for this class
38 : : // ParticleAttribute<double> rad; // radius
39 : : // particle_position_type vel; // velocity, same storage type as R
40 : : //
41 : : // // constructor: add attributes to base class
42 : : // UserParticles(ParticleSpatialLayout<double,2>* L) : ParticleBase(L) {
43 : : // addAttribute(rad);
44 : : // addAttribute(vel);
45 : : // }
46 : : // };
47 : : //
48 : : // This example defines a user class with 3D position and two extra
49 : : // attributes: a radius rad (double), and a velocity vel (a 3D Vector).
50 : : //
51 : : #ifndef IPPL_PARTICLE_BASE_H
52 : : #define IPPL_PARTICLE_BASE_H
53 : :
54 : : #include <tuple>
55 : : #include <type_traits>
56 : : #include <vector>
57 : :
58 : : #include "Types/IpplTypes.h"
59 : :
60 : : #include "Utility/TypeUtils.h"
61 : :
62 : : #include "Particle/ParticleLayout.h"
63 : :
64 : : namespace ippl {
65 : :
66 : : /*!
67 : : * @class ParticleBase
68 : : * @tparam PLayout the particle layout implementing an algorithm to
69 : : * distribute the particles among MPI ranks
70 : : * @tparam IDProperties the view properties for particle IDs (if any
71 : : * of the provided types is ippl::DisableParticleIDs, then particle
72 : : * IDs will be disabled for the bunch)
73 : : */
74 : : template <class PLayout, typename... IDProperties>
75 : : class ParticleBase {
76 : : constexpr static bool EnableIDs = sizeof...(IDProperties) > 0;
77 : :
78 : : public:
79 : : using vector_type = typename PLayout::vector_type;
80 : : using index_type = typename PLayout::index_type;
81 : : using particle_position_type = typename PLayout::particle_position_type;
82 : : using particle_index_type = ParticleAttrib<index_type, IDProperties...>;
83 : :
84 : : using Layout_t = PLayout;
85 : :
86 : : template <typename... Properties>
87 : : using attribute_type = typename detail::ParticleAttribBase<Properties...>;
88 : :
89 : : template <typename MemorySpace>
90 : : using container_type = std::vector<attribute_type<MemorySpace>*>;
91 : :
92 : : using attribute_container_type =
93 : : typename detail::ContainerForAllSpaces<container_type>::type;
94 : :
95 : : using bc_container_type = typename PLayout::bc_container_type;
96 : :
97 : : using hash_container_type = typename detail::ContainerForAllSpaces<detail::hash_type>::type;
98 : :
99 : : using size_type = detail::size_type;
100 : :
101 : : public:
102 : : //! view of particle positions
103 : : particle_position_type R;
104 : :
105 : : //! view of particle IDs
106 : : particle_index_type ID;
107 : :
108 : : /*!
109 : : * If this constructor is used, the user must call 'initialize' with
110 : : * a layout object in order to use this.
111 : : */
112 : : ParticleBase();
113 : :
114 : : /*!
115 : : * Ctor called when layout is provided with std::shared_ptr. It
116 : : * calls the default ctor which then calls the private ctor. The
117 : : * layout instance is moved to this class, hence, the argument
118 : : * is null afterwards, i.e., layout == nullptr.
119 : : * @param layout to be moved.
120 : : */
121 : : ParticleBase(Layout_t& layout);
122 : :
123 : : /* cannot use '= default' since we get a
124 : : * compiler warning otherwise:
125 : : * warning: calling a __host__ function("std::vector< ::ippl::detail::ParticleAttribBase *,
126 : : * ::std::allocator<
127 : : * ::ippl::detail::ParticleAttribBase *> > ::~vector") from a __host__ __device__
128 : : * function("ippl::ParticleBase<
129 : : * ::ippl::ParticleLayout<double, (unsigned int)3u> > ::~ParticleBase") is not allowed
130 : : */
131 : 204 : ~ParticleBase() {} // = default; //{ }
132 : :
133 : : /*!
134 : : * Initialize the particle layout. Needs to be called
135 : : * when the ParticleBase instance is constructed with the
136 : : * default ctor.
137 : : */
138 : : void initialize(Layout_t& layout);
139 : :
140 : : /*!
141 : : * @returns processor local number of particles
142 : : */
143 : 3144 : size_type getLocalNum() const { return localNum_m; }
144 : :
145 : : void setLocalNum(size_type size) { localNum_m = size; }
146 : :
147 : : /*!
148 : : * @returns total number of particles (across all processes)
149 : : */
150 : : size_type getTotalNum() const { return totalNum_m; }
151 : :
152 : : /*!
153 : : * @returns particle layout
154 : : */
155 : 120 : Layout_t& getLayout() { return *layout_m; }
156 : :
157 : : /*!
158 : : * @returns particle layout
159 : : */
160 : : const Layout_t& getLayout() const { return *layout_m; }
161 : :
162 : : /*!
163 : : * Set all boundary conditions
164 : : * @param bc the boundary conditions
165 : : */
166 : 12 : void setParticleBC(const bc_container_type& bcs) { layout_m->setParticleBC(bcs); }
167 : :
168 : : /*!
169 : : * Set all boundary conditions to this BC
170 : : * @param bc the boundary conditions
171 : : */
172 : 96 : void setParticleBC(BC bc) { layout_m->setParticleBC(bc); }
173 : :
174 : : /*!
175 : : * Add particle attribute
176 : : * @param pa attribute to be added to ParticleBase
177 : : */
178 : : template <typename MemorySpace>
179 : : void addAttribute(detail::ParticleAttribBase<MemorySpace>& pa);
180 : :
181 : : /*!
182 : : * Get particle attribute
183 : : * @param i attribute number in container
184 : : * @returns a pointer to the attribute
185 : : */
186 : : template <typename MemorySpace = Kokkos::DefaultExecutionSpace::memory_space>
187 : : attribute_type<MemorySpace>* getAttribute(size_t i) {
188 : : return attributes_m.template get<MemorySpace>()[i];
189 : : }
190 : :
191 : : /*!
192 : : * Calls a given function for all attributes in the bunch
193 : : * @tparam MemorySpace the memory space of the attributes to visit (void to visit all of
194 : : * them)
195 : : * @tparam Functor the functor type
196 : : * @param f a functor taking a single ParticleAttrib<MemorySpace>
197 : : */
198 : : template <typename MemorySpace = void, typename Functor>
199 : 0 : void forAllAttributes(Functor&& f) const {
200 : : if constexpr (std::is_void_v<MemorySpace>) {
201 : : attributes_m.forAll(f);
202 : : } else {
203 [ # # # # ]: 0 : for (auto& attribute : attributes_m.template get<MemorySpace>()) {
204 [ # # ]: 0 : f(attribute);
205 : : }
206 : : }
207 : 0 : }
208 : :
209 : : // Non-const variant of same function
210 : : template <typename MemorySpace = void, typename Functor>
211 : 180 : void forAllAttributes(Functor&& f) {
212 : : if constexpr (std::is_void_v<MemorySpace>) {
213 [ + - ]: 360 : attributes_m.forAll([&]<typename Attributes>(Attributes& atts) {
214 [ + + + + : 456 : for (auto& attribute : atts) {
+ + + + +
+ + + + +
+ + + + +
+ + + + +
+ + + + +
+ + + + +
+ + + + +
+ + + + +
+ + + + ]
[ + + + +
+ + + + +
+ + + + +
+ + + + +
+ + + +
+ ]
[ # # # # ]
215 [ + - + - : 276 : f(attribute);
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - ]
[ + - + -
+ - + - +
- + - + -
+ - + - +
- + - +
- ]
[ # # # # ]
216 : : }
217 : : });
218 : : } else {
219 [ # # # # ]: 0 : for (auto& attribute : attributes_m.template get<MemorySpace>()) {
220 [ # # ]: 0 : f(attribute);
221 : : }
222 : : }
223 : 180 : }
224 : :
225 : : /*!
226 : : * @returns the number of attributes
227 : : */
228 : 12 : unsigned getAttributeNum() const {
229 : 12 : unsigned total = 0;
230 [ + - ]: 36 : detail::runForAllSpaces([&]<typename MemorySpace>() {
231 : 12 : total += attributes_m.template get<MemorySpace>().size();
232 : : });
233 : 12 : return total;
234 : : }
235 : :
236 : : /*!
237 : : * Create nLocal processor local particles. This is a collective call,
238 : : * i.e. all MPI ranks must call this.
239 : : * @param nLocal number of local particles to be created
240 : : */
241 : : void create(size_type nLocal);
242 : :
243 : : /*!
244 : : * Create a new particle with a given ID. This is a collective call. If a process
245 : : * passes a negative number, it does not create a particle.
246 : : * @param id particle identity number
247 : : */
248 : : void createWithID(index_type id);
249 : :
250 : : /*!
251 : : * Create nTotal particles globally, equally distributed among all processors.
252 : : * This is a collective call.
253 : : * @param nTotal number of total particles to be created
254 : : */
255 : : void globalCreate(size_type nTotal);
256 : :
257 : : /*!
258 : : * Particle deletion Function. Partition the particles into a valid region
259 : : * and an invalid region,
260 : : * effectively deleting the invalid particles. This is a collective call.
261 : : * @param invalid View marking which indices are invalid
262 : : * @param destroyNum Total number of invalid particles
263 : : */
264 : : template <typename... Properties>
265 : : void destroy(const Kokkos::View<bool*, Properties...>& invalid, const size_type destroyNum);
266 : :
267 : : // This is a collective call.
268 : 84 : void update() { layout_m->update(*this); }
269 : :
270 : : /*
271 : : * The following functions should not be called in an application.
272 : : */
273 : :
274 : : /* This function does not alter the totalNum_m member function. It should only be called
275 : : * during the update function where we know the number of particles remains the same.
276 : : */
277 : : template <typename... Properties>
278 : : void internalDestroy(const Kokkos::View<bool*, Properties...>& invalid,
279 : : const size_type destroyNum);
280 : :
281 : : /*!
282 : : * Sends particles to another rank
283 : : * @tparam HashType the hash view type
284 : : * @param rank the destination rank
285 : : * @param tag the MPI tag
286 : : * @param sendNum the number of messages already sent (to distinguish the buffers)
287 : : * @param requests destination vector in which to store the MPI requests for polling
288 : : * purposes
289 : : * @param hash a hash view indicating which particles need to be sent to which rank
290 : : */
291 : : template <typename HashType>
292 : : void sendToRank(int rank, int tag, std::vector<MPI_Request>& requests,
293 : : const HashType& hash);
294 : :
295 : : /*!
296 : : * Receives particles from another rank
297 : : * @param rank the source rank
298 : : * @param tag the MPI tag
299 : : * @param recvNum the number of messages already received (to distinguish the buffers)
300 : : * @param nRecvs the number of particles to receive
301 : : */
302 : : void recvFromRank(int rank, int tag, size_type nRecvs);
303 : :
304 : : /*!
305 : : * Serialize to do MPI calls.
306 : : * @param ar archive
307 : : */
308 : : template <typename Archive>
309 : : void serialize(Archive& ar, size_type nsends);
310 : :
311 : : /*!
312 : : * Deserialize to do MPI calls.
313 : : * @param ar archive
314 : : */
315 : : template <typename Archive>
316 : : void deserialize(Archive& ar, size_type nrecvs);
317 : :
318 : : /*!
319 : : * Determine the total space necessary to store a certain number of particles
320 : : * @tparam MemorySpace only consider attributes stored in this memory space
321 : : * @param count particle number
322 : : * @return Total size of a buffer packed with the given number of particles
323 : : */
324 : : template <typename MemorySpace>
325 : : size_type packedSize(const size_type count) const;
326 : :
327 : : protected:
328 : : /*!
329 : : * Fill attributes of buffer.
330 : : * @param buffer to send
331 : : * @param hash function to access index.
332 : : */
333 : : void pack(const hash_container_type& hash);
334 : :
335 : : /*!
336 : : * Fill my attributes.
337 : : * @param buffer received
338 : : */
339 : : void unpack(size_type nrecvs);
340 : :
341 : : private:
342 : : //! particle layout
343 : : // cannot use std::unique_ptr due to Kokkos
344 : : Layout_t* layout_m;
345 : :
346 : : //! processor local number of particles
347 : : size_type localNum_m;
348 : :
349 : : //! total number of particles (across all processes)
350 : : size_type totalNum_m;
351 : :
352 : : //! all attributes
353 : : attribute_container_type attributes_m;
354 : :
355 : : //! next unique particle ID
356 : : index_type nextID_m;
357 : :
358 : : //! number of MPI ranks
359 : : index_type numNodes_m;
360 : :
361 : : //! buffers for particle partitioning
362 : : hash_container_type deleteIndex_m;
363 : : hash_container_type keepIndex_m;
364 : : };
365 : : } // namespace ippl
366 : :
367 : : #include "Particle/ParticleBase.hpp"
368 : :
369 : : #endif
|
