# 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:
...

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.