The Taylor-Green Vortex
This example solves the classic Taylor-Green Vortex problem in two-dimensions. To run it one may do:
$ pysph run taylor_green
There are many command line options that this example provides, check them out with:
$ pysph run taylor_green -h
The example source can be seen at taylor_green.py.
This example demonstrates several useful features:
user defined command line arguments and how they can be used.
running the problem with multiple schemes.
periodicity in both dimensions.
post processing of generated data.
using the
pysph.tools.sph_evaluator.SPHEvaluator
class for post-processing.
We discuss each of these below.
User command line arguments
The user defined command line arguments are easy to add. The following code snippet demonstrates how one adds this.
class TaylorGreen(Application):
def add_user_options(self, group):
group.add_argument(
"--init", action="store", type=str, default=None,
help="Initialize particle positions from given file."
)
group.add_argument(
"--perturb", action="store", type=float, dest="perturb", default=0,
help="Random perturbation of initial particles as a fraction "\
"of dx (setting it to zero disables it, the default)."
)
# ...
This code is straight-forward Python code to add options using the argparse
API. It is important to
note that the options are then available in the application's options
attribute and can be accessed as self.options
from the application's
methods. The consume_user_options
method highlights this.
def consume_user_options(self):
nx = self.options.nx
re = self.options.re
self.nu = nu = U*L/re
# ...
This method is called after the command line arguments are passed. To refresh
your memory on the order of invocation of the various methods of the
application, see the documentation of the
pysph.solver.application.Application
class. This shows that once
the application is run using the run
method, the command line arguments
are parsed and the following methods are called (this means that at this
point, the application has a valid self.options
):
consume_user_options()
configure_scheme()
The configure_scheme
is important as this example allows the user to
change the Reynolds number which changes the viscosity as well as the
resolution via --nx
and --hdx
. The code for the configuration looks like:
def configure_scheme(self):
scheme = self.scheme
h0 = self.hdx * self.dx
if self.options.scheme == 'tvf':
scheme.configure(pb=self.options.pb_factor*p0, nu=self.nu, h0=h0)
elif self.options.scheme == 'wcsph':
scheme.configure(hdx=self.hdx, nu=self.nu, h0=h0)
elif self.options.scheme == 'edac':
scheme.configure(h=h0, nu=self.nu, pb=self.options.pb_factor*p0)
kernel = QuinticSpline(dim=2)
scheme.configure_solver(kernel=kernel, tf=self.tf, dt=self.dt)
Note the use of the self.options.scheme
and the use of the
scheme.configure
method. Furthermore, the method also calls the scheme's
configure_solver
method.
Using multiple schemes
This is relatively easy, this is achieved by using the
pysph.sph.scheme.SchemeChooser
scheme as follows:
def create_scheme(self):
wcsph = WCSPHScheme(
['fluid'], [], dim=2, rho0=rho0, c0=c0, h0=h0,
hdx=hdx, nu=None, gamma=7.0, alpha=0.0, beta=0.0
)
tvf = TVFScheme(
['fluid'], [], dim=2, rho0=rho0, c0=c0, nu=None,
p0=p0, pb=None, h0=h0
)
edac = EDACScheme(
['fluid'], [], dim=2, rho0=rho0, c0=c0, nu=None,
pb=p0, h=h0
)
s = SchemeChooser(default='tvf', wcsph=wcsph, tvf=tvf, edac=edac)
return s
When using multiple schemes it is important to recall that each scheme needs
different particle properties. The schemes set these extra properties for you.
In this example, the create_particles
method has the following code:
def create_particles(self):
# ...
fluid = get_particle_array(name='fluid', x=x, y=y, h=h)
self.scheme.setup_properties([fluid])
The line tht calls setup_properties
passes a list of the particle arrays
to the scheme so the scheme can configure/setup any additional properties.
Periodicity
This is rather easily done with the code in the create_domain
method:
def create_domain(self):
return DomainManager(
xmin=0, xmax=L, ymin=0, ymax=L, periodic_in_x=True,
periodic_in_y=True
)
See also Simulating periodicity.
Post-processing
The code has a significant chunk of code for post-processing the results. This
is in the post_process
method. This demonstrates how to iterate over the
files and read the file data to calculate various quantities. In particular it
also demonstrates the use of the
pysph.tools.sph_evaluator.SPHEvaluator
class. For example consider
the method:
def _get_sph_evaluator(self, array):
if not hasattr(self, '_sph_eval'):
from pysph.tools.sph_evaluator import SPHEvaluator
equations = [
ComputeAveragePressure(dest='fluid', sources=['fluid'])
]
dm = self.create_domain()
sph_eval = SPHEvaluator(
arrays=[array], equations=equations, dim=2,
kernel=QuinticSpline(dim=2), domain_manager=dm
)
self._sph_eval = sph_eval
return self._sph_eval
This code, creates the evaluator, note that it just takes the particle arrays of interest, a set of equations (this can be as complex as the normal SPH equations, with groups and everything), the kernel, and a domain manager. The evaluator has two important methods:
update_particle_arrays(...): this allows a user to update the arrays to a new set of values efficiently.
evaluate: this actually performs the evaluation of the equations.
The example has this code which demonstrates these:
def _get_post_process_props(self, array):
# ...
sph_eval = self._get_sph_evaluator(array)
sph_eval.update_particle_arrays([array])
sph_eval.evaluate()
# ...
Note the use of the above methods.