Skip to content
Snippets Groups Projects
Select Git revision
  • f04aaf315ba00a59c68eb967d780f2d7dae338be
  • master default protected
  • dev
  • sybilNLO
  • gprBug
  • maximumtotalflux
  • easyConstraint
  • switchbug
  • thuong
  • momafix
  • rmReactBug
11 results

checkDefaultMethod.R

Blame
  • Code owners
    Assign users and groups as approvers for specific file changes. Learn more.
    Limiter.py 3.28 KiB
    # -*- coding: utf-8 -*-
    """
    @author: Laura C. Kühle
    
    """
    import numpy as np
    import timeit
    
    
    class Limiter(object):
        def __init__(self, config):
            self.function_name = 'None'
    
        def get_name(self):
            return self.function_name
    
        def apply(self, projection, cell):
            pass
    
    
    class NoLimiter(Limiter):
        def __init__(self, config):
            # Set name of function
            self.function_name = 'NoLimiter'
    
        def apply(self, projection, cell):
            return projection[:, cell]
    
    
    class MinMod(Limiter):
        def __init__(self, config):
            # Unpack necessary parameter
            self.erase_degree = config.pop('erase_degree', 0)
    
            # Set name of function
            self.function_name = 'MinMod' + str(self.erase_degree)
    
            # Pop unnecessary parameter
            config.pop('cell_len')
    
            self.projection = []
            self.cell = 0
    
        def apply(self, projection, cell):
            self.projection = projection
            self.cell = cell
            self._set_cell_slope()
            is_good_cell = self._determine_modification()
    
            if is_good_cell:
                return self.projection[:, self.cell]
    
            adapted_projection = self.projection[:, self.cell].copy()
            for i in range(len(adapted_projection)):
                if i > self.erase_degree:
                    adapted_projection[i] = 0
            return adapted_projection
    
        def _set_cell_slope(self):
            tic = timeit.default_timer()
            slope = []
            transposed_projection = np.transpose(self.projection)
            for cell in range(len(transposed_projection)):
                new_entry = sum(transposed_projection[cell][degree] * (degree+0.5)**0.5
                                for degree in range(1, len(self.projection)))
                slope.append(new_entry)
            toc = timeit.default_timer()
            print('Trans:', toc-tic)
    
            tic = timeit.default_timer()
            slope1 = []
            transposed_projection = self.projection
            for cell in range(len(transposed_projection[0])):
                new_entry = sum(transposed_projection[degree][cell] * (degree+0.5)**0.5
                                for degree in range(1, len(self.projection)))
                slope1.append(new_entry)
            toc = timeit.default_timer()
            print('Vecto:', toc-tic)
    
            print(slope == slope1)
            self.cell_slope = slope[self.cell]
    
        def _determine_modification(self):
            forward_slope = (self.projection[0][self.cell+1] - self.projection[0][self.cell]) * (0.5**0.5)
            backward_slope = (self.projection[0][self.cell] - self.projection[0][self.cell-1]) * (0.5**0.5)
    
            return (forward_slope <= 0) & (backward_slope <= 0) & (self.cell_slope <= 0) \
                | (forward_slope >= 0) & (backward_slope >= 0) & (self.cell_slope >= 0)
    
    
    class ModifiedMinMod(MinMod):
        def __init__(self, config):
            # Unpack necessary configurations
            self.cell_len = config.pop('cell_len')
            self.erase_degree = config.pop('erase_degree', 0)
            self.mod_factor = config.pop('mod_factor', 0)
    
            # Set name of function
            self.function_name = 'ModifiedMinMod' + str(self.erase_degree)
    
            self.projection = []
            self.cell = 0
    
        def _determine_modification(self):
            if abs(self.cell_slope) <= self.mod_factor*self.cell_len**2:
                return True
    
            return super()._determine_modification()