-
Notifications
You must be signed in to change notification settings - Fork 738
New issue
Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.
By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.
Already on GitHub? Sign in to your account
Step-68 : Particle tracking of a massless tracer in a vortical flow #10308
Step-68 : Particle tracking of a massless tracer in a vortical flow #10308
Conversation
There was a problem hiding this comment.
Choose a reason for hiding this comment
The reason will be displayed to describe this comment to others. Learn more.
Looks good!
Are you planing to also add also an advection solver? I would be fine, if you wouldn't, and you would concentrate on particle-related aspect.
examples/step-x/step-x.cc
Outdated
const auto pic = particle_handler.particles_in_cell(cell); | ||
|
||
for (unsigned int i = 0; particle != pic.end(); ++particle, ++i) | ||
{ |
There was a problem hiding this comment.
Choose a reason for hiding this comment
The reason will be displayed to describe this comment to others. Learn more.
Couldn't you replace this by an iterator?
examples/step-x/step-x.cc
Outdated
|
||
particle_velocity[comp_j.first] += | ||
fluid_fe.shape_value(j, reference_location) * | ||
field_relevant(dof_indices[j]); |
There was a problem hiding this comment.
Choose a reason for hiding this comment
The reason will be displayed to describe this comment to others. Learn more.
I would read the values first from the global vector into a cell-local vector and only operate with j
here.
Two questions regarding the usability of the const auto &cell =
particle->get_surrounding_cell(background_triangulation);
const auto &dh_cell =
typename DoFHandler<dim>::cell_iterator(*cell, &fluid_dh);
dh_cell->get_dof_indices(dof_indices); to: const auto cell = particle->get_surrounding_cell(fluid_dh); The following code loop over all cells that contain cells and within that cell it loops over all particles: auto particle = particle_handler.begin();
while (particle != particle_handler.end())
{
const auto &cell = particle->get_surrounding_cell(triangulation);
const auto pic = particle_handler.particles_in_cell(cell);
for (unsigned int i = 0; particle != pic.end(); ++particle, ++i)
/*do something*/
} Wouldn't be possible to introduce appropriate iterators? step-70 already contained these lines of code? If you want, I could help and open PRs regarding to these points. |
I think I prefer to concentrate on the particle aspects. I think there are already many tutorials that describe solving equations in parallel. I just envision this step has a very simple, barebone step that focuses on everything related to basic operations on particles. |
I am looking into adding load balancing right now. Once I have something working lets have a chat so I can walk you through the steps. Also I will look into your questions Peter. |
Load balancing is in chaos-polymtl#1 @peterrum:
The second case is a bit more complicated. I think Bruno changed it already for this step, which is possible here. But the general issue (if I remember correctly) is that the following three ways to do the same thing (iterating over all particles) have very different performance characteristics:
I think there were cases where the third version is necessary. Were you suggesting to add new particle iterators that would only iterate over the particles of a single cell? That could cover the third case. I would be interested in hearing how you would do that, my knowledge about iterators is still a bit limited. |
@peterrum I reserved step-68 like you suggested by putting it in the PR's name. Is that ok? |
Dear @gassmoeller and @peterrum. I finished a first full version of the tutorial with documentations. Rene there are two very minor places where I would appreciate your input for the documentation. The results are on the following youtube links: As always, I am grateful for all your comments and ideas :) |
There was a problem hiding this comment.
Choose a reason for hiding this comment
The reason will be displayed to describe this comment to others. Learn more.
Very nice! I have bunch of minor requests.
examples/step-68/doc/intro.dox
Outdated
\frac{d \textbf{x}_i}{dt} =\textbf{u}(\textbf{x}_i) | ||
@f] | ||
|
||
where $\textbf{x}_i$ is the postion of particle $i$. In the present step, |
There was a problem hiding this comment.
Choose a reason for hiding this comment
The reason will be displayed to describe this comment to others. Learn more.
... and u its verlocity.
examples/step-68/doc/intro.dox
Outdated
of the motion of the particles. However, this does not alter which capacities | ||
are displayed in the present step. |
There was a problem hiding this comment.
Choose a reason for hiding this comment
The reason will be displayed to describe this comment to others. Learn more.
does not alter which capacities are displayed
sounds odd...
examples/step-68/doc/results.dox
Outdated
Regardless of the specific parameter file name, if the specified file does not | ||
exist, when you execute the program you will get an exception that no such file | ||
can be found: | ||
|
||
@code | ||
---------------------------------------------------- | ||
Exception on processing: | ||
|
||
-------------------------------------------------------- | ||
An error occurred in line <74> of file <../source/base/parameter_acceptor.cc> in function | ||
static void dealii::ParameterAcceptor::initialize(const std::string &, const std::string &, const ParameterHandler::OutputStyle, dealii::ParameterHandler &) | ||
The violated condition was: | ||
false | ||
Additional information: | ||
You specified <parameters.prm> as input parameter file, but it does not exist. We created it for you. | ||
-------------------------------------------------------- | ||
|
||
Aborting! | ||
---------------------------------------------------- | ||
@endcode | ||
|
||
However, as the error message already states, the code that triggers the | ||
exception will also generate the specified file ("`parameters.prm`" in this case). |
There was a problem hiding this comment.
Choose a reason for hiding this comment
The reason will be displayed to describe this comment to others. Learn more.
Not needed!
examples/step-68/doc/results.dox
Outdated
this case the particles would need to have additional properties such as their mass, | ||
and their diameter. | ||
- Coupling to a flow solver. This step could be straightforwardly coupled to any parallel | ||
steps in which the Stokes or the Navier-Stokes equations are solved (e.g. step-57) |
There was a problem hiding this comment.
Choose a reason for hiding this comment
The reason will be displayed to describe this comment to others. Learn more.
You could add a reference to step-70.
There was a problem hiding this comment.
Choose a reason for hiding this comment
The reason will be displayed to describe this comment to others. Learn more.
and step-32
There was a problem hiding this comment.
Choose a reason for hiding this comment
The reason will be displayed to describe this comment to others. Learn more.
Looks very nice! Let me know if you want me to take another look after merging my changes and addressing @peterrum and my comments.
examples/step-68/doc/results.dox
Outdated
this case the particles would need to have additional properties such as their mass, | ||
and their diameter. | ||
- Coupling to a flow solver. This step could be straightforwardly coupled to any parallel | ||
steps in which the Stokes or the Navier-Stokes equations are solved (e.g. step-57) |
There was a problem hiding this comment.
Choose a reason for hiding this comment
The reason will be displayed to describe this comment to others. Learn more.
and step-32
51943c1
to
874eafa
Compare
Please do not review this commit. I might (possibly) have identified a bug in insert_global_particles and that hindered my progression with adding the properties to the particles. |
874eafa
to
b2d056b
Compare
This branch is still not ready for final review. I am sorry. I am facing what appears to be a bug with the data out of particles in parallel if the particles have properties, I will open an issue |
Dear @peterrum and @gassmoeller,
I would greatly welcome your comments and your reviews? I don't plan on adding new features, so I think this is ready for a final round of review. All of your comments are more than welcomed :) |
There was a problem hiding this comment.
Choose a reason for hiding this comment
The reason will be displayed to describe this comment to others. Learn more.
Very nice! I made some text suggestions, but they are all minor.
The only bigger question I have is that you claim in the results that this tutorial highlights some of the main capabilities of particles, notably their capacity to be used in distributed parallel simulations.
I feel that for that to be true we would need to add a few paragraphs in the introduction that highlight what is necessary to use particles in distributed simulations, and a few paragraphs in the results that point out where and when this happens in the example. Specifically, I think we should shortly discuss the following processes:
- Generating the particles using a distributed triangulation that is different from the triangulation we use for the flow. This allows a convenient parallel creation of particles, but requires a redistribution of particles after the generation, which can be expensive. Nevertheless, since it is a one-time process it is often worth the convenience over algorithms that only generate particles on the local process (which are also available in deal.II, e.g. the
Particles::Generators::regular_reference_locations
used with the flow triangulation orParticles::Generators::probabilistic_locations
with a probability density function - The exchange of particles that leave a local domain, including mentioning that this is only efficient (and in fact only implemented at the moment) if particles move to the ghost layer of the local process. Distributing particles to elements outside the ghost layer has to be implemented manually, e.g. like in step-70.
- The importance of load balancing, and how particles are shipped during mesh repartition. That we use the
cell_weight
function to influence the normal deal.II (in fact p4est) repartition algorithm, and that particle data is serialized and attached to cells just like solution vector data and deserialized on the receiving process.
Do you think we should a paragraph for each of these points? I can give particle transfer and load balancing a try, do you want to take a shot at particle generation?
examples/step-68/doc/intro.dox
Outdated
and Peter Munch (Technical University of Munich and Helmholtz-Zentrum Geesthacht) | ||
</i> | ||
|
||
@dealiiTutorialDOI{10.5281/zenodo.3829064,https://zenodo.org/badge/DOI/10.5281/zenodo.3829064.svg} |
There was a problem hiding this comment.
Choose a reason for hiding this comment
The reason will be displayed to describe this comment to others. Learn more.
The doi needs to be updated or removed when finished.
There was a problem hiding this comment.
Choose a reason for hiding this comment
The reason will be displayed to describe this comment to others. Learn more.
You are absolutely right.
I felt that the parallel load balancing, although very interesting, appeared out of the blue. I really love your three suggestions as they are very didactic and that would improve the quality of the step for users who are not experience in particle tracking. I will give a shot at parallel particle generation and you can give a shot at load balancing and particle transfer like you suggested. I will also integrate your other comments :). Thank you very much for taking the time to review and contribute this much :)!
examples/step-68/doc/intro.dox
Outdated
|
||
Particles play an important part in numerical models for a large | ||
number of applications. Particles are routinely used | ||
as massless tracer to visualize the dynamic of a transient flow. They |
There was a problem hiding this comment.
Choose a reason for hiding this comment
The reason will be displayed to describe this comment to others. Learn more.
Maybe?
as massless tracer to visualize the dynamic of a transient flow. They | |
as massless tracers to visualize the dynamic of a transient flow. They |
examples/step-68/doc/intro.dox
Outdated
number of applications. Particles are routinely used | ||
as massless tracer to visualize the dynamic of a transient flow. They | ||
can also play an intrinsic role as part of a more complex finite element | ||
model, as is the case of the Particle-In-Cell (PIC) method (Gassmöller et al. 2018) |
There was a problem hiding this comment.
Choose a reason for hiding this comment
The reason will be displayed to describe this comment to others. Learn more.
model, as is the case of the Particle-In-Cell (PIC) method (Gassmöller et al. 2018) | |
model, as is the case for the Particle-In-Cell (PIC) method (Gassmöller et al. 2018) |
examples/step-68/doc/intro.dox
Outdated
or they can even be used to simulate the motion of granular matter, as is | ||
the case with the Discrete Element Method (DEM) (Blais et al. 2019). In the case |
There was a problem hiding this comment.
Choose a reason for hiding this comment
The reason will be displayed to describe this comment to others. Learn more.
or they can even be used to simulate the motion of granular matter, as is | |
the case with the Discrete Element Method (DEM) (Blais et al. 2019). In the case | |
or they can even be used to simulate the motion of granular matter, as in | |
the Discrete Element Method (DEM) (Blais et al. 2019). In the case |
examples/step-68/doc/intro.dox
Outdated
of DEM, the resulting model is not related to the finite element method anymore, | ||
but just leads to a system of ordinary differential equation which describes | ||
the motion of the particles and the dynamic of their collisions. All of | ||
these models can be built using deal.II particle handling capabilities. |
There was a problem hiding this comment.
Choose a reason for hiding this comment
The reason will be displayed to describe this comment to others. Learn more.
these models can be built using deal.II particle handling capabilities. | |
these models can be built using deal.II's particle handling capabilities. |
examples/step-68/doc/results.dox
Outdated
|
||
We note that, by default, the simulation runs the particle tracking with | ||
an analytical velocity for 2000 iterations, then runs the particle tracking with | ||
velocity interpolationn for the same duration. The results are written every |
There was a problem hiding this comment.
Choose a reason for hiding this comment
The reason will be displayed to describe this comment to others. Learn more.
velocity interpolationn for the same duration. The results are written every | |
velocity interpolation for the same duration. The results are written every |
examples/step-68/doc/results.dox
Outdated
|
||
<h3>Possibilities for extensions</h3> | ||
|
||
This steps highlights some of the main capabilities of particles, notably their |
There was a problem hiding this comment.
Choose a reason for hiding this comment
The reason will be displayed to describe this comment to others. Learn more.
This steps highlights some of the main capabilities of particles, notably their | |
This steps highlights some of the main capabilities for handling particles in deal.II, notably their |
examples/step-68/doc/results.dox
Outdated
this case the particles would need to have additional properties such as their mass, | ||
and their diameter. | ||
- Coupling to a flow solver. This step could be straightforwardly coupled to any parallel | ||
steps in which the Stokes (step-32, step-70) or the Navier-Stokes equations are solved (e.g. step-57) |
There was a problem hiding this comment.
Choose a reason for hiding this comment
The reason will be displayed to describe this comment to others. Learn more.
steps in which the Stokes (step-32, step-70) or the Navier-Stokes equations are solved (e.g. step-57) | |
steps in which the Stokes (step-32, step-70) or the Navier-Stokes equations are solved (e.g. step-57). |
examples/step-68/doc/results.dox
Outdated
<h3>Possibilities for extensions</h3> | ||
|
||
This steps highlights some of the main capabilities of particles, notably their | ||
capacity to be use in distributed parallel simulations. However, this step could |
There was a problem hiding this comment.
Choose a reason for hiding this comment
The reason will be displayed to describe this comment to others. Learn more.
capacity to be use in distributed parallel simulations. However, this step could | |
capacity to be used in distributed parallel simulations. However, this step could |
76e3037
to
5d8b9a4
Compare
@gassmoeller In this section, I added the discussion on the global generation of the particles. The two elements missing would be load balancing and particle exchange between the processors. I think that adding this to the tutorial makes the step a lot easier to follow and a lot more didactic. I will be waiting for your two paragraph and I think that after this the step should be finished and ready for final review :). I am very happy about the result. |
ping @gassmoeller |
Sorry for the radio silence. I sent my paragraphs in chaos-polymtl#3 a while ago, but I did not mention that here so it got lost. I will read through the tutorials as it is right now, my changes in the other PR are pretty self-contained. |
There was a problem hiding this comment.
Choose a reason for hiding this comment
The reason will be displayed to describe this comment to others. Learn more.
Looks nearly ready. I have some text suggestions, and I think there are some suggestions from @peterrum that are not yet addressed (like renaming euler_analytical
into euler_step_analytical
). If you want me to take care of any of that let me know, but I think it is quicker to fix this on your side (without going through another PR from me).
examples/step-68/doc/intro.dox
Outdated
diameter, temperature, etc.). In the present tutorial, this is used to | ||
store the value of the fluid velocity and the process id to which the particles | ||
belong. |
There was a problem hiding this comment.
Choose a reason for hiding this comment
The reason will be displayed to describe this comment to others. Learn more.
diameter, temperature, etc.). In the present tutorial, this is used to | |
store the value of the fluid velocity and the process id to which the particles | |
belong. | |
diameter, temperature, etc.). In the present tutorial, this is used to | |
store the value of the fluid velocity and the process id to which the particles | |
belong. |
examples/step-68/doc/intro.dox
Outdated
|
||
<h3>Challenges related to distributed particle simulations</h3> | ||
|
||
Although the present step is not computationnaly intensive, simulations that |
There was a problem hiding this comment.
Choose a reason for hiding this comment
The reason will be displayed to describe this comment to others. Learn more.
Although the present step is not computationnaly intensive, simulations that | |
Although the present step is not computationally intensive, simulations that |
examples/step-68/doc/intro.dox
Outdated
<h3>Challenges related to distributed particle simulations</h3> | ||
|
||
Although the present step is not computationnaly intensive, simulations that | ||
include particles can be computationnaly demanding and require parallelization. |
There was a problem hiding this comment.
Choose a reason for hiding this comment
The reason will be displayed to describe this comment to others. Learn more.
include particles can be computationnaly demanding and require parallelization. | |
include particles can be computationally demanding and require parallelization. |
examples/step-68/doc/intro.dox
Outdated
Generating the particles is not straightforward since the processor to which they belong | ||
must first be identified before the cell in which they are located is found. | ||
Deal.II provides numerous capabilities to generate particles through the Particles::Generator namespace. | ||
Some of these particle generator generate particles on the locally own subdomain. For example, |
There was a problem hiding this comment.
Choose a reason for hiding this comment
The reason will be displayed to describe this comment to others. Learn more.
Some of these particle generator generate particles on the locally own subdomain. For example, | |
Some of these particle generators generate particles on the locally owned subdomain. For example, |
examples/step-68/doc/intro.dox
Outdated
does not constitute a large portion of the computational cost. For these occasions, deal.II provides | ||
convenient Particles::Generators that can globally insert the particles even if they are not located | ||
on the subdomain from which they are created. The generators first locate on which subdomain the particles | ||
are situated, identify is which cell they are located and exchange the necessary information amongst the processors |
There was a problem hiding this comment.
Choose a reason for hiding this comment
The reason will be displayed to describe this comment to others. Learn more.
are situated, identify is which cell they are located and exchange the necessary information amongst the processors | |
are situated, identify in which cell they are located and exchange the necessary information amongst the processors |
examples/step-68/doc/intro.dox
Outdated
the dynamics of a particular vortical flow : the Rayleigh-Kotte Vortex. This flow pattern | ||
is generally used as a complex test case for interface tracking methods | ||
(e.g. volume-of-fluid and level set approches) since | ||
it leads to strong rotation and elongation of the fluid (Blais 2013). |
There was a problem hiding this comment.
Choose a reason for hiding this comment
The reason will be displayed to describe this comment to others. Learn more.
it leads to strong rotation and elongation of the fluid (Blais 2013). | |
it leads to strong rotation and elongation of the fluid (Blais, 2013). |
examples/step-68/doc/intro.dox
Outdated
v &=& \frac{\partial\Psi}{\partial x} = 2 \cos(\pi x) \sin(\pi x) \sin^2 (\pi y) \cos \left( \pi \frac{t}{T} \right) | ||
@f} | ||
|
||
|
There was a problem hiding this comment.
Choose a reason for hiding this comment
The reason will be displayed to describe this comment to others. Learn more.
Maybe add a sentence like the following explaining that the flow will reverse periodically and material will end up where it started:
It can be seen that this velocity reverses periodically due to the term $\cos \left( \pi \frac{t}{T} \right)$ and that material will end up at its starting position after every period of length $t=2T$. We will run this tutorial program for exactly one period and compare the final particle location to the initial location to illustrate this flow property.
My bad, I am sorry. I did not get that pull request warning (or it got lost through the mail). |
31af547
to
fac4066
Compare
@gassmoeller @peterrum Sorry for the delay in merging your pull request @gassmoeller |
There was a problem hiding this comment.
Choose a reason for hiding this comment
The reason will be displayed to describe this comment to others. Learn more.
Comments about the introduction.
My apologies for the long delay -- the start of the semester has been a bitch :-(
There was a problem hiding this comment.
Choose a reason for hiding this comment
The reason will be displayed to describe this comment to others. Learn more.
And some on the results section.
I applied all of Wolfgang's comment. Thank you very much for taking the time to review the tutorial and for the suggestions :)! The tutorial now assumes that step-19 exists (it depends on step-19). I think it is ready to be merged, but that's your call. I would merge it after step-19 though :)! That was fun work, once this one is merged I will start work on another example. |
Do you want to to squash your commits? |
Added that the tutorial for the particles build on step-40 which I think is the first complete parallel tutorial. Added changelog entry in major changes Fixed additional spelling mistake Apply suggestions from code review by bangerth Applied all additional suggestions by Wolfgang Bangerth - Fixed spelling mistakes - Added an animation for the Rayleigh-Kothe vortex in the introduction to illustrate the flow pattern Co-authored-by: Wolfgang Bangerth <bangerth@colostate.edu>
8474111
to
b8e0fe7
Compare
Don't worry about it. Same story here.
"Gotta squash em all, gotta squash em all...." |
There was a problem hiding this comment.
Choose a reason for hiding this comment
The reason will be displayed to describe this comment to others. Learn more.
First set of comments on the .cc file. Rest later today. Only small stuff, should be easy to address!
I think we are at the point (like in step-69) where, nearing 200 comments, we are likely to start breaking GitHub. @bangerth if there are more large change sets could you collect them into a PR against this branch on lethe-cfd? |
Yes, good point. I keep forgetting. My remaining edits are all here: chaos-polymtl#4 |
Make whitespace more uniform. Edit euler_step_interpolated() somewhat. Leave a note about step-68. Edit the remainder of the program. Apply suggestions from code review by bangerth Co-authored-by: Wolfgang Bangerth <bangerth@colostate.edu> Applied the final round of comments from Wolfgang
753f6a1
to
d11b348
Compare
@bangerth I applied all of your comments but there are two points that remain unresolved. Could you look at them in the file tab of this PR? :) Thank you so much for the review. |
There was a problem hiding this comment.
Choose a reason for hiding this comment
The reason will be displayed to describe this comment to others. Learn more.
👍
examples/step-68/step-68.cc
Outdated
background_triangulation.signals.pre_distributed_repartition.connect( | ||
std::bind( | ||
&Particles::ParticleHandler<dim>::register_store_callback_function, | ||
&particle_handler)); |
There was a problem hiding this comment.
Choose a reason for hiding this comment
The reason will be displayed to describe this comment to others. Learn more.
background_triangulation.signals.pre_distributed_repartition.connect( | |
std::bind( | |
&Particles::ParticleHandler<dim>::register_store_callback_function, | |
&particle_handler)); | |
background_triangulation.signals.pre_distributed_repartition.connect( | |
[this]() {this->particle_handler.register_store_callback_function(); }); |
There was a problem hiding this comment.
Choose a reason for hiding this comment
The reason will be displayed to describe this comment to others. Learn more.
This works for the register_store_callback_function.
However, the register_load_callback_function expects an argument in the form of a serialization (see https://www.dealii.org/current/doxygen/deal.II/classParticles_1_1ParticleHandler.html#a9a79889c1ad3b569a405488d4bab8263)
How do I deal with this? Because
background_triangulation.signals.post_distributed_repartition.connect( [this]() { this->particle_handler.register_load_callback_function(); });
does not work obviously since it is missing an argument. Sorry again for asking, but my experience with signals or lambdas is extremely limited.
There was a problem hiding this comment.
Choose a reason for hiding this comment
The reason will be displayed to describe this comment to others. Learn more.
Cannot you simply write?
background_triangulation.signals.post_distributed_repartition.connect(
[&](){this->particle_handler.register_load_callback_function(false)});
There was a problem hiding this comment.
Choose a reason for hiding this comment
The reason will be displayed to describe this comment to others. Learn more.
Ok this seems to compile well. But now the code segfaults in parallel when partitioning. I'll try to debug and see what happens. Some change somehow must have broken things.
@blaisb There seems to be a merge conflict here. Could you fix it. After that I think it will be merged! |
Yeah no problem, I will take care of that tomorrow morning first thing. I'll message you after that. |
Fixed a bug related to deal.II distributed vector and to the particle loop in interpolated euler.
If you can't figure it out, just leave it as you had it and one of us takes care of it as a follow-up. |
@bangerth does that comment signify your approval with the current state? If so lets merge! |
Yes! I've got to run, which is typically a bad sign to commit or merge anything, but happy to let someone else do it who can devote a minute or two of thought to the process! |
Toni El Geitani Nehme (Polytechnique Montréal), | ||
Rene Gassmöller (University of California Davis), | ||
and Peter Munch (Technical University of Munich and Helmholtz-Zentrum Geesthacht). | ||
Bruno Blais was supported by NSERC Discovery grant |
There was a problem hiding this comment.
Choose a reason for hiding this comment
The reason will be displayed to describe this comment to others. Learn more.
It took me a minute to realize that this is not a typo for NERSC :)
I figured it out. |
I would like to take some time to thank you all for the reviews. It was a great learning opportunity for me and I am glad I was able to make a durable contribution to a library that has really been a blessing since I started my career as a professor. Thank you for your time. I know we are all swamped by so many tasks and I appreciate every moment of the time you took to help. |
The pleasure is all ours! We hope for more contributions from you and your group! :-) |
For some reason the videos are not displayed in my case properly? Does anyone have the same issue? step-19 is fine!? |
Yeah they are not displayed correctly on mine also. I think the issue is because i did not use a /embed/ link like Wolfgang did in step-19. I'll make a PR for that tomorrow. :)!. |
Preliminary version of a step on particle tracking in an analytically defined velocity field.
It is very simple, but it showcases particles in parallel. It uses an analytically defined velocity field to move the particles either by interpolating from an MPI::Vector (e.g. from Trilinos) or analytically from a function. It uses the DiscreteTime class for time-stepping, a simple Euler scheme and ParameterAccessor for parsing (similar to step-70). The only thing missing that would be very interesting would be to add load balancing using something like 1000+1000*nb_particles_per_cell as a weight. I tried looking over the CellWeight class but I think I will need some help figuring out how to use it outside of it's original intended scope. I think Rene already did something similar for ASPECT. Furthermore, once we figure out a generic data out for particle properties, we could attach the mpi rank to the particles.
This is a work in progress and there is no documentation yet.
@peterrum @gassmoeller