Module application

class pysph.solver.application.Application(fname=None, output_dir=None, domain=None)[source]

Bases: object

Subclass this to run any SPH simulation. There are several important methods that this class provides. The application is typically used as follows:

class EllipticalDrop(Application):
    def create_particles(self):
        # ...
    def create_scheme(self):
        # ...
app = EllipticalDrop()

The post_process() method is entirely optional and typically performs the post-processing. It is important to understand the correct sequence of the method calls. When the Application instance is created, the following methods are invoked by the __init__() method:

  1. initialize(): use this to setup any constants etc.
  2. create_scheme(): this needs to be overridden if one wishes to use a pysph.sph.scheme.Scheme. If one does not want to use a scheme, the create_equations() and create_solver() methods must be overridden.
  3. self.scheme.add_user_options(): i.e. the scheme’s command line options are added, if there is a scheme.
  4. add_user_options(): add any user specified command line options.

When is called, the following methods are called in order:

  1. _parse_command_line(): this is a private method but it is important to note that the command line arguments are first parsed.
  2. consume_user_options(): this is called right after the command line args are parsed.
  3. configure_scheme(): This is where one may configure the scheme according to the passed command line arguments.
  4. create_solver(): Create the solver, note that this is needed only if one has not used a scheme, otherwise, this will by default return the solver created by the scheme chosen.
  5. create_equations(): Create any equations. Defaults to letting the scheme generate and return the desired equations.
  6. create_particles()
  7. create_inlet_outlet()
  8. create_domain(): Not needed for non-periodic domains.
  9. create_nnps(): Not needed unless one wishes to override the default NNPS.
  10. create_tools(): Add any instances.
  11. customize_output(): Customize the output visualization.

Additionally, as the application runs there are several convenient optional callbacks setup:

  1. pre_step(): Called before each time step.
  2. post_stage(): Called after every stage of the integration.
  3. post_step(): Called after each time step.

Finally, it is a good idea to overload the post_process() method to perform any post processing for the generated data.

The application instance also has several important attributes, some of these are as follows:

  • args: command line arguments, typically sys.argv[1:].
  • domain: optional pysph.base.nnps_base.DomainManager instance.
  • fname: filename pattern to use when dumping output.
  • inlet_outlet: list of inlet/outlets.
  • nnps: instance of pysph.base.nnps_base.NNPS.
  • num_procs: total number of processes running.
  • output_dir: Output directory.
  • parallel_manager: in parallel, an instance of pysph.parallel.parallel_manager.ParallelManager.
  • particles: list of :py:class:`pysph.base.particle_array.ParticleArray`s.
  • rank: Rank of this process.
  • scheme: the optional pysph.sph.scheme.Scheme instance.
  • solver: the solver instance, pysph.solver.solver.Solver.
  • tools: a list of possible :py:class:``s.


  • fname (str) – file name to use for the output files.
  • output_dir (str) – output directory name.
  • domain (pysph.base.nnps_base.DomainManager) – A domain manager to use. This is used for periodic domains etc.

Add a instance to the application.


Add any user-defined options to the given option group.


This uses the argparse module.


This is called after consume_user_options() is called. One can configure the SPH scheme here as at this point all the command line options are known.


This is called right after the command line arguments are parsed.

All the parsed options are available in self.options and can be used in this method.

This is meant to be overridden by users to setup any internal variables etc. that depend on the command line arguments passed. Note that this method is called well before the solver or particles are created.


Create a pysph.base.nnps_base.DomainManager and return it if needed.

This is used for periodic domains etc. Note that if the domain is passed to __init__(), then this method is not called.


Create the equations to be used and return them.


Create inlet and outlet objects and return them as a list.

The method is passed a dictionary of particle arrays keyed on the name of the particle array.


Create any NNPS if desired and return it, else a default NNPS will be created automatically.


Create particle arrays and return a list of them.


Create a suitable SPH scheme and return it.

Note that this method is called after the arguments are all processed and after consume_user_options() is called.


Create the solver and return it.


Create any tools and return a sequence of them. This method is called after particles/inlets etc. are all setup, configured etc.


Customize the output file visualization by adding any files.

For example, the pysph view command will look for a file that can be used to script the viewer. You can use self._mayavi_config(‘code’) to add a default customization here.

Note that this is executed before the simulation starts.


Dump the generated code to given file.


Called on the constructor, set constants etc. up here if needed.


Given an info filename or a directory containing the info file, read the information and do any post-processing of the results. Please overload the method to perform any processing.

The info file has a few useful attributes and can be read using the read_info() method.

The output_files property should provide the output files generated.

post_stage(current_time, dt, stage)[source]

If overloaded, this is called automatically after each integrator stage, i.e. if the integrator is a two stage integrator it will be called after the first and second stages.

The method is passed (current_time, dt, stage). See the the pysph.sph.integrator.Integrator.one_timestep() methods for examples of how this is called.


If overloaded, this is called automatically after each integrator step. The method is passed the solver instance.


If overloaded, this is called automatically before each integrator step. The method is passed the solver instance.


Read the information from the given info file (or directory containing the info file, the first found info file will be used).


Run the application.

setup(solver, equations, nnps=None, inlet_outlet_factory=None, particle_factory=None, *args, **kwargs)[source]

Setup the application’s solver.

This will parse the command line arguments (if this is not called from within an IPython notebook or shell) and then using those parameters and any additional parameters and call the solver’s setup method.

  • solver (pysph.solver.solver.Solver) – The solver instance.
  • equations (list) – A list of Groups/Equations.
  • nnps (pysph.base.nnps_base.NNPS) – Optional NNPS instance. If None is given a default NNPS is created.
  • inlet_outlet_factory (callable or None) – The inlet_outlet_factory is passed a dictionary of the particle arrays. The factory should return a list of inlets and outlets.
  • particle_factory (callable or None) – If supplied, particles will be created for the solver using the particle arrays returned by the callable. Else particles for the solver need to be set before calling this method
  • args – extra positional arguments passed on to the particle_factory.
  • kwargs – extra keyword arguments passed to the particle_factory.


>>> def create_particles():
...    ...
>>> solver = Solver(...)
>>> equations = [...]
>>> app = Application()
>>> app.setup(solver=solver, equations=equations,
...           particle_factory=create_particles)

Return True if the code is being run from an IPython session or notebook.


Return list of available kernels.