Changed 'xi' to 'z'. Removed unnecessary imports.

Basis_Function.py

@@ -7,14 +7,14 @@ import numpy as np
 from sympy import Symbol, integrate
 
 x = Symbol('x')
-xi = Symbol('z')
+z = Symbol('z')
 
 
 class Vector(object):
     def __init__(self, polynomial_degree):
         self._polynomial_degree = polynomial_degree
         self._basis = self._build_basis_vector(x)
-        self._wavelet = self._build_wavelet_vector(xi)
+        self._wavelet = self._build_wavelet_vector(z)
 
     def get_basis_vector(self):
         return self._basis
@@ -90,8 +90,8 @@ class OrthonormalLegendre(Legendre):
                          up to degree 4 for this application')
 
     def get_basis_projections(self):
-        basis_projection_left = self._build_basis_matrix(xi, 0.5 * (xi - 1))
-        basis_projection_right = self._build_basis_matrix(xi, 0.5 * (xi + 1))
+        basis_projection_left = self._build_basis_matrix(z, 0.5 * (z - 1))
+        basis_projection_right = self._build_basis_matrix(z, 0.5 * (z + 1))
         return basis_projection_left, basis_projection_right
 
     def _build_basis_matrix(self, first_param, second_param):
@@ -101,14 +101,14 @@ class OrthonormalLegendre(Legendre):
             for j in range(self._polynomial_degree + 1):
                 entry = integrate(self._basis[i].subs(x, first_param)
                                   * self._basis[j].subs(x, second_param),
-                                  (xi, -1, 1))
+                                  (z, -1, 1))
                 row.append(np.float64(entry))
             matrix.append(row)
         return matrix
 
     def get_multiwavelet_projections(self):
-        wavelet_projection_left = self._build_multiwavelet_matrix(xi, -0.5*(xi-1), True)
-        wavelet_projection_right = self._build_multiwavelet_matrix(xi, 0.5*(xi+1), False)
+        wavelet_projection_left = self._build_multiwavelet_matrix(z, -0.5*(z-1), True)
+        wavelet_projection_right = self._build_multiwavelet_matrix(z, 0.5*(z+1), False)
         return wavelet_projection_left, wavelet_projection_right
 
     def _build_multiwavelet_matrix(self, first_param, second_param, is_left_matrix):
@@ -116,8 +116,8 @@ class OrthonormalLegendre(Legendre):
         for i in range(self._polynomial_degree+1):
             row = []
             for j in range(self._polynomial_degree+1):
-                entry = integrate(self._basis[i].subs(x, first_param) * self._wavelet[j].subs(xi, second_param),
-                                  (xi, -1, 1))
+                entry = integrate(self._basis[i].subs(x, first_param) * self._wavelet[j].subs(z, second_param),
+                                  (z, -1, 1))
                 if is_left_matrix:
                     entry = entry * (-1)**(j + self._polynomial_degree + 1)
                 row.append(np.float64(entry))

DG_Approximation.py

@@ -14,10 +14,11 @@ TODO: Restructure Vectors_of_Polynomials -> Done
 TODO: Rename Vectors_of_Polynomials -> Done (Basis_Function)
 TODO: Contemplate how to make shock tubes comparable
 TODO: Implement type check for all kwargs and configs -> Done (not recommended for Python)
+TODO: Create a Conda environment with dependencies -> Done
 
 """
 import numpy as np
-from sympy import Symbol, integrate
+from sympy import Symbol
 import math
 import matplotlib.pyplot as plt
 
@@ -29,7 +30,6 @@ import Update_Scheme
 from Basis_Function import OrthonormalLegendre
 
 x = Symbol('x')
-xi = Symbol('z')
 
 
 class DGScheme(object):

Main.py

@@ -20,21 +20,22 @@ xL = -1
 xR = 1
 
 detector_config = {}
+init_config = {}
+limiter_config = {}
+quadrature_config = {}
+
 fold_len = 16
 whisker_len = 3
 
 detector_config['fold_len'] = fold_len
 detector_config['whisker_len'] = whisker_len
 
-init_config = {}
 init_config['factor'] = 4
 init_config['left_factor'] = 3
 
-limiter_config = {}
 limiter_config['mod_factor'] = 0
 limiter_config['erase_degree'] = 0
 
-quadrature_config = {}
 quadrature_config['num_eval_points'] = 12  # 12
 
 detector = 'Theoretical'

Troubled_Cell_Detector.py

@@ -7,10 +7,10 @@ import os
 import numpy as np
 import matplotlib.pyplot as plt
 import seaborn as sns
-from sympy import Symbol, integrate
+from sympy import Symbol
 
 x = Symbol('x')
-xi = Symbol('z')
+z = Symbol('z')
 
 
 class TroubledCellDetector(object):
@@ -232,9 +232,9 @@ class WaveletDetector(TroubledCellDetector):
         # for degree in range(self._polynomial_degree + 1):
         #     leftMesh = coarse_projection[degree] * basis[degree].subs(x, -1 / 2)
         #     rightMesh = coarse_projection[degree] * basis[degree].subs(x, 1 / 2)
-        #     leftTest = multiwavelet_coeffs[degree] * wavelet[degree].subs(xi, 1 / 2) \
+        #     leftTest = multiwavelet_coeffs[degree] * wavelet[degree].subs(z, 1 / 2) \
         #                * (-1)**(self._polynomial_degree + 1 + degree)
-        #     rightTest = multiwavelet_coeffs[degree] * wavelet[degree].subs(xi, 1 / 2)
+        #     rightTest = multiwavelet_coeffs[degree] * wavelet[degree].subs(z, 1 / 2)
         #     newRowMesh = []
         #     newRowTest = []
         #     for i in range(len(coarse_projection[0])):
@@ -254,7 +254,7 @@ class WaveletDetector(TroubledCellDetector):
                                 for value in [-0.5, 0.5]]
                                for degree in range(self._polynomial_degree + 1)]
 
-        wavelet_projection = [[multiwavelet_coeffs[degree][cell] * wavelet[degree].subs(xi, 0.5) * value
+        wavelet_projection = [[multiwavelet_coeffs[degree][cell] * wavelet[degree].subs(z, 0.5) * value
                                for cell in range(self._num_coarse_grid_cells)
                                for value in [(-1) ** (self._polynomial_degree + degree + 1), 1]]
                               for degree in range(self._polynomial_degree + 1)]