modellib/py_src/temperature.py

# $Id$

from esys.escript import *
from esys.escript.modelframe import Model,IterationDivergenceError
from esys.escript.linearPDEs import AdvectivePDE,LinearPDE
import numarray


class TemperatureAdvection(Model):
       """

       The conservation of internal heat energy is given by

       M{S{rho} c_p ( dT/dt+v[j]*grad(T)[j])-grad(\kappa grad(T)_{,i}=Q}

       M{n_i\kappa T_{,i}=0}

       it is assummed that M{\rho c_p} is constant in time.

       solved by Taylor Galerkin method

       """
       def __init__(self,debug=False):
           Model.__init__(self,debug=debug)
           self.declareParameter(domain=None, \
                                 temperature=1., \
                                 velocity=numarray.zeros([3]),
                                 density=1., \
                                 heat_capacity=1., \
                                 thermal_permabilty=1., \
                                 # reference_temperature=0., \
                                 # radiation_coefficient=0., \
                                 thermal_source=0., \
                                 fixed_temperature=0.,
                                 location_fixed_temperature=Data(),
                                 safety_factor=0.1)

       def doInitialization(self):
           self.__pde=LinearPDE(self.domain)
           self.__pde.setSymmetryOn()
           self.__pde.setReducedOrderOn()
           self.__pde.setSolverMethod(self.__pde.LUMPING)
           self.__pde.setValue(D=self.heat_capacity*self.density)

       def getSafeTimeStepSize(self,dt):
           """
           returns new step size
           """
           h=self.domain.getSize()
           return self.safety_factor*inf(h**2/(h*abs(self.heat_capacity*self.density)*length(self.velocity)+self.thermal_permabilty))

       def G(self,T,alpha):
           """
           tangential operator for taylor galerikin
           """
           g=grad(T)
           self.__pde.setValue(X=-self.thermal_permabilty*g, \
                               Y=self.thermal_source-self.__rhocp*inner(self.velocity,g), \
                               r=(self.__fixed_T-self.temperature)*alpha,\
                               q=self.location_fixed_temperature)
           return self.__pde.getSolution()
           

       def doStepPostprocessing(self,dt):
           """
           perform taylor galerkin step
           """
           T=self.temperature
       self.__rhocp=self.heat_capacity*self.density
           self.__fixed_T=self.fixed_temperature
           self.temperature=dt*self.G(dt/2*self.G(T,1./dt)+T,1./dt)+T
           self.trace("Temperature range is %e %e"%(inf(self.temperature),sup(self.temperature)))
1	# $Id$
2
3	from esys.escript import *
4	from esys.escript.modelframe import Model,IterationDivergenceError
5	from esys.escript.linearPDEs import AdvectivePDE,LinearPDE
6	import numarray
7
8
9	class TemperatureAdvection(Model):
10	"""
11
12	The conservation of internal heat energy is given by
13
14	M{S{rho} c_p ( dT/dt+v[j]*grad(T)[j])-grad(\kappa grad(T)_{,i}=Q}
15
16	M{n_i\kappa T_{,i}=0}
17
18	it is assummed that M{\rho c_p} is constant in time.
19
20	solved by Taylor Galerkin method
21
22	"""
23	def __init__(self,debug=False):
24	Model.__init__(self,debug=debug)
25	self.declareParameter(domain=None, \
26	temperature=1., \
27	velocity=numarray.zeros([3]),
28	density=1., \
29	heat_capacity=1., \
30	thermal_permabilty=1., \
31	# reference_temperature=0., \
32	# radiation_coefficient=0., \
33	thermal_source=0., \
34	fixed_temperature=0.,
35	location_fixed_temperature=Data(),
36	safety_factor=0.1)
37
38	def doInitialization(self):
39	self.__pde=LinearPDE(self.domain)
40	self.__pde.setSymmetryOn()
41	self.__pde.setReducedOrderOn()
42	self.__pde.setSolverMethod(self.__pde.LUMPING)
43	self.__pde.setValue(D=self.heat_capacity*self.density)
44
45	def getSafeTimeStepSize(self,dt):
46	"""
47	returns new step size
48	"""
49	h=self.domain.getSize()
50	return self.safety_factorinf(h2/(habs(self.heat_capacityself.density)length(self.velocity)+self.thermal_permabilty))
51
52	def G(self,T,alpha):
53	"""
54	tangential operator for taylor galerikin
55	"""
56	g=grad(T)
57	self.__pde.setValue(X=-self.thermal_permabilty*g, \
58	Y=self.thermal_source-self.__rhocp*inner(self.velocity,g), \
59	r=(self.__fixed_T-self.temperature)*alpha,\
60	q=self.location_fixed_temperature)
61	return self.__pde.getSolution()
62
63
64	def doStepPostprocessing(self,dt):
65	"""
66	perform taylor galerkin step
67	"""
68	T=self.temperature
69	self.__rhocp=self.heat_capacity*self.density
70	self.__fixed_T=self.fixed_temperature
71	self.temperature=dtself.G(dt/2self.G(T,1./dt)+T,1./dt)+T
72	self.trace("Temperature range is %e %e"%(inf(self.temperature),sup(self.temperature)))
Name	Value
svn:eol-style	native
svn:keywords	Author Date Id Revision