source: inundation/ga/storm_surge/parallel/parallel_advection.py @ 1387

import sys
from os import sep
sys.path.append('..'+sep+'pyvolution')

"""Class Parallel_Domain -
2D triangular domains for finite-volume computations of
the advection equation, with extra structures to allow
communication between other Parallel_Domains and itself

This module contains a specialisation of class Domain from module advection.py

Ole Nielsen, Stephen Roberts, Duncan Gray, Christopher Zoppou
Geoscience Australia, 2004
"""

from advection import *
Advection_Domain = Domain
from Numeric import zeros, Float, Int

class Parallel_Domain(Advection_Domain):

    def __init__(self, coordinates, vertices, boundary = None, velocity = None,
                 processor = 0, global_ids = None):

        Advection_Domain.__init__(self, coordinates, vertices, boundary, velocity)

        self.processor = processor

        N = self.number_of_elements

        if  global_ids == None:
            self.global_ids = global_ids
        else:
            self.global_ids = zeros(N, Int)


    def check_integrity(self):
        Advection_Domain.check_integrity(self)

        msg = 'Will need to check global and local numbering'
        assert self.conserved_quantities[0] == 'stage', msg




    def evolve(self, yieldstep = None, finaltime = None):
        """Specialisation of basic evolve method from parent class
        """

        #Initialise real time viz if requested
        if self.visualise is True and self.time == 0.0:
            import realtime_visualisation_new as visualise
            self.visualiser = visualise.Visualiser(self)

        #Call basic machinery from parent class
        for t in Advection_Domain.evolve(self, yieldstep, finaltime):
            #Real time viz
            if self.visualise is True:
                self.visualiser.update_quantity('stage')

            #Pass control on to outer loop for more specific actions
            yield(t)



def rectangular_with_ghosts(m, n, len1=1.0, len2=1.0, origin = (0.0, 0.0)):

    """Setup a rectangular grid of triangles
    with m+1 by n+1 grid points
    and side lengths len1, len2. If side lengths are omitted
    the mesh defaults to the unit square.

    len1: x direction (left to right)
    len2: y direction (bottom to top)

    Also returns a list of

    Return to lists: points and elements suitable for creating a Mesh or
    FVMesh object, e.g. Mesh(points, elements)
    """

    from config import epsilon

    #E = m*n*2        #Number of triangular elements
    #P = (m+1)*(n+1)  #Number of initial vertices

    delta1 = float(len1)/m
    delta2 = float(len2)/n

    #Dictionary of vertex objects
    vertices = {}
    points = []

    for i in range(m+1):
        for j in range(n+1):
            vertices[i,j] = len(points)
            points.append([i*delta1 + origin[0], j*delta2 + origin[1]])



    #Construct 2 triangles per rectangular element and assign tags to boundary
    elements = []
    boundary = {}
    for i in range(m):
        for j in range(n):
            v1 = vertices[i,j+1]
            v2 = vertices[i,j]
            v3 = vertices[i+1,j+1]
            v4 = vertices[i+1,j]

            #Update boundary dictionary and create elements
            if i == m-1:
                boundary[(len(elements), 2)] = 'right'
            if j == 0:
                boundary[(len(elements), 1)] = 'bottom'
            elements.append([v4,v3,v2]) #Lower element

            if i == 0:
                boundary[(len(elements), 2)] = 'left'
            if j == n-1:
                boundary[(len(elements), 1)] = 'top'
            elements.append([v1,v2,v3]) #Upper element

    ghosts = {}
    i=0
    for j in range(n):
        v1 = vertices[i,j+1]
        v2 = vertices[i,j]
        v3 = vertices[i+1,j+1]
        v4 = vertices[i+1,j]
        ghosts.append(elements.index([

    return points, elements, boundary