/[escript]/trunk/esys2/escript/py_src/linearPDEs.py

Diff of /trunk/esys2/escript/py_src/linearPDEs.py

Parent Directory | Revision Log | View Patch Patch

-revision 110 by jgs,
Mon Feb 14 04:14:42 2005 UTC
+revision 122 by jgs,
Thu Jun  9 05:38:05 2005 UTC
 Line 3
  ## @file linearPDEs.py
  """
- @brief Functions and classes for linear PDEs
+ Functions and classes for linear PDEs
  """
  import escript
 Line 13 
 import numarray
  def _CompTuple2(t1,t2):
     """
-    @brief
+    Compare two tuples
-    @param t1
+    \param t1 The first tuple
-    @param t2
+    \param t2 The second tuple
     """
     dif=t1[0]+t1[1]-(t2[0]+t2[1])
     if dif<0: return 1
     elif dif>0: return -1
     else: return 0
+ def ELMAN_RAMAGE(P):
+     return (P-1.).wherePositive()*0.5*(1.-1./(P+1.e-15))
+ def SIMPLIFIED_BROOK_HUGHES(P):
+     c=(P-3.).whereNegative()
+     return P/6.*c+1./2.*(1.-c)
+ def HALF(P):
+     return escript.Scalar(0.5,P.getFunctionSpace())
  class PDECoefficient:
      """
-     @brief
+     A class for PDE coefficients
      """
      # identifier for location of Data objects defining COEFFICIENTS
      INTERIOR=0
-Line 44 
 class PDECoefficient:
+Line 55 
 class PDECoefficient:
      BOTH=7
      def __init__(self,where,pattern,altering):
         """
-        @brief Initialise a PDE Coefficient type
+        Initialise a PDE Coefficient type
         """
         self.what=where
         self.pattern=pattern
-Line 53 
 class PDECoefficient:
+Line 64 
 class PDECoefficient:
      def resetValue(self):
         """
-        @brief resets coefficient value to default
+        resets coefficient value to default
         """
         self.value=escript.Data()
      def getFunctionSpace(self,domain):
         """
-        @brief defines the FunctionSpace of the coefficient on the domain
+        defines the FunctionSpace of the coefficient on the domain
-        @param domain
+        @param domain:
         """
         if self.what==self.INTERIOR: return escript.Function(domain)
         elif self.what==self.BOUNDARY: return escript.FunctionOnBoundary(domain)
-Line 70 
 class PDECoefficient:
+Line 81 
 class PDECoefficient:
      def getValue(self):
         """
-        @brief returns the value of the coefficient:
+        returns the value of the coefficient:
         """
         return self.value
      def setValue(self,newValue):
         """
-        @brief set the value of the coefficient to new value
+        set the value of the coefficient to new value
         """
         self.value=newValue
      def isAlteringOperator(self):
          """
-     @brief return true if the operator of the PDE is changed when the coefficient is changed
+     return true if the operator of the PDE is changed when the coefficient is changed
      """
          if self.altering==self.OPERATOR or self.altering==self.BOTH:
              return not None
-Line 91 
 class PDECoefficient:
+Line 102 
 class PDECoefficient:
      def isAlteringRightHandSide(self):
          """
-     @brief return true if the right hand side of the PDE is changed when the coefficient is changed
+     return true if the right hand side of the PDE is changed when the coefficient is changed
      """
          if self.altering==self.RIGHTHANDSIDE or self.altering==self.BOTH:
              return not None
-Line 100 
 class PDECoefficient:
+Line 111 
 class PDECoefficient:
      def estimateNumEquationsAndNumSolutions(self,shape=(),dim=3):
         """
-        @brief tries to estimate the number of equations in a given tensor shape for a given spatial dimension dim
+        tries to estimate the number of equations in a given tensor shape for a given spatial dimension dim
-        @param shape
+        @param shape:
-        @param dim
+        @param dim:
         """
         if len(shape)>0:
             num=max(shape)+1
-Line 124 
 class PDECoefficient:
+Line 135 
 class PDECoefficient:
      def buildShape(self,e=1,u=1,dim=3):
          """
-     @brief builds the required shape for a given number of equations e, number of unknowns u and spatial dimension dim
+     builds the required shape for a given number of equations e, number of unknowns u and spatial dimension dim
-     @param e
+     @param e:
-     @param u
+     @param u:
-     @param dim
+     @param dim:
      """
          s=()
          for i in self.pattern:
-Line 142 
 class PDECoefficient:
