def calculate_boundary_points(boundary_polygon, zone, ll_lat, ll_long, grid_spacing, lat_amount, long_amount, isSouthHemisphere=True, use_cache=False, verbose=False): args = (boundary_polygon, zone, ll_lat, ll_long, grid_spacing, lat_amount, long_amount, isSouthHemisphere) kwargs = {} if use_cache is True: try: from anuga.caching import cache except: msg = 'Caching was requested, but caching module' \ 'could not be imported' raise Exception(msg) geo = cache(_calculate_boundary_points, args, kwargs, verbose=verbose, compression=False) else: geo = _calculate_boundary_points(*args, **kwargs) return geo
def llasc2pts(name_in, name_out=None, use_cache=False, show_progress=False, verbose=False,): """Read Digital Elevation model from the following ASCII format (.asc) Example: ncols 968 nrows 698 xllcorner 144.966666666667 yllcorner -18.500000000000 cellsize 0.004166666667 NODATA_value -32767 138.3698 137.4194 136.5062 135.5558 .......... Convert name_in (.asc) to NetCDF format (.pts) """ kwargs = {'name_out': name_out, 'verbose': verbose, 'show_progress': show_progress} if use_cache is True: from anuga.caching import cache result = cache(_convert_dem_from_llasc2pts, name_in, kwargs, dependencies=[name_in], verbose=verbose) else: result = _convert_dem_from_llasc2pts(*[name_in], **kwargs) return result
def calculate_boundary_points(boundary_polygon, zone, ll_lat, ll_long, grid_spacing, lat_amount, long_amount, isSouthHemisphere=True, use_cache=False, verbose=False): args = (boundary_polygon, zone, ll_lat, ll_long, grid_spacing, lat_amount, long_amount, isSouthHemisphere) kwargs = {} if use_cache is True: try: from anuga.caching import cache except: msg = 'Caching was requested, but caching module' \ 'could not be imported' raise Exception(msg) geo = cache(_calculate_boundary_points, args, kwargs, verbose=verbose, compression=False) else: geo = apply(_calculate_boundary_points, args, kwargs) return geo
def create_domain_from_regions_sed(bounding_polygon, boundary_tags, maximum_triangle_area=None, mesh_filename=None, interior_regions=None, interior_holes=None, hole_tags=None, poly_geo_reference=None, mesh_geo_reference=None, minimum_triangle_angle=28.0, conserved_quantities=None, evolved_quantities=None, other_quantities=None, fail_if_polygons_outside=True, use_cache=False, verbose=True): # Build arguments and keyword arguments for use with caching or apply. args = (bounding_polygon, boundary_tags) kwargs = {'maximum_triangle_area': maximum_triangle_area, 'mesh_filename': mesh_filename, 'interior_regions': interior_regions, 'interior_holes': interior_holes, 'hole_tags': hole_tags, 'poly_geo_reference': poly_geo_reference, 'mesh_geo_reference': mesh_geo_reference, 'minimum_triangle_angle': minimum_triangle_angle, 'conserved_quantities': conserved_quantities, 'evolved_quantities': evolved_quantities, 'other_quantities': other_quantities, 'fail_if_polygons_outside': fail_if_polygons_outside, 'verbose': verbose} #FIXME (Ole): See ticket:14 # Call underlying engine with or without caching if use_cache is True: try: from anuga.caching import cache except: msg = 'Caching was requested, but caching module'+\ 'could not be imported' raise (msg) domain = cache(_create_domain_from_regions_sed, args, kwargs, verbose=verbose, compression=False) else: domain = apply(_create_domain_from_regions_sed, args, kwargs) return domain
def fit_to_mesh(point_coordinates, vertex_coordinates=None, triangles=None, mesh=None, point_attributes=None, alpha=DEFAULT_ALPHA, verbose=False, mesh_origin=None, data_origin=None, max_read_lines=None, attribute_name=None, use_cache=False, cg_precon='Jacobi', use_c_cg=True): """Wrapper around internal function _fit_to_mesh for use with caching. """ args = (point_coordinates, ) kwargs = { 'vertex_coordinates': vertex_coordinates, 'triangles': triangles, 'mesh': mesh, 'point_attributes': point_attributes, 'alpha': alpha, 'verbose': verbose, 'mesh_origin': mesh_origin, 'data_origin': data_origin, 'max_read_lines': max_read_lines, 'attribute_name': attribute_name, 'cg_precon': cg_precon, 'use_c_cg': use_c_cg } if use_cache is True: if isinstance(point_coordinates, basestring): # We assume that point_coordinates is the name of a .csv/.txt # file which must be passed onto caching as a dependency # (in case it has changed on disk) dep = [point_coordinates] else: dep = None return cache(_fit_to_mesh, args, kwargs, verbose=verbose, compression=False, dependencies=dep) else: res = apply(_fit_to_mesh, args, kwargs) "print intep should go out of range" return res
def fit_to_mesh(point_coordinates, vertex_coordinates=None, triangles=None, mesh=None, point_attributes=None, alpha=DEFAULT_ALPHA, verbose=False, mesh_origin=None, data_origin=None, max_read_lines=None, attribute_name=None, use_cache=False, cg_precon='Jacobi', use_c_cg=True): """Wrapper around internal function _fit_to_mesh for use with caching. """ args = (point_coordinates, ) kwargs = {'vertex_coordinates': vertex_coordinates, 'triangles': triangles, 'mesh': mesh, 'point_attributes': point_attributes, 'alpha': alpha, 'verbose': verbose, 'mesh_origin': mesh_origin, 'data_origin': data_origin, 'max_read_lines': max_read_lines, 'attribute_name': attribute_name, 'cg_precon': cg_precon, 'use_c_cg': use_c_cg } if use_cache is True: if isinstance(point_coordinates, basestring): # We assume that point_coordinates is the name of a .csv/.txt # file which must be passed onto caching as a dependency # (in case it has changed on disk) dep = [point_coordinates] else: dep = None return cache(_fit_to_mesh, args, kwargs, verbose=verbose, compression=False, dependencies=dep) else: res = apply(_fit_to_mesh, args, kwargs) "print intep should go out of range" return res
def dem2pts( name_in, name_out=None, easting_min=None, easting_max=None, northing_min=None, northing_max=None, use_cache=False, verbose=False, ): """Read Digitial Elevation model from the following NetCDF format (.dem) Example: ncols 3121 nrows 1800 xllcorner 722000 yllcorner 5893000 cellsize 25 NODATA_value -9999 138.3698 137.4194 136.5062 135.5558 .......... name_in may be a .asc or .dem file to be converted. Convert to NetCDF pts format which is points: (Nx2) float array elevation: N float array """ kwargs = { 'name_out': name_out, 'easting_min': easting_min, 'easting_max': easting_max, 'northing_min': northing_min, 'northing_max': northing_max, 'verbose': verbose } if use_cache is True: from anuga.caching import cache result = cache(_dem2pts, name_in, kwargs, dependencies=[name_in], verbose=verbose) else: result = apply(_dem2pts, [name_in], kwargs) return result
def get_intersecting_segments(self, polyline, use_cache=False, verbose=False): """Find edges intersected by polyline Input: polyline - list of points forming a segmented line use_cache verbose Output: list of instances of class Triangle_intersection The polyline may break inside any triangle causing multiple segments per triangle - consequently the same triangle may appear in several entries. If a polyline segment coincides with a triangle edge, the the entire shared segment will be used. Onle one of the triangles thus intersected will be used and that is the first one encountered. Intersections with single vertices are ignored. Resulting segments are unsorted """ V = self.get_vertex_coordinates() N = len(self) # Adjust polyline to mesh spatial origin polyline = self.geo_reference.get_relative(polyline) if use_cache is True: segments = cache(get_intersecting_segments, (V, N, polyline), {'verbose': verbose}, verbose=verbose) else: segments = get_intersecting_segments(V, N, polyline, verbose=verbose) return segments
def pmesh_to_domain_instance(source, DomainClass, use_cache=False, verbose=False): """Converts a mesh file(.tsh or .msh), to a Domain instance. file_name is the name of the mesh file to convert, including the extension DomainClass is the Class that will be returned. It must be a subclass of Domain, with the same interface as domain. use_cache: True means that caching is attempted for the computed domain. """ if use_cache is True: from anuga.caching import cache result = cache(_pmesh_to_domain_instance, (source, DomainClass), dependencies=[source], verbose=verbose) else: result = apply(_pmesh_to_domain_instance, (source, DomainClass)) return result
def dem2pts(name_in, name_out=None, easting_min=None, easting_max=None, northing_min=None, northing_max=None, use_cache=False, verbose=False,): """Read Digitial Elevation model from the following NetCDF format (.dem) Example: ncols 3121 nrows 1800 xllcorner 722000 yllcorner 5893000 cellsize 25 NODATA_value -9999 138.3698 137.4194 136.5062 135.5558 .......... name_in may be a .asc or .dem file to be converted. Convert to NetCDF pts format which is points: (Nx2) float array elevation: N float array """ kwargs = {'name_out': name_out, 'easting_min': easting_min, 'easting_max': easting_max, 'northing_min': northing_min, 'northing_max': northing_max, 'verbose': verbose} if use_cache is True: from anuga.caching import cache result = cache(_dem2pts, name_in, kwargs, dependencies = [name_in], verbose = verbose) else: result = apply(_dem2pts, [name_in], kwargs) return result
def pmesh_to_domain(file_name=None, mesh_instance=None, use_cache=False, verbose=False): """Convert a pmesh file or a pmesh mesh instance to a bunch of lists that can be used to instanciate a domain object. use_cache: True means that caching is attempted for the computed domain. """ if verbose: log.critical('Pmesh_to_Domain: Initialising') if use_cache is True: from anuga.caching import cache result = cache(_pmesh_to_domain, (file_name, mesh_instance), dependencies=[file_name], verbose=verbose) else: result = apply(_pmesh_to_domain, (file_name, mesh_instance)) if verbose: log.critical('Pmesh_to_Domain: Done') return result
def test_create_mesh_from_regions_with_caching(self): x = -500 y = -1000 mesh_geo = geo_reference = Geo_reference(56, x, y) # These are the absolute values polygon_absolute = [[0, 0], [100, 0], [100, 100], [0, 100]] x_p = -10 y_p = -40 geo_ref_poly = Geo_reference(56, x_p, y_p) polygon = geo_ref_poly.change_points_geo_ref(polygon_absolute) boundary_tags = {'walls': [0, 1], 'bom': [2, 3]} inner1_polygon_absolute = [[10, 10], [20, 10], [20, 20], [10, 20]] inner1_polygon = geo_ref_poly.\ change_points_geo_ref(inner1_polygon_absolute) inner2_polygon_absolute = [[30, 30], [40, 30], [40, 40], [30, 40]] inner2_polygon = geo_ref_poly.\ change_points_geo_ref(inner2_polygon_absolute) interior_regions = [(inner1_polygon, 5), (inner2_polygon, 10)] interior_holes = None # Clear cache first from anuga.caching import cache cache(_create_mesh_from_regions, (polygon, boundary_tags), { 'minimum_triangle_angle': 28.0, 'maximum_triangle_area': 10000000, 'interior_regions': interior_regions, 'interior_holes': interior_holes, 'poly_geo_reference': geo_ref_poly, 'mesh_geo_reference': mesh_geo, 'verbose': False }, verbose=False, clear=1) m = create_mesh_from_regions(polygon, boundary_tags, maximum_triangle_area=10000000, interior_regions=interior_regions, poly_geo_reference=geo_ref_poly, mesh_geo_reference=mesh_geo, verbose=False, use_cache=True) # Test the mesh instance self.assertTrue(len(m.regions) == 3, 'FAILED!') segs = m.getUserSegments() self.assertTrue(len(segs) == 12, 'FAILED!') self.assertTrue(len(m.userVertices) == 12, 'FAILED!') self.assertTrue(segs[0].tag == 'walls', 'FAILED!') self.assertTrue(segs[1].tag == 'walls', 'FAILED!') self.assertTrue(segs[2].tag == 'bom', 'FAILED!') self.assertTrue(segs[3].tag == 'bom', 'FAILED!') # Assuming the order of the region points is known. # (This isn't true, if you consider create_mesh_from_regions # a black box) poly_point = m.getRegions()[0] # poly_point values are relative to the mesh geo-ref # make them absolute self.assertTrue( is_inside_polygon([poly_point.x + x, poly_point.y + y], polygon_absolute, closed=False), 'FAILED!') # Assuming the order of the region points is known. # (This isn't true, if you consider create_mesh_from_regions # a black box) poly_point = m.getRegions()[1] # poly_point values are relative to the mesh geo-ref # make them absolute self.assertTrue( is_inside_polygon([poly_point.x + x, poly_point.y + y], inner1_polygon_absolute, closed=False), 'FAILED!') # Assuming the order of the region points is known. # (This isn't true, if you consider create_mesh_from_regions # a black box) poly_point = m.getRegions()[2] # poly_point values are relative to the mesh geo-ref # make them absolute self.assertTrue( is_inside_polygon([poly_point.x + x, poly_point.y + y], inner2_polygon_absolute, closed=False), 'FAILED!') # Now create m using cached values m_cache = create_mesh_from_regions(polygon, boundary_tags, 10000000, interior_regions=interior_regions, poly_geo_reference=geo_ref_poly, mesh_geo_reference=mesh_geo, verbose=False, use_cache=True)
def create_mesh_from_regions(bounding_polygon, boundary_tags, maximum_triangle_area=None, filename=None, interior_regions=None, interior_holes=None, hole_tags=None, poly_geo_reference=None, mesh_geo_reference=None, minimum_triangle_angle=28.0, fail_if_polygons_outside=True, breaklines=None, use_cache=False, verbose=True, regionPtArea=None): """Create mesh from bounding polygons, and resolutions. bounding_polygon is a list of points in Eastings and Northings, relative to the poly_geo_reference. Boundary tags is a dictionary of symbolic tags. For every tag there is a list of indices referring to segments associated with that tag. If a segment is omitted an Exception will be raised. maximum_triangle_area is the maximal area per triangle for the bounding polygon, excluding the interior regions. Interior_regions is a list of tuples consisting of (polygon, resolution) for each region to be separately refined. Do not have polygon lines cross or be on-top of each other. Also do not have polygon close to each other. NOTE: If a interior_region is outside the bounding_polygon it should throw an error Interior_holes is a list of polygons for each hole. hole_tags is an optional list of boundary tags for the holes, see boundary_tags parameter. This function does not allow segments to share points - use underlying pmesh functionality for that poly_geo_reference is the geo_reference of the bounding polygon and the interior polygons. If none, assume absolute. Please pass one though, since absolute references have a zone. mesh_geo_reference is the geo_reference of the mesh to be created. If none is given one will be automatically generated. It was use the lower left hand corner of bounding_polygon (absolute) as the x and y values for the geo_ref. breaklines is a list of polygons. These lines will be preserved by the triangulation algorithm - useful for coastlines, walls, etc. The polygons are not closed. Returns the mesh instance if no filename is given Note, interior regions should be fully nested, as overlaps may cause unintended resolutions. fail_if_polygons_outside: If True (the default) Exception in thrown where interior polygons fall outside bounding polygon. If False, these will be ignored and execution continued. """ if verbose: log.resource_usage_timing(log.logging.INFO, "start_") if verbose: log.timingInfo("maximum_triangle_area, " + str(maximum_triangle_area)) if verbose: log.timingInfo("minimum_triangle_angle, " + str(minimum_triangle_angle)) if verbose: log.timingInfo("startMesh, '%s'" % log.CurrentDateTime()) # Build arguments and keyword arguments for use with caching or apply. args = (bounding_polygon, boundary_tags) kwargs = {'maximum_triangle_area': maximum_triangle_area, 'filename': filename, 'interior_regions': interior_regions, 'interior_holes': interior_holes, 'hole_tags': hole_tags, 'poly_geo_reference': poly_geo_reference, 'mesh_geo_reference': mesh_geo_reference, 'minimum_triangle_angle': minimum_triangle_angle, 'fail_if_polygons_outside': fail_if_polygons_outside, 'breaklines': breaklines, 'verbose': verbose, 'regionPtArea': regionPtArea} # FIXME (Ole): Should be bypassed one day. See ticket:14 # Call underlying engine with or without caching if use_cache is True: try: from anuga.caching import cache except: msg = 'Caching was requested, but caching module'+\ 'could not be imported' raise Exception(msg) m = cache(_create_mesh_from_regions, args, kwargs, verbose=verbose, compression=False) else: m = apply(_create_mesh_from_regions, args, kwargs) return m
def create_mesh_from_regions(bounding_polygon, boundary_tags, maximum_triangle_area=None, filename=None, interior_regions=None, interior_holes=None, hole_tags=None, poly_geo_reference=None, mesh_geo_reference=None, minimum_triangle_angle=28.0, fail_if_polygons_outside=True, breaklines=None, use_cache=False, verbose=True, regionPtArea=None): """Create mesh from bounding polygons, and resolutions. bounding_polygon is a list of points in Eastings and Northings, relative to the poly_geo_reference. Boundary tags is a dictionary of symbolic tags. For every tag there is a list of indices referring to segments associated with that tag. If a segment is omitted an Exception will be raised. maximum_triangle_area is the maximal area per triangle for the bounding polygon, excluding the interior regions. Interior_regions is a list of tuples consisting of (polygon, resolution) for each region to be separately refined. Do not have polygon lines cross or be on-top of each other. Also do not have polygon close to each other. NOTE: If a interior_region is outside the bounding_polygon it should throw an error Interior_holes is a list of polygons for each hole. hole_tags is an optional list of boundary tags for the holes, see boundary_tags parameter. This function does not allow segments to share points - use underlying pmesh functionality for that poly_geo_reference is the geo_reference of the bounding polygon and the interior polygons. If none, assume absolute. Please pass one though, since absolute references have a zone. mesh_geo_reference is the geo_reference of the mesh to be created. If none is given one will be automatically generated. It was use the lower left hand corner of bounding_polygon (absolute) as the x and y values for the geo_ref. breaklines is a list of polygons. These lines will be preserved by the triangulation algorithm - useful for coastlines, walls, etc. The polygons are not closed. Returns the mesh instance if no filename is given Note, interior regions should be fully nested, as overlaps may cause unintended resolutions. fail_if_polygons_outside: If True (the default) Exception in thrown where interior polygons fall outside bounding polygon. If False, these will be ignored and execution continued. """ if verbose: log.resource_usage_timing(log.logging.INFO, "start_") if verbose: log.timingInfo("maximum_triangle_area, " + str(maximum_triangle_area)) if verbose: log.timingInfo("minimum_triangle_angle, " + str(minimum_triangle_angle)) if verbose: log.timingInfo("startMesh, '%s'" % log.CurrentDateTime()) # Build arguments and keyword arguments for use with caching or apply. args = (bounding_polygon, boundary_tags) kwargs = { 'maximum_triangle_area': maximum_triangle_area, 'filename': filename, 'interior_regions': interior_regions, 'interior_holes': interior_holes, 'hole_tags': hole_tags, 'poly_geo_reference': poly_geo_reference, 'mesh_geo_reference': mesh_geo_reference, 'minimum_triangle_angle': minimum_triangle_angle, 'fail_if_polygons_outside': fail_if_polygons_outside, 'breaklines': breaklines, 'verbose': verbose, 'regionPtArea': regionPtArea } # FIXME (Ole): Should be bypassed one day. See ticket:14 # Call underlying engine with or without caching if use_cache is True: try: from anuga.caching import cache except: msg = 'Caching was requested, but caching module'+\ 'could not be imported' raise Exception(msg) m = cache(_create_mesh_from_regions, args, kwargs, verbose=verbose, compression=False) else: m = apply(_create_mesh_from_regions, args, kwargs) return m
def create_domain_from_regions(bounding_polygon, boundary_tags, maximum_triangle_area=None, mesh_filename=None, interior_regions=None, interior_holes=None, hole_tags=None, poly_geo_reference=None, mesh_geo_reference=None, breaklines=None, regionPtArea=None, minimum_triangle_angle=28.0, fail_if_polygons_outside=True, use_cache=False, verbose=False): """Create domain from bounding polygons and resolutions. bounding_polygon is a list of points in Eastings and Northings, relative to the zone stated in poly_geo_reference if specified. Otherwise points are just x, y coordinates with no particular association to any location. boundary_tags is a dictionary of symbolic tags. For every tag there is a list of indices referring to segments associated with that tag. If a segment is omitted it will be assigned the default tag ''. maximum_triangle_area is the maximal area per triangle for the bounding polygon, excluding the interior regions. Interior_regions is a list of tuples consisting of (polygon, resolution) for each region to be separately refined. Do not have polygon lines cross or be on-top of each other. Also do not have polygon close to each other. NOTE: If a interior_region is outside the bounding_polygon it should throw an error interior_holes is a list of polygons for each hole. These polygons do not need to be closed, but their points must be specified in a counter-clockwise order. hole_tags is a list of tag segment dictionaries. This function does not allow segments to share points - use underlying pmesh functionality for that poly_geo_reference is the geo_reference of the bounding polygon and the interior polygons. If none, assume absolute. Please pass one though, since absolute references have a zone. mesh_geo_reference is the geo_reference of the mesh to be created. If none is given one will be automatically generated. It was use the lower left hand corner of bounding_polygon (absolute) as the x and y values for the geo_ref. breaklines is a list of polygons. These lines will be preserved by the triangulation algorithm - useful for coastlines, walls, etc. The polygons are not closed. regionPtArea is a list of user-specified point-based regions with max area Returns the shallow water domain instance Note, interior regions should be fully nested, as overlaps may cause unintended resolutions. fail_if_polygons_outside: If True (the default) Exception in thrown where interior polygons fall outside bounding polygon. If False, these will be ignored and execution continued. """ # Build arguments and keyword arguments for use with caching or apply. args = (bounding_polygon, boundary_tags) if mesh_filename is None: import tempfile import time mesh_filename = 'mesh_%d.msh' % int(time.time()) kwargs = { 'maximum_triangle_area': maximum_triangle_area, 'mesh_filename': mesh_filename, 'interior_regions': interior_regions, 'interior_holes': interior_holes, 'hole_tags': hole_tags, 'poly_geo_reference': poly_geo_reference, 'mesh_geo_reference': mesh_geo_reference, 'breaklines': breaklines, 'regionPtArea': regionPtArea, 'minimum_triangle_angle': minimum_triangle_angle, 'fail_if_polygons_outside': fail_if_polygons_outside, 'verbose': verbose } #FIXME (Ole): See ticket:14 # Call underlying engine with or without caching if use_cache is True: try: from anuga.caching import cache except: msg = 'Caching was requested, but caching module'+\ 'could not be imported' raise (msg) domain = cache(_create_domain_from_regions, args, kwargs, verbose=verbose, compression=False) else: domain = apply(_create_domain_from_regions, args, kwargs) return domain
from anuga.fit_interpolate.fit import _fit_to_mesh import project import numpy as num import time internal_verbose = True # Verbosity used within this function filename=project.bathymetry_filename alpha=0.02 from anuga.config import points_file_block_line_size as max_read_lines #------------------------- # Create Domain from mesh #------------------------- domain = cache(Domain, (project.mesh_filename, {'verbose': True}), verbose=False) # Clear caching of underlying function args = (filename, ) kwargs = {'vertex_coordinates': None, 'triangles': None, 'mesh': domain.mesh, 'point_attributes': None, 'alpha': alpha, 'verbose': internal_verbose, 'mesh_origin': None, 'data_origin': None, 'max_read_lines': max_read_lines, 'attribute_name': None }
def create_domain_from_regions(bounding_polygon, boundary_tags, maximum_triangle_area=None, mesh_filename=None, interior_regions=None, interior_holes=None, hole_tags=None, poly_geo_reference=None, mesh_geo_reference=None, breaklines=None, regionPtArea=None, minimum_triangle_angle=28.0, fail_if_polygons_outside=True, use_cache=False, verbose=False): """Create domain from bounding polygons and resolutions. bounding_polygon is a list of points in Eastings and Northings, relative to the zone stated in poly_geo_reference if specified. Otherwise points are just x, y coordinates with no particular association to any location. boundary_tags is a dictionary of symbolic tags. For every tag there is a list of indices referring to segments associated with that tag. If a segment is omitted it will be assigned the default tag ''. maximum_triangle_area is the maximal area per triangle for the bounding polygon, excluding the interior regions. Interior_regions is a list of tuples consisting of (polygon, resolution) for each region to be separately refined. Do not have polygon lines cross or be on-top of each other. Also do not have polygon close to each other. NOTE: If a interior_region is outside the bounding_polygon it should throw an error interior_holes is a list of polygons for each hole. These polygons do not need to be closed, but their points must be specified in a counter-clockwise order. hole_tags is a list of tag segment dictionaries. This function does not allow segments to share points - use underlying pmesh functionality for that poly_geo_reference is the geo_reference of the bounding polygon and the interior polygons. If none, assume absolute. Please pass one though, since absolute references have a zone. mesh_geo_reference is the geo_reference of the mesh to be created. If none is given one will be automatically generated. It was use the lower left hand corner of bounding_polygon (absolute) as the x and y values for the geo_ref. breaklines is a list of polygons. These lines will be preserved by the triangulation algorithm - useful for coastlines, walls, etc. The polygons are not closed. regionPtArea is a list of user-specified point-based regions with max area Returns the shallow water domain instance Note, interior regions should be fully nested, as overlaps may cause unintended resolutions. fail_if_polygons_outside: If True (the default) Exception in thrown where interior polygons fall outside bounding polygon. If False, these will be ignored and execution continued. """ # Build arguments and keyword arguments for use with caching or apply. args = (bounding_polygon, boundary_tags) if mesh_filename is None: import tempfile import time mesh_filename = 'mesh_%d.msh'%int(time.time()) kwargs = {'maximum_triangle_area': maximum_triangle_area, 'mesh_filename': mesh_filename, 'interior_regions': interior_regions, 'interior_holes': interior_holes, 'hole_tags': hole_tags, 'poly_geo_reference': poly_geo_reference, 'mesh_geo_reference': mesh_geo_reference, 'breaklines' : breaklines, 'regionPtArea' : regionPtArea, 'minimum_triangle_angle': minimum_triangle_angle, 'fail_if_polygons_outside': fail_if_polygons_outside, 'verbose': verbose} #FIXME (Ole): See ticket:14 # Call underlying engine with or without caching if use_cache is True: try: from anuga.caching import cache except: msg = 'Caching was requested, but caching module'+\ 'could not be imported' raise (msg) domain = cache(_create_domain_from_regions, args, kwargs, verbose=verbose, compression=False) else: domain = apply(_create_domain_from_regions, args, kwargs) return domain
def file_function(filename, domain=None, quantities=None, interpolation_points=None, time_thinning=1, time_limit=None, verbose=False, use_cache=False, boundary_polygon=None, output_centroids=False): """Read time history of spatial data from NetCDF file and return a callable object. Input variables: filename - Name of sww, tms or sts file If the file has extension 'sww' then it is assumed to be spatio-temporal or temporal and the callable object will have the form f(t,x,y) or f(t) depending on whether the file contains spatial data If the file has extension 'tms' then it is assumed to be temporal only and the callable object will have the form f(t) Either form will return interpolated values based on the input file using the underlying interpolation_function. domain - Associated domain object If domain is specified, model time (domain.starttime) will be checked and possibly modified. All times are assumed to be in UTC All spatial information is assumed to be in absolute UTM coordinates. quantities - the name of the quantity to be interpolated or a list of quantity names. The resulting function will return a tuple of values - one for each quantity If quantities are None, the default quantities are ['stage', 'xmomentum', 'ymomentum'] interpolation_points - list of absolute UTM coordinates for points (N x 2) or geospatial object or points file name at which values are sought time_thinning - verbose - use_cache: True means that caching of intermediate result of Interpolation_function is attempted boundary_polygon - See Interpolation function in anuga.fit_interpolate.interpolation for further documentation """ # FIXME (OLE): Should check origin of domain against that of file # In fact, this is where origin should be converted to that of domain # Also, check that file covers domain fully. # Take into account: # - domain's georef # - sww file's georef # - interpolation points as absolute UTM coordinates if quantities is None: if verbose: msg = 'Quantities specified in file_function are None,' msg += ' so using stage, xmomentum, and ymomentum in that order' log.critical(msg) quantities = ['stage', 'xmomentum', 'ymomentum'] # Use domain's startime if available if domain is not None: domain_starttime = domain.get_starttime() else: domain_starttime = None # Build arguments and keyword arguments for use with caching or apply. args = (filename, ) # FIXME (Ole): Caching this function will not work well # if domain is passed in as instances change hash code. # Instead we pass in those attributes that are needed (and return them # if modified) kwargs = { 'quantities': quantities, 'interpolation_points': interpolation_points, 'domain_starttime': domain_starttime, 'time_thinning': time_thinning, 'time_limit': time_limit, 'verbose': verbose, 'boundary_polygon': boundary_polygon, 'output_centroids': output_centroids } # Call underlying engine with or without caching if use_cache is True: try: from anuga.caching import cache except: msg = 'Caching was requested, but caching module'+\ 'could not be imported' raise Exception(msg) f, starttime = cache(_file_function, args, kwargs, dependencies=[filename], compression=False, verbose=verbose) else: f, starttime = apply(_file_function, args, kwargs) #FIXME (Ole): Pass cache arguments, such as compression, in some sort of #structure f.starttime = starttime f.filename = filename if domain is not None: #Update domain.startime if it is *earlier* than starttime from file if starttime > domain.starttime: msg = 'WARNING: Start time as specified in domain (%f)' \ % domain.starttime msg += ' is earlier than the starttime of file %s (%f).' \ % (filename, starttime) msg += ' Modifying domain starttime accordingly.' if verbose: log.critical(msg) domain.set_starttime(starttime) #Modifying model time if verbose: log.critical('Domain starttime is now set to %f' % domain.starttime) return f
def file_function(filename, domain=None, quantities=None, interpolation_points=None, time_thinning=1, time_limit=None, verbose=False, use_cache=False, boundary_polygon=None, output_centroids=False): """Read time history of spatial data from NetCDF file and return a callable object. Input variables: filename - Name of sww, tms or sts file If the file has extension 'sww' then it is assumed to be spatio-temporal or temporal and the callable object will have the form f(t,x,y) or f(t) depending on whether the file contains spatial data If the file has extension 'tms' then it is assumed to be temporal only and the callable object will have the form f(t) Either form will return interpolated values based on the input file using the underlying interpolation_function. domain - Associated domain object If domain is specified, model time (domain.starttime) will be checked and possibly modified. All times are assumed to be in UTC All spatial information is assumed to be in absolute UTM coordinates. quantities - the name of the quantity to be interpolated or a list of quantity names. The resulting function will return a tuple of values - one for each quantity If quantities are None, the default quantities are ['stage', 'xmomentum', 'ymomentum'] interpolation_points - list of absolute UTM coordinates for points (N x 2) or geospatial object or points file name at which values are sought time_thinning - verbose - use_cache: True means that caching of intermediate result of Interpolation_function is attempted boundary_polygon - See Interpolation function in anuga.fit_interpolate.interpolation for further documentation """ # FIXME (OLE): Should check origin of domain against that of file # In fact, this is where origin should be converted to that of domain # Also, check that file covers domain fully. # Take into account: # - domain's georef # - sww file's georef # - interpolation points as absolute UTM coordinates if quantities is None: if verbose: msg = 'Quantities specified in file_function are None,' msg += ' so using stage, xmomentum, and ymomentum in that order' log.critical(msg) quantities = ['stage', 'xmomentum', 'ymomentum'] # Use domain's startime if available if domain is not None: domain_starttime = domain.get_starttime() else: domain_starttime = None # Build arguments and keyword arguments for use with caching or apply. args = (filename,) # FIXME (Ole): Caching this function will not work well # if domain is passed in as instances change hash code. # Instead we pass in those attributes that are needed (and return them # if modified) kwargs = {'quantities': quantities, 'interpolation_points': interpolation_points, 'domain_starttime': domain_starttime, 'time_thinning': time_thinning, 'time_limit': time_limit, 'verbose': verbose, 'boundary_polygon': boundary_polygon, 'output_centroids': output_centroids} # Call underlying engine with or without caching if use_cache is True: try: from anuga.caching import cache except: msg = 'Caching was requested, but caching module'+\ 'could not be imported' raise Exception(msg) f, starttime = cache(_file_function, args, kwargs, dependencies=[filename], compression=False, verbose=verbose) else: f, starttime = apply(_file_function, args, kwargs) #FIXME (Ole): Pass cache arguments, such as compression, in some sort of #structure f.starttime = starttime f.filename = filename if domain is not None: #Update domain.startime if it is *earlier* than starttime from file if starttime > domain.starttime: msg = 'WARNING: Start time as specified in domain (%f)' \ % domain.starttime msg += ' is earlier than the starttime of file %s (%f).' \ % (filename, starttime) msg += ' Modifying domain starttime accordingly.' if verbose: log.critical(msg) domain.set_starttime(starttime) #Modifying model time if verbose: log.critical('Domain starttime is now set to %f' % domain.starttime) return f
def test_create_mesh_from_regions_with_caching(self): x=-500 y=-1000 mesh_geo = geo_reference=Geo_reference(56, x, y) # These are the absolute values polygon_absolute = [[0,0], [100,0], [100,100], [0,100]] x_p = -10 y_p = -40 geo_ref_poly = Geo_reference(56, x_p, y_p) polygon = geo_ref_poly.change_points_geo_ref(polygon_absolute) boundary_tags = {'walls': [0,1], 'bom': [2,3]} inner1_polygon_absolute = [[10,10], [20,10], [20,20], [10,20]] inner1_polygon = geo_ref_poly.\ change_points_geo_ref(inner1_polygon_absolute) inner2_polygon_absolute = [[30,30], [40,30], [40,40], [30,40]] inner2_polygon = geo_ref_poly.\ change_points_geo_ref(inner2_polygon_absolute) interior_regions = [(inner1_polygon, 5), (inner2_polygon, 10)] interior_holes = None # Clear cache first from anuga.caching import cache cache(_create_mesh_from_regions, (polygon, boundary_tags), {'minimum_triangle_angle': 28.0, 'maximum_triangle_area': 10000000, 'interior_regions': interior_regions, 'interior_holes': interior_holes, 'poly_geo_reference': geo_ref_poly, 'mesh_geo_reference': mesh_geo, 'verbose': False}, verbose=False, clear=1) m = create_mesh_from_regions(polygon, boundary_tags, maximum_triangle_area=10000000, interior_regions=interior_regions, poly_geo_reference=geo_ref_poly, mesh_geo_reference=mesh_geo, verbose=False, use_cache=True) # Test the mesh instance self.assertTrue(len(m.regions)==3, 'FAILED!') segs = m.getUserSegments() self.assertTrue(len(segs)==12, 'FAILED!') self.assertTrue(len(m.userVertices)==12, 'FAILED!') self.assertTrue(segs[0].tag=='walls', 'FAILED!') self.assertTrue(segs[1].tag=='walls', 'FAILED!') self.assertTrue(segs[2].tag=='bom', 'FAILED!') self.assertTrue(segs[3].tag=='bom', 'FAILED!') # Assuming the order of the region points is known. # (This isn't true, if you consider create_mesh_from_regions # a black box) poly_point = m.getRegions()[0] # poly_point values are relative to the mesh geo-ref # make them absolute self.assertTrue(is_inside_polygon([poly_point.x+x, poly_point.y+y], polygon_absolute, closed=False), 'FAILED!') # Assuming the order of the region points is known. # (This isn't true, if you consider create_mesh_from_regions # a black box) poly_point = m.getRegions()[1] # poly_point values are relative to the mesh geo-ref # make them absolute self.assertTrue(is_inside_polygon([poly_point.x+x, poly_point.y+y], inner1_polygon_absolute, closed=False), 'FAILED!') # Assuming the order of the region points is known. # (This isn't true, if you consider create_mesh_from_regions # a black box) poly_point = m.getRegions()[2] # poly_point values are relative to the mesh geo-ref # make them absolute self.assertTrue(is_inside_polygon([poly_point.x+x, poly_point.y+y], inner2_polygon_absolute, closed=False), 'FAILED!') # Now create m using cached values m_cache = create_mesh_from_regions(polygon, boundary_tags, 10000000, interior_regions=interior_regions, poly_geo_reference=geo_ref_poly, mesh_geo_reference=mesh_geo, verbose=False, use_cache=True)
from anuga.fit_interpolate.fit import _fit_to_mesh import project import numpy as num import time internal_verbose = True # Verbosity used within this function filename = project.bathymetry_filename alpha = 0.02 from anuga.config import points_file_block_line_size as max_read_lines #------------------------- # Create Domain from mesh #------------------------- domain = cache(Domain, (project.mesh_filename, { 'verbose': True }), verbose=False) # Clear caching of underlying function args = (filename, ) kwargs = { 'vertex_coordinates': None, 'triangles': None, 'mesh': domain.mesh, 'point_attributes': None, 'alpha': alpha, 'verbose': internal_verbose, 'mesh_origin': None, 'data_origin': None, 'max_read_lines': max_read_lines, 'attribute_name': None