[pylithapp] # Permit unknown components so that we can ignore warnings associated # with replacing the spatial database for the power-law rheology. typos = strict # ---------------------------------------------------------------------- # PROBLEM DESCRIPTION # ---------------------------------------------------------------------- # # This is a time-dependent problem with velocity boundary conditions # and multiple earthquake ruptures as well as fault creep at constant # velocity. # This problem is identical to example 7 except that it includes # power-law rheology, which requires the use of a nonlinear solver. # Two materials are used: # 1. Elastic upper crust. # 2. Viscoelastic (power-law) lower crust. # ---------------------------------------------------------------------- # RUNNING THE SIMULATON # ---------------------------------------------------------------------- # This is not a self-contained simulation configuration file. This # file only specifies parameters specific to tutorial step08. # The general parameters are specificed in the pylithapp.cfg # file which PyLith reads by default. # # To run the simulation: # pylith step08.cfg # # Output will be directed to the directory output. # ---------------------------------------------------------------------- # problem # ---------------------------------------------------------------------- [pylithapp.timedependent] # For this problem we must switch to a nonlinear solver. implicit.solver = pylith.problems.SolverNonlinear # Set bc to an array of 3 boundary conditions: 'x_pos','x_neg', and 'z_neg'. bc = [x_pos,x_neg,z_neg] normalizer = spatialdata.units.NondimElasticQuasistatic # Set interfaces to an array of 1 fault: 'fault'. interfaces = [fault] [pylithapp.timedependent.implicit] # Set the output to an array of 2 output managers. # We will output the solution over the domain and the ground surface. output = [domain,subdomain] # Set subdomain component to OutputSolnSubset (boundary of the domain). output.subdomain = pylith.meshio.OutputSolnSubset # Change time stepping algorithm from uniform time step, to adaptive # time stepping. time_step = pylith.problems.TimeStepAdapt # Change the total simulation time to 700 years, and set the maximum time # step size to 10 years. [pylithapp.timedependent.implicit.time_step] total_time = 0.0*year max_dt = 5.0*year stability_factor = 1.0 ; use time step equal to stable value from materials # For this problem we set adapt_skip to zero so that the time step size is # readjusted every time step. adapt_skip = 0 [pylithapp.timedependent.normalizer] length_scale = 0.01*km # ---------------------------------------------------------------------- # materials # ---------------------------------------------------------------------- # Change material type of lower crust to power-law viscoelastic. [pylithapp.timedependent] materials.upper_crust = pylith.materials.PowerLaw3D # Provide a spatial database from which to obtain property values. # In this case, we prefer to obtain the power-law properties from one # database and the elastic properties from another database, so we use # a CompositeDB. Each part of the CompositeDB is a SimpleDB. [pylithapp.timedependent.materials.upper_crust] db_properties = spatialdata.spatialdb.CompositeDB db_properties.db_A = spatialdata.spatialdb.SimpleDB db_properties.db_B = spatialdata.spatialdb.SimpleDB # Provide the values to be obtained from each database and the database # name. [pylithapp.timedependent.materials.upper_crust.db_properties] values_A = [density,vs,vp] ; Elastic properties. db_A.label = Elastic properties db_A.iohandler.filename = spatialdb/mat_elastic.spatialdb values_B = [reference-stress,reference-strain-rate,power-law-exponent] ; Power-law properties. db_B.label = Power-law properties db_B.iohandler.filename = spatialdb/mat_powerlaw.spatialdb db_B.query_type = linear # Since there are additional properties and state variables for the # power-law model, we explicitly request that they be output. Properties are # named in cell_info_fields and state variables are named in # cell_data_fields. [pylithapp.timedependent.materials.upper_crust] output.cell_info_fields = [density,mu,lambda,reference_strain_rate,reference_stress,power_law_exponent] output.cell_data_fields = [total_strain,stress,viscous_strain] # ---------------------------------------------------------------------- # boundary conditions # ---------------------------------------------------------------------- # Set the parameters for Dirichlet boundary conditions applied on the # +x, -x, and -z faces of the box. # # We fix the x degree of freedom on the +x and -x faces, and # fix the z degree of freedom on the bottom (-z) face. Constant velocities # in the +y and -y directions are applied on +x and -x. # # For x_pos and x_neg, we retain the default ZeroDispDB for displacements # (db_initial), since we do not want initial displacements. We change the # default database for velocities (db_rate) to UniformDB, which allows # nonzero velocities. Using UniformDB, we also specify the velocity values # in this .cfg file, rather than using a spatialdb file. # # For z_neg, we keep the default ZeroDispDB, since we just want zero # z-displacements on that boundary. # Note that since the fault cuts through the base of the model (z_neg), # we can only constrain the portion of the bottom boundary that does not # include the fault. A nodeset named 'face_zneg_nofault' has been defined # in Cubit for this purpose. # # The label corresponds to the name of the nodeset in CUBIT. # +x face [pylithapp.timedependent.bc.x_pos] bc_dof = [0, 1] label = face_xpos db_initial.label = Dirichlet BC on +x db_rate = spatialdata.spatialdb.UniformDB db_rate.label = Dirichlet rate BC on +x db_rate.values = [displacement-rate-x,displacement-rate-y,rate-start-time] db_rate.data = [0.0*cm/year,0.0*cm/year,0.0*year] # -x face [pylithapp.timedependent.bc.x_neg] bc_dof = [0, 1] label = face_xneg db_initial.label = Dirichlet BC on -x db_rate = spatialdata.spatialdb.UniformDB db_rate.label = Dirichlet rate BC on +x db_rate.values = [displacement-rate-x,displacement-rate-y,rate-start-time] db_rate.data = [0.0*cm/year,0.0*cm/year,0.0*year] # -z face [pylithapp.timedependent.bc.z_neg] bc_dof = [2] label = face_zneg db_initial.label = Dirichlet BC on -z # ---------------------------------------------------------------------- # faults # ---------------------------------------------------------------------- [pylithapp.timedependent.interfaces] # Set the parameters for the fault interface conditions. [pylithapp.timedependent.interfaces.fault] # This corresponds to the label of the Cubit nodeset defining the fault. label = fault # Provide quadrature information for the fault surface. quadrature.cell = pylith.feassemble.FIATSimplex quadrature.cell.dimension = 2 # The slip time and final slip are defined in spatial databases. [pylithapp.timedependent.interfaces.fault.eq_srcs.rupture.slip_function] slip.label = Final slip slip.iohandler.filename = spatialdb/finalslip.spatialdb slip.query_type = linear slip_time.label = Slip initiation time slip_time.iohandler.filename = spatialdb/sliptime.spatialdb # ---------------------------------------------------------------------- # output # ---------------------------------------------------------------------- # Give basename for output of solution over domain. [pylithapp.problem.formulation.output.domain] # We specify that output occurs in terms of a given time frequency, and # ask for output every 50 years. output_freq = time_step time_step = 50.0*year # We are using HDF5 output so we must change the default writer. writer = pylith.meshio.DataWriterHDF5 writer.filename = output/powerlaw.h5 # Give basename for output of solution over ground surface. [pylithapp.problem.formulation.output.subdomain] # Name of nodeset for ground surface. label = face_zpos # We keep the default output frequency behavior (skip every n steps), and # ask to skip 0 steps between output, so that we get output every time step. skip = 0 # We again switch the writer to produce HDF5 output. # Note that we specifically ask for a submesh writer. writer = pylith.meshio.DataWriterHDF5 writer.filename = output/powerlaw-groundsurf.h5 # Give basename for fault rupture output. [pylithapp.problem.interfaces.fault.output] # We keep the default output frequency behavior (skip every n steps), and # ask to skip 0 steps between output, so that we get output every time step. skip = 0 # We again switch the writer to produce HDF5 output. # Note that we specifically ask for a subsubmesh writer. writer = pylith.meshio.DataWriterHDF5 writer.filename = output/powerlaw-fault.h5 # Give basename for output of upper_crust state variables. [pylithapp.timedependent.materials.upper_crust.output] # Average values over quadrature points. cell_filter = pylith.meshio.CellFilterAvg # We specify that output occurs in terms of a given time frequency, and # ask for output every 50 years. output_freq = time_step time_step = 50.0*year # We again switch the writer to produce HDF5 output. writer = pylith.meshio.DataWriterHDF5 writer.filename = output/step08-upper_crust.h5 # Give basename for output of lower_crust state variables. [pylithapp.timedependent.materials.upper_crust.output] # Average values over quadrature points. cell_filter = pylith.meshio.CellFilterAvg # We specify that output occurs in terms of a given time frequency, and # ask for output every 50 years. output_freq = time_step time_step = 50.0*year # We again switch the writer to produce HDF5 output. writer = pylith.meshio.DataWriterHDF5 writer.filename = output/powerlaw-lower_crust.h5 # ---------------------------------------------------------------------- # PETSc # ---------------------------------------------------------------------- [pylithapp.petsc] # Set smaller absolute linear convergence tolerance to help convergence of # nonlinear solution. ksp_atol = 1.0e-20