def test_main(): flex = gflex.F2D() flex.Quiet = False flex.Method = 'FD' # Solution method: * FD (finite difference) # * SAS (superposition of analytical solutions) # * SAS_NG (ungridded SAS) flex.PlateSolutionType = 'vWC1994' # van Wees and Cloetingh (1994) # The other option is 'G2009': Govers et al. (2009) flex.Solver = 'direct' # direct or iterative # convergence = 1E-3 # convergence between iterations, if an iterative solution # method is chosen flex.g = 9.8 # acceleration due to gravity flex.E = 65E9 # Young's Modulus flex.nu = 0.25 # Poisson's Ratio flex.rho_m = 3300. # MantleDensity flex.rho_fill = 0. # InfiillMaterialDensity flex.Te = 35000. * np.ones( (50, 50)) # Elastic thickness [m] -- scalar but may be an array flex.Te[:, -3:] = 0. flex.qs = np.zeros((50, 50)) # Template array for surface load stresses flex.qs[10:40, 10:40] += 1E6 # Populating this template flex.dx = 5000. # grid cell size, x-oriented [m] flex.dy = 5000. # grid cell size, y-oriented [m] # Boundary conditions can be: # (FD): 0Slope0Shear, 0Moment0Shear, 0Displacement0Slope, Mirror, or Periodic # For SAS or SAS_NG, NoOutsideLoads is valid, and no entry defaults to this flex.BC_W = '0Displacement0Slope' # west boundary condition flex.BC_E = '0Moment0Shear' # east boundary condition flex.BC_S = '0Displacement0Slope' # south boundary condition flex.BC_N = '0Displacement0Slope' # north boundary condition # latitude/longitude solutions are exact for SAS, approximate otherwise #latlon = # true/false: flag to enable lat/lon input. Defaults False. #PlanetaryRadius = # radius of planet [m], for lat/lon solutions flex.initialize() flex.run() flex.finalize() # If you want to plot the output #flex.plotChoice='both' # An output file for deflections could also be defined here # flex.wOutFile = flex.output() # Plots and/or saves output, or does nothing, depending on # whether flex.plotChoice and/or flex.wOutFile have been set # TO OBTAIN OUTPUT DIRECTLY IN PYTHON, you can assign the internal variable, # flex.w, to another variable -- or as an element in a list if you are looping # over many runs of gFlex: deflection = flex.w
def start_gflex_and_assign_default_variables(self): import gflex self.flex = gflex.F2D() self.flex.Quiet = False self.flex.Method = 'FD' self.flex.PlateSolutionType = 'vWC1994' self.flex.Solver = 'direct' self.flex.g = 9.8 # acceleration due to gravity self.flex.E = 65E9 # Young's Modulus self.flex.nu = 0.25 # Poisson's Ratio self.flex.rho_m = 3300. # MantleDensity self.flex.rho_fill = 0. # InfiillMaterialDensity self.flex.BC_W = '0Displacement0Slope' # west boundary condition self.flex.BC_E = '0Displacement0Slope' # east boundary condition self.flex.BC_S = '0Displacement0Slope' # south boundary condition self.flex.BC_N = '0Displacement0Slope' # north boundary condition self.flex.north = None self.flex.south = None self.flex.west = None self.flex.east = None self.flex.dx = None self.flex.dy = None
def __init__(self, grid, Youngs_modulus=6.5e11, Poissons_ratio=0.25, rho_mantle=3300., rho_fill=0., elastic_thickness=35000., BC_W='0Displacement0Slope', BC_E='0Displacement0Slope', BC_N='0Displacement0Slope', BC_S='0Displacement0Slope', g=9.81, **kwds): """Constructor for Wickert's gFlex in Landlab.""" assert RasterModelGrid in inspect.getmro(grid.__class__) if NO_GFLEX: raise ImportError( "gFlex not installed! For installation instructions see " + "gFlex on GitHub: https://github.com/awickert/gFlex") BC_options = ('0Displacement0Slope', '0Moment0Shear', '0Slope0Shear', 'Periodic') # instantiate the module: self.flex = gflex.F2D() flex = self.flex # set up the grid variables: self._grid = grid flex.dx = grid.dx flex.dy = grid.dy # we assume these properties are fixed in this relatively # straightforward implementation, but they can still be set if you # want: try: flex.Method = kwds['Method'] except KeyError: flex.Method = 'FD' try: flex.PlateSolutionType = kwds['PlateSolutionType'] except KeyError: flex.PlateSolutionType = 'vWC1994' try: flex.Solver = kwds['Solver'] except KeyError: flex.Solver = 'direct' try: quiet = kwds['Quiet'] except KeyError: flex.Quiet = True else: flex.Quiet = bool(quiet) flex.E = float(Youngs_modulus) flex.nu = float(Poissons_ratio) flex.rho_m = float(rho_mantle) flex.rho_fill = float(rho_fill) flex.g = float(g) flex.BC_W = BC_W flex.BC_E = BC_E flex.BC_S = BC_S flex.BC_N = BC_N for i in (flex.BC_E, flex.BC_W, flex.BC_N, flex.BC_S): assert i in BC_options if BC_W == 'Periodic': assert BC_E == 'Periodic' if BC_E == 'Periodic': assert BC_W == 'Periodic' if BC_N == 'Periodic': assert BC_S == 'Periodic' if BC_S == 'Periodic': assert BC_N == 'Periodic' Te_in = elastic_thickness try: flex.Te = float(Te_in) except ValueError: try: flex.Te = grid.at_node[Te_in].view().reshape(grid.shape) except TypeError: flex.Te = Te_in.view().reshape(grid.shape) self._input_var_names.add(Te_in) self._output_var_names.add(Te_in) # set up the link between surface load stresses in the gFlex component # and the LL grid field: flex.qs = grid.at_node['surface_load__stress'].view().reshape( grid.shape) # create a holder for the "pre-flexure" state of the grid, to allow # updating of elevs: self.pre_flex = np.zeros(grid.number_of_nodes, dtype=float) # create the primary output field: self.grid.add_zeros('lithosphere__vertical_displacement', at='node', dtype=float, noclobber=False)
def main(): """ Superposition of analytical solutions in gFlex for flexural isostasy in GRASS GIS """ options, flags = grass.parser() # if just interface description is requested, it will not get to this point # so gflex will not be needed # GFLEX # try to import gflex only after we know that # we will actually do the computation try: import gflex except: print("") print("MODULE IMPORT ERROR.") print( "In order to run r.flexure or g.flexure, you must download and install" ) print("gFlex. The most recent development version is available from") print("https://github.com/awickert/gFlex") print("Installation instructions are available on the page.") grass.fatal("Software dependency must be installed.") ########## # SET-UP # ########## # This code is for 2D flexural isostasy flex = gflex.F2D() # And show that it is coming from GRASS GIS flex.grass = True # Method flex.Method = 'SAS_NG' # Parameters that are often changed for the solution ###################################################### # x, y, q flex.x, flex.y = get_points_xy(options['input']) # xw, yw: gridded output if len( grass.parse_command('g.list', type='vect', pattern=options['output'])): if not grass.overwrite(): grass.fatal("Vector map '" + options['output'] + "' already exists. Use '--o' to overwrite.") # Just check raster at the same time if it exists if len( grass.parse_command('g.list', type='rast', pattern=options['raster_output'])): if not grass.overwrite(): grass.fatal("Raster map '" + options['raster_output'] + "' already exists. Use '--o' to overwrite.") grass.run_command('v.mkgrid', map=options['output'], type='point', overwrite=grass.overwrite(), quiet=True) grass.run_command('v.db.addcolumn', map=options['output'], columns='w double precision', quiet=True) flex.xw, flex.yw = get_points_xy( options['output']) # gridded output coordinates vect_db = grass.vector_db_select(options['input']) col_names = np.array(vect_db['columns']) q_col = (col_names == options['column']) if np.sum(q_col): col_values = np.array(list(vect_db['values'].values())).astype(float) flex.q = col_values[:, q_col].squeeze( ) # Make it 1D for consistency w/ x, y else: grass.fatal("provided column name, " + options['column'] + " does not match\nany column in " + options['q0'] + ".") # Elastic thickness flex.Te = float(options['te']) if options['te_units'] == 'km': flex.Te *= 1000 elif options['te_units'] == 'm': pass else: grass.fatal( "Inappropriate te_units. How? Options should be limited by GRASS.") flex.rho_fill = float(options['rho_fill']) # Parameters that often stay at their default values ###################################################### flex.g = float(options['g']) flex.E = float(options['ym'] ) # Can't just use "E" because reserved for "east", I think flex.nu = float(options['nu']) flex.rho_m = float(options['rho_m']) # Set verbosity if grass.verbosity() >= 2: flex.Verbose = True if grass.verbosity() >= 3: flex.Debug = True elif grass.verbosity() == 0: flex.Quiet = True # Check if lat/lon and let user know if verbosity is True if grass.region_env()[6] == '3': flex.latlon = True flex.PlanetaryRadius = float( grass.parse_command('g.proj', flags='j')['+a']) if flex.Verbose: print("Latitude/longitude grid.") print("Based on r_Earth = 6371 km") print( "Computing distances between load points using great circle paths" ) ########## # SOLVE! # ########## flex.initialize() flex.run() flex.finalize() # Now to use lower-level GRASS vector commands to work with the database # table and update its entries # See for help: # http://nbviewer.ipython.org/github/zarch/workshop-pygrass/blob/master/02_Vector.ipynb w = vector.VectorTopo(options['output']) w.open('rw') # Get ready to read and write wdb = w.dblinks[0] wtable = wdb.table() col = int((np.array( wtable.columns.names()) == 'w').nonzero()[0]) # update this column for i in range(1, len(w) + 1): # ignoring 1st column: assuming it will be category (always true here) wnewvalues = list(w[i].attrs.values())[1:col] + tuple( [flex.w[i - 1]]) + list(w[i].attrs.values())[col + 1:] wtable.update(key=i, values=wnewvalues) wtable.conn.commit() # Save this w.close(build=False) # don't build here b/c it is always verbose grass.run_command('v.build', map=options['output'], quiet=True) # And raster export # "w" vector defined by raster resolution, so can do direct v.to.rast # though if this option isn't selected, the user can do a finer-grained # interpolation, which shouldn't introduce much error so long as these # outputs are spaced at << 1 flexural wavelength. if options['raster_output']: grass.run_command('v.to.rast', input=options['output'], output=options['raster_output'], use='attr', attribute_column='w', type='point', overwrite=grass.overwrite(), quiet=True) # And create a nice colormap! grass.run_command('r.colors', map=options['raster_output'], color='differences', quiet=True)
def buildGrid(self, nx, ny, youngMod, mantleDensity, sedimentDensity, elasticT, elasticT2, Boundaries, xyTIN, ftime): """ gFlex initialisation function. Args: nx: number of points along the X axis ny: number of points along the Y axis youngMod: Young's modulus mantleDensity: mantle density sedimentDensity: sediment density elasticT: elastic thickness. Can be scalar or an array elasticT2: initial elastic thickness. Boundaries: list of string describing boundary conditions for West, East, South and North. xyTIN: numpy float-type array containing the coordinates for each nodes in the TIN ftime: flexure time step """ # Build the flexural grid self.nx = nx self.ny = ny self.xyTIN = xyTIN xmin, xmax = min(self.xyTIN[:,0]), max(self.xyTIN[:,0]) ymin, ymax = min(self.xyTIN[:,1]), max(self.xyTIN[:,1]) self.xgrid = numpy.linspace(xmin,xmax,num=self.nx) self.ygrid = numpy.linspace(ymin,ymax,num=self.ny) self.xi, self.yi = numpy.meshgrid(self.xgrid, self.ygrid) self.xyi = numpy.dstack([self.xi.flatten(), self.yi.flatten()])[0] self.ftime = ftime # Call gFlex instance self.flex = gflex.F2D() flex = self.flex # Set-up the grid variable self.flex.dx = self.xgrid[1]-self.xgrid[0] self.flex.dy = self.ygrid[1]-self.ygrid[0] self.ball = math.sqrt(0.25*(self.flex.dx*self.flex.dx + self.flex.dy*self.flex.dy)) tindx = self.xyTIN[1,0] - self.xyTIN[0,0] self.searchpts = max(int(self.flex.dx*self.flex.dy/(tindx*tindx)),4) # Solution method finite difference self.flex.Method = 'FD' self.flex.Quiet = True # van Wees and Cloetingh (1994) self.flex.PlateSolutionType = 'vWC1994' self.flex.Solver = 'direct' # Acceleration due to gravity self.flex.g = 9.8 # Poisson's Ratio self.flex.nu = 0.25 # Infill Material Density self.flex.rho_fill = 0. # Young's Modulus self.flex.E = youngMod # Mantle Density self.flex.rho_m = mantleDensity # Sediment Density self.rho_s = sedimentDensity # Sea Water Density self.rho_w = 1029.0 # Elastic thickness [m] if isinstance(elasticT, str): TeMap = pandas.read_csv(elasticT, sep=r'\s+', engine='c', header=None, na_filter=False, dtype=numpy.float, low_memory=False) self.Te = numpy.reshape(TeMap.values, (self.ny, self.nx)) elif elasticT2 is None: self.Te = elasticT * numpy.ones((self.ny, self.nx)) else: self.Te = elasticT2 * numpy.ones((self.ny, self.nx)) self.Te1 = elasticT # Surface load stresses self.flex.qs = numpy.zeros((self.ny, self.nx), dtype=float) # Boundary conditions self.flex.BC_W = Boundaries[0] self.flex.BC_E = Boundaries[1] self.flex.BC_S = Boundaries[2] self.flex.BC_N = Boundaries[3] # State of the previous flexural grid used for updating current # flexural displacements. self.previous_flex = numpy.zeros((self.ny, self.nx), dtype=float) self.tree = cKDTree(self.xyTIN) #self.Acell = Acell return
def __init__( self, grid, Youngs_modulus=6.5e11, Poissons_ratio=0.25, rho_mantle=3300.0, rho_fill=0.0, elastic_thickness=35000.0, Method="FD", Solver="direct", PlateSolutionType="vWC1994", quiet=True, BC_W="0Displacement0Slope", BC_E="0Displacement0Slope", BC_N="0Displacement0Slope", BC_S="0Displacement0Slope", g=scipy.constants.g, ): """Constructor for Wickert's gFlex in Landlab.""" super(gFlex, self).__init__(grid) assert isinstance(grid, RasterModelGrid) if NO_GFLEX: raise ImportError( "gFlex not installed! For installation instructions see " + "gFlex on GitHub: https://github.com/awickert/gFlex") BC_options = ( "0Displacement0Slope", "0Moment0Shear", "0Slope0Shear", "Periodic", ) # instantiate the module: self._flex = gflex.F2D() flex = self._flex # set up the grid variables: flex.dx = grid.dx flex.dy = grid.dy # we assume these properties are fixed in this relatively # straightforward implementation, but they can still be set if you # want: flex.Method = Method flex.PlateSolutionType = PlateSolutionType flex.Solver = Solver flex.Quiet = quiet flex.E = float(Youngs_modulus) flex.nu = float(Poissons_ratio) flex.rho_m = float(rho_mantle) flex.rho_fill = float(rho_fill) flex.g = float(g) flex.BC_W = BC_W flex.BC_E = BC_E flex.BC_S = BC_S flex.BC_N = BC_N for i in (flex.BC_E, flex.BC_W, flex.BC_N, flex.BC_S): assert i in BC_options if BC_W == "Periodic": assert BC_E == "Periodic" if BC_E == "Periodic": assert BC_W == "Periodic" if BC_N == "Periodic": assert BC_S == "Periodic" if BC_S == "Periodic": assert BC_N == "Periodic" Te_in = elastic_thickness try: flex.Te = float(Te_in) except ValueError: try: flex.Te = grid.at_node[Te_in].view().reshape(grid.shape) except TypeError: flex.Te = Te_in.view().reshape(grid.shape) self._input_var_names.add(Te_in) self._output_var_names.add(Te_in) # set up the link between surface load stresses in the gFlex component # and the LL grid field: flex.qs = grid.at_node["surface_load__stress"].view().reshape( grid.shape) # create a holder for the "pre-flexure" state of the grid, to allow # updating of elevs: self._pre_flex = np.zeros(grid.number_of_nodes, dtype=float) # create the primary output field: self._grid.add_zeros( "lithosphere_surface__elevation_increment", at="node", dtype=float, clobber=True, )
#! /usr/bin/env python import gflex import numpy as np from matplotlib import pyplot as plt flex = gflex.F2D() flex.Quiet = False flex.Method = 'FD' # Solution method: * FD (finite difference) # * SAS (superposition of analytical solutions) # * SAS_NG (ungridded SAS) flex.PlateSolutionType = 'vWC1994' # van Wees and Cloetingh (1994) # The other option is 'G2009': Govers et al. (2009) flex.Solver = 'direct' # direct or iterative # convergence = 1E-3 # convergence between iterations, if an iterative solution # method is chosen flex.g = 9.8 # acceleration due to gravity flex.E = 65E9 # Young's Modulus flex.nu = 0.25 # Poisson's Ratio flex.rho_m = 3300. # MantleDensity flex.rho_fill = 0. # InfiillMaterialDensity flex.Te = 35000.*np.ones((50, 50)) # Elastic thickness [m] -- scalar but may be an array flex.Te[:,-3:] = 0. flex.qs = np.zeros((50, 50)) # Template array for surface load stresses flex.qs[10:40, 10:40] += 1E6 # Populating this template flex.dx = 5000. # grid cell size, x-oriented [m] flex.dy = 5000. # grid cell size, y-oriented [m]
def main(): """ Gridded flexural isostatic solutions """ options, flags = grass.parser() # if just interface description is requested, it will not get to this point # so gflex will not be needed # GFLEX # try to import gflex only after we know that # we will actually do the computation try: import gflex except: print("") print("MODULE IMPORT ERROR.") print("In order to run r.flexure or g.flexure, you must download and install") print("gFlex. The most recent development version is available from") print("https://github.com/awickert/gFlex.") print("Installation instructions are available on the page.") grass.fatal("Software dependency must be installed.") # This code is for 2D flexural isostasy flex = gflex.F2D() # And show that it is coming from GRASS GIS flex.grass = True # Flags latlon_override = flags["l"] # Inputs # Solution selection flex.Method = options["method"] if flex.Method == "FD": flex.Solver = options["solver"] if flex.Solver: flex.ConvergenceTolerance = options["tolerance"] # Always use the van Wees and Cloetingh (1994) solution type. # It is the best. flex.PlateSolutionType = "vWC1994" # Parameters that are often changed for the solution qs = options["input"] flex.qs = garray.array() flex.qs.read(qs) # Elastic thickness try: flex.Te = float(options["te"]) except: flex.Te = garray.array() # FlexureTe is the one that is used by Flexure flex.Te.read(options["te"]) flex.Te = np.array(flex.Te) if options["te_units"] == "km": flex.Te *= 1000 elif options["te_units"] == "m": pass # No "else"; shouldn't happen flex.rho_fill = float(options["rho_fill"]) # Parameters that often stay at their default values flex.g = float(options["g"]) flex.E = float( options["ym"] ) # Can't just use "E" because reserved for "east", I think flex.nu = float(options["nu"]) flex.rho_m = float(options["rho_m"]) # Solver type and iteration tolerance flex.Solver = options["solver"] flex.ConvergenceTolerance = float(options["tolerance"]) # Boundary conditions flex.BC_N = options["northbc"] flex.BC_S = options["southbc"] flex.BC_W = options["westbc"] flex.BC_E = options["eastbc"] # Set verbosity if grass.verbosity() >= 2: flex.Verbose = True if grass.verbosity() >= 3: flex.Debug = True elif grass.verbosity() == 0: flex.Quiet = True # First check if output exists if len(grass.parse_command("g.list", type="rast", pattern=options["output"])): if not grass.overwrite(): grass.fatal( "Raster map '" + options["output"] + "' already exists. Use '--o' to overwrite." ) # Get grid spacing from GRASS # Check if lat/lon and proceed as directed if grass.region_env()[6] == "3": if latlon_override: if flex.Verbose: print("Latitude/longitude grid.") print("Based on r_Earth = 6371 km") print("Setting y-resolution [m] to 111,195 * [degrees]") flex.dy = grass.region()["nsres"] * 111195.0 NSmid = (grass.region()["n"] + grass.region()["s"]) / 2.0 dx_at_mid_latitude = ( (3.14159 / 180.0) * 6371000.0 * np.cos(np.deg2rad(NSmid)) ) if flex.Verbose: print( "Setting x-resolution [m] to " + "%.2f" % dx_at_mid_latitude + " * [degrees]" ) flex.dx = grass.region()["ewres"] * dx_at_mid_latitude else: grass.fatal("Need the '-l' flag to enable lat/lon solution approximation.") # Otherwise straightforward else: flex.dx = grass.region()["ewres"] flex.dy = grass.region()["nsres"] # CALCULATE! flex.initialize() flex.run() flex.finalize() # Write to GRASS # Create a new garray buffer and write to it outbuffer = garray.array() # Instantiate output buffer outbuffer[...] = flex.w outbuffer.write( options["output"], overwrite=grass.overwrite() ) # Write it with the desired name # And create a nice colormap! grass.run_command( "r.colors", map=options["output"], color="differences", quiet=True )
def initialize(self, grid, params): """ grid must be a landlab RasterModelGrid to use gFlex. params may be a dictionary of input parameters, or a standard Landlab input text file. gFlex requires: * E, Young's modulus * nu, Poisson's ratio * rho_m, the mantle density * rho_fill, the infill material density * Te, the elastic thickness. Can be scalar or an nnodes-long array. If you want an array, supply a grid field name where the data can be found. * BC_W, BC_E, BC_S, BC_N, strings describing the boundary conditions. Choose from ('Dirichlet0', '0Moment0Shear', 'Periodic'). gFlex can take as options: * g, the gravitational acceleration (defaults to 9.81) gFlex takes as input fields: * surface_load__stress gFlex modifies/returns: * topographic__elevation (if it exists already) * lithosphere__vertical_displacement """ assert RasterModelGrid in inspect.getmro(grid.__class__) BC_options = ('Dirichlet0', '0Moment0Shear', '0Slope0Shear', 'Periodic') if type(params) == str: input_dict = ModelParameterDictionary(params) else: assert type(params) == dict input_dict = params #instantiate the module: self.flex = gflex.F2D() flex = self.flex #set up the grid variables: self._grid = grid flex.dx = grid.dx flex.dy = grid.dy #we assume these properties are fixed in this relatively #straightforward implementation, but they can still be set if you want: try: flex.Method = input_dict['Method'] except KeyError: flex.Method = 'FD' try: flex.PlateSolutionType = input_dict['PlateSolutionType'] except KeyError: flex.PlateSolutionType = 'vWC1994' try: flex.Solver = input_dict['Solver'] except KeyError: flex.Solver = 'direct' try: quiet = input_dict['Quiet'] except KeyError: flex.Quiet = True else: flex.Quiet = bool(quiet) flex.E = float(input_dict['E']) flex.nu = float(input_dict['nu']) flex.rho_m = float(input_dict['rho_m']) flex.rho_fill = float(input_dict['rho_fill']) try: flex.g = input_dict['g'] except KeyError: flex.g = 9.81 flex.BC_W = input_dict['BC_W'] flex.BC_E = input_dict['BC_E'] flex.BC_S = input_dict['BC_S'] flex.BC_N = input_dict['BC_N'] for i in (flex.BC_E, flex.BC_W, flex.BC_N, flex.BC_S): assert i in BC_options Te_in = input_dict['Te'] try: flex.Te = float(Te_in) except ValueError: flex.Te = grid.at_node[Te_in].view().reshape( (grid.number_of_node_rows, grid.number_of_node_columns)) self._input_var_names.add(Te_in) self._output_var_names.add(Te_in) #set up the link between surface load stresses in the gFlex component and the LL grid field: flex.qs = grid.at_node['surface_load__stress'].view().reshape( (grid.number_of_node_rows, grid.number_of_node_columns)) #create a holder for the "pre-flexure" state of the grid, to allow updating of elevs: self.pre_flex = np.zeros(grid.number_of_nodes, dtype=float)
def buildGrid(self, nx, ny, youngMod, mantleDensity, sedimentDensity, elasticT, Boundaries, xyTIN): """ gFlex initialisation function. Parameters ---------- variable : nx, ny Number of points along the X and Y axis variable : youngMod Young's modulus variable : mantleDensity Mantle density variable : sedimentDensity Sediment density variable : elasticT The elastic thickness. Can be scalar or an array variable : Boundaries List of string describing boundary conditions for West, East, South and North Choose from '0Slope0Shear', 'Dirichlet0', '0Displacement0Slope', '0Moment0Shear', 'Periodic', 'Mirror' variable : xyTIN Numpy float-type array containing the coordinates for each nodes in the TIN (in m2) """ # Build the flexural grid self.nx = nx self.ny = ny self.xyTIN = xyTIN xmin, xmax = min(self.xyTIN[:, 0]), max(self.xyTIN[:, 0]) ymin, ymax = min(self.xyTIN[:, 1]), max(self.xyTIN[:, 1]) self.xgrid = numpy.linspace(xmin, xmax, num=self.nx) self.ygrid = numpy.linspace(ymin, ymax, num=self.ny) self.xi, self.yi = numpy.meshgrid(self.xgrid, self.ygrid) self.xyi = numpy.dstack([self.xi.flatten(), self.yi.flatten()])[0] # Call gFlex instance self.flex = gflex.F2D() flex = self.flex # Set-up the grid variable self.flex.dx = self.xgrid[1] - self.xgrid[0] self.flex.dy = self.ygrid[1] - self.ygrid[0] self.ball = math.sqrt( 0.25 * (self.flex.dx * self.flex.dx + self.flex.dy * self.flex.dy)) tindx = self.xyTIN[1, 0] - self.xyTIN[0, 0] self.searchpts = max( int(self.flex.dx * self.flex.dy / (tindx * tindx)), 4) ''' area = numpy.zeros((self.nx, self.ny)) area.fill(self.flex.dx*self.flex.dy) area[0,:] = 0.5 * self.flex.dx*self.flex.dy area[self.nx-1,:] = 0.5 * self.flex.dx*self.flex.dy area[:,0] = 0.5 * self.flex.dx*self.flex.dy area[:,self.ny-1] = 0.5 * self.flex.dx*self.flex.dy area[0,0] = 0.25 * self.flex.dx*self.flex.dy area[self.nx-1,0] = area[0,0] area[0,self.ny-1] = area[0,0] area[self.nx-1,self.ny-1] = area[0,0] self.Area = area.flatten() ''' # Solution method finite difference self.flex.Method = 'FD' self.flex.Quiet = True # van Wees and Cloetingh (1994) self.flex.PlateSolutionType = 'vWC1994' self.flex.Solver = 'direct' # Acceleration due to gravity self.flex.g = 9.8 # Poisson's Ratio self.flex.nu = 0.25 # Infill Material Density self.flex.rho_fill = 0. # Young's Modulus self.flex.E = youngMod # Mantle Density self.flex.rho_m = mantleDensity # Sediment Density self.rho_s = sedimentDensity # Sea Water Density self.rho_w = 1029.0 # Elastic thickness [m] if isinstance(elasticT, basestring): TeMap = pandas.read_csv(elasticT, sep=r'\s+', engine='c', header=None, na_filter=False, dtype=numpy.float, low_memory=False) self.Te = numpy.reshape(TeMap.values, (self.ny, self.nx)) else: self.Te = elasticT * numpy.ones((self.ny, self.nx)) # Surface load stresses self.flex.qs = numpy.zeros((self.ny, self.nx), dtype=float) # Boundary conditions self.flex.BC_W = Boundaries[0] self.flex.BC_E = Boundaries[1] self.flex.BC_S = Boundaries[2] self.flex.BC_N = Boundaries[3] # State of the previous flexural grid used for updating current # flexural displacements. self.previous_flex = numpy.zeros((self.ny, self.nx), dtype=float) self.tree = cKDTree(self.xyTIN) #self.Acell = Acell return