Changeset 3510 for development/pyvolution-1d/quantity.py

Timestamp:

Aug 21, 2006, 10:03:42 AM (18 years ago)

Author:

jakeman

Message:

Files now contain inmplementation of method in which advection terms and
pressure terms are split. problems are present.

File:

• development/pyvolution-1d/quantity.py (modified) (5 diffs)

development/pyvolution-1d/quantity.py

@@ -51 +51 @@
         #self.edge_values = zeros((N, 2), Float)
         #edge values are values of the ends of each interval
-        
-        #does oe dimension need edge values???
-
+      
         #Intialise centroid values
         self.interpolate()
@@ -414 +412 @@
         self.centroid_values += timestep*self.explicit_update
 
+        #SECOND ORDER RUNGE_KUTTA
+        #Re-evaluate source term with updated centroid values
+        #and update conserved quantities accordingly
+        """
+        self.explicit_update = zeros(N, Float)
+        self.domain.compute_forcing_terms()
+        self.centroid_values += 0.5*timestep*(explicit_update
+        """
+        
 ##         #Semi implicit updates
 ##         denominator = ones(N, Float)-timestep*self.semi_implicit_update
@@ -679 +686 @@
     """
 
-    def limit(self):
-        """Limit slopes for each volume to eliminate artificial variance
+    """def limit(self):
+        Limit slopes for each volume to eliminate artificial variance
         introduced by e.g. second order extrapolator
 
@@ -690 +697 @@
         postcondition:
         vertex values are updated
-        """
-
+        
         from Numeric import zeros, Float
 
         N = self.domain.number_of_elements
-        #beta = self.beta
-        beta = 0.8
+        beta = self.beta
+        #beta = 0.8
 
         qc = self.centroid_values
@@ -741 +747 @@
                 qv[k,i] = qc[k] + phi*dq[k,i]
 
-        
-
+    """
+   
+    
+    def limit(self):
+        """Limit slopes for each volume to eliminate artificial variance
+         introduced by e.g. second order extrapolator
+         
+        This is an unsophisticated limiter as it does not take into
+        account dependencies among quantities.
+
+        precondition:
+        vertex values are estimated from gradient
+        postcondition:
+        vertex values are updated
+
+        """
+        import sys
+        from Numeric import zeros, Float
+        from util import minmod, minmod_kurganov, maxmod, vanleer
+
+        N = self.domain.number_of_elements
+        limiter = self.domain.limiter
+        limiter_type = self.domain.limiter_type
+            
+        qc = self.centroid_values
+        qv = self.vertex_values
+
+        #Find min and max of this and neighbour's centroid values
+        beta_p = zeros(N,Float)
+        beta_m = zeros(N,Float)
+        beta_x = zeros(N,Float)
+        C = self.domain.centroids
+        X = self.domain.vertices
+
+        for k in range(N):
+        
+            n0 = self.domain.neighbours[k,0]
+            n1 = self.domain.neighbours[k,1]
+            if limiter_type == "slope":
+                if ( n0 >= 0) & (n1 >= 0):
+                    #SLOPE DERIVATIVE LIMIT
+                    beta_p[k] = (qc[k]-qc[k-1])/(C[k]-C[k-1])
+                    beta_m[k] = (qc[k+1]-qc[k])/(C[k+1]-C[k])
+                    beta_x[k] = (qc[k+1]-qc[k-1])/(C[k+1]-C[k-1])
+            elif limiter_type == "flux":
+                if (n0 >= 0) & (n1 >= 0):
+                    # Check denominator not zero
+                    if (qc[k+1]-qc[k]) == 0.0:
+                        beta_p[k] = float(sys.maxint)
+                        beta_m[k] = float(sys.maxint)
+                    else:
+                        #STEVE LIMIT
+                        beta_p[k] = (qc[k]-qc[k-1])/(qc[k+1]-qc[k])
+                        beta_m[k] = (qc[k+2]-qc[k+1])/(qc[k+1]-qc[k])
+
+        #Deltas between vertex and centroid values
+        dq = zeros(qv.shape, Float)
+        for i in range(2):
+            dq[:,i] =self.domain.vertices[:,i]-self.domain.centroids
+            
+        #Phi limiter
+        for k in range(N):
+            if limiter_type == "slope":
+                if limiter == "minmod":
+                    phi = minmod(beta_p[k],beta_m[k])
+
+                elif limiter == "minmod_kurganov":
+                    # Also known as monotonized central difference limiter
+                    # if theta = 2.0
+                    theta = 2.0 
+                    phi = minmod_kurganov(theta*beta_p[k],theta*beta_m[k],beta_x[k])
+                elif limiter == "superbee":
+                    slope1 = minmod(beta_m[k],2.0*beta_p[k])
+                    slope2 = minmod(2.0*beta_m[k],beta_p[k])
+                    phi = maxmod(slope1,slope2)
+                    #phi = max(0.0,min(1.0,2.0*beta_m[k]),min(2.0,beta_m[k]))+max(0.0,min(1.0,2.0*beta_p[k]),min(2.0,beta_p[k]))-1.0
+
+                elif limiter == "vanleer":
+                    phi = vanleer(beta_p[k],beta_m[k])
+
+
+                elif limiter == "muscl":
+
+                    #MINMOD
+                    #phi = minmod(1.0,beta_m[k])
+                    #SUPERBEE
+                    #phi = max(0.0,min(2.0*beta_m[k],1.0),min(beta_m[k],2.0))
+                    #VAN LEER
+                    phi = (beta_m[k]+abs(beta_m[k]))/(1.0+abs(beta_m[k]))
+                    
+                for i in range(2):
+                    qv[k,i] = qc[k] + phi*dq[k,i]
+                
+            elif limiter_type == "flux":
+                phi = 0.0
+                if limiter == "flux_minmod":
+                    #FLUX MINMOD
+                    phi = minmod_kurganov(1.0,beta_m[k],beta_p[k])
+                elif limiter == "flux_superbee":
+                    #FLUX SUPERBEE
+                    phi = max(0.0,min(1.0,2.0*beta_m[k]),min(2.0,beta_m[k]))+max(0.0,min(1.0,2.0*beta_p[k]),min(2.0,beta_p[k]))-1.0
+                elif limiter == "flux_muscl":
+                    #FLUX MUSCL
+                    phi = max(0.0,min(2.0,2.0*beta_m[k],2.0*beta_p[k],0.5*(beta_m[k]+beta_p[k])))
+                elif limiter == "flux_vanleer":
+                    #FLUX VAN LEER
+                    phi = (beta_m[k]+abs(beta_m[k]))/(1.0+abs(beta_m[k]))+(beta_p[k]+abs(beta_p[k]))/(1.0+abs(beta_p[k]))-1.0
+
+                #Then update using phi limiter
+                n = self.domain.neighbours[k,1]
+                if n>=0:
+                    #qv[k,0] = qc[k] - 0.5*phi*(qc[k+1]-qc[k])
+                    #qv[k,1] = qc[k] + 0.5*phi*(qc[k+1]-qc[k])
+                    qv[k,0] = qc[k] + 0.5*phi*(qv[k,0]-qc[k])
+                    qv[k,1] = qc[k] + 0.5*phi*(qv[k,1]-qc[k])
+                else:
+                    qv[k,i] = qc[k]
+                    
+            
 def newLinePlot(title='Simple Plot'):
     import Gnuplot