/[escript]/temp_trunk_copy/modellib/py_src/flow.py
ViewVC logotype

Diff of /temp_trunk_copy/modellib/py_src/flow.py

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

trunk/esys2/modellib/py_src/flow.py revision 144 by jgs, Mon Jul 25 05:42:21 2005 UTC trunk/modellib/py_src/flow.py revision 918 by gross, Wed Jan 3 06:30:00 2007 UTC
# Line 1  Line 1 
1  # $Id$  # $Id$
2    
3    __copyright__="""  Copyright (c) 2006 by ACcESS MNRF
4                        http://www.access.edu.au
5                    Primary Business: Queensland, Australia"""
6    __license__="""Licensed under the Open Software License version 3.0
7                 http://www.opensource.org/licenses/osl-3.0.php"""
8    
9  from esys.escript import *  from esys.escript import *
10  from esys.modelframe import Model,IterationDivergenceError  from esys.escript.modelframe import Model,IterationDivergenceError
11  from esys.linearPDEs import LameEquation  from esys.escript.linearPDEs import LameEquation
12    
13  class SteadyIncompressibleFlow(Model):  class SteadyIncompressibleFlow(Model):
14         """         """
15    
16           M{-\left(\eta\left(v_{i,j}+v_{j,i}\right)\right)_{,j}+p_{,i}=F_i}
17          
18           M{\sigma_{ij}=2\eta D_{ij}-p\,\delta_{ij}}
19    
20           M{D_{ij}=\frac{1}{2}\left( v_{j,i} + v_{i,j }\right)}
21          
22           M{v_{k,k} = 0}
23    
                    \f[  
                    -\left(\eta\left(v_{i,j}+v_{j,i}\right)\right)_{,j}+p_{,i}=F_i  
                    \f]  
   
                    \f[  
                    \sigma_{ij}=2\eta D_{ij}-p\,\delta_{ij}  
                    \f[  
                    D_{ij}=\frac{1}{2}\left( v_{j,i} + v_{i,j }\right) \; .  
                    \f]  
   
                    \f[  
                    -v_{k,k} = 0 \; .  
                    \f]  
                     
24         """         """
25    
26         def __init__(self,debug=False):         def __init__(self,**kwargs):
27             """set up model"""             """
28             Model.__init__(self,debug=debug)             set up model
29               """
30               Model.__init__(self,**kwargs)
31             self.declareParameter(domain=None, \             self.declareParameter(domain=None, \
32                                   velocity=0., \                                   velocity=0., \
33                                   pressure=0., \                                   pressure=0., \
34                                   viscocity=1., \                                   viscosity=1., \
35                                   internal_force=0., \                                   internal_force=0., \
36                                   location_prescribed_velocities=Data(), \                                   location_prescribed_velocity=None, \
37                                   prescribed_velocities=Data(), \                                   prescribed_velocity=None, \
38                                   rel_tol=1.e-8,abs_tol=1.e-15,max_iter=10,relaxation=0.01)                                   rel_tol=1.e-3,abs_tol=0.,max_iter=10,relaxation=0.0001)
39             self.__iter=0             self.__iter=0
40    
41         def doInitialization(self,t):         def doInitialization(self):
42             """initialize model"""             """
43             self.__pressure_history=None             initialize model
44             self.__dt_history=None             """
45               self.__p_old=None
46               self.__p_very_old=None
47               self.__dt_old=None
48             self.__pde=LameEquation(self.domain)             self.__pde=LameEquation(self.domain)
49               self.__pde.setSolverMethod(LameEquation.DIRECT)
50               if self.location_prescribed_velocity == None: self.location_prescribed_velocit=Data()
51               if self.prescribed_velocity == None: self.prescribed_velocity=Data()
52    
53         def stress(self):         def stress(self):
54             """returns current stress"""             """
55             return 2*self.viscocity*self.stretching-self.pressure             returns current stress"""
56               return 2*self.viscosity*self.stretching-self.pressure*kronecker(self.domain)
57    
58         def stretching(self):         def stretching(self):
59             """returns stertching tensor"""             """
60               returns stertching tensor
61               """
62             g=grad(self.velocity)             g=grad(self.velocity)
63             return (g+transpose(g))/2             return (g+transpose(g))/2
64              
65         def doIterationInitialization(self,dt):         def doStepPreprocessing(self,dt):
66              """              """
67                 step up pressure iteration              step up pressure iteration
68    
69                 if run within a time dependend problem extrapolation of pressure from previous time steps is used to              if run within a time dependend problem extrapolation of pressure from previous time steps is used to
70                 get an initial guess              get an initial guess (that needs some work!!!!!!!)
71              """              """
72              if self.__dt_history==None:              self.__iter=0
73                 self.__pressure_history=self.pressure              self.__diff=1.e40
74                 self.__iter=0              if not self.__p_old==None:
75              else:                 if self.__p_very_old==None:
76                 self.__pressure_history,self.pressure=self.pressure,(1.+dt/self.__dt_history)*self.pressure+dt/self.__dt_history*self.__pressure_history                    self.pressure=self.__p_old
77                 self.__iter=1                 else:
78              self.diff=1.e400                    self.pressure=(1.+dt/self.__dt_old)*self.__p_old-dt/self.__dt_old*self.__p_very_old
79    
80         def doIterationStep(self,dt):         def doStep(self,dt):
81            """            """
82    
83               performs an iteration step of the penalty method.            performs an iteration step of the penalty method.
84               IterationDivergenceError is raised if pressure error cannot be reduced or max_iter is reached.            IterationDivergenceError is raised if pressure error cannot be reduced or max_iter is reached.
85    
86            """            """
87            penalty=self.viscosity/self.relaxation            penalty=self.viscosity/self.relaxation
88            self.__pde.setValue(lame_lambda=self.viscosity, \            self.__pde.setValue(lame_mu=self.viscosity, \
89                                lame_my=penalty, \                                lame_lambda=penalty, \
90                                F=F, \                                F=self.internal_force, \
91                                sigma0=self.pressure*kronecker(self.__pde.getDomain()), \                                sigma=self.pressure*kronecker(self.__pde.getDomain()), \
92                                r=self.location_prescribed_velocities, \                                r=self.prescribed_velocity, \
93                                q=self.location_prescribed_velocities)                                q=self.location_prescribed_velocity)
94            self.__pde.setTolerance(self.tol*1.e-2)            self.__pde.setTolerance(self.rel_tol/10.)
95            self.velocity=self.pde.getSolution()            self.velocity=self.__pde.getSolution()
96            update=penalty*div(self.velocity)            update=penalty*div(self.velocity)
97            self.pressure=self.pressure-update            self.pressure=self.pressure-update
98            self.diff,diff=Lsup(update),self.diff            self.__diff,diff_old=Lsup(update),self.__diff
99            print "Pressure iteration: step %d: correction %e"%(self.__iter,self.diff/Lsup(self.pressure))            self.__iter+=1
100            if diff<=self.diff:            self.trace("velocity range %e:%e"%(inf(self.velocity),sup(self.velocity)))
101              self.trace("pressure range %e:%e"%(inf(self.pressure),sup(self.pressure)))
102              self.trace("pressure correction: %e"%self.__diff)
103              if self.__iter>2 and diff_old<self.__diff:
104                  self.trace("Pressure iteration failed!")
105                raise IterationDivergenceError,"no improvement in pressure iteration"                raise IterationDivergenceError,"no improvement in pressure iteration"
106              if self.__iter>self.max_iter:
107                  raise IterationDivergenceError,"Maximum number of iterations steps reached"
108    
109         def terminate(self):         def terminateIteration(self):
110            """iteration is terminated if relative pressure change is less then rel_tol"""            """iteration is terminateIterationd if relative pressure change is less then rel_tol"""
111            if self.iter<2:            return self.__diff<=self.rel_tol*Lsup(self.pressure)+self.abs_tol
112                return False  
113            else:         def doStepPostprocessing(self,dt):
114               return self.diff<self.rel_tol*Lsup(self.pressure)+self.abs_tol            self.__dt_old=dt
115              self.__p_old,self.__p_very_old=self.pressure,self.__p_old
        def doIterationFinalization(self,dt):  
           self.__dt_history=dt  
 if __name__=="__main__":  
   
   
   
    from esys.modelframe import Link,Simulation,ExplicitSimulation  
    from esys.geometry import RectangularDomain,VectorConstrainer  
    from esys.probe import Probe  
    from esys.input import InterpolatedTimeProfile,GausseanProfile  
   
    dom=RectangularDomain()  
    constraints=VectorConstrainer()  
    constraints.domain=Link(dom)  
    constraints.left=[1,1,1]  
    constraints.right=[1,1,1]  
    constraints.top=[1,1,1]  
    constraints.bottom=[1,1,1]  
    constraints.front=[1,1,1]  
    constraints.back=[1,1,1]  
   
    flow=SteadyIncompressibleFlow()  
    flow.domain=Link(dom)  
    flow.velocity=0.  
    flow.pressure=0.  
    flow.viscocity=1.  
    flow.internal_force=[1.,1.,0.]  
    flow.location_prescribed_velocities=Link(constraints,"location_of_constraint")  
    flow.prescribed_velocities=Data(), \  
   
    ptest=Probe()  
    ptest.reference("x[0]+x[1]")  
    ptest.value=Link(flow,"pressure")  
   
    s=ExplicitSimulation([dom,constraints,flow,ptest])  
    s.writeXML()  
    s.run()  

Legend:
Removed from v.144  
changed lines
  Added in v.918

  ViewVC Help
Powered by ViewVC 1.1.26