Module solver

An implementation of a general solver base class

class pysph.solver.solver.Solver(dim=2, integrator=None, kernel=None, n_damp=0, tf=1.0, dt=0.001, adaptive_timestep=False, cfl=0.3, output_at_times=[], fixed_h=False, **kwargs)

Bases: object

Base class for all PySPH Solvers

Constructor

Any additional keyword args are used to set the values of any of the attributes.

Parameters:

• dim (int) – Dimension of the problem
• integrator (pysph.sph.integrator.Integrator) – Integrator to use
• kernel (pysph.base.kernels.Kernel) – SPH kernel to use
• n_damp (int) – Number of timesteps for which the initial damping is required. This is used to improve stability for problems with strong discontinuity in initial condition. Setting it to zero will disable damping of the timesteps.
• dt (double) – Suggested initial time step for integration
• tf (double) – Final time for integration
• adaptive_timestep (bint) – Flag to use adaptive time steps
• cfl (double) – CFL number for adaptive time stepping
• pfreq (int) – Output files dumping frequency.
• output_at_times (list/array) – Optional list of output times to force dump the output file
• fixed_h (bint) – Flag for constant smoothing lengths h

Example

>>> integrator = PECIntegrator(fluid=WCSPHStep())
>>> kernel = CubicSpline(dim=2)
>>> solver = Solver(dim=2, integrator=integrator, kernel=kernel,
...                 n_damp=50, tf=1.0, dt=1e-3, adaptive_timestep=True,
...                 pfreq=100, cfl=0.5, output_at_times=[1e-1, 1.0])

add_post_stage_callback(callback)

These callbacks are called after each integrator stage.

The callbacks are passed (current_time, dt, stage). See the the Integrator.one_timestep methods for examples of how this is called.

Example

>>> def post_stage_callback_function(t, dt, stage):
>>>     # This function is called after every stage of integrator.
>>>     print t, dt, stage
>>>     # Do something
>>> solver.add_post_stage_callback(post_stage_callback_function)

add_post_step_callback(callback)

These callbacks are called after each timestep is performed.

The callbacks are passed the solver instance (i.e. self).

Example

>>> def post_step_callback_function(solver):
>>>     # This function is called after every time step.
>>>     print solver.t, solver.dt
>>>     # Do something
>>> solver.add_post_step_callback(post_step_callback_function)

add_pre_step_callback(callback)

These callbacks are called before each timestep is performed.

The callbacks are passed the solver instance (i.e. self).

Example

>>> def pre_step_callback_function(solver):
>>>     # This function is called before every time step.
>>>     print solver.t, solver.dt
>>>     # Do something
>>> solver.add_pre_step_callback(pre_step_callback_function)

append_particle_arrrays(arrays)

Append the particle arrays to the existing particle arrays

dump_output()

Dump the simulation results to file

The arrays used for printing are determined by the particle array’s output_property_arrays data attribute. For debugging it is sometimes nice to have all the arrays (including accelerations) saved. This can be chosen from using the command line option –detailed-output

Output data Format:

A single file named as: <fname>_<rank>_<iteration_count>.npz

The data is saved as a Python dictionary with two keys:

solver_data : Solver meta data like time, dt and iteration number

arrays : A dictionary keyed on particle array names and with

particle properties as value.

Example:

You can load the data output by PySPH like so:

>>> from pysph.solver.utils import load
>>> data = load('output_directory/filename_x_xxx.npz')
>>> solver_data = data['solver_data']
>>> arrays = data['arrays']
>>> fluid = arrays['fluid']
>>> ...

In the above example, it is assumed that the output file contained an array named fluid.

get_options(opt_parser)

Implement this to add additional options for the application

load_output(count)

Load particle data from dumped output file.

Parameters:count (str) – The iteration time from which to load the data. If time is ‘?’ then list of available data files is returned else the latest available data file is used

Notes

Data is loaded from the output_directory using the same format as stored by the dump_output() method. Proper functioning required that all the relevant properties of arrays be dumped.

set_adaptive_timestep(value)

Set it to True to use adaptive timestepping based on cfl, viscous and force factor.

Look at pysph.sph.integrator.compute_time_step for more details.

set_arrays_to_print(array_names=None)

Only print the arrays with the given names.

set_cfl(value)

Set the CFL number for adaptive time stepping

set_command_handler(callable, command_interval=1)

set the callable to be called at every command_interval iteration

the callable is called with the solver instance as an argument

set_disable_output(value)

Disable file output.

set_final_time(tf)

Set the final time for the simulation

set_output_at_times(output_at_times)

Set a list of output times

set_output_directory(path)

Set the output directory

set_output_fname(fname)

Set the output file name

set_output_only_real(output_only_real)

Set the flag to save out only real particles

set_output_printing_level(detailed_output)

Set the output printing level

set_parallel_output_mode(mode='collected')

Set the default solver dump mode in parallel.

The available modes are:

collected : Collect array data from all processors on root and

dump a single file.

distributed : Each processor dumps a file locally.

set_print_freq(n)

Set the output print frequency

set_time_step(dt)

Set the time step to use

setup(particles, equations, nnps, kernel=None, fixed_h=False)

Setup the solver.

The solver’s processor id is set if the in_parallel flag is set to true.

The order of the integrating calcs is determined by the solver’s order attribute.

This is usually called at the start of a PySPH simulation.

setup_solver(options=None)

Implement the basic solvers here

All subclasses of Solver may implement this function to add the necessary operations for the problem at hand.

Look at solver/fluid_solver.py for an example.

Parameters:options (dict) – options set by the user using commandline (there is no guarantee of existence of any key)

solve(show_progress=True)

Solve the system

Notes

Pre-stepping functions are those that need to be called before the integrator is called.

Similarly, post step functions are those that are called after the stepping within the integrator.