def METHOD_NAME(self, group=None):
    """Creates the relation for the class:`PiecewiseLinearConverter`.
    Parameters
    ----------
    group : list
        List of
        oemof.solph.components.experimental.PiecewiseLinearConverter
        objects for which the relation of inputs and outputs is created
        e.g. group = [pwltf1, pwltf2, pwltf3, ...].
    """
    if group is None:
        return None
    m = self.parent_block()
    self.PWLINEARCONVERTERS = Set(initialize=[n for n in group])
    pw_repns = [n.pw_repn for n in group]
    if all(x == pw_repns[0] for x in pw_repns):
        self.pw_repn = pw_repns[0]
    else:
        print(
            "Cannot model different piecewise representations ",
            [n.pw_repn for n in group],
        )
    self.breakpoints = {}
    def build_breakpoints(block, n):
        for t in m.TIMESTEPS:
            self.breakpoints[(n, t)] = n.in_breakpoints
    self.breakpoint_build = BuildAction(
        self.PWLINEARCONVERTERS, rule=build_breakpoints
    )
    def _conversion_function(block, n, t, x):
        expr = n.conversion_function(x)
        return expr
    # bounds are min/max of breakpoints
    lower_bound_in = {n: min(n.in_breakpoints) for n in group}
    upper_bound_in = {n: max(n.in_breakpoints) for n in group}
    lower_bound_out = {
        n: n.conversion_function(bound)
        for (n, bound) in lower_bound_in.items()
    }
    upper_bound_out = {
        n: n.conversion_function(bound)
        for (n, bound) in upper_bound_in.items()
    }
    def get_inflow_bounds(model, n, t):
        return lower_bound_in[n], upper_bound_in[n]
    def get_outflow_bounds(model, n, t):
        return lower_bound_out[n], upper_bound_out[n]
    self.inflow = Var(
        self.PWLINEARCONVERTERS, m.TIMESTEPS, bounds=get_inflow_bounds
    )
    self.outflow = Var(
        self.PWLINEARCONVERTERS, m.TIMESTEPS, bounds=get_outflow_bounds
    )
    def _in_equation(block, n, p, t):
        """Link binary input and output flow to component outflow."""
        expr = 0
        expr += -m.flow[list(n.inputs.keys())[0], n, p, t]
        expr += self.inflow[n, t]
        return expr == 0
    self.equate_in = Constraint(
        self.PWLINEARCONVERTERS, m.TIMEINDEX, rule=_in_equation
    )
    def _out_equation(block, n, p, t):
        """Link binary input and output flow to component outflow."""
        expr = 0
        expr += -m.flow[n, list(n.outputs.keys())[0], p, t]
        expr += self.outflow[n, t]
        return expr == 0
    self.equate_out = Constraint(
        self.PWLINEARCONVERTERS, m.TIMEINDEX, rule=_out_equation
    )
    self.piecewise = Piecewise(
        self.PWLINEARCONVERTERS,
        m.TIMESTEPS,
        self.outflow,
        self.inflow,
        pw_repn=self.pw_repn,
        pw_constr_type="EQ",
        pw_pts=self.breakpoints,
        f_rule=_conversion_function,
    )