oasislmf.pytools.pla.streams
============================

.. py:module:: oasislmf.pytools.pla.streams


Attributes
----------

.. autoapisummary::

   oasislmf.pytools.pla.streams.logger


Classes
-------

.. autoapisummary::

   oasislmf.pytools.pla.streams.PlaReader


Functions
---------

.. autoapisummary::

   oasislmf.pytools.pla.streams.read_buffer
   oasislmf.pytools.pla.streams.read_buffer_uniform
   oasislmf.pytools.pla.streams.read_and_write_streams


Module Contents
---------------

.. py:data:: logger

.. py:function:: read_buffer(byte_mv, cursor, valid_buff, event_id, item_id, items_amps, plafactors, default_factor, out_byte_mv, out_cursor)

   Read the gul loss stream, apply the post loss amplification factor and load it into out_byte_mv buffer
   This modified version of the read_buffer template return result when the whole input buffer is read and not when an event is read.
   therefore it cannot be used to read multiple stream at a time because events would be mixed up.

   :param byte_mv: input byte array
   :param cursor: read cursor
   :param valid_buff: valid part of input array
   :param event_id: last event id
   :param item_id: last item_id
   :param items_amps: amplification IDs where indexes correspond to item IDs
   :type items_amps: numpy array
   :param plafactors: event ID and amplification ID pairs mapped to loss factors
   :type plafactors: dict
   :param default_factor: post loss reduction/amplification factor to be used if loss factor not found in plafactors
   :type default_factor: float
   :param out_byte_mv: output byte arrau
   :param out_cursor: single value array to store valid part of out_byte_mv


.. py:function:: read_buffer_uniform(byte_mv, cursor, valid_buff, event_id, item_id, items_amps, plafactors, default_factor, out_byte_mv, out_cursor)

.. py:class:: PlaReader(items_amps, plafactors, default_factor)

   Bases: :py:obj:`oasislmf.pytools.common.event_stream.EventReader`


   Read an event loss stream and apply post-loss amplification factors to each loss.


   .. py:attribute:: items_amps


   .. py:attribute:: plafactors


   .. py:attribute:: default_factor


   .. py:attribute:: out_byte_mv


   .. py:attribute:: out_cursor


   .. py:attribute:: event_id
      :value: 0



   .. py:attribute:: item_id
      :value: 0



   .. py:attribute:: logger


   .. py:method:: read_buffer(byte_mv, cursor, valid_buff, event_id, item_id, **kwargs)


.. py:function:: read_and_write_streams(stream_in, stream_out, items_amps, plafactors, default_factor)

   Read input stream from gulpy or gulcalc, determine amplification ID from
   item ID, determine loss factor from event ID and amplification ID pair,
   multiply losses by relevant factors, and write to output stream.

   Input stream is binary file with layout:
       stream type (oasis_int), maximum sidx value (oasis_int),
       event ID 1 (oasis_int), item ID 1 (oasis_int),
       sample ID/sidx 1 (oasis_int), loss for sidx 1 (oasis_float),
       ...
       sample ID/sidx n (oasis_int), loss for sidx n (oasis_float),
       0 (oasis_int), 0.0 (4-byte float),
       event ID 1 (oasis_int), item ID 2 (oasis_int),
       ...
       event ID M (oasis_int), item ID N (oasis_int),
       sample ID/sidx 1 (oasis_int), loss for sidx 1 (oasis_float),
       ...
       sample ID/sidx n (oasis_int), loss for sidx n (oasis_float)

   Sample ID/sidx of 0 indicates start of next event ID-item ID pair. Output
   stream has same format as input stream.

   :param stream_in: input stream
   :type stream_in: buffer
   :param stream_out: output stream
   :type stream_out: buffer
   :param items_amps: amplification IDs where indexes correspond to item IDs
   :type items_amps: numpy array
   :param plafactors: event ID and amplification ID pairs mapped to loss factors
   :type plafactors: dict
   :param default_factor: post loss reduction/amplification factor to be used if loss factor not found in plafactors
   :type default_factor: float