def test(mfault): from clawpack.clawutil.data import ClawData length_scale = 1.e-3 # m to km probdata = ClawData() probdata.read('setprob.data',force=True) fault = dtopotools.Fault() fault.read('fault.data') mapping = Mapping(fault) domain_depth = probdata.domain_depth domain_width = probdata.domain_width # num of cells here determined in a similar fashion to that in setrun.py dx = mapping.fault_width/mfault num_cells_above = numpy.rint(mapping.fault_depth/dx) dy = mapping.fault_depth/num_cells_above mx = int(numpy.ceil(domain_width/dx)) # mx my = int(numpy.ceil(domain_depth/dy)) # my mr = mx - mfault x = linspace(mapping.xcenter-0.5*mapping.fault_width - numpy.floor(mr/2.0)*dx, mapping.xcenter+0.5*mapping.fault_width + numpy.ceil(mr/2.0)*dx, mx+1) y = linspace(-my*dy, 0.0, my+1) xc,yc = meshgrid(x,y) xp,yp = mapping.mapc2p(xc,yc) figure() plot(xp*length_scale,yp*length_scale,'k-') plot(xp.T*length_scale,yp.T*length_scale,'k-') plot((mapping.xp1*length_scale,mapping.xp2*length_scale), (mapping.yp1*length_scale,mapping.yp2*length_scale),'-g',linewidth=3) axis('scaled')
def setplot(plotdata): #-------------------------- """ Specify what is to be plotted at each frame. Input: plotdata, an instance of clawpack.visclaw.data.ClawPlotData. Output: a modified version of plotdata. """ slice_number = 3 tmpdir = os.path.abspath(os.curdir) os.chdir(plotdata.outdir) for filename in os.listdir('.'): if (filename.startswith('slice_%d' % slice_number)): shutil.copyfile( filename, filename.replace('slice_%d' % slice_number, 'fort', 1)) fault = dtopotools.Fault() fault.read('fault.data') os.chdir(tmpdir) mapping = Mapping(fault) xp1 = mapping.xp1 * length_scale xp2 = mapping.xp2 * length_scale zp1 = mapping.zp1 * length_scale zp2 = mapping.zp2 * length_scale xcenter = mapping.xcenter ycenter = mapping.ycenter def mapc2p(xc, yc): xp, yp = mapping.mapc2p_xz(xc, yc) return xp * length_scale, yp * length_scale def plot_fault(current_data): from pylab import linspace, plot, xlabel, ylabel, tick_params xl = linspace(xp1, xp2, 100) zl = linspace(zp1, zp2, 100) plot(xl, zl, 'g', linewidth=3) tick_params(labelsize=25) xlabel('kilometers', fontsize=25) ylabel('kilometers', fontsize=25) from clawpack.visclaw import colormaps plotdata.clearfigures() # clear any old figures,axes,items data #plotdata.format = 'binary' def sigmatr(current_data): # return -trace(sigma) q = current_data.q return -(q[0, :, :] + q[1, :, :] + q[2, :, :]) # Figure for trace(sigma) plotfigure = plotdata.new_plotfigure(name='fault', figno=1) plotfigure.kwargs = {'figsize': (11, 6)} # Set up for axes in this figure: plotaxes = plotfigure.new_plotaxes() plotaxes.xlimits = xlimits plotaxes.ylimits = zlimits plotaxes.title_with_t = False plotaxes.title = '' plotaxes.scaled = True plotaxes.afteraxes = plot_fault # Set up for item on these axes: plotitem = plotaxes.new_plotitem(plot_type='2d_pcolor') plotitem.plot_var = sigmatr plotitem.pcolor_cmap = colormaps.blue_white_red plotitem.pcolor_cmin = -1e6 plotitem.pcolor_cmax = 1e6 plotitem.add_colorbar = False plotitem.amr_celledges_show = [0] plotitem.amr_patchedges_show = [0] plotitem.MappedGrid = True plotitem.mapc2p = mapc2p # Parameters used only when creating html and/or latex hardcopy # e.g., via clawpack.visclaw.frametools.printframes: plotdata.printfigs = True # print figures plotdata.print_format = 'png' # file format plotdata.print_framenos = 'all' # list of frames to print plotdata.print_fignos = 'all' # list of figures to print plotdata.html = True # create html files of plots? plotdata.html_homelink = '../README.html' # pointer for top of index plotdata.latex = True # create latex file of plots? plotdata.latex_figsperline = 2 # layout of plots plotdata.latex_framesperline = 1 # layout of plots plotdata.latex_makepdf = False # also run pdflatex? # plotdata.parallel = True return plotdata
def setrun(claw_pkg='amrclaw'): #------------------------------ """ Define the parameters used for running Clawpack. INPUT: claw_pkg expected to be "amrclaw" for this setrun. OUTPUT: rundata - object of class ClawRunData """ from clawpack.clawutil import data assert claw_pkg.lower() == 'amrclaw', "Expected claw_pkg = 'amrclaw'" num_dim = 2 rundata = data.ClawRunData(claw_pkg, num_dim) #------------------------------------------------------------------ # Problem-specific parameters to be written to setprob.data: #------------------------------------------------------------------ probdata = rundata.new_UserData(name='probdata', fname='setprob.data') probdata.add_param('domain_depth', 300e3, 'depth of domain') probdata.add_param('domain_width', 600e3, 'width of domain') #------------------------------------------------------------------ # Read in fault information #------------------------------------------------------------------ fault = dtopotools.Fault() fault.read('fault.data') mapping = Mapping(fault) fault_width = mapping.fault_width fault_depth = mapping.fault_depth fault_center = mapping.xcenter rupture_rise_time = 0.0 for subfault in fault.subfaults: rupture_rise_time = max(rupture_rise_time, subfault.rupture_time + subfault.rise_time) #------------------------------------------------------------------ # Standard Clawpack parameters to be written to claw.data: #------------------------------------------------------------------ clawdata = rundata.clawdata # initialized when rundata instantiated # --------------- # Spatial domain: # --------------- # Number of space dimensions: clawdata.num_dim = num_dim # Number of grid cells: num_cells_fault = 4 dx = fault_width / num_cells_fault # determine cell number and set computational boundaries target_num_cells = np.rint(probdata.domain_width / dx) # x direction num_cells_below = np.rint((target_num_cells - num_cells_fault) / 2.0) num_cells_above = target_num_cells - num_cells_below - num_cells_fault clawdata.lower[0] = fault_center - 0.5 * fault_width - num_cells_below * dx clawdata.upper[0] = fault_center + 0.5 * fault_width + num_cells_above * dx clawdata.num_cells[0] = int(num_cells_below + num_cells_fault + num_cells_above) num_cells_above = np.rint(fault_depth / dx) # y direction dy = fault_depth / num_cells_above target_num_cells = np.rint(probdata.domain_depth / dy) num_cells_below = target_num_cells - num_cells_above clawdata.lower[1] = -fault_depth - num_cells_below * dy clawdata.upper[1] = 0.0 clawdata.num_cells[1] = int(num_cells_below + num_cells_above) # adjust probdata probdata.domain_width = clawdata.upper[0] - clawdata.lower[0] probdata.domain_depth = clawdata.upper[1] - clawdata.lower[1] # --------------- # Size of system: # --------------- # Number of equations in the system: clawdata.num_eqn = 5 # Number of auxiliary variables in the aux array (initialized in setaux) clawdata.num_aux = 13 # Index of aux array corresponding to capacity function, if there is one: clawdata.capa_index = 12 # ------------- # Initial time: # ------------- clawdata.t0 = 0.000000 # Restart from checkpoint file of a previous run? # Note: If restarting, you must also change the Makefile to set: # RESTART = True # If restarting, t0 above should be from original run, and the # restart_file 'fort.qNNNN' specified below should be in # the OUTDIR indicated in Makefile. clawdata.restart = False # True to restart from prior results clawdata.restart_file = 'fort.q0006' # File to use for restart data # ------------- # Output times: #-------------- # Specify at what times the results should be written to fort.q files. # Note that the time integration stops after the final output time. clawdata.output_style = 2 if clawdata.output_style == 1: # Output ntimes frames at equally spaced times up to tfinal: # Can specify num_output_times = 0 for no output clawdata.num_output_times = 50 clawdata.tfinal = 100.0 clawdata.output_t0 = True # output at initial (or restart) time? elif clawdata.output_style == 2: # Specify a list or numpy array of output times: # Include t0 if you want output at the initial time. clawdata.output_times = [90.0] elif clawdata.output_style == 3: # Output every step_interval timesteps over total_steps timesteps: clawdata.output_step_interval = 1 clawdata.total_steps = 40 clawdata.output_t0 = True # output at initial (or restart) time? clawdata.output_format = 'binary' # 'ascii', 'binary', 'netcdf' clawdata.output_q_components = 'all' # could be list such as [True,True] clawdata.output_aux_components = 'none' # could be list clawdata.output_aux_onlyonce = True # output aux arrays only at t0 # --------------------------------------------------- # Verbosity of messages to screen during integration: # --------------------------------------------------- # The current t, dt, and cfl will be printed every time step # at AMR levels <= verbosity. Set verbosity = 0 for no printing. # (E.g. verbosity == 2 means print only on levels 1 and 2.) clawdata.verbosity = 0 # -------------- # Time stepping: # -------------- # if dt_variable==True: variable time steps used based on cfl_desired, # if dt_variable==False: fixed time steps dt = dt_initial always used. clawdata.dt_variable = True # Initial time step for variable dt. # (If dt_variable==0 then dt=dt_initial for all steps) clawdata.dt_initial = 0.25 # Max time step to be allowed if variable dt used: clawdata.dt_max = 1.000000e+99 # Desired Courant number if variable dt used clawdata.cfl_desired = 0.900000 # max Courant number to allow without retaking step with a smaller dt: clawdata.cfl_max = 1.000000 # Maximum number of time steps to allow between output times: clawdata.steps_max = 1000 # ------------------ # Method to be used: # ------------------ # Order of accuracy: 1 => Godunov, 2 => Lax-Wendroff plus limiters clawdata.order = 2 # Use dimensional splitting? (not yet available for AMR) clawdata.dimensional_split = 'unsplit' # For unsplit method, transverse_waves can be # 0 or 'none' ==> donor cell (only normal solver used) # 1 or 'increment' ==> corner transport of waves # 2 or 'all' ==> corner transport of 2nd order corrections too clawdata.transverse_waves = 2 # Number of waves in the Riemann solution: clawdata.num_waves = 4 # List of limiters to use for each wave family: # Required: len(limiter) == num_waves # Some options: # 0 or 'none' ==> no limiter (Lax-Wendroff) # 1 or 'minmod' ==> minmod # 2 or 'superbee' ==> superbee # 3 or 'vanleer' ==> van Leer # 4 or 'mc' ==> MC limiter clawdata.limiter = ['mc', 'mc', 'mc', 'mc'] clawdata.use_fwaves = False # True ==> use f-wave version of algorithms # Source terms splitting: # src_split == 0 or 'none' ==> no source term (src routine never called) # src_split == 1 or 'godunov' ==> Godunov (1st order) splitting used, # src_split == 2 or 'strang' ==> Strang (2nd order) splitting used, not recommended. clawdata.source_split = 0 # -------------------- # Boundary conditions: # -------------------- # Number of ghost cells (usually 2) clawdata.num_ghost = 2 # Choice of BCs at xlower and xupper: # 0 or 'user' => user specified (must modify bcNamr.f to use this option) # 1 or 'extrap' => extrapolation (non-reflecting outflow) # 2 or 'periodic' => periodic (must specify this at both boundaries) # 3 or 'wall' => solid wall for systems where q(2) is normal velocity clawdata.bc_lower[0] = 'extrap' # at xlower clawdata.bc_upper[0] = 'extrap' # at xupper clawdata.bc_lower[1] = 'extrap' # at ylower clawdata.bc_upper[1] = 'user' # at yupper # --------------- # Gauges: # --------------- gauges = rundata.gaugedata.gauges # for gauges append lines of the form [gaugeno, x, y, t1, t2] # top edge: xgauges = np.linspace(-150e3, 200e3, 350) for gaugeno, x in enumerate(xgauges): gauges.append([gaugeno, x, clawdata.upper[1] - 1, 0, 1e10]) # -------------- # Checkpointing: # -------------- # Specify when checkpoint files should be created that can be # used to restart a computation. clawdata.checkpt_style = 2 if clawdata.checkpt_style == 0: # Do not checkpoint at all pass elif clawdata.checkpt_style == 1: # Checkpoint only at tfinal. pass elif clawdata.checkpt_style == 2: # Specify a list of checkpoint times. clawdata.checkpt_times = [rupture_rise_time] elif clawdata.checkpt_style == 3: # Checkpoint every checkpt_interval timesteps (on Level 1) # and at the final time. clawdata.checkpt_interval = 5 # --------------- # AMR parameters: # --------------- amrdata = rundata.amrdata # max number of refinement levels: amrdata.amr_levels_max = 6 # List of refinement ratios at each level (length at least # amr_level_max-1) amrdata.refinement_ratios_x = [2, 2, 2, 2, 2, 2] amrdata.refinement_ratios_y = [2, 2, 2, 2, 2, 2] amrdata.refinement_ratios_t = [2, 2, 2, 2, 2, 2] # Specify type of each aux variable in amrdata.auxtype. # This must be a list of length num_aux, each element of which is one # of: # 'center', 'capacity', 'xleft', or 'yleft' (see documentation). amrdata.aux_type = ['center', 'center', 'center', 'center', 'center', \ 'center', 'center', 'center', 'center', 'center', 'center', \ 'capacity','yleft'] # Flag for refinement based on Richardson error estimater: amrdata.flag_richardson = False # use Richardson? amrdata.flag_richardson_tol = 1. # Richardson tolerance # Flag for refinement using routine flag2refine: amrdata.flag2refine = True # use this? amrdata.flag2refine_tol = 0.0001 # tolerance used in this routine # User can modify flag2refine to change the criterion for flagging. # Default: check maximum absolute difference of first component of q # between a cell and each of its neighbors. # steps to take on each level L between regriddings of level L+1: amrdata.regrid_interval = 2 # width of buffer zone around flagged points: # (typically the same as regrid_interval so waves don't escape): amrdata.regrid_buffer_width = 2 # clustering alg. cutoff for (# flagged pts) / (total # of cells # refined) # (closer to 1.0 => more small grids may be needed to cover flagged # cells) amrdata.clustering_cutoff = 0.7 # print info about each regridding up to this level: amrdata.verbosity_regrid = 0 # --------------- # Regions: # --------------- regions = rundata.regiondata.regions # to specify regions of refinement append lines of the form # [minlevel,maxlevel,t1,t2,x1,x2,y1,y2] ybuffer = dy # high-resolution region to surround the fault during slip regions.append([ amrdata.amr_levels_max, amrdata.amr_levels_max, 0, rupture_rise_time, fault_center - 0.5 * fault_width, fault_center + 0.5 * fault_width, -fault_depth - dx, -fault_depth + dx ]) for j in range(amrdata.amr_levels_max - 1): regions.append([ 1, amrdata.amr_levels_max - j, 0, 1e9, -1e9, 1e9, -2.0 * fault_depth - j * ybuffer, 0.0 ]) regions.append([1, 1, 0, 1e9, -1.e9, 1.e9, -1.e9, 0.0]) # ----- For developers ----- # Toggle debugging print statements: amrdata.dprint = False # print domain flags amrdata.eprint = False # print err est flags amrdata.edebug = False # even more err est flags amrdata.gprint = False # grid bisection/clustering amrdata.nprint = False # proper nesting output amrdata.pprint = False # proj. of tagged points amrdata.rprint = False # print regridding summary amrdata.sprint = False # space/memory output amrdata.tprint = False # time step reporting each level amrdata.uprint = False # update/upbnd reporting return rundata
def setplot(plotdata): #-------------------------- """ Specify what is to be plotted at each frame. Input: plotdata, an instance of clawpack.visclaw.data.ClawPlotData. Output: a modified version of plotdata. """ slice_number = 1 # set to surface slice number tmpdir = os.path.abspath(os.curdir) os.chdir(plotdata.outdir) for filename in os.listdir('.'): if (filename.startswith('slice_%d' % slice_number)): shutil.copyfile( filename, filename.replace('slice_%d' % slice_number, 'fort', 1)) fault = dtopotools.Fault() fault.read('fault.data') os.chdir(tmpdir) from clawpack.visclaw import colormaps xc = np.linspace(-150e3, 200e3, 350) yc = np.linspace(-87.5e3, 87.5e3, 175) fault.create_dtopography(xc / LAT2METER, yc / LAT2METER, [1.0]) Xc, Yc = np.meshgrid(xc * length_scale, yc * length_scale) okada_max = np.max(fault.dtopo.dZ[0, :, :]) clevels = np.linspace(-okada_max, okada_max, 10) plotdata.clearfigures() # clear any old figures,axes,items data #plotdata.format = 'binary' def mapc2p(xc, yc): return xc * length_scale, yc * length_scale def plot_okada_contour(current_data): from pylab import contour, ylabel, tick_params contour(Xc, Yc, fault.dtopo.dZ[0, :, :], levels=clevels, colors='r', linewidths=2) tick_params(labelsize=25) ylabel('kilometers', fontsize=25) # Figure for vertical displacement plotfigure = plotdata.new_plotfigure(name='surface', figno=1) plotfigure.kwargs = {'figsize': (11, 6)} # Set axes for numerical solution: plotaxes = plotfigure.new_plotaxes() plotaxes.xlimits = xlimits plotaxes.ylimits = ylimits plotaxes.title = '' plotaxes.title_with_t = False plotaxes.scaled = True plotaxes.afteraxes = plot_okada_contour # Set up for item on these axes: plotitem = plotaxes.new_plotitem(plot_type='2d_pcolor') plotitem.plot_var = 9 plotitem.pcolor_cmap = 'BrBG' plotitem.pcolor_cmin = clevels[0] plotitem.pcolor_cmax = clevels[-1] plotitem.add_colorbar = False plotitem.amr_celledges_show = [0] plotitem.amr_patchedges_show = [0] plotitem.MappedGrid = True plotitem.mapc2p = mapc2p # Set up for item on these axes: plotitem = plotaxes.new_plotitem(plot_type='2d_contour') plotitem.plot_var = 9 plotitem.contour_colors = 'k' plotitem.contour_levels = clevels plotitem.kwargs = {'linewidths': 3} plotitem.amr_contour_show = [0, 0, 0, 1] plotitem.amr_celledges_show = [0] plotitem.amr_patchedges_show = [0] plotitem.MappedGrid = True plotitem.mapc2p = mapc2p # Parameters used only when creating html and/or latex hardcopy # e.g., via clawpack.visclaw.frametools.printframes: plotdata.printfigs = True # print figures plotdata.print_format = 'png' # file format plotdata.print_framenos = 'all' # list of frames to print plotdata.print_fignos = 'all' # list of figures to print plotdata.html = True # create html files of plots? plotdata.html_homelink = '../README.html' # pointer for top of index plotdata.latex = True # create latex file of plots? plotdata.latex_figsperline = 2 # layout of plots plotdata.latex_framesperline = 1 # layout of plots plotdata.latex_makepdf = False # also run pdflatex? # plotdata.parallel = True return plotdata
import dtopotools_horiz_okada_and_1d as dtopotools from numpy import arange,cos,sin,pi reload(dtopotools) from clawpack.geoclaw.data import LAT2METER fault = dtopotools.Fault(coordinate_specification='top center') fault.subfaults = [] width = 50000.0 length = 25000.0 theta = 0.2 fault_centroid = [25e3,0.0,-20e3] fault_top_center = [fault_centroid[0] - cos(theta)*0.5*width, 0.0, fault_centroid[2] + sin(theta)*0.5*width] slip = 1.0 mu = 3e10 rupture_time = 0.0 rise_time = 1.0 nsubfaults_dip = 1 nsubfaults_strike = 1 longitude0 = fault_top_center[0]/LAT2METER latitude0 = fault_top_center[1]/LAT2METER dlongitude = width*cos(theta)/LAT2METER / nsubfaults_dip dlatitude = length/LAT2METER / nsubfaults_strike ddepth = width*sin(theta) / nsubfaults_dip subfault_width = width/nsubfaults_dip subfault_length = length/nsubfaults_strike
def setplot(plotdata): #-------------------------- """ Specify what is to be plotted at each frame. Input: plotdata, an instance of clawpack.visclaw.data.ClawPlotData. Output: a modified version of plotdata. """ fault = dtopotools.Fault() fault.read(plotdata.outdir + '/fault.data') mapping = Mapping(fault) xp1 = mapping.xp1*length_scale xp2 = mapping.xp2*length_scale yp1 = mapping.yp1*length_scale yp2 = mapping.yp2*length_scale gaugedata = ClawData() gaugedata.read(plotdata.outdir + '/gauges.data', force=True) ngauges = gaugedata.ngauges xc = np.zeros(ngauges) for j in range(ngauges): g = plotdata.getgauge(j) xc[j] = g.location[0] fault.create_dtopography(xc/LAT2METER,np.array([0.]),[1.0],y_disp=True) from clawpack.visclaw import colormaps plotdata.clearfigures() # clear any old figures,axes,items data plotdata.format = 'binary' def mapc2p(xc,yc): xp,yp = mapping.mapc2p(xc,yc) return xp*length_scale,yp*length_scale def plot_fault(current_data): from pylab import linspace, plot, xlabel, ylabel, tick_params xl = linspace(xp1,xp2,100) yl = linspace(yp1,yp2,100) plot(xl,yl,'k',linewidth=3) tick_params(labelsize=25) xlabel('kilometers',fontsize=25) ylabel('kilometers',fontsize=25) def sigmatr(current_data): # return -trace(sigma) q = current_data.q return -(q[0,:,:] + q[1,:,:]) def plot_vertical_displacement(current_data): from pylab import plot,zeros,ylabel,tick_params t = current_data.t ys = zeros(ngauges) for gaugeno in range(ngauges): g = plotdata.getgauge(gaugeno) for k in range(1,len(g.t)): if g.t[k] > t: break dt = g.t[k] - g.t[k-1] v = 0.5*(g.q[4,k]+g.q[4,k-1]) ys[gaugeno] += dt*v plot(xc[:ngauges]*length_scale,ys,linewidth=3) plot(xc*length_scale,fault.dtopo.dZ[0,0,:],linestyle='--',color='r',linewidth=3) tick_params(labelsize=25) ylabel('meters',fontsize=25) # Figure for surface plotfigure = plotdata.new_plotfigure(name='surface', figno=1) plotfigure.kwargs = {'figsize':(11,4)} # Set up for axes in this figure: plotaxes = plotfigure.new_plotaxes() plotaxes.xlimits = xlimits plotaxes.ylimits = ylimits_surface plotaxes.title_with_t = False plotaxes.title = '' plotaxes.scaled = False plotaxes.afteraxes = plot_vertical_displacement # Figure for fault plotfigure = plotdata.new_plotfigure(name='fault', figno=2) plotfigure.kwargs = {'figsize':(11,6)} # Set up for axes in this figure: plotaxes = plotfigure.new_plotaxes() plotaxes.xlimits = xlimits plotaxes.ylimits = ylimits_fault plotaxes.title = '' plotaxes.title_with_t = False plotaxes.scaled = True plotaxes.afteraxes = plot_fault # Set up for item on these axes: plotitem = plotaxes.new_plotitem(plot_type='2d_pcolor') plotitem.plot_var = sigmatr plotitem.pcolor_cmap = colormaps.blue_white_red plotitem.pcolor_cmin = -1e6 plotitem.pcolor_cmax = 1e6 plotitem.add_colorbar = False plotitem.amr_celledges_show = [0] plotitem.amr_patchedges_show = [0] plotitem.MappedGrid = True plotitem.mapc2p = mapc2p # Parameters used only when creating html and/or latex hardcopy # e.g., via clawpack.visclaw.frametools.printframes: plotdata.printfigs = True # print figures plotdata.print_format = 'png' # file format plotdata.print_framenos = 'all' # list of frames to print plotdata.print_fignos = 'all' # list of figures to print plotdata.html = True # create html files of plots? plotdata.html_homelink = '../README.html' # pointer for top of index plotdata.latex = True # create latex file of plots? plotdata.latex_figsperline = 2 # layout of plots plotdata.latex_framesperline = 1 # layout of plots plotdata.latex_makepdf = False # also run pdflatex? plotdata.parallel = True return plotdata
def setplot(plotdata): #-------------------------- """ Specify what is to be plotted at each frame. Input: plotdata, an instance of clawpack.visclaw.data.ClawPlotData. Output: a modified version of plotdata. """ fault = dtopotools.Fault() fault.read(plotdata.outdir + '/fault.data') gdata = ClawData() gdata.read(plotdata.outdir + '/gauges.data', force=True) ngauges = gdata.ngauges xc = np.zeros(ngauges) for j in range(ngauges): g = plotdata.getgauge(j) xc[j] = g.location[0] fault.create_dtopography(xc / LAT2METER, np.array([0.]), [1.0], y_disp=True) from clawpack.visclaw import colormaps plotdata.clearfigures() # clear any old figures,axes,items data plotdata.format = 'binary' def plot_vertical_displacement(current_data): from pylab import plot, zeros, xlabel, ylabel, tick_params t = current_data.t ys = zeros(ngauges) for gaugeno in range(ngauges): g = plotdata.getgauge(gaugeno) for k in range(1, len(g.t)): if g.t[k] > t: break dt = g.t[k] - g.t[k - 1] v = 0.5 * (g.q[4, k] + g.q[4, k - 1]) ys[gaugeno] += dt * v plot(xc[:ngauges] * length_scale, ys, linewidth=3) plot(xc * length_scale, fault.dtopo.dZ[0, 0, :], linestyle='--', color='r', linewidth=3) tick_params(labelsize=25) xlabel('kilometers', fontsize=25) ylabel('meters', fontsize=25) def plot_horizontal_displacement(current_data): from pylab import plot, zeros, xlabel, ylabel, tick_params t = current_data.t xs = zeros(ngauges) for gaugeno in range(ngauges): g = plotdata.getgauge(gaugeno) for k in range(1, len(g.t)): if g.t[k] > t: break dt = g.t[k] - g.t[k - 1] u = 0.5 * (g.q[3, k] + g.q[3, k - 1]) xs[gaugeno] += dt * u plot(xc[:ngauges] * length_scale, xs, linewidth=3) plot(xc * length_scale, fault.dtopo.dY[0, 0, :], linestyle='--', color='r', linewidth=3) tick_params(labelsize=25) xlabel('kilometers', fontsize=25) ylabel('meters', fontsize=25) # Figure for vertical displacement plotfigure = plotdata.new_plotfigure(name='vertical', figno=1) plotfigure.kwargs = {'figsize': (11, 8)} # Set up for axes in this figure: plotaxes = plotfigure.new_plotaxes() plotaxes.xlimits = xlimits plotaxes.ylimits = ylimits plotaxes.title_with_t = False plotaxes.title = '' plotaxes.scaled = False plotaxes.afteraxes = plot_vertical_displacement # Figure for horizontal displacement plotfigure = plotdata.new_plotfigure(name='horizontal', figno=2) plotfigure.kwargs = {'figsize': (11, 8)} # Set up for axes in this figure: plotaxes = plotfigure.new_plotaxes() plotaxes.xlimits = xlimits plotaxes.ylimits = ylimits plotaxes.title_with_t = False plotaxes.title = '' plotaxes.scaled = False plotaxes.afteraxes = plot_horizontal_displacement # Parameters used only when creating html and/or latex hardcopy # e.g., via clawpack.visclaw.frametools.printframes: plotdata.printfigs = True # print figures plotdata.print_format = 'png' # file format plotdata.print_framenos = 'all' # list of frames to print plotdata.print_fignos = 'all' # list of figures to print plotdata.html = True # create html files of plots? plotdata.html_homelink = '../README.html' # pointer for top of index plotdata.latex = True # create latex file of plots? plotdata.latex_figsperline = 2 # layout of plots plotdata.latex_framesperline = 1 # layout of plots plotdata.latex_makepdf = False # also run pdflatex? plotdata.parallel = True return plotdata