Ejemplo n.º 1
0
class SimpleStokesProblem(SaddlePointProblem):
      """
      simple example of saddle point problem
      """
      def __init__(self,domain):
         super(SimpleStokesProblem, self).__init__(self)

         self.__pde_u=LinearPDE(domain)
         self.__pde_u.setSymmetryOn()
         self.__pde_u.setValue(A=identityTensor4(dom))

         self.__pde_p=LinearPDE(domain)
         self.__pde_p.setReducedOrderOn()
         self.__pde_p.setSymmetryOn()
         self.__pde_p.setValue(D=1.)

      def initialize(self,f=Data(),fixed_u_mask=Data()):
         self.__pde_u.setValue(q=fixed_u_mask,Y=f)
      def inner(self,p0,p1):
         return integrate(p0*p1,Function(self.__pde_p.getDomain()))

      def solve_f(self,u,p,tol=1.e-8):
         self.__pde_u.setTolerance(tol)
         self.__pde_u.setValue(X=grad(u)+p*kronecker(self.__pde_u.getDomain()))
         return  self.__pde_u.getSolution()
      def solve_g(self,u,tol=1.e-8):
         self.__pde_p.setTolerance(tol)
         self.__pde_p.setValue(X=-u) 
         dp=self.__pde_p.getSolution()
         return  dp
Ejemplo n.º 2
0
class SimpleStokesProblem(SaddlePointProblem):
    """
      simple example of saddle point problem
      """
    def __init__(self, domain):
        super(SimpleStokesProblem, self).__init__(self)

        self.__pde_u = LinearPDE(domain)
        self.__pde_u.setSymmetryOn()
        self.__pde_u.setValue(A=identityTensor4(dom))

        self.__pde_p = LinearPDE(domain)
        self.__pde_p.setReducedOrderOn()
        self.__pde_p.setSymmetryOn()
        self.__pde_p.setValue(D=1.)

    def initialize(self, f=Data(), fixed_u_mask=Data()):
        self.__pde_u.setValue(q=fixed_u_mask, Y=f)

    def inner(self, p0, p1):
        return integrate(p0 * p1, Function(self.__pde_p.getDomain()))

    def solve_f(self, u, p, tol=1.e-8):
        self.__pde_u.setTolerance(tol)
        self.__pde_u.setValue(X=grad(u) +
                              p * kronecker(self.__pde_u.getDomain()))
        return self.__pde_u.getSolution()

    def solve_g(self, u, tol=1.e-8):
        self.__pde_p.setTolerance(tol)
        self.__pde_p.setValue(X=-u)
        dp = self.__pde_p.getSolution()
        return dp
Ejemplo n.º 3
0
class StokesProblem(SaddlePointProblem):
    """
      simple example of saddle point problem
      """
    def __init__(self, domain, debug=False):
        super(StokesProblem, self).__init__(self, debug)
        self.domain = domain
        self.__pde_u = LinearPDE(domain,
                                 numEquations=self.domain.getDim(),
                                 numSolutions=self.domain.getDim())
        self.__pde_u.setSymmetryOn()

        self.__pde_p = LinearPDE(domain)
        self.__pde_p.setReducedOrderOn()
        self.__pde_p.setSymmetryOn()

    def initialize(self, f=Data(), fixed_u_mask=Data(), eta=1):
        self.eta = eta
        A = self.__pde_u.createCoefficientOfGeneralPDE("A")
        for i in range(self.domain.getDim()):
            for j in range(self.domain.getDim()):
                A[i, j, j, i] += self.eta
                A[i, j, i, j] += self.eta
        self.__pde_p.setValue(D=1 / self.eta)
        self.__pde_u.setValue(A=A, q=fixed_u_mask, Y=f)

    def inner(self, p0, p1):
        return integrate(p0 * p1, Function(self.__pde_p.getDomain()))

    def solve_f(self, u, p, tol=1.e-8):
        self.__pde_u.setTolerance(tol)
        g = grad(u)
        self.__pde_u.setValue(X=self.eta * symmetric(g) +
                              p * kronecker(self.__pde_u.getDomain()))
        return self.__pde_u.getSolution()

    def solve_g(self, u, tol=1.e-8):
        self.__pde_p.setTolerance(tol)
        self.__pde_p.setValue(X=-u)
        dp = self.__pde_p.getSolution()
        return dp