+Line 153 
 class PDECoefficient:
  class LinearPDE:
     """
-    @brief Class to handel a linear PDE
+    Class to handle a linear PDE
     class to define a linear PDE of the form
+    \f[
       -(A_{ijkl}u_{k,l})_{,j} -(B_{ijk}u_k)_{,j} + C_{ikl}u_{k,l} +D_{ik}u_k = - (X_{ij})_{,j} + Y_i
+    \f]
-      with boundary conditons:
+    with boundary conditons:
-         n_j*(A_{ijkl}u_{k,l}+B_{ijk}u_k)_{,j} + d_{ik}u_k = - n_j*X_{ij} + y_i
+    \f[
+    n_j*(A_{ijkl}u_{k,l}+B_{ijk}u_k)_{,j} + d_{ik}u_k = - n_j*X_{ij} + y_i
+    \f]
-     and contact conditions
+    and contact conditions
-         n_j*(A_{ijkl}u_{k,l}+B_{ijk}u_k)_{,j} + d_contact_{ik}[u_k] = - n_j*X_{ij} + y_contact_i
+    \f[
+    n_j*(A_{ijkl}u_{k,l}+B_{ijk}u_k)_{,j} + d_contact_{ik}[u_k] = - n_j*X_{ij} + y_contact_i
+    \f]
-     and constraints:
+    and constraints:
-          u_i=r_i where q_i>0
+    \f[
+    u_i=r_i \quad \mathrm{where} \quad q_i>0
+    \f]
     """
     TOL=1.e-13
-Line 172 
 class LinearPDE:
+Line 191 
 class LinearPDE:
     SSOR=util.SSOR
     GMRES=util.GMRES
     PRES20=util.PRES20
