Upload Initial_Condition.py (as of March 16 2020)

Initial_Condition.py

+# -*- coding: utf-8 -*-
+"""
+@author: Laura C. Kühle
+
+TODO: Rename initial conditions -> Renamed returned names
+"""
+import numpy as np
+
+class InitialCondition(object):
+
+    def __init__(self, left_bound, right_bound, config):
+        self.left_bound = left_bound
+        self.right_bound = right_bound
+        self.interval_len = self.right_bound-self.left_bound
+        pass
+
+    def get_name(self):
+        return self.function_name
+
+    def calculate(self, x):
+        while (x < self.left_bound):
+            x = x + self.interval_len
+        while (x > self.right_bound):
+            x = x - self.interval_len
+        return self._get_point(x)
+
+    def _get_point(self, x):
+        pass
+
+
+class InitialCondition1(InitialCondition):
+
+    def __init__(self, left_bound, right_bound, config):
+        super().__init__(left_bound, right_bound, config)
+        # Set name of function
+        self.function_name = 'Sine'
+
+        self.factor = config.pop('factor', 2)
+        pass
+
+    def _get_point(self, x):
+        return np.sin(self.factor * np.pi * x)
+
+
+class InitialCondition2(InitialCondition):
+
+    def __init__(self, left_bound, right_bound, config):
+        super().__init__(left_bound, right_bound, config)
+        # Set name of function
+        self.function_name = 'Box'
+        pass
+
+    def _get_point(self, x):
+        if (x < -1):
+            x = x + 2
+        if (x > 1):
+            x = x - 2
+        if ((x >= -0.5) & (x <= 0.5)):
+            return 1
+        else:
+            return 0
+
+
+class InitialCondition3(InitialCondition):
+
+    def __init__(self, left_bound, right_bound, config):
+        super().__init__(left_bound, right_bound, config)
+        # Set name of function
+        self.function_name = 'FourMixedTypes'
+
+        self.alpha = 10
+        self.delta = 0.005
+        self.beta = np.log(2) / (36 * self.delta**2)
+        self.a = 0.5
+        self.z = -0.7
+        pass
+
+    def _get_point(self, x):
+        if ((x >= -0.8) & (x <= -0.6)):
+            return 1/6 * (self._G(x, self.z-self.delta)
+                          + self._G(x, self.z+self.delta)
+                          + 4 * self._G(x, self.z))
+        if ((x >= -0.4) & (x <= -0.2)):
+            return 1
+        if ((x >= 0) & (x <= 0.2)):
+            return 1 - abs(10 * (x-0.1))
+        if ((x >= 0.4) & (x <= 0.6)):
+            return 1/6 * (self._F(x, self.a-self.delta)
+                          + self._F(x, self.a+self.delta)
+                          + 4 * self._F(x, self.a))
+        return 0
+
+    def _G(self, x, z):
+        return np.exp(-self.beta * (x-z)**2)
+
+    def _F(self, x, a):
+        return np.sqrt(max(1 - self.alpha**2 * (x-a)**2, 0))
+
+
+class InitialCondition4(InitialCondition):
+
+    def __init__(self, left_bound, right_bound, config):
+        super().__init__(left_bound, right_bound, config)
+        # Set name of function
+        self.function_name = 'Linear'
+
+        self.factor = config.pop('factor', 1)
+        pass
+
+    def _get_point(self, x):
+        return self.factor * x
+
+
+class InitialCondition5(InitialCondition):
+
+    def __init__(self, left_bound, right_bound, config):
+        super().__init__(left_bound, right_bound, config)
+        # Set name of function
+        self.function_name = 'LinearAbsolut'
+
+        self.factor = config.pop('factor', 1)
+        pass
+
+    def _get_point(self, x):
+        return self.factor * abs(x)
+
+
+class InitialCondition6(InitialCondition):
+
+    def __init__(self, left_bound, right_bound, config):
+        super().__init__(left_bound, right_bound, config)
+        # Set name of function
+        self.function_name = 'ConstantWithDiscontinuity'
+
+        self.x0 = config.pop('x0', 0)
+        self.left_factor = config.pop('left_factor', 1)
+        self.right_factor = config.pop('right_factor', 0.5)
+        pass
+
+    def _get_point(self, x):
+        return self.left_factor * (x <= self.x0) \
+            + self.right_factor * (x > self.x0)