Writing inlet oulet manager

This section discusses writing your own Inlet Outlet Manager (IOM). If you want to use the existing IOM subclass present in PySPH see Flow past a circular cylinder using open boundary conditions. The IOM manages all the inputs required to simulate the open boundaries in PySPH. It has the following functions:

• Create ghost particles
• Create inlet/outlet stepper
• Creation of inlet/outlet equations
• Creation of inlet/outlet particle updater

Overview

The brief overview of InletOutletManager subclass:

class MyIOM(InletOutletManager):
    def __init__(self, fluid_arrays, inletinfo, outletinfo,
                extraeqns=None):
        # Create the object to manage inlet outlet boundary conditions.
        # Most of the variables are evaluated after the scheme and particles
        # are created after application.consume_user_options runs.

    def create_ghost(self, pa_arr, inlet=True):
        # Creates ghosts for the given inlet/outlet particles
        # return ghost_pa (the ghost particle array for the pa_arr)

    def update_dx(self, dx):
        # Update the discretization length

    def add_io_properties(self, pa, scheme=None):
        # Add properties to be used in inlet/outlet equations
        # return the list of properties

    def get_io_names(self, ghost=False):
        # Return all the names of inlets and outlets

    def get_stepper(self, scheme, integrator, **kw):
        # Returns the steppers for inlet/outlet

    def setup_iom(self, dim, kernel):
        # User data in application.consume_user_options are passed

    def get_equations(self, scheme, **kw):
        # Returns the equations for inlet/outlet

    def get_equations_post_compute_acceleration(self):
        # Returns the equations for inlet/outlet used post acceleration
        # computation

    def get_inlet_outlet(self, particle_array):
        # Returns list of `Inlet` and `Outlet` instances which
        # updates inlet particles to fluid and fluid particles to outlet.
        # This also creates new inlet particle and consume outlet particles.

• The IOM gets initialized in the configure_scheme method in the Application instance.
• The IOM is initialized using the list of fluid particle array fluid_arrays, and inlet_info and outlet_info instances of InletInfo and OutletInfo, respectively. These info class contains the information of inlet/outlet like direction, size etc.

To explain the inlet outlet manager in detail, let us consider the mirror boundary implemented using IOM class in simple_inlet_outlet.py for EDACScheme:

class EDACScheme(Scheme):
    def __init__(self, fluids, solids, dim, c0, nu, rho0, pb=0.0,
                gx=0.0, gy=0.0, gz=0.0, tdamp=0.0, eps=0.0, h=0.0,
                edac_alpha=0.5, alpha=0.0, bql=True, clamp_p=False,
                inlet_outlet_manager=None, inviscid_solids=None):
        ...
        self.inlet_outlet_manager = inlet_outlet_manager
        ...

    def configure_solver(self, kernel=None, integrator_cls=None,
                        extra_steppers=None, **kw):
        ...
        iom = self.inlet_outlet_manager
        if iom is not None:
            iom_stepper = iom.get_stepper(self, cls, self.use_tvf)
            for name in iom_stepper:
                steppers[name] = iom_stepper[name]
        ...
        if iom is not None:
            iom.setup_iom(dim=self.dim, kernel=kernel)

    def setup_properties(self, particles, clean=True):
        ...
        iom = self.inlet_outlet_manager
        fluids_with_io = self.fluids
        if iom is not None:
            io_particles = iom.get_io_names(ghost=True)
            fluids_with_io = self.fluids + io_particles
        for fluid in fluids_with_io:
            ...
            if iom is not None:
                iom.add_io_properties(pa, self)
        ...

    def create_equations(self):
        ...
        return self._get_internal_flow_equations()

    def _get_internal_flow_equations(self):
        ...
        iom = self.inlet_outlet_manager
        fluids_with_io = self.fluids
        if iom is not None:
            fluids_with_io = self.fluids + iom.get_io_names()

        equations = []
        if iom is not None:
            io_eqns = iom.get_equations(self, self.use_tvf)
            for grp in io_eqns:
                equations.append(grp)
        ...
        if iom is not None:
            io_eqns = iom.get_equations_post_compute_acceleration()
            for grp in io_eqns:
                equations.append(grp)

        return equations

• The additional properties can be added in the function add_io_properties which is called in the function setup_properties of a Scheme instance.
• The get_stepper function passes the appropriate stepper for the inlet and outlet in the configure_solver method of the Scheme instance.
• The get_equations and get_equations_post_compute_acceleration provides the additional equations to be used to interpolate properties from fluid particle arrays. This is to be called in create_equations method of the Scheme instance.
• Any additional data required from the Application or Scheme instance can be passed to the IOM using setup_iom method.

Additionally, in the Application instance:

• The get_inlet_outlet methods provides the instances for the Inlet and Outlet which updates the particles when they cross the interface. This method is called in create_inlet_outlet method of the Application instance.
• In mirror type inlet-outlet a ghost layer of particles is required which is a mere reflection about the inlet/outlet-fluid interface. It is created in create_particles using create_ghost.

The IOM enables the management of the above steps easy to handle. An example showing the usage of IOM is the flow_past_cylinder_2d.py.

Note

The IOM is a convenience to manage various attributes of inlet/outlet implementation in PySPH but all this is not automatic. The user has to take care of appropriate invocation of the methods in the IOM in Application and Scheme instances.