class StokesProblem(SaddlePointProblem):
      """
      simple example of saddle point problem
      """
      def __init__(self,domain,debug=False):
         super(StokesProblem, self).__init__(self,debug)
         self.domain=domain
         self.__pde_u=LinearPDE(domain,numEquations=self.domain.getDim(),numSolutions=self.domain.getDim())
         self.__pde_u.setSymmetryOn()

         self.__pde_p=LinearPDE(domain)
         self.__pde_p.setReducedOrderOn()
         self.__pde_p.setSymmetryOn()

      def initialize(self,f=Data(),fixed_u_mask=Data(),eta=1):
         self.eta=eta
         A =self.__pde_u.createCoefficientOfGeneralPDE("A")
         for i in range(self.domain.getDim()):
           for j in range(self.domain.getDim()):
             A[i,j,j,i] += self.eta
             A[i,j,i,j] += self.eta
         self.__pde_p.setValue(D=1/self.eta)
         self.__pde_u.setValue(A=A,q=fixed_u_mask,Y=f)

      def inner(self,p0,p1):
         return integrate(p0*p1,Function(self.__pde_p.getDomain()))

      def solve_f(self,u,p,tol=1.e-8):
         self.__pde_u.setTolerance(tol)
         g=grad(u)
         self.__pde_u.setValue(X=self.eta*symmetric(g)+p*kronecker(self.__pde_u.getDomain()))
         return  self.__pde_u.getSolution()

      def solve_g(self,u,tol=1.e-8):
         self.__pde_p.setTolerance(tol)
         self.__pde_p.setValue(X=-u) 
         dp=self.__pde_p.getSolution()
         return  dp
Ejemplo n.º 5
0
class SonicWaveInFrequencyDomain(object):
    """  
    This class is a simple wrapper for the solution of the 2D or 3D sonic wave equtaion in the frequency domain.  
    It solves complex PDE
        div (grad p) - k^2 p = Q
    where 
        k = omega/c
        Q = source term : Dirac function
 
    Boundary conditions implemented are   NEED TO SET PML CONDITION FIRST
       - perfectly matched layer : see class PMLCondition
       - fixed BC - all but the top surface

    It has functions
       - getDomain
       - setFrequency
       - setVp
       
    Output solution
       - getWave
    """

    def __init__(self, domain, pml_condition=None, frequency=None, vp=None, fix_boundary=True):
        """
        Initialise the class with domain, boundary conditions and frequency.
        Setup PDE 
        :param domain: the domain : setup with Dirac points
        :type domain: `Domain`
        :param pml_condition: 
        :type pml_condition:  
        :param frequency: 
        :type frequency: 
        :param vp: velocity field 
        :type vp: `Data`
        :param fix_boundary: if true fix all the boundaries except the top
        :type fix_boundary: `bool`
        
        """
        Dim=domain.getDim()
        self.pde=LinearPDE(domain, numEquations=1, numSolutions=1, isComplex=True)
        self.pde.getSolverOptions().setSolverMethod(SolverOptions.DIRECT)
        self.pml=pml_condition
        if not self.pml:
            self.pde.setValue(A=kronecker(domain))
            self.J=1.
        if fix_boundary:
            x=domain.getX()
            q=whereZero(x[Dim-1]-inf(x[Dim-1]))
            for i in range(Dim-1):
                q+=whereZero(x[i]-inf(x[i]))+whereZero(x[i]-sup(x[i]))
            self.pde.setValue(q=q)
        self.setFrequency(frequency)        
        self.setVp(vp)
        
    def getDomain(self):
        """
        returns the domain
        """
        return self.pde.getDomain()
    
    def setFrequency(self, frequency):
        """
        sets the frequency 
        """
        self.frequency=frequency
        self.newFreq=True
        return self
        
    def setVp(self, vp):
        """
        sets the velocity for the rock
        """
        self.newVp=True
        if vp is None:
            self.sigma2=None
        else:
            self.sigma2=1./vp**2
        return self
    
    def getWave(self, source):
        """
        solve the PDE 
        """
        omega=self.frequency*2*np.pi
        if self.pml and self.newFreq:
            Dim=self.getDomain().getDim()
            A=kronecker(Function(self.getDomain()))
            alpha, J = self.pml.getPMLWeights(self.getDomain(), omega=omega)
            for d in range(Dim):
                A[d,d]=J/alpha[d]**2
            self.J=J
            self.pde.setValue(A=A)

        if self.newFreq or self.newVp:
            if self.frequency is None or self.sigma2 is None:
                raise ValueError("freqency/propagation speed vp is not set.")
            omega=self.frequency*2*np.pi
            self.pde.setValue(D=-self.J*omega**2*self.sigma2)
            self.newFreq=False
            self.newVp=False
        self.pde.setValue(y_dirac=source)
        return self.pde.getSolution()