+    ILU0=util.ILU0
+    JACOBI=util.JACOBI
     def __init__(self,domain,numEquations=0,numSolutions=0):
       """
-      @brief initializes a new linear PDE.
+      initializes a new linear PDE.
-      @param args
+      @param args:
       """
       # COEFFICIENTS can be overwritten by subclasses:
       self.COEFFICIENTS={
-Line 220 
 class LinearPDE:
+Line 241 
 class LinearPDE:
     def createCoefficient(self, name):
       """
-      @brief create a data object corresponding to coefficient name
+      create a data object corresponding to coefficient name
-      @param name
+      @param name:
       """
       return escript.Data(shape = getShapeOfCoefficient(name), \
                           what = getFunctionSpaceForCoefficient(name))
-Line 231 
 class LinearPDE:
+Line 252 
 class LinearPDE:
     def getCoefficient(self,name):
       """
-      @brief return the value of the parameter name
+      return the value of the parameter name
-      @param name
+      @param name:
       """
       return self.COEFFICIENTS[name].getValue()
     def getCoefficientOfPDE(self,name):
       """
-      @brief return the value of the coefficient name of the general PDE. This method is called by the assembling routine
+      return the value of the coefficient name of the general PDE.
-             it can be overwritten to map coefficients of a particualr PDE to the general PDE.
+      This method is called by the assembling routine it can be
-      @param name
+      overwritten to map coefficients of a particualr PDE to the general PDE.
+      @param name:
       """
       return self.getCoefficient(name)
     def hasCoefficient(self,name):
        """
-       @brief return true if name is the name of a coefficient
+       return true if name is the name of a coefficient
-       @param name
+       @param name:
        """
        return self.COEFFICIENTS.has_key(name)
     def getFunctionSpaceForEquation(self):
       """
-      @brief return true if the test functions should use reduced order
+      return true if the test functions should use reduced order
       """
       return self.__row_function_space
     def getFunctionSpaceForSolution(self):
       """
-      @brief return true if the interpolation of the solution should use reduced order
+      return true if the interpolation of the solution should use reduced order
       """
       return self.__column_function_space
     def setValue(self,**coefficients):
        """
-       @brief sets new values to coefficients
+       sets new values to coefficients
-       @param coefficients
+       @param coefficients:
        """
-       self._setValue(**coefficients)
+       self.__setValue(**coefficients)
     def cleanCoefficients(self):
       """
-      @brief resets all coefficients to default values.
+      resets all coefficients to default values.
       """
       for i in self.COEFFICIENTS.iterkeys():
           self.COEFFICIENTS[i].resetValue()
     def createNewCoefficient(self,name):
       """
-      @brief returns a new coefficient appropriate for coefficient name:
+      returns a new coefficient appropriate for coefficient name:
       """
       return escript.Data(0,self.getShapeOfCoefficient(name),self.getFunctionSpaceForCoefficient(name))
     def getShapeOfCoefficient(self,name):
       """
-      @brief return the shape of the coefficient name
+      return the shape of the coefficient name
-      @param name
+      @param name:
       """
       if self.hasCoefficient(name):
          return self.COEFFICIENTS[name].buildShape(self.getNumEquations(),self.getNumSolutions(),self.getDomain().getDim())
-Line 301 
 class LinearPDE:
+Line 324 
 class LinearPDE:
     def getFunctionSpaceForCoefficient(self,name):
       """
-      @brief return the atoms of the coefficient name
+      return the atoms of the coefficient name
-      @param name
+      @param name:
       """
       if self.hasCoefficient(name):
          return self.COEFFICIENTS[name].getFunctionSpace(self.getDomain())
-Line 312 
 class LinearPDE:
+Line 335 
 class LinearPDE:
     def alteredCoefficient(self,name):
       """
-      @brief annonced that coefficient name has been changed
+      announce that coefficient name has been changed
-      @param name
+      @param name:
       """
       if self.hasCoefficient(name):
          if self.COEFFICIENTS[name].isAlteringOperator(): self.__rebuildOperator()
-Line 325 
 class LinearPDE:
+Line 348 
 class LinearPDE:
     # ===== debug ==============================================================
     def setDebugOn(self):
         """
-        @brief
         """
         self.__debug=not None
     def setDebugOff(self):
         """
-        @brief
         """
         self.__debug=None
     def debug(self):
         """
-        @brief returns true if the PDE is in the debug mode
+        returns true if the PDE is in the debug mode
         """
         return self.__debug
     #===== Lumping ===========================
     def setLumpingOn(self):
        """
-       @brief indicates to use matrix lumping
+       indicates to use matrix lumping
        """
        if not self.isUsingLumping():
           if self.debug() : print "PDE Debug: lumping is set on"
-Line 353 
 class LinearPDE:
+Line 374 
 class LinearPDE:
     def setLumpingOff(self):
        """
-       @brief switches off matrix lumping
+       switches off matrix lumping
        """
        if self.isUsingLumping():
           if self.debug() : print "PDE Debug: lumping is set off"
-Line 362 
 class LinearPDE:
+Line 383 
 class LinearPDE:
     def setLumping(self,flag=False):
        """
-       @brief set the matrix lumping flag to flag
+       set the matrix lumping flag to flag
        """
        if flag:
           self.setLumpingOn()
-Line 371 
 class LinearPDE:
+Line 392 
 class LinearPDE:
     def isUsingLumping(self):
        """
-       @brief
        """
        return self.__lumping
     #============ method business =========================================================
     def setSolverMethod(self,solver=util.DEFAULT_METHOD):
         """
-        @brief sets a new solver
+        sets a new solver
         """
         if not solver==self.getSolverMethod():
             self.__solver_method=solver
-Line 387 
 class LinearPDE:
+Line 408 
 class LinearPDE:
     def getSolverMethod(self):
         """
-        @brief returns the solver method
+        returns the solver method
         """
         return self.__solver_method
     #============ tolerance business =========================================================
     def setTolerance(self,tol=1.e-8):
         """
-        @brief resets the tolerance to tol.
+        resets the tolerance to tol.
         """
         if not tol>0:
             raise ValueException,"Tolerance as to be positive"
-Line 404 
 class LinearPDE:
+Line 425 
 class LinearPDE:
         return
     def getTolerance(self):
         """
-        @brief returns the tolerance set for the solution
+        returns the tolerance set for the solution
         """
         return self.__tolerance
     #===== symmetry  flag ==========================
     def isSymmetric(self):
        """
-       @brief returns true is the operator is considered to be symmetric
+       returns true is the operator is considered to be symmetric
        """
        return self.__sym
     def setSymmetryOn(self):
        """
-       @brief sets the symmetry flag to true
+       sets the symmetry flag to true
        """
        if not self.isSymmetric():
           if self.debug() : print "PDE Debug: Operator is set to be symmetric"
-Line 426 
 class LinearPDE:
+Line 447 
 class LinearPDE:
     def setSymmetryOff(self):
        """
-       @brief sets the symmetry flag to false
+       sets the symmetry flag to false
        """
        if self.isSymmetric():
           if self.debug() : print "PDE Debug: Operator is set to be unsymmetric"
-Line 435 
 class LinearPDE:
+Line 456 
 class LinearPDE:
     def setSymmetryTo(self,flag=False):
       """
-      @brief sets the symmetry flag to flag
+      sets the symmetry flag to flag
-      @param flag
+      @param flag:
       """
       if flag:
          self.setSymmetryOn()
-Line 447 
 class LinearPDE:
+Line 468 
 class LinearPDE:
     #===== order reduction ==========================
     def setReducedOrderOn(self):
       """
-      @brief switches to on reduced order
+      switches to on reduced order
       """
       self.setReducedOrderForSolutionOn()
       self.setReducedOrderForEquationOn()
     def setReducedOrderOff(self):
       """
-      @brief switches to full order
+      switches to full order
       """
       self.setReducedOrderForSolutionOff()
       self.setReducedOrderForEquationOff()
     def setReducedOrderTo(self,flag=False):
       """
-      @brief sets order according to flag
+      sets order according to flag
-      @param flag
+      @param flag:
       """
       self.setReducedOrderForSolutionTo(flag)
       self.setReducedOrderForEquationTo(flag)
-Line 472 
 class LinearPDE:
+Line 493 
 class LinearPDE:
     #===== order reduction solution ==========================
     def setReducedOrderForSolutionOn(self):
       """
-      @brief switches to reduced order to interpolate solution
+      switches to reduced order to interpolate solution
       """
       new_fs=escript.ReducedSolution(self.getDomain())
       if self.getFunctionSpaceForSolution()!=new_fs:
-Line 482 
 class LinearPDE:
+Line 503 
 class LinearPDE:
     def setReducedOrderForSolutionOff(self):
       """
-      @brief switches to full order to interpolate solution
+      switches to full order to interpolate solution
       """
       new_fs=escript.Solution(self.getDomain())
       if self.getFunctionSpaceForSolution()!=new_fs:
-Line 492 
 class LinearPDE:
+Line 513 
 class LinearPDE:
     def setReducedOrderForSolutionTo(self,flag=False):
       """
-      @brief sets order for test functions according to flag
+      sets order for test functions according to flag
-      @param flag
+      @param flag:
       """
       if flag:
          self.setReducedOrderForSolutionOn()
-Line 504 
 class LinearPDE:
+Line 525 
 class LinearPDE:
     #===== order reduction equation ==========================
     def setReducedOrderForEquationOn(self):
       """
-      @brief switches to reduced order for test functions
+      switches to reduced order for test functions
       """
       new_fs=escript.ReducedSolution(self.getDomain())
       if self.getFunctionSpaceForEquation()!=new_fs:
-Line 514 
 class LinearPDE:
+Line 535 
 class LinearPDE:
     def setReducedOrderForEquationOff(self):
       """
-      @brief switches to full order for test functions
+      switches to full order for test functions
       """
       new_fs=escript.Solution(self.getDomain())
       if self.getFunctionSpaceForEquation()!=new_fs:
-Line 524 
 class LinearPDE:
+Line 545 
 class LinearPDE:
     def setReducedOrderForEquationTo(self,flag=False):
       """
-      @brief sets order for test functions according to flag
+      sets order for test functions according to flag
-      @param flag
+      @param flag:
       """
       if flag:
          self.setReducedOrderForEquationOn()
-Line 534 
 class LinearPDE:
+Line 555 
 class LinearPDE:
          self.setReducedOrderForEquationOff()
     # ==== initialization =====================================================================
-    def __makeNewOperator(self):
+    def __getNewOperator(self):
         """
-        @brief
         """
         return self.getDomain().newOperator( \
                             self.getNumEquations(), \
-Line 545 
 class LinearPDE:
+Line 565 
 class LinearPDE:
                             self.getFunctionSpaceForSolution(), \
                             self.__matrix_type)
-    def __makeNewRightHandSide(self):
+    def __makeFreshRightHandSide(self):
         """
-        @brief
         """
-        return escript.Data(0.,(self.getNumEquations(),),self.getFunctionSpaceForEquation(),True)
+        if self.debug() : print "PDE Debug: New right hand side allocated"
+        if self.getNumEquations()>1:
+            self.__righthandside=escript.Data(0.,(self.getNumEquations(),),self.getFunctionSpaceForEquation(),True)
+        else:
+            self.__righthandside=escript.Data(0.,(),self.getFunctionSpaceForEquation(),True)
+        return self.__righthandside
-    def __makeNewSolution(self):
+    def __getNewSolution(self):
         """
-        @brief
         """
-        return escript.Data(0.,(self.getNumSolutions(),),self.getFunctionSpaceForSolution(),True)
+        if self.debug() : print "PDE Debug: New right hand side allocated"
+        if self.getNumSolutions()>1:
+            return escript.Data(0.,(self.getNumSolutions(),),self.getFunctionSpaceForSolution(),True)
+        else:
+            return escript.Data(0.,(),self.getFunctionSpaceForSolution(),True)
-    def __getFreshOperator(self):
+    def __makeFreshOperator(self):
         """
-        @brief
         """
         if self.__operator.isEmpty():
-            self.__operator=self.__makeNewOperator()
+            self.__operator=self.__getNewOperator()
             if self.debug() : print "PDE Debug: New operator allocated"
         else:
             self.__operator.setValue(0.)
-Line 570 
 class LinearPDE:
+Line 596 
 class LinearPDE:
             if self.debug() : print "PDE Debug: Operator reset to zero"
         return self.__operator
-    def __getFreshRightHandSide(self):
-        """
-        @brief
-        """
-        if self.__righthandside.isEmpty():
-            self.__righthandside=self.__makeNewRightHandSide()
-            if self.debug() : print "PDE Debug: New right hand side allocated"
-        else:
-            print "fix self.__righthandside*=0"
-            self.__righthandside*=0.
-            if self.debug() : print "PDE Debug: Right hand side reset to zero"
-        return  self.__righthandside
     #============ some serivice functions  =====================================================
     def getDomain(self):
       """
-      @brief returns the domain of the PDE
+      returns the domain of the PDE
       """
       return self.__domain
     def getDim(self):
       """
-      @brief returns the spatial dimension of the PDE
+      returns the spatial dimension of the PDE
       """
       return self.getDomain().getDim()
     def getNumEquations(self):
       """
-      @brief returns the number of equations
+      returns the number of equations
       """
       if self.__numEquations>0:
           return self.__numEquations
-Line 607 
 class LinearPDE:
+Line 620 
 class LinearPDE:
     def getNumSolutions(self):
       """
-      @brief returns the number of unknowns
+      returns the number of unknowns
       """
       if self.__numSolutions>0:
          return self.__numSolutions
-Line 617 
 class LinearPDE:
+Line 630 
 class LinearPDE:
     def checkSymmetry(self,verbose=True):
        """
-       @brief returns if the Operator is symmetric. This is a very expensive operation!!! The symmetry flag is not altered.
+       returns if the Operator is symmetric. This is a very expensive operation!!! The symmetry flag is not altered.
        """
        verbose=verbose or self.debug()
        out=True
-Line 678 
 class LinearPDE:
+Line 691 
 class LinearPDE:
     def getFlux(self,u):
         """
-        @brief returns the flux J_ij for a given u
+        returns the flux J_ij for a given u
-             J_ij=A_{ijkl}u_{k,l}+B_{ijk}u_k-X_{ij}
+        \f[
+        J_ij=A_{ijkl}u_{k,l}+B_{ijk}u_k-X_{ij}
-        @param u argument of the operator
+        \f]
+        @param u: argument of the operator
         """
         raise SystemError,"getFlux is not implemented yet"
         return None
     def applyOperator(self,u):
         """
-        @brief applies the operator of the PDE to a given solution u in weak from
+        applies the operator of the PDE to a given solution u in weak from
-        @param u argument of the operator
+        @param u: argument of the operator
         """
         return self.getOperator()*escript.Data(u,self.getFunctionSpaceForSolution())
     def getResidual(self,u):
         """
-        @brief return the residual of u in the weak from
+        return the residual of u in the weak from
-        @param u
+        @param u:
         """
         return self.applyOperator(u)-self.getRightHandSide()
-    def _setValue(self,**coefficients):
+    def __setValue(self,**coefficients):
        """
-       @brief sets new values to coefficient
+       sets new values to coefficient
-       @param coefficients
+       @param coefficients:
        """
        # check if the coefficients are  legal:
        for i in coefficients.iterkeys():
-Line 759 
 class LinearPDE:
+Line 772 
 class LinearPDE:
     def __setHomogeneousConstraintFlag(self):
        """
-       @brief checks if the constraints are homogeneous and sets self.__homogeneous_constraint accordingly.
+       checks if the constraints are homogeneous and sets self.__homogeneous_constraint accordingly.
        """
        self.__homogeneous_constraint=True
        q=self.getCoefficientOfPDE("q")
-Line 776 
 class LinearPDE:
+Line 789 
 class LinearPDE:
     # ==== rebuild switches =====================================================================
     def __rebuildSolution(self,deep=False):
         """
-        @brief indicates the PDE has to be reolved if the solution is requested
+        indicates the PDE has to be reolved if the solution is requested
         """
         if self.__solution_isValid and self.debug() : print "PDE Debug: PDE has to be resolved."
         self.__solution_isValid=False
-Line 785 
 class LinearPDE:
+Line 798 
 class LinearPDE:
     def __rebuildOperator(self,deep=False):
         """
-        @brief indicates the operator has to be rebuilt next time it is used
+        indicates the operator has to be rebuilt next time it is used
         """
         if self.__operator_isValid and self.debug() : print "PDE Debug: Operator has to be rebuilt."
         self.__rebuildSolution(deep)
-Line 794 
 class LinearPDE:
+Line 807 
 class LinearPDE:
     def __rebuildRightHandSide(self,deep=False):
         """
-        @brief indicates the right hand side has to be rebuild next time it is used
+        indicates the right hand side has to be rebuild next time it is used
         """
         if self.__righthandside_isValid and self.debug() : print "PDE Debug: Right hand side has to be rebuilt."
         self.__rebuildSolution(deep)
-Line 803 
 class LinearPDE:
+Line 816 
 class LinearPDE:
     def __rebuildSystem(self,deep=False):
         """
-        @brief annonced that all coefficient name has been changed
+        annonced that all coefficient name has been changed
         """
         self.__rebuildSolution(deep)
         self.__rebuildOperator(deep)
-Line 811 
 class LinearPDE:
+Line 824 
 class LinearPDE:
     def __checkMatrixType(self):
       """
-      @brief reassess the matrix type and, if needed, initiates an operator rebuild
+      reassess the matrix type and, if needed, initiates an operator rebuild
       """
       new_matrix_type=self.getDomain().getSystemMatrixTypeId(self.getSolverMethod(),self.isSymmetric())
       if not new_matrix_type==self.__matrix_type:
-Line 822 
 class LinearPDE:
+Line 835 
 class LinearPDE:
     #============ assembling =======================================================
     def __copyConstraint(self):
        """
-       @brief copies the constrint condition into u
+       copies the constrint condition into u
        """
        if not self.__righthandside.isEmpty():
           q=self.getCoefficientOfPDE("q")
-Line 836 
 class LinearPDE:
+Line 849 
 class LinearPDE:
     def __applyConstraint(self):
         """
-        @brief applies the constraints defined by q and r to the system
+        applies the constraints defined by q and r to the system
         """
         q=self.getCoefficientOfPDE("q")
         r=self.getCoefficientOfPDE("r")
-Line 844 
 class LinearPDE:
+Line 857 
 class LinearPDE:
            # q is the row and column mask to indicate where constraints are set:
            row_q=escript.Data(q,self.getFunctionSpaceForEquation())
            col_q=escript.Data(q,self.getFunctionSpaceForSolution())
-           u=self.__makeNewSolution()
+           u=self.__getNewSolution()
            if r.isEmpty():
-              r_s=self.__makeNewSolution()
+              r_s=self.__getNewSolution()
            else:
               r_s=escript.Data(r,self.getFunctionSpaceForSolution())
            u.copyWithMask(r_s,col_q)
-Line 858 
 class LinearPDE:
+Line 871 
 class LinearPDE:
     def getSystem(self):
         """
-        @brief return the operator and right hand side of the PDE
+        return the operator and right hand side of the PDE
         """
         if not self.__operator_isValid or not self.__righthandside_isValid:
            if self.isUsingLumping():
-Line 872 
 class LinearPDE:
+Line 885 
 class LinearPDE:
                   if not self.getCoefficientOfPDE("C").isEmpty():
                            raise Warning,"Lumped matrix does not allow coefficient C"
                   if self.debug() : print "PDE Debug: New lumped operator is built."
-                  mat=self.__makeNewOperator()
+                  mat=self.__getNewOperator()
                   self.getDomain().addPDEToSystem(mat,escript.Data(), \
                             self.getCoefficientOfPDE("A"), \
                             self.getCoefficientOfPDE("B"), \
-Line 889 
 class LinearPDE:
+Line 902 
 class LinearPDE:
                   self.__operator_isValid=True
                if not self.__righthandside_isValid:
                   if self.debug() : print "PDE Debug: New right hand side is built."
-                  self.getDomain().addPDEToRHS(self.__getFreshRightHandSide(), \
+                  self.getDomain().addPDEToRHS(self.__makeFreshRightHandSide(), \
                                 self.getCoefficientOfPDE("X"), \
                                 self.getCoefficientOfPDE("Y"),\
                                 self.getCoefficientOfPDE("y"),\
-Line 899 
 class LinearPDE:
+Line 912 
 class LinearPDE:
            else:
               if not self.__operator_isValid and not self.__righthandside_isValid:
                   if self.debug() : print "PDE Debug: New system is built."
-                  self.getDomain().addPDEToSystem(self.__getFreshOperator(),self.__getFreshRightHandSide(), \
+                  self.getDomain().addPDEToSystem(self.__makeFreshOperator(),self.__makeFreshRightHandSide(), \
                                 self.getCoefficientOfPDE("A"), \
                                 self.getCoefficientOfPDE("B"), \
                                 self.getCoefficientOfPDE("C"), \
-Line 916 
 class LinearPDE:
+Line 929 
 class LinearPDE:
                   self.__righthandside_isValid=True
               elif not self.__righthandside_isValid:
                   if self.debug() : print "PDE Debug: New right hand side is built."
-                  self.getDomain().addPDEToRHS(self.__getFreshRightHandSide(), \
+                  self.getDomain().addPDEToRHS(self.__makeFreshRightHandSide(), \
                                 self.getCoefficientOfPDE("X"), \
                                 self.getCoefficientOfPDE("Y"),\
                                 self.getCoefficientOfPDE("y"),\
-Line 925 
 class LinearPDE:
+Line 938 
 class LinearPDE:
                   self.__righthandside_isValid=True
               elif not self.__operator_isValid:
                   if self.debug() : print "PDE Debug: New operator is built."
-                  self.getDomain().addPDEToSystem(self.__getFreshOperator(),escript.Data(), \
+                  self.getDomain().addPDEToSystem(self.__makeFreshOperator(),escript.Data(), \
                              self.getCoefficientOfPDE("A"), \
                              self.getCoefficientOfPDE("B"), \
                              self.getCoefficientOfPDE("C"), \
-Line 941 
 class LinearPDE:
+Line 954 
 class LinearPDE:
         return (self.__operator,self.__righthandside)
     def getOperator(self):
         """
-        @brief returns the operator of the PDE
+        returns the operator of the PDE
         """
         return self.getSystem()[0]
     def getRightHandSide(self):
         """
-        @brief returns the right hand side of the PDE
+        returns the right hand side of the PDE
         """
         return self.getSystem()[1]
     def solve(self,**options):
        """
-       @brief solve the PDE
+       solve the PDE
-       @param options
+       @param options:
        """
        mat,f=self.getSystem()
        if self.isUsingLumping():
-Line 970 
 class LinearPDE:
+Line 983 
 class LinearPDE:
     def getSolution(self,**options):
         """
-        @brief returns the solution of the PDE
+        returns the solution of the PDE
-        @param options
+        @param options:
         """
         if not self.__solution_isValid:
             if self.debug() : print "PDE Debug: PDE is resolved."
-Line 982 
 class LinearPDE:
+Line 995 
 class LinearPDE:
- def ELMAN_RAMAGE(P): return (P-1.).wherePositive()*0.5*(1.-1./(P+1.e-15))
+ def ELMAN_RAMAGE(P):
+      """   """
+      return (P-1.).wherePositive()*0.5*(1.-1./(P+1.e-15))
  def SIMPLIFIED_BROOK_HUGHES(P):
-          c=(P-3.).whereNegative()
+      """   """
-          return P/6.*c+1./2.*(1.-c)
+      c=(P-3.).whereNegative()
- def HALF(P): return escript.Scalar(0.5,P.getFunctionSpace())
+      return P/6.*c+1./2.*(1.-c)
+ def HALF(P):
+     """ """
+     return escript.Scalar(0.5,P.getFunctionSpace())
  class AdvectivePDE(LinearPDE):
     """
-    @brief Class to handel a linear PDE domineated by advective terms:
+    Class to handle a linear PDE dominated by advective terms:
     class to define a linear PDE of the form
-      -(A_{ijkl}u_{k,l})_{,j} -(B_{ijk}u_k)_{,j} + C_{ikl}u_{k,l} +D_{ik}u_k = - (X_{ij})_{,j} + Y_i
+    \f[
+    -(A_{ijkl}u_{k,l})_{,j} -(B_{ijk}u_k)_{,j} + C_{ikl}u_{k,l} +D_{ik}u_k = - (X_{ij})_{,j} + Y_i
+    \f]
-      with boundary conditons:
+    with boundary conditons:
-         n_j*(A_{ijkl}u_{k,l}+B_{ijk}u_k)_{,j} + d_{ik}u_k = - n_j*X_{ij} + y_i
+    \f[
+    n_j*(A_{ijkl}u_{k,l}+B_{ijk}u_k)_{,j} + d_{ik}u_k = - n_j*X_{ij} + y_i
+    \f]
-     and contact conditions
+    and contact conditions
-         n_j*(A_{ijkl}u_{k,l}+B_{ijk}u_k)_{,j} + d_contact_{ik}[u_k] = - n_j*X_{ij} + y_contact_i
+    \f[
+    n_j*(A_{ijkl}u_{k,l}+B_{ijk}u_k)_{,j} + d^{contact}_{ik}[u_k] = - n_j*X_{ij} + y^{contact}_{i}
+    \f]
-     and constraints:
+    and constraints:
-          u_i=r_i where q_i>0
+    \f[
+    u_i=r_i \quad \mathrm{where} \quad q_i>0
+    \f]
     """
     def __init__(self,domain,numEquations=0,numSolutions=0,xi=ELMAN_RAMAGE):
        LinearPDE.__init__(self,domain,numEquations,numSolutions)
-Line 1024 
 class AdvectivePDE(LinearPDE):
+Line 1049 
 class AdvectivePDE(LinearPDE):
     def setValue(self,**args):
         if "A" in args.keys()   or "B" in args.keys() or "C" in args.keys(): self.__Xi=escript.Data()
-        self._setValue(**args)
+        self._LinearPDE__setValue(**args)
     def getXi(self):
        if self.__Xi.isEmpty():
-Line 1073 
 class AdvectivePDE(LinearPDE):
+Line 1098 
 class AdvectivePDE(LinearPDE):
     def getCoefficientOfPDE(self,name):
       """
-      @brief return the value of the coefficient name of the general PDE
+      return the value of the coefficient name of the general PDE
-      @param name
+      @param name:
       """
       if not self.getNumEquations() == self.getNumSolutions():
            raise ValueError,"AdvectivePDE expects the number of solution componets and the number of equations to be equal."
-Line 1214 
 class AdvectivePDE(LinearPDE):
+Line 1240 
 class AdvectivePDE(LinearPDE):
  class Poisson(LinearPDE):
     """
-    @brief Class to define a Poisson equstion problem:
+    Class to define a Poisson equstion problem:
     class to define a linear PDE of the form
+    \f[
-         -u_{,jj} = f
+    -u_{,jj} = f
+    \f]
-      with boundary conditons:
+    with boundary conditons:
-         n_j*u_{,j} = 0
+    \f[
-     and constraints:
+    n_j*u_{,j} = 0
+    \f]
-          u=0 where q>0
+    and constraints:
+    \f[
+    u=0 \quad \mathrm{where} \quad q>0
+    \f]
     """
     def __init__(self,domain,f=escript.Data(),q=escript.Data()):
-Line 1239 
 class Poisson(LinearPDE):
+Line 1269 
 class Poisson(LinearPDE):
         self.setValue(f,q)
     def setValue(self,f=escript.Data(),q=escript.Data()):
-        self._setValue(f=f,q=q)
+        self._LinearPDE__setValue(f=f,q=q)
     def getCoefficientOfPDE(self,name):
       """
-      @brief return the value of the coefficient name of the general PDE
+      return the value of the coefficient name of the general PDE
-      @param name
+      @param name:
       """
       if name == "A" :
           return escript.Data(numarray.identity(self.getDim()),escript.Function(self.getDomain()))
-Line 1272 
 class Poisson(LinearPDE):
+Line 1303 
 class Poisson(LinearPDE):
           return self.getCoefficient("q")
       else:
           raise SystemError,"unknown PDE coefficient %s",name
+ # $Log$
+ # Revision 1.8  2005/06/09 05:37:59  jgs
+ # Merge of development branch back to main trunk on 2005-06-09
+ #
+ # Revision 1.7  2005/05/06 04:26:10  jgs
+ # Merge of development branch back to main trunk on 2005-05-06
+ #
+ # Revision 1.1.2.23  2005/05/13 00:55:20  cochrane
+ # Fixed up some docstrings.  Moved module-level functions to top of file so
+ # that epydoc and doxygen can pick them up properly.
+ #
+ # Revision 1.1.2.22  2005/05/12 11:41:30  gross
+ # some basic Models have been added
+ #
+ # Revision 1.1.2.21  2005/05/12 07:16:12  cochrane
+ # Moved ELMAN_RAMAGE, SIMPLIFIED_BROOK_HUGHES, and HALF functions to bottom of
+ # file so that the AdvectivePDE class is picked up by doxygen.  Some
+ # reformatting of docstrings.  Addition of code to make equations come out
+ # as proper LaTeX.
+ #
+ # Revision 1.1.2.20  2005/04/15 07:09:08  gross
+ # some problems with functionspace and linearPDEs fixed.
+ #
+ # Revision 1.1.2.19  2005/03/04 05:27:07  gross
+ # bug in SystemPattern fixed.
+ #
+ # Revision 1.1.2.18  2005/02/08 06:16:45  gross
+ # Bugs in AdvectivePDE fixed, AdvectiveTest is stable but more testing is needed
+ #
+ # Revision 1.1.2.17  2005/02/08 05:56:19  gross
+ # Reference Number handling added
+ #
+ # Revision 1.1.2.16  2005/02/07 04:41:28  gross
+ # some function exposed to python to make mesh merging running
+ #
+ # Revision 1.1.2.15  2005/02/03 00:14:44  gross
+ # timeseries add and ESySParameter.py renames esysXML.py for consistence
+ #
+ # Revision 1.1.2.14  2005/02/01 06:44:10  gross
+ # new implementation of AdvectivePDE which now also updates right hand side. systems of PDEs are still not working
+ #
+ # Revision 1.1.2.13  2005/01/25 00:47:07  gross
+ # updates in the documentation
+ #
+ # Revision 1.1.2.12  2005/01/12 01:28:04  matt
+ # Added createCoefficient method for linearPDEs.
+ #
+ # Revision 1.1.2.11  2005/01/11 01:55:34  gross
+ # a problem in linearPDE class fixed
+ #
+ # Revision 1.1.2.10  2005/01/07 01:13:29  gross
+ # some bugs in linearPDE fixed
+ #
+ # Revision 1.1.2.9  2005/01/06 06:24:58  gross
+ # some bugs in slicing fixed
+ #
+ # Revision 1.1.2.8  2005/01/05 04:21:40  gross
+ # FunctionSpace checking/matchig in slicing added
+ #
+ # Revision 1.1.2.7  2004/12/29 10:03:41  gross
+ # bug in setValue fixed
+ #
+ # Revision 1.1.2.6  2004/12/29 05:29:59  gross
+ # AdvectivePDE successfully tested for Peclet number 1000000. there is still a problem with setValue and Data()
+ #
+ # Revision 1.1.2.5  2004/12/29 00:18:41  gross
+ # AdvectivePDE added
+ #
+ # Revision 1.1.2.4  2004/12/24 06:05:41  gross
+ # some changes in linearPDEs to add AdevectivePDE
+ #
+ # Revision 1.1.2.3  2004/12/16 00:12:34  gross
+ # __init__ of LinearPDE does not accept any coefficient anymore
+ #
+ # Revision 1.1.2.2  2004/12/14 03:55:01  jgs
+ # *** empty log message ***
+ #
+ # Revision 1.1.2.1  2004/12/12 22:53:47  gross
+ # linearPDE has been renamed LinearPDE
+ #
+ # Revision 1.1.1.1.2.7  2004/12/07 10:13:08  gross
+ # GMRES added
+ #
+ # Revision 1.1.1.1.2.6  2004/12/07 03:19:50  gross
+ # options for GMRES and PRES20 added
+ #
+ # Revision 1.1.1.1.2.5  2004/12/01 06:25:15  gross
+ # some small changes
+ #
+ # Revision 1.1.1.1.2.4  2004/11/24 01:50:21  gross
+ # Finley solves 4M unknowns now
+ #
+ # Revision 1.1.1.1.2.3  2004/11/15 06:05:26  gross
+ # poisson solver added
+ #
+ # Revision 1.1.1.1.2.2  2004/11/12 06:58:15  gross
+ # a lot of changes to get the linearPDE class running: most important change is that there is no matrix format exposed to the user anymore. the format is chosen by the Domain according to the solver and symmetry
+ #
+ # Revision 1.1.1.1.2.1  2004/10/28 22:59:22  gross
+ # finley's RecTest.py is running now: problem in SystemMatrixAdapater fixed
+ #
+ # Revision 1.1.1.1  2004/10/26 06:53:56  jgs
+ # initial import of project esys2
+ #
+ # Revision 1.3.2.3  2004/10/26 06:43:48  jgs
+ # committing Lutz's and Paul's changes to brach jgs
+ #
+ # Revision 1.3.4.1  2004/10/20 05:32:51  cochrane
+ # Added incomplete Doxygen comments to files, or merely put the docstrings that already exist into Doxygen form.
+ #
+ # Revision 1.3  2004/09/23 00:53:23  jgs
+ # minor fixes
+ #
+ # Revision 1.1  2004/08/28 12:58:06  gross
+ # SimpleSolve is not running yet: problem with == of functionsspace
+ #
+ #

 Legend:



Removed from v.110
 


changed lines


 
Added in v.122
 Legend:



Removed from v.110
 


changed lines


 
Added in v.122
-Removed from v.110
+Added in v.122

	ViewVC Help
Powered by ViewVC 1.1.26