source: trunk/anuga_work/development/2010-projects/anuga_1d/sqpipe/sqpipe_template_domain.py @ 8236

"""
Template file for implementing a square pipe domain.
Replace the following placeholders:

<name> 

The name of the class. For example, we have:

free_surface_fixed_width_a_d

which implements a free surface flow with a fixed width channel
and the conserved quantities are a = area, d = discharge.

<conserved> 

List of conserved quantities.

<centroids>

Code to clean up centroids.

<extrapolate>

List of quantities to extrapolate from centroids to vertices.

<extrapolated>

Shortcut code for quantities that have been extrapolated.

<update>

Shortcut code for quantities that need to be updated.

<reconstruct>

Code to reconstruct update quantities from extrapolated quantities.
May need to fix up small heights.
"""

from anuga_1d.sqpipe.sqpipe_domain import Sqpipe_domain
from anuga_1d.sqpipe.sqpipe_forcing_terms import *
from anuga_1d.sqpipe.sqpipe_boundary_conditions import *


class Domain(Sqpipe_domain):

    def __init__(self, coordinates, boundary = None, tagged_elements = None):
        conserved_quantities = [<conserved>]
        forcing_terms = [gravity]
        Sqpipe_domain.__init__(self,
                               coordinates          = coordinates,
                               conserved_quantities = conserved_quantities,
                               forcing_terms        = forcing_terms,
                               boundary             = boundary,
                               tagged_elements      = tagged_elements)

        self.__doc__ = 'sqpipe_<name>_domain'

    def compute_fluxes(self):        
        #Call correct module function
        #(either from this module or C-extension)

        # Set initial timestep to a large value
        import sys
        timestep = float(sys.maxint)

        # Import flux method and call it
        from anuga_1d.sqpipe.sqpipe_<name>_comp_flux import compute_fluxes_ext
        self.flux_timestep = compute_fluxes_ext(timestep,self)        
        
    def distribute_to_vertices_and_edges(self):
        # Shortcuts
        h0 = self.h0
        epsilon = self.epsilon

        area      = self.quantities['area']
        discharge = self.quantities['discharge']
        bed       = self.quantities['elevation']
        height    = self.quantities['height']
        velocity  = self.quantities['velocity']
        width     = self.quantities['width']
        top       = self.quantities['top']
        stage     = self.quantities['stage']
        state     = self.quantities['state']

        #Arrays   
        a_C   = area.centroid_values
        d_C   = discharge.centroid_values
        z_C   = bed.centroid_values
        h_C   = height.centroid_values
        u_C   = velocity.centroid_values
        b_C   = width.centroid_values
        t_C   = top.centroid_values
        w_C   = stage.centroid_values
        s_C   = state.centroid_values

        <centroids>

        for name in [<extrapolate>]:
            Q = self.quantities[name]
            if self.order == 1:
                Q.extrapolate_first_order()
            elif self.order == 2:
                Q.extrapolate_second_order()
            else:
                raise 'Unknown order'

        # These have been extrapolated
        <extrapolated>
        # e.g.
        #w_V = self.quantities['stage'].vertex_values
        #u_V = self.quantities['velocity'].vertex_values

        # These are the given geometry and remain fixed
        z_V  = bed.vertex_values
        b_V  = width.vertex_values
        t_V  = top.vertex_values

        # These need to be updated
        <update>
        # e.g. 
        #a_V  = area.vertex_values
        #d_V  = discharge.vertex_values
        #h_V  = height.vertex_values

        <reconstruct>

        return