def create_problem(arg, name="rough_example", outname="ufault", refine=1):
"""
Create demo problem
Inputs:
Required:
arg = 1d array of length 3 holding simulation inputs
(shear/normal stress, normal stress, ratio of out of plane to in plane normal component)
Optional:
name = problem name (string)
outname = name of output file (string)
refine = simulation refinement (default is 1, which should be fine for this)
Outputs:
None
Note: function will fail if the stress on any point of the fault exceeds the strength. Should
(probably) not occur for the parameter range specified in the demo, but in here for safety purposes.
"""
assert len(arg) == 3
syy, ston, sxtosy = arg
p = fdfault.problem(name)
# set rk and fd order
p.set_rkorder(4)
p.set_sbporder(4)
# set problem info
nt = 800*refine + 1
nx = 400*refine + 1
ny = 150*refine + 1
lx = 32.
ly = 12.
p.set_nt(nt)
p.set_cfl(0.3)
p.set_ninfo((nt-1)//4)
# set number of blocks and coordinate information
p.set_nblocks((1,2,1))
p.set_nx_block(([nx], [ny, ny], [1]))
# set block dimensions
p.set_block_lx((0,0,0),(lx, ly))
p.set_block_lx((0,1,0),(lx, ly))
# set block boundary conditions
p.set_bounds((0,0,0),['absorbing', 'absorbing', 'absorbing', 'none'])
p.set_bounds((0,1,0),['absorbing', 'absorbing', 'none', 'absorbing'])
# set block surface
sxx = sxtosy*syy
sxy = -syy*ston
x = np.linspace(0., lx, nx)
y = ly*np.ones(nx)+generate_profile(nx, lx, 1.e-2, 20, 1., 18749)
surf = fdfault.curve(nx, 'y', x, y)
# set initial fields
norm_x, norm_y = generate_normals_2d(x, y, 'y')
sn = np.zeros(nx)
st = np.zeros(nx)
for i in range(nx):
sn[i], st[i] = rotate_xy2nt_2d(sxx, sxy, syy, (norm_x[i], norm_y[i]), 'y')
assert np.all(st+0.7*sn < 0.), "shear stress is too high"
p.set_block_surf((0,0,0), 3, surf)
p.set_block_surf((0,1,0), 2, surf)
p.set_stress((sxx, sxy, 0., syy, 0., 0.))
# set interface type
p.set_iftype(0,'slipweak')
# set slip weakening parameters
p.add_pert(fdfault.swparam('constant', dc = 0.8, mus = 0.7, mud = 0.2),0)
p.add_pert(fdfault.swparam('boxcar', x0 = 2., dx = 2., mus = 10000.),0)
p.add_pert(fdfault.swparam('boxcar', x0 = 30., dx = 2., mus = 10000.),0)
# add load perturbation
nuc_pert = np.zeros((nx, 1))
idx = (np.abs(x - lx/2.) < 2.)
nuc_pert[idx, 0] = (-0.7*sn[idx]-st[idx])+0.1
p.set_loadfile(0, fdfault.loadfile(nx, 1, np.zeros((nx, 1)), nuc_pert, np.zeros((nx, 1))))
# add output unit
outname = "ufault"
p.add_output(fdfault.output(outname,'U', nt, nt, 1, 0, nx - 1, 1, ny, ny, 1, 0, 0, 1))
p.write_input(directory=join(fdfault_path,"problems"))
nby1 = mesh.nby1 * refine + 1 # for 000 and 100 blocks
ny = nby0 + nby1
[x1, y1, x2, y2, block010_length,
block110_length] = read_surface_data(nx1, nx2)
import pickle
mydict = {'x1': x1, 'x2': x2, 'y1': y1 - 70, 'y2': y2 - 70}
output = open('surface.pkl', 'wb')
surf_height = max([max(y1), max(y2)])
arg = str(50)
problem_name = 'longterm_' + arg
p = fdfault.problem(problem_name)
# set rk and fd order
p.set_rkorder(4)
p.set_sbporder(4)
# set time step info
p.set_nt(nt)
p.set_cfl(0.3)
p.set_ninfo(100 * refine)
# set number of blocks and coordinate information
p.set_nblocks((2, 2, 1))
p.set_nx_block(([nx1, nx2], [nby0, nby1], [1]))
# set block dimensions
added_layer_thickness = 60.
import fdfault
import numpy as np
# create problem
p = fdfault.problem('tpv5')
# set rk and fd order
p.set_rkorder(4)
p.set_sbporder(4)
# set time step info
refine = 1
nt = 700 * refine
p.set_nt(nt)
p.set_cfl(0.3)
p.set_ninfo(50 * refine)
p.set_ndim(3)
# set number of blocks and coordinate information
nx = 200 * refine + 1
ny = 100 * refine + 1
nz = 100 * refine + 1
p.set_nblocks((1, 2, 1))
p.set_nx_block(([nx], [ny, ny], [nz]))
seed = 38
seed_iterations = 20
number_of_iterations = 80
for i in range(number_of_iterations):
np.random.seed(seed)
rms_ratio = np.array([np.random.uniform(0.03, 0.001)])
#var = 0.002
#p = fdfault.problem('seed' + str(seed_iterations) )
name = 'patch_length'
number = str(seed_iterations).zfill(4)
problem_id = str(name + number)
p = fdfault.problem(problem_id)
# set rk and fd order
p.set_rkorder(4)
p.set_sbporder(4)
# set time step info
end_time = 8000
nt = end_time
interval_time = 200
p.set_nt(end_time)
p.set_cfl(0.3)
p.set_ninfo(interval_time)
refine = 1
nt = 7000*refine # Number of timesteps
nx1 = 600*refine+1 # number of grid point in left block
nx2 = 600*refine+1 # number of grid point in right block
nx = nx1+nx2 # total for x coordinates
nby0 = 200*refine+1 # for 000 and 100 blocks
fault_surface = 51.
fault_bottom = 42.
surf_height = 10.
[x1, y1, x2, y2, block000_length, block100_length] = read_surface_data(nx1, nx2, fault_bottom,
fault_surface, surf_height)
p = fdfault.problem('normalfault')
# set rk and fd order
p.set_rkorder(4)
p.set_sbporder(4)
# set time step info
p.set_nt(nt)
p.set_cfl(0.3)
p.set_ninfo(100*refine)
# set number of blocks and coordinate information
p.set_nblocks((2,1,1))
p.set_nx_block(([nx1, nx2], [nby0], [1]))
# set block dimensions
import fdfault
import numpy as np
# create problem
p = fdfault.problem('testprob')
# set rk and fd order
p.set_rkorder(4)
p.set_sbporder(4)
# set time step info
p.set_nt(1601)
p.set_cfl(0.3)
p.set_ninfo(50)
# set number of blocks and coordinate information
p.set_nblocks((2, 1, 1))
p.set_nx_block(([601, 601], [1601], [1]))
# set block dimensions
p.set_block_lx((0, 0, 0), (12., 32.))
p.set_block_lx((1, 0, 0), (12., 32.))
# set block boundary conditions
p.set_bounds((0, 0, 0), ['absorbing', 'none', 'absorbing', 'absorbing'])
import fdfault
import numpy as np
# create problem
p = fdfault.problem('input_example')
# set rk and fd order
p.set_rkorder(4)
p.set_sbporder(4)
# set time step info
p.set_nt(1601)
p.set_cfl(0.3)
p.set_ninfo(50)
# set number of blocks and coordinate information
p.set_nblocks((1, 2, 1))
p.set_nx_block(([1601], [801, 801], [1]))
# set block dimensions
p.set_block_lx((0, 0, 0), (40., 20.))
p.set_block_lx((0, 1, 0), (40., 20.))
# set block boundary conditions
p.set_bounds((0, 0, 0), ['absorbing', 'absorbing', 'absorbing', 'none'])