Limiter.py

# -*- coding: utf-8 -*-
"""
@author: Laura C. Kühle

"""


class Limiter(object):
    def __init__(self, config):
        self._reset(config)

    def _reset(self, config):
        pass

    def get_name(self):
        return self.__class__.__name__

    def apply(self, projection, cell):
        pass


class NoLimiter(Limiter):
    def apply(self, projection, cell):
        return projection[:, cell]


class MinMod(Limiter):
    def _reset(self, config):
        # Unpack necessary configurations
        self._erase_degree = config.pop('erase_degree', 0)

    def get_name(self):
        return self.__class__.__name__ + str(self._erase_degree)

    def apply(self, projection, cell):
        cell_slope = self._set_cell_slope(projection, cell)
        is_good_cell = self._determine_modification(projection, cell, cell_slope)

        if is_good_cell:
            return projection[:, cell]

        adapted_projection = projection[:, cell].copy()
        for i in range(len(adapted_projection)):
            if i > self._erase_degree:
                adapted_projection[i] = 0
        return adapted_projection

    def _determine_modification(self, projection, cell, cell_slope):
        forward_slope = (projection[0][cell+1] - projection[0][cell]) * (0.5**0.5)
        backward_slope = (projection[0][cell] - projection[0][cell-1]) * (0.5**0.5)

        return (forward_slope <= 0) & (backward_slope <= 0) & (cell_slope <= 0) \
            | (forward_slope >= 0) & (backward_slope >= 0) & (cell_slope >= 0)

    @staticmethod
    def _set_cell_slope(projection, cell):
        slope = []
        for current_cell in range(len(projection[0])):
            new_entry = sum(projection[degree][current_cell] * (degree+0.5)**0.5
                            for degree in range(1, len(projection)))
            slope.append(new_entry)
        return slope[cell]


class ModifiedMinMod(MinMod):
    def _reset(self, config):
        super()._reset(config)

        # Unpack necessary configurations
        self._cell_len = config.pop('cell_len')
        self._mod_factor = config.pop('mod_factor', 0)

    def get_name(self):
        return self.__class__.__name__ + str(self._erase_degree)

    def _determine_modification(self, projection, cell, cell_slope):
        if abs(cell_slope) <= self._mod_factor*self._cell_len**2:
            return True

        return super()._determine_modification(projection, cell, cell_slope)