def getCellSizeDB(points):
from spatialdata.geocoords.CSCart import CSCart
from spatialdata.spatialdb.SimpleDB import SimpleDB
from spatialdata.spatialdb.SimpleIOAscii import SimpleIOAscii
# Coordinate system for mesh (must match coordsys in ExodusII file)
cs = CSCart()
cs._configure()
cs.initialize()
# Spatial database with physical properties (Vs)
dbIO = SimpleIOAscii()
dbIO.inventory.filename = filenameDB
dbIO._configure()
db = SimpleDB()
db.inventory.iohandler = dbIO
db.inventory.label = "Physical properties"
db.inventory.queryType = "linear"
db._configure()
(npoints, spacedim) = points.shape
# Query database
db.open()
db.queryVals(["vs"])
data = numpy.zeros((npoints, 1), dtype=numpy.float64)
err = numpy.zeros((npoints,), dtype=numpy.int32)
db.multiquery(data, err, points, cs)
db.close()
vs = data[:,0]
cellSize = minPeriod*vs / 10.0
return cellSize
def getCellSizeDB(points):
from spatialdata.geocoords.CSCart import CSCart
from spatialdata.spatialdb.SimpleDB import SimpleDB
from spatialdata.spatialdb.SimpleIOAscii import SimpleIOAscii
# Coordinate system for mesh (must match coordsys in ExodusII file)
cs = CSCart()
cs._configure()
# Spatial database with physical properties (Vs)
dbIO = SimpleIOAscii()
dbIO.inventory.filename = filenameDB
dbIO._configure()
db = SimpleDB()
db.inventory.iohandler = dbIO
db.inventory.label = "Physical properties"
db.inventory.queryType = "linear"
db._configure()
(npoints, spacedim) = points.shape
# Query database
db.open()
db.setQueryValues(["vs"])
data = numpy.zeros((npoints, 1), dtype=numpy.float64)
err = numpy.zeros((npoints, ), dtype=numpy.int32)
db.multiquery(data, err, points, cs)
db.close()
vs = data[:, 0]
cellSize = minPeriod * vs / 10.0
return cellSize
def _preinitialize(self):
"""
Setup mesh and integrator and preinitialize integrator.
"""
from spatialdata.units.Nondimensional import Nondimensional
normalizer = Nondimensional()
normalizer._configure()
# Setup mesh
cs = CSCart()
cs.inventory.spaceDim = 2
cs._configure()
from pylith.meshio.MeshIOAscii import MeshIOAscii
importer = MeshIOAscii()
importer.inventory.filename = "data/tri3.mesh"
importer.inventory.coordsys = cs
importer._configure()
mesh = importer.read(debug=False, interpolate=False)
# Setup material
from pylith.feassemble.FIATSimplex import FIATSimplex
cell = FIATSimplex()
cell.inventory.dimension = 2
cell.inventory.degree = 1
cell.inventory.order = 1
cell._configure()
from pylith.feassemble.Quadrature import Quadrature
quadrature = Quadrature()
quadrature.inventory.cell = cell
quadrature._configure()
from spatialdata.spatialdb.SimpleDB import SimpleDB
from spatialdata.spatialdb.SimpleIOAscii import SimpleIOAscii
iohandler = SimpleIOAscii()
iohandler.inventory.filename = "data/elasticplanestrain.spatialdb"
iohandler._configure()
db = SimpleDB()
db.inventory.label = "elastic plane strain"
db.inventory.iohandler = iohandler
db._configure()
from pylith.materials.ElasticPlaneStrain import ElasticPlaneStrain
material = ElasticPlaneStrain()
material.inventory.label = "elastic plane strain"
material.inventory.id = 0
material.inventory.dbProperties = db
material.inventory.quadrature = quadrature
material._configure()
from pylith.meshio.OutputMatElastic import OutputMatElastic
material.output = OutputMatElastic()
material.output._configure()
material.output.writer._configure()
# Setup integrator
integrator = ElasticityImplicitLgDeform()
integrator.preinitialize(mesh, material)
return (mesh, integrator)
def _preinitialize(self):
"""
Setup mesh and integrator and preinitialize integrator.
"""
from spatialdata.units.Nondimensional import Nondimensional
normalizer = Nondimensional()
normalizer._configure()
# Setup mesh
cs = CSCart()
cs.inventory.spaceDim = 2
cs._configure()
from pylith.meshio.MeshIOAscii import MeshIOAscii
importer = MeshIOAscii()
importer.inventory.filename = "data/tri3.mesh"
importer.inventory.coordsys = cs
importer._configure()
mesh = importer.read(debug=False, interpolate=False)
# Setup material
from pylith.feassemble.FIATSimplex import FIATSimplex
cell = FIATSimplex()
cell.inventory.dimension = 2
cell.inventory.degree = 1
cell.inventory.order = 1
cell._configure()
from pylith.feassemble.Quadrature import Quadrature
quadrature = Quadrature()
quadrature.inventory.cell = cell
quadrature._configure()
from spatialdata.spatialdb.SimpleDB import SimpleDB
from spatialdata.spatialdb.SimpleIOAscii import SimpleIOAscii
iohandler = SimpleIOAscii()
iohandler.inventory.filename = "data/elasticplanestrain.spatialdb"
iohandler._configure()
db = SimpleDB()
db.inventory.label = "elastic plane strain"
db.inventory.iohandler = iohandler
db._configure()
from pylith.materials.ElasticPlaneStrain import ElasticPlaneStrain
material = ElasticPlaneStrain()
material.inventory.label = "elastic plane strain"
material.inventory.id = 0
material.inventory.dbProperties = db
material.inventory.quadrature = quadrature
material._configure()
from pylith.meshio.OutputMatElastic import OutputMatElastic
material.output = OutputMatElastic()
material.output._configure()
material.output.writer._configure()
# Setup integrator
integrator = ElasticityImplicitLgDeform()
integrator.preinitialize(mesh, material)
return (mesh, integrator)
def test_preinitialize(self):
"""
Test preinitialize().
WARNING: This is not a rigorous test of initialize() because we
don't verify the results.
"""
from pylith.feassemble.FIATSimplex import FIATSimplex
cell = FIATSimplex()
cell.inventory.dimension = 2
cell.inventory.order = 1
cell.inventory.degree = 1
cell._configure()
from pylith.feassemble.Quadrature import Quadrature
quadrature = Quadrature()
quadrature.inventory.cell = cell
quadrature.inventory.minJacobian = 1.0e-4
quadrature._configure()
from spatialdata.spatialdb.SimpleDB import SimpleDB
from spatialdata.spatialdb.SimpleIOAscii import SimpleIOAscii
iohandler = SimpleIOAscii()
iohandler.inventory.filename = "data/matinitialize.spatialdb"
iohandler._configure()
db = SimpleDB()
db.inventory.label = "material properties"
db.inventory.iohandler = iohandler
db._configure()
from pylith.materials.ElasticPlaneStrain import ElasticPlaneStrain
material = ElasticPlaneStrain()
material.inventory.quadrature = quadrature
material.inventory.dbProperties = db
material.inventory.label = "my material"
material.inventory.id = 54
material._configure()
from spatialdata.geocoords.CSCart import CSCart
cs = CSCart()
cs.inventory.spaceDim = 2
cs._configure()
from spatialdata.units.Nondimensional import Nondimensional
normalizer = Nondimensional()
normalizer._configure()
from pylith.meshio.MeshIOAscii import MeshIOAscii
importer = MeshIOAscii()
importer.inventory.filename = "data/twoelems.mesh"
importer.inventory.coordsys = cs
importer._configure()
mesh = importer.read(debug=False, interpolate=False)
material.preinitialize(mesh)
# No test of result.
return
def test_preinitialize(self):
"""
Test preinitialize().
WARNING: This is not a rigorous test of initialize() because we
don't verify the results.
"""
from pylith.feassemble.FIATSimplex import FIATSimplex
cell = FIATSimplex()
cell.inventory.dimension = 2
cell.inventory.order = 1
cell.inventory.degree = 1
cell._configure()
from pylith.feassemble.Quadrature import Quadrature
quadrature = Quadrature()
quadrature.inventory.cell = cell
quadrature.inventory.minJacobian = 1.0e-4
quadrature._configure()
from spatialdata.spatialdb.SimpleDB import SimpleDB
from spatialdata.spatialdb.SimpleIOAscii import SimpleIOAscii
iohandler = SimpleIOAscii()
iohandler.inventory.filename = "data/matinitialize.spatialdb"
iohandler._configure()
db = SimpleDB()
db.inventory.label = "material properties"
db.inventory.iohandler = iohandler
db._configure()
from pylith.materials.ElasticPlaneStrain import ElasticPlaneStrain
material = ElasticPlaneStrain()
material.inventory.quadrature = quadrature
material.inventory.dbProperties = db
material.inventory.label = "my material"
material.inventory.id = 54
material._configure()
from spatialdata.geocoords.CSCart import CSCart
cs = CSCart()
cs.inventory.spaceDim = 2
cs._configure()
from spatialdata.units.Nondimensional import Nondimensional
normalizer = Nondimensional()
normalizer._configure()
from pylith.meshio.MeshIOAscii import MeshIOAscii
importer = MeshIOAscii()
importer.inventory.filename = "data/twoelems.mesh"
importer.inventory.coordsys = cs
importer._configure()
mesh = importer.read(debug=False, interpolate=False)
material.preinitialize(mesh)
# No test of result.
return
def generate(sim, fileRoot, materials):
for material in materials:
filenameH5 = "../output/%s-%s.h5" % (sim, material)
filenameDB = "%s-%s.spatialdb" % (fileRoot, material)
# Open HDF5 file and get coordinates, cells, and stress.
h5 = h5py.File(filenameH5, "r")
vertices = h5['geometry/vertices'][:]
cells = numpy.array(h5['topology/cells'][:], dtype=numpy.int)
# Get stresses from final time step.
stress = h5['cell_fields/stress'][-1,:,:]
h5.close()
# Compute coordinates of quadrature points.
quadCoords = getCellCenters(vertices, cells)
# Create writer for spatial database file
writer = SimpleIOAscii()
writer.inventory.filename = filenameDB
writer._configure()
values = [{'name': "stress-xx",
'units': "Pa",
'data': stress[:,0]},
{'name': "stress-yy",
'units': "Pa",
'data': stress[:,1]},
{'name': "stress-zz",
'units': "Pa",
'data': stress[:,2]},
{'name': "stress-xy",
'units': "Pa",
'data': stress[:,3]},
{'name': "stress-yz",
'units': "Pa",
'data': stress[:,4]},
{'name': "stress-xz",
'units': "Pa",
'data': stress[:,5]},
]
writer.write({'points': quadCoords,
'coordsys': cs,
'data_dim': 3,
'values': values})
return
def test_configure(self):
"""
Test initialize().
"""
from spatialdata.spatialdb.SimpleDB import SimpleDB
from spatialdata.spatialdb.SimpleIOAscii import SimpleIOAscii
from pyre.units.time import second
ioInitial = SimpleIOAscii()
ioInitial.inventory.filename = "tri3_initialtractions.spatialdb"
ioInitial._configure()
dbInitial = SimpleDB()
dbInitial.inventory.iohandler = ioInitial
dbInitial.inventory.label = "initial tractions"
dbInitial._configure()
ioChange = SimpleIOAscii()
ioChange.inventory.filename = "tri3_changetractions.spatialdb"
ioChange._configure()
dbChange = SimpleDB()
dbChange.inventory.iohandler = ioChange
dbChange.inventory.label = "traction change"
dbChange._configure()
tract = TractPerturbation()
tract.inventory.dbInitial = dbInitial
tract.inventory.dbChange = dbChange
tract._configure()
return
def test_initialize(self):
"""
Test initialize().
"""
from spatialdata.spatialdb.SimpleDB import SimpleDB
from spatialdata.spatialdb.SimpleIOAscii import SimpleIOAscii
ioSlipRate = SimpleIOAscii()
ioSlipRate.inventory.filename = "sliprate.spatialdb"
ioSlipRate._configure()
dbSlipRate = SimpleDB()
dbSlipRate.inventory.iohandler = ioSlipRate
dbSlipRate.inventory.label = "slip rate"
dbSlipRate._configure()
ioSlipTime = SimpleIOAscii()
ioSlipTime.inventory.filename = "sliptime.spatialdb"
ioSlipTime._configure()
dbSlipTime = SimpleDB()
dbSlipTime.inventory.iohandler = ioSlipTime
dbSlipTime.inventory.label = "slip time"
dbSlipTime._configure()
slipFn = ConstRateSlipFn()
slipFn.inventory.dbSlipRate = dbSlipRate
slipFn.inventory.dbSlipTime = dbSlipTime
slipFn._configure()
slipFn.preinitialize()
slipFn.verifyConfiguration()
slipFn.initialize()
return
def run(self):
"""
Generate the database.
"""
# Domain
x = numpy.arange(-4000.0, 4000.1, 500.0)
y = numpy.arange(-4000.0, 4000.1, 500.0)
z = numpy.arange(-6000.0, 0.1, 500.0)
nxpts = x.shape[0]
nypts = y.shape[0]
nzpts = z.shape[0]
xx = numpy.tile(x, (1,nypts*nzpts))
yy = numpy.tile(y, (nxpts,nzpts)).transpose()
zz = numpy.tile(z, (nxpts*nypts,1)).transpose()
xyz = numpy.zeros( (nxpts*nypts*nzpts, 3), dtype=numpy.float64)
xyz[:,0] = numpy.ravel(xx)
xyz[:,1] = numpy.ravel(yy)
xyz[:,2] = numpy.ravel(zz)
from axialdisp_soln import AnalyticalSoln
soln = AnalyticalSoln()
disp = soln.displacement(xyz)
from spatialdata.geocoords.CSCart import CSCart
cs = CSCart()
cs.inventory.spaceDim = 3
cs._configure()
data = {'points': xyz,
'coordsys': cs,
'data_dim': 3,
'values': [{'name': "displacement-x",
'units': "m",
'data': numpy.ravel(disp[:,0])},
{'name': "displacement-y",
'units': "m",
'data': numpy.ravel(disp[:,1])},
{'name': "displacement-z",
'units': "m",
'data': numpy.ravel(disp[:,2])}]}
from spatialdata.spatialdb.SimpleIOAscii import SimpleIOAscii
io = SimpleIOAscii()
io.inventory.filename = "axial_disp.spatialdb"
io._configure()
io.write(data)
return
def run(self):
"""
Generate the database.
"""
# Domain
x = numpy.arange(-4000.0, 4000.1, 1000.0)
y = numpy.arange(-4000.0, 4000.1, 1000.0)
z = numpy.arange(-6000.0, 0000.1, 1000.0)
nptsX = x.shape[0]
nptsY = y.shape[0]
nptsZ = z.shape[0]
xx = x * numpy.ones( (nptsY*nptsZ, 1), dtype=numpy.float64)
yy0 = y * numpy.ones( (nptsZ, 1), dtype=numpy.float64)
yy = yy0.ravel() * numpy.ones( (nptsX, 1), dtype=numpy.float64)
zz = z * numpy.ones( (nptsX*nptsY, 1), dtype=numpy.float64)
xyz = numpy.zeros( (nptsX*nptsY*nptsZ, 3), dtype=numpy.float64)
xyz[:,0] = numpy.ravel(xx)
xyz[:,1] = numpy.ravel(numpy.transpose(yy))
xyz[:,2] = numpy.ravel(numpy.transpose(zz))
from rigidbody_soln import AnalyticalSoln
soln = AnalyticalSoln()
disp = soln.displacement(xyz)
from spatialdata.geocoords.CSCart import CSCart
cs = CSCart()
cs.inventory.spaceDim = 3
cs._configure()
data = {'locs': xyz,
'coordsys': cs,
'data_dim': 2,
'values': [{'name': "displacement-x",
'units': "m",
'data': numpy.ravel(disp[:,0])},
{'name': "displacement-y",
'units': "m",
'data': numpy.ravel(disp[:,1])},
{'name': "displacement-z",
'units': "m",
'data': numpy.ravel(disp[:,2])}]}
from spatialdata.spatialdb.SimpleIOAscii import SimpleIOAscii
io = SimpleIOAscii()
io.inventory.filename = "rigidbody_disp.spatialdb"
io._configure()
io.write(data)
return
def testDBInitialState(self):
"""
Test dbInitialState().
"""
from spatialdata.spatialdb.SimpleDB import SimpleDB
from spatialdata.spatialdb.SimpleIOAscii import SimpleIOAscii
iohandler = SimpleIOAscii()
iohandler.inventory.filename = "data/matinitialize.spatialdb"
iohandler._configure()
db = SimpleDB()
db.inventory.label = "material properties"
db.inventory.iohandler = iohandler
db._configure()
self.material.dbInitialState(db)
# No test of result.
return
def testDBInitialState(self):
"""
Test dbInitialState().
"""
from spatialdata.spatialdb.SimpleDB import SimpleDB
from spatialdata.spatialdb.SimpleIOAscii import SimpleIOAscii
iohandler = SimpleIOAscii()
iohandler.inventory.filename = "data/matinitialize.spatialdb"
iohandler._configure()
db = SimpleDB()
db.inventory.label = "material properties"
db.inventory.iohandler = iohandler
db._configure()
self.material.dbInitialState(db)
# No test of result.
return
def testDBProperties(self):
"""
Test dbProperties().
"""
from spatialdata.spatialdb.SimpleDB import SimpleDB
from spatialdata.spatialdb.SimpleIOAscii import SimpleIOAscii
iohandler = SimpleIOAscii()
iohandler.inventory.filename = "data/staticfriction.spatialdb"
iohandler._configure()
db = SimpleDB()
db.inventory.label = "friction properties"
db.inventory.iohandler = iohandler
db._configure()
self.friction.dbProperties(db)
# No test of result.
return
def testDBProperties(self):
"""
Test dbProperties().
"""
from spatialdata.spatialdb.SimpleDB import SimpleDB
from spatialdata.spatialdb.SimpleIOAscii import SimpleIOAscii
iohandler = SimpleIOAscii()
iohandler.inventory.filename = "data/staticfriction.spatialdb"
iohandler._configure()
db = SimpleDB()
db.inventory.label = "friction properties"
db.inventory.iohandler = iohandler
db._configure()
self.friction.dbProperties(db)
# No test of result.
return
def testDBInitialStrain(self):
from spatialdata.spatialdb.SimpleDB import SimpleDB
from spatialdata.spatialdb.SimpleIOAscii import SimpleIOAscii
iohandler = SimpleIOAscii()
iohandler.inventory.filename = "data/matinitialize.spatialdb"
iohandler._configure()
db = SimpleDB()
db.inventory.label = "material properties"
db.inventory.iohandler = iohandler
db._configure()
material = self.material
material.inventory.label = "Elastic material"
material.inventory.dbInitialStrain = db
material.inventory.useInitialStrain = True
material._configure()
# No test of result.
return
def testDBInitialStrain(self):
from spatialdata.spatialdb.SimpleDB import SimpleDB
from spatialdata.spatialdb.SimpleIOAscii import SimpleIOAscii
iohandler = SimpleIOAscii()
iohandler.inventory.filename = "data/matinitialize.spatialdb"
iohandler._configure()
db = SimpleDB()
db.inventory.label = "material properties"
db.inventory.iohandler = iohandler
db._configure()
material = self.material
material.inventory.label = "Elastic material"
material.inventory.dbInitialStrain = db
material.inventory.useInitialStrain = True
material._configure()
# No test of result.
return
def run(self):
"""
Generate the database.
"""
from sheardisp_soln import AnalyticalSoln
soln = AnalyticalSoln()
from spatialdata.geocoords.CSCart import CSCart
cs = CSCart()
cs.inventory.spaceDim = 3
cs._configure()
from spatialdata.spatialdb.SimpleIOAscii import SimpleIOAscii
io = SimpleIOAscii()
for component in ["x","y","z"]:
if component == "y":
xyz = numpy.array([[-40.0e+3, 0.0, 0.0],
[+40.0e+3, 0.0, 0.0]], dtype=numpy.float64)
ic = 1
elif component == "x":
xyz = numpy.array([[0.0, -40.0e+3, 0.0],
[0.0, +40.0e+3, 0.0]], dtype=numpy.float64)
ic = 0
elif component == "z":
xyz = numpy.array([[0.0, 0.0, -40.0e+3],
[0.0, 0.0, 0.0]], dtype=numpy.float64)
ic = 2
disp = soln.displacement(xyz)
io.inventory.filename = "shear_disp%s.spatialdb" % component
io._configure()
data = {'points': xyz,
'coordsys': cs,
'data_dim': 1,
'values': [{'name': "displacement-%s" % component,
'units': "m",
'data': numpy.ravel(disp[0,:,ic])},
]}
io.write(data)
return
def run(self):
"""
Generate the database.
"""
# Domain
x = numpy.arange(-4000.0, 4000.1, 1000.0)
y = numpy.arange(-4000.0, 4000.1, 1000.0)
npts = x.shape[0]
xx = x * numpy.ones((npts, 1), dtype=numpy.float64)
yy = y * numpy.ones((npts, 1), dtype=numpy.float64)
xy = numpy.zeros((npts ** 2, 2), dtype=numpy.float64)
xy[:, 0] = numpy.ravel(xx)
xy[:, 1] = numpy.ravel(numpy.transpose(yy))
from sheardisp_soln import AnalyticalSoln
soln = AnalyticalSoln()
disp = soln.displacement(xy)
from spatialdata.geocoords.CSCart import CSCart
cs = CSCart()
cs.inventory.spaceDim = 2
cs._configure()
data = {
"points": xy,
"coordsys": cs,
"data_dim": 2,
"values": [
{"name": "displacement-x", "units": "m", "data": numpy.ravel(disp[0, :, 0])},
{"name": "displacement-y", "units": "m", "data": numpy.ravel(disp[0, :, 1])},
],
}
from spatialdata.spatialdb.SimpleIOAscii import SimpleIOAscii
io = SimpleIOAscii()
io.inventory.filename = "shear_disp.spatialdb"
io._configure()
io.write(data)
return
def run(self):
"""
Generate the database.
"""
# Domain
dx = 200.0
x = numpy.arange(-1000.0, 1000.1, dx)
y = numpy.arange(-1000.0, 0.1, dx)
nptsx = x.shape[0]
nptsy = y.shape[0]
xx = x * numpy.ones( (nptsy, 1), dtype=numpy.float64)
yy = y * numpy.ones( (nptsx, 1), dtype=numpy.float64)
xy = numpy.zeros( (nptsx*nptsy, 2), dtype=numpy.float64)
xy[:,0] = numpy.ravel(xx)
xy[:,1] = numpy.ravel(numpy.transpose(yy))
from compressrotate_soln import AnalyticalSoln
soln = AnalyticalSoln()
disp = soln.displacement(xy)
from spatialdata.geocoords.CSCart import CSCart
cs = CSCart()
cs.inventory.spaceDim = 2
cs._configure()
data = {'points': xy,
'coordsys': cs,
'data_dim': 2,
'values': [{'name': "displacement-x",
'units': "m",
'data': numpy.ravel(disp[0,:,0])},
{'name': "displacement-y",
'units': "m",
'data': numpy.ravel(disp[0,:,1])}]}
from spatialdata.spatialdb.SimpleIOAscii import SimpleIOAscii
io = SimpleIOAscii()
io.inventory.filename = "compressrotate_disp.spatialdb"
io._configure()
io.write(data)
return
def test_initialize(self):
"""
Test initialize().
"""
from spatialdata.spatialdb.SimpleDB import SimpleDB
from spatialdata.spatialdb.SimpleIOAscii import SimpleIOAscii
ioFinalSlip = SimpleIOAscii()
ioFinalSlip.inventory.filename = "finalslip.spatialdb"
ioFinalSlip._configure()
dbFinalSlip = SimpleDB()
dbFinalSlip.inventory.iohandler = ioFinalSlip
dbFinalSlip.inventory.label = "final slip"
dbFinalSlip._configure()
ioSlipTime = SimpleIOAscii()
ioSlipTime.inventory.filename = "sliptime.spatialdb"
ioSlipTime._configure()
dbSlipTime = SimpleDB()
dbSlipTime.inventory.iohandler = ioSlipTime
dbSlipTime.inventory.label = "slip time"
dbSlipTime._configure()
slipFn = StepSlipFn()
slipFn.inventory.dbSlip = dbFinalSlip
slipFn.inventory.dbSlipTime = dbSlipTime
slipFn._configure()
slipFn.preinitialize()
slipFn.verifyConfiguration()
slipFn.initialize()
return
def test_configure(self):
"""
Test initialize().
"""
from spatialdata.spatialdb.SimpleDB import SimpleDB
from spatialdata.spatialdb.SimpleIOAscii import SimpleIOAscii
from pyre.units.time import second
ioInitial = SimpleIOAscii()
ioInitial.inventory.filename = "tri3_initialtractions.spatialdb"
ioInitial._configure()
dbInitial = SimpleDB()
dbInitial.inventory.iohandler = ioInitial
dbInitial.inventory.label = "initial tractions"
dbInitial._configure()
ioChange = SimpleIOAscii()
ioChange.inventory.filename = "tri3_changetractions.spatialdb"
ioChange._configure()
dbChange = SimpleDB()
dbChange.inventory.iohandler = ioChange
dbChange.inventory.label = "traction change"
dbChange._configure()
tract = TractPerturbation()
tract.inventory.dbInitial = dbInitial
tract.inventory.dbChange = dbChange
tract._configure()
return
def run(self):
"""
Generate the database.
"""
# Domain
x = numpy.arange(-4000.0, 4000.1, 500.0)
y = numpy.arange(-4000.0, 4000.1, 500.0)
npts = x.shape[0]
xx = x * numpy.ones( (npts, 1), dtype=numpy.float64)
yy = y * numpy.ones( (npts, 1), dtype=numpy.float64)
xy = numpy.zeros( (npts**2, 2), dtype=numpy.float64)
xy[:,0] = numpy.ravel(xx)
xy[:,1] = numpy.ravel(numpy.transpose(yy))
disp = self.soln.displacement(xy)
from spatialdata.geocoords.CSCart import CSCart
cs = CSCart()
cs.inventory.spaceDim = 2
cs._configure()
data = {'points': xy,
'coordsys': cs,
'data_dim': 2,
'values': [{'name': "displacement-x",
'units': "m",
'data': numpy.ravel(disp[0,:,0])},
{'name': "displacement-y",
'units': "m",
'data': numpy.ravel(disp[0,:,1])}]}
from spatialdata.spatialdb.SimpleIOAscii import SimpleIOAscii
io = SimpleIOAscii()
io.inventory.filename = self.filename
io._configure()
io.write(data)
return
def run(self):
"""
Generate the database.
"""
from axialdisp_soln import AnalyticalSoln
soln = AnalyticalSoln()
from spatialdata.geocoords.CSCart import CSCart
cs = CSCart()
cs.inventory.spaceDim = 3
cs._configure()
from spatialdata.spatialdb.SimpleIOAscii import SimpleIOAscii
io = SimpleIOAscii()
for component in ["x", "y", "z"]:
if component == "x":
xyz = numpy.array([[-40.0e+3, 0.0, 0.0], [+40.0e+3, 0.0, 0.0]],
dtype=numpy.float64)
ic = 0
elif component == "y":
xyz = numpy.array([[0.0, -40.0e+3, 0.0], [0.0, +40.0e+3, 0.0]],
dtype=numpy.float64)
ic = 1
elif component == "z":
xyz = numpy.array([[0.0, 0.0, -40.0e+3], [0.0, 0.0, 0.0]],
dtype=numpy.float64)
ic = 2
disp = soln.displacement(xyz)
io.inventory.filename = "axial_disp%s.spatialdb" % component
io._configure()
data = {
'points':
xyz,
'coordsys':
cs,
'data_dim':
1,
'values': [
{
'name': "displacement-%s" % component,
'units': "m",
'data': numpy.ravel(disp[0, :, ic])
},
]
}
io.write(data)
return
def run(self):
"""
Generate the database.
"""
# Domain
dx = 200.0
x = numpy.arange(-1000.0, 1000.1, dx)
y = numpy.arange(-1000.0, 0.1, dx)
nptsx = x.shape[0]
nptsy = y.shape[0]
xx = x * numpy.ones((nptsy, 1), dtype=numpy.float64)
yy = y * numpy.ones((nptsx, 1), dtype=numpy.float64)
xy = numpy.zeros((nptsx * nptsy, 2), dtype=numpy.float64)
xy[:, 0] = numpy.ravel(xx)
xy[:, 1] = numpy.ravel(numpy.transpose(yy))
from shearrotate_soln import AnalyticalSoln
soln = AnalyticalSoln()
disp = soln.displacement(xy)
from spatialdata.geocoords.CSCart import CSCart
cs = CSCart()
cs.inventory.spaceDim = 2
cs._configure()
data = {
'points':
xy,
'coordsys':
cs,
'data_dim':
2,
'values': [{
'name': "displacement-x",
'units': "m",
'data': numpy.ravel(disp[0, :, 0])
}, {
'name': "displacement-y",
'units': "m",
'data': numpy.ravel(disp[0, :, 1])
}]
}
from spatialdata.spatialdb.SimpleIOAscii import SimpleIOAscii
io = SimpleIOAscii()
io.inventory.filename = "shearrotate_disp.spatialdb"
io._configure()
io.write(data)
return
def test_initialize(self):
"""
Test initialize().
"""
from spatialdata.spatialdb.SimpleDB import SimpleDB
from spatialdata.spatialdb.SimpleIOAscii import SimpleIOAscii
from pyre.units.time import second
ioFinalSlip = SimpleIOAscii()
ioFinalSlip.inventory.filename = "finalslip.spatialdb"
ioFinalSlip._configure()
dbFinalSlip = SimpleDB()
dbFinalSlip.inventory.iohandler = ioFinalSlip
dbFinalSlip.inventory.label = "final slip"
dbFinalSlip._configure()
ioSlipTime = SimpleIOAscii()
ioSlipTime.inventory.filename = "sliptime.spatialdb"
ioSlipTime._configure()
dbSlipTime = SimpleDB()
dbSlipTime.inventory.iohandler = ioSlipTime
dbSlipTime.inventory.label = "slip time"
dbSlipTime._configure()
from pylith.faults.StepSlipFn import StepSlipFn
slipfn = StepSlipFn()
slipfn.inventory.dbSlip = dbFinalSlip
slipfn.inventory.dbSlipTime = dbSlipTime
slipfn._configure()
eqsrc = EqKinSrc()
eqsrc.inventory.originTime = 5.3 * second
eqsrc.inventory.slipfn = slipfn
eqsrc._configure()
eqsrc.preinitialize()
eqsrc.verifyConfiguration()
eqsrc.initialize()
return
def test_initialize(self):
"""
Test initialize().
"""
from spatialdata.spatialdb.SimpleDB import SimpleDB
from spatialdata.spatialdb.SimpleIOAscii import SimpleIOAscii
from spatialdata.spatialdb.TimeHistory import TimeHistory
ioFinalSlip = SimpleIOAscii()
ioFinalSlip.inventory.filename = "finalslip.spatialdb"
ioFinalSlip._configure()
dbFinalSlip = SimpleDB()
dbFinalSlip.inventory.iohandler = ioFinalSlip
dbFinalSlip.inventory.label = "slip amplitude"
dbFinalSlip._configure()
ioSlipTime = SimpleIOAscii()
ioSlipTime.inventory.filename = "sliptime.spatialdb"
ioSlipTime._configure()
dbSlipTime = SimpleDB()
dbSlipTime.inventory.iohandler = ioSlipTime
dbSlipTime.inventory.label = "slip time"
dbSlipTime._configure()
dbTimeHistory = TimeHistory()
dbTimeHistory.inventory.filename = "slipfn.timedb"
dbTimeHistory.inventory.label = "time history"
dbTimeHistory._configure()
slipFn = TimeHistorySlipFn()
slipFn.inventory.dbslip = dbFinalSlip
slipFn.inventory.dbSlipTime = dbSlipTime
slipFn.inventory.dbTimeHistory = dbTimeHistory
slipFn._configure()
slipFn.preinitialize()
slipFn.verifyConfiguration()
slipFn.initialize()
return
def run(self):
"""
Generate the database.
"""
# Domain
x = numpy.arange(-4000.0, 4000.1, 500.0)
y = numpy.arange(-4000.0, 4000.1, 500.0)
npts = x.shape[0]
xx = x * numpy.ones((npts, 1), dtype=numpy.float64)
yy = y * numpy.ones((npts, 1), dtype=numpy.float64)
xy = numpy.zeros((npts**2, 2), dtype=numpy.float64)
xy[:, 0] = numpy.ravel(xx)
xy[:, 1] = numpy.ravel(numpy.transpose(yy))
disp = self.soln.displacement(xy)
from spatialdata.geocoords.CSCart import CSCart
cs = CSCart()
cs.inventory.spaceDim = 2
cs._configure()
data = {
'points':
xy,
'coordsys':
cs,
'data_dim':
2,
'values': [{
'name': "displacement-x",
'units': "m",
'data': numpy.ravel(disp[0, :, 0])
}, {
'name': "displacement-y",
'units': "m",
'data': numpy.ravel(disp[0, :, 1])
}]
}
from spatialdata.spatialdb.SimpleIOAscii import SimpleIOAscii
io = SimpleIOAscii()
io.inventory.filename = self.filename
io._configure()
io.write(data)
return
def test_initialize(self):
"""
Test initialize().
"""
from spatialdata.spatialdb.SimpleDB import SimpleDB
from spatialdata.spatialdb.SimpleIOAscii import SimpleIOAscii
from pyre.units.time import second
ioFinalSlip = SimpleIOAscii()
ioFinalSlip.inventory.filename = "finalslip.spatialdb"
ioFinalSlip._configure()
dbFinalSlip = SimpleDB()
dbFinalSlip.inventory.iohandler = ioFinalSlip
dbFinalSlip.inventory.label = "final slip"
dbFinalSlip._configure()
ioSlipTime = SimpleIOAscii()
ioSlipTime.inventory.filename = "sliptime.spatialdb"
ioSlipTime._configure()
dbSlipTime = SimpleDB()
dbSlipTime.inventory.iohandler = ioSlipTime
dbSlipTime.inventory.label = "slip time"
dbSlipTime._configure()
from pylith.faults.StepSlipFn import StepSlipFn
slipfn = StepSlipFn()
slipfn.inventory.dbSlip = dbFinalSlip
slipfn.inventory.dbSlipTime = dbSlipTime
slipfn._configure()
eqsrc = EqKinSrc()
eqsrc.inventory.originTime = 5.3*second
eqsrc.inventory.slipfn = slipfn
eqsrc._configure()
eqsrc.preinitialize()
eqsrc.verifyConfiguration()
eqsrc.initialize()
return
def test_initialize(self):
"""
Test initialize().
"""
from spatialdata.spatialdb.SimpleDB import SimpleDB
from spatialdata.spatialdb.SimpleIOAscii import SimpleIOAscii
from spatialdata.spatialdb.TimeHistory import TimeHistory
ioFinalSlip = SimpleIOAscii()
ioFinalSlip.inventory.filename = "finalslip.spatialdb"
ioFinalSlip._configure()
dbFinalSlip = SimpleDB()
dbFinalSlip.inventory.iohandler = ioFinalSlip
dbFinalSlip.inventory.label = "slip amplitude"
dbFinalSlip._configure()
ioSlipTime = SimpleIOAscii()
ioSlipTime.inventory.filename = "sliptime.spatialdb"
ioSlipTime._configure()
dbSlipTime = SimpleDB()
dbSlipTime.inventory.iohandler = ioSlipTime
dbSlipTime.inventory.label = "slip time"
dbSlipTime._configure()
dbTimeHistory = TimeHistory()
dbTimeHistory.inventory.filename = "slipfn.timedb"
dbTimeHistory.inventory.label = "time history"
dbTimeHistory._configure()
slipFn = TimeHistorySlipFn()
slipFn.inventory.dbslip = dbFinalSlip
slipFn.inventory.dbSlipTime = dbSlipTime
slipFn.inventory.dbTimeHistory = dbTimeHistory
slipFn._configure()
slipFn.preinitialize()
slipFn.verifyConfiguration()
slipFn.initialize()
return
# because the normal tractions are negative.
tractions_bg_shear = coef_friction * tractions_bg_normal
# Combine traction changes and background tractions
tractions_shear = tractions_bg_shear + tractions_change[:, 0]
tractions_normal = tractions_bg_normal + tractions_change[:, 1]
# Create coordinate system for spatial database
from spatialdata.geocoords.CSCart import CSCart
cs = CSCart()
cs._configure()
cs.setSpaceDim(2)
# Create writer for spatial database file
from spatialdata.spatialdb.SimpleIOAscii import SimpleIOAscii
writer = SimpleIOAscii()
writer.inventory.filename = "afterslip_tractions.spatialdb"
writer._configure()
writer.write({
'points':
vertices,
'coordsys':
cs,
'data_dim':
1,
'values': [{
'name': "traction-shear",
'units': "Pa",
'data': tractions_shear
}, {
'name': "traction-normal",
mask1 = z >= -15.6e+3
Pf = -densityW*gacc*z
Szz = density*gacc*z
Szz[z > -1.0] = (density-densityW)*gacc*-10.0
Syy = mask1*(b22*(Szz+Pf)-0*Pf) + ~mask1*Szz
Sxx = mask1*(b33*(Szz+Pf)-0*Pf) + ~mask1*Szz
Sxy = mask1*(-b23*(Szz+Pf)) + ~mask1*0.0
Syz = 0.0*z
Sxz = 0.0*z
writer = SimpleIOAscii()
writer.inventory.filename = "empty"
writer._configure()
# ----------------------------------------------------------------------
# Initial stresses in domain
writer.filename("%s_initial_stress.spatialdb" % sim)
dataOut = {'points': points,
'coordsys': cs,
'data_dim': 1,
'values': [{'name': 'stress-xx',
'units': 'Pa',
'data': Sxx},
{'name': 'stress-yy',
'units': 'Pa',
def test_write(self):
"""
Test write().
"""
# Database info
cs = CSCart()
cs.initialize()
filename = "data/test.spatialdb"
data = {
'points':
numpy.array([[1.0, 2.0, 3.0], [0.5, 3.0, -3.0]], numpy.float64),
'coordsys':
cs,
'data_dim':
1,
'values': [{
'name': "One",
'units': "m",
'data': numpy.array([2.0, 8.0], numpy.float64)
}, {
'name': "Two",
'units': "m",
'data': numpy.array([-2.0, 3.0], numpy.float64)
}]
}
dataDim = 1
qlocs = numpy.array(
[[0.875, 2.25, 1.5], [0.6, 2.8, -1.8], [1.0, 2.0, 3.0]],
numpy.float64)
valsE = numpy.array([[-0.75, 3.5], [2.0, 6.8], [-2.0, 2.0]],
numpy.float64)
errE = [0, 0, 0]
# Write database
from spatialdata.spatialdb.SimpleIOAscii import SimpleIOAscii
writer = SimpleIOAscii()
writer.inventory.filename = filename
writer._configure()
writer.write(data)
# Test write using query
from spatialdata.spatialdb.SimpleDB import SimpleDB
db = SimpleDB()
db.inventory.label = "test"
db.inventory.queryType = "linear"
db.inventory.iohandler.inventory.filename = filename
db.inventory.iohandler._configure()
db._configure()
db.open()
db.queryVals(["two", "one"])
vals = numpy.zeros(valsE.shape, dtype=numpy.float64)
err = []
nlocs = qlocs.shape[0]
for i in xrange(nlocs):
e = db.query(vals[i, :], qlocs[i, :], cs)
err.append(e)
db.close()
self.assertEqual(len(valsE.shape), len(vals.shape))
for dE, d in zip(valsE.shape, vals.shape):
self.assertEqual(dE, d)
for vE, v in zip(numpy.reshape(valsE, -1), numpy.reshape(vals, -1)):
self.assertAlmostEqual(vE, v, 6)
return
def _initialize(self):
"""
Initialize fault.
"""
dt = 2.4
from spatialdata.units.Nondimensional import Nondimensional
normalizer = Nondimensional()
normalizer._configure()
# Setup mesh
cs = CSCart()
cs.inventory.spaceDim = 2
cs._configure()
from pylith.meshio.MeshIOAscii import MeshIOAscii
importer = MeshIOAscii()
importer.inventory.filename = "data/tri3.mesh"
importer.inventory.coordsys = cs
importer._configure()
mesh = importer.read(debug=False, interpolate=False)
# Setup quadrature
from pylith.feassemble.FIATSimplex import FIATSimplex
cell = FIATSimplex()
cell.inventory.dimension = 1
cell.inventory.degree = 1
cell.inventory.order = 1
cell._configure()
from pylith.feassemble.Quadrature import Quadrature
quadrature = Quadrature()
quadrature.inventory.cell = cell
quadrature._configure()
# Setup earthquake source
from spatialdata.spatialdb.SimpleDB import SimpleDB
from spatialdata.spatialdb.SimpleIOAscii import SimpleIOAscii
ioFinalSlip = SimpleIOAscii()
ioFinalSlip.inventory.filename = "data/tri3_finalslip.spatialdb"
ioFinalSlip._configure()
dbFinalSlip = SimpleDB()
dbFinalSlip.inventory.iohandler = ioFinalSlip
dbFinalSlip.inventory.label = "final slip"
dbFinalSlip._configure()
ioSlipTime = SimpleIOAscii()
ioSlipTime.inventory.filename = "data/tri3_sliptime.spatialdb"
ioSlipTime._configure()
dbSlipTime = SimpleDB()
dbSlipTime.inventory.iohandler = ioSlipTime
dbSlipTime.inventory.label = "slip time"
dbSlipTime._configure()
from pylith.faults.StepSlipFn import StepSlipFn
slipfn = StepSlipFn()
slipfn.inventory.dbSlip = dbFinalSlip
slipfn.inventory.dbSlipTime = dbSlipTime
slipfn._configure()
# Setup fault
fault = FaultCohesiveKin()
fault.inventory.output.inventory.writer._configure()
fault.inventory.output._configure()
fault.inventory.matId = 10
fault.inventory.faultLabel = "fault"
fault.inventory.upDir = [0, 0, 1]
fault.inventory.faultQuadrature = quadrature
fault._configure()
eqsrc = fault.eqsrcs.components()[0]
eqsrc.inventory.originTime = 1.23*second
eqsrc.inventory.slipfn = slipfn
eqsrc._configure()
nvertices = fault.numVerticesNoMesh(mesh)
firstFaultVertex = 0
firstLagrangeVertex = nvertices
firstFaultCell = 2*nvertices
fault.adjustTopology(mesh, firstFaultVertex, firstLagrangeVertex,
firstFaultCell)
fault.preinitialize(mesh)
fault.timeStep(dt)
fault.verifyConfiguration()
from pyre.units.time import s
fault.initialize(totalTime=0.0*s, numTimeSteps=1, normalizer=normalizer)
# Setup fields
from pylith.topology.SolutionFields import SolutionFields
fields = SolutionFields(mesh)
fields.add("residual", "residual")
fields.add("dispIncr(t->t+dt)", "displacement_increment")
fields.add("disp(t)", "displacement")
fields.solutionName("dispIncr(t->t+dt)")
residual = fields.get("residual")
residual.subfieldAdd("displacement", cs.spaceDim(), residual.VECTOR)
residual.subfieldAdd("lagrange_multiplier", cs.spaceDim(), residual.VECTOR)
residual.subfieldsSetup()
residual.setupSolnChart()
residual.setupSolnDof(cs.spaceDim())
fault.setupSolnDof(residual)
residual.allocate()
residual.zero()
fields.copyLayout("residual")
return (mesh, fault, fields)
def test_write(self):
"""
Test write().
"""
# Database info
cs = CSCart()
cs.initialize()
filename = "data/test.spatialdb"
data = {'points': numpy.array( [ [1.0, 2.0, 3.0],
[0.5, 3.0, -3.0]], numpy.float64),
'coordsys': cs,
'data_dim': 1,
'values': [{'name': "One",
'units': "m",
'data': numpy.array( [2.0, 8.0], numpy.float64)},
{'name': "Two",
'units': "m",
'data': numpy.array( [-2.0, 3.0], numpy.float64)}]}
dataDim = 1
qlocs = numpy.array( [[0.875, 2.25, 1.5],
[0.6, 2.8, -1.8],
[1.0, 2.0, 3.0]],
numpy.float64)
valsE = numpy.array( [[-0.75, 3.5],
[2.0, 6.8],
[-2.0, 2.0]], numpy.float64)
errE = [0, 0, 0]
# Write database
from spatialdata.spatialdb.SimpleIOAscii import SimpleIOAscii
writer = SimpleIOAscii()
writer.inventory.filename = filename
writer._configure()
writer.write(data)
# Test write using query
from spatialdata.spatialdb.SimpleDB import SimpleDB
db = SimpleDB()
db.inventory.label = "test"
db.inventory.queryType = "linear"
db.inventory.iohandler.inventory.filename = filename
db.inventory.iohandler._configure()
db._configure()
db.open()
db.queryVals(["two", "one"])
vals = numpy.zeros(valsE.shape, dtype=numpy.float64)
err = []
nlocs = qlocs.shape[0]
for i in xrange(nlocs):
e = db.query(vals[i,:], qlocs[i,:], cs)
err.append(e)
db.close()
self.assertEqual(len(valsE.shape), len(vals.shape))
for dE, d in zip(valsE.shape, vals.shape):
self.assertEqual(dE, d)
for vE, v in zip(numpy.reshape(valsE, -1), numpy.reshape(vals, -1)):
self.assertAlmostEqual(vE, v, 6)
return
# Open HDF5 file and get coordinates, cells, and stress.
h5 = h5py.File(filenameH5, "r")
vertices = h5['geometry/vertices'][:]
cells = numpy.array(h5['topology/cells'][:], dtype=numpy.int)
stress = h5['cell_fields/stress'][0,:,:]
strain = h5['cell_fields/total_strain'][0,:,:]
strainViscous = h5['cell_fields/viscous_strain'][0,:,:]
h5.close()
# Get cell centers for output.
cellCoords = vertices[cells,:]
cellCenters = numpy.mean(cellCoords, axis=1)
# Create writer for spatial database file
writer = SimpleIOAscii()
writer.inventory.filename = filenameDB
writer._configure()
values = [{'name': "stress-xx",
'units': "Pa",
'data': stress[:,0]},
{'name': "stress-yy",
'units': "Pa",
'data': stress[:,1]},
{'name': "stress-xy",
'units': "Pa",
'data': stress[:,2]},
]
#if "mantle" in material:
def test_initialize(self):
"""
Test initialize().
"""
from spatialdata.spatialdb.SimpleDB import SimpleDB
from spatialdata.spatialdb.SimpleIOAscii import SimpleIOAscii
ioFinalSlip = SimpleIOAscii()
ioFinalSlip.inventory.filename = "finalslip.spatialdb"
ioFinalSlip._configure()
dbFinalSlip = SimpleDB()
dbFinalSlip.inventory.iohandler = ioFinalSlip
dbFinalSlip.inventory.label = "final slip"
dbFinalSlip._configure()
ioSlipTime = SimpleIOAscii()
ioSlipTime.inventory.filename = "sliptime.spatialdb"
ioSlipTime._configure()
dbSlipTime = SimpleDB()
dbSlipTime.inventory.iohandler = ioSlipTime
dbSlipTime.inventory.label = "slip time"
dbSlipTime._configure()
ioRiseTime = SimpleIOAscii()
ioRiseTime.inventory.filename = "risetime.spatialdb"
ioRiseTime._configure()
dbRiseTime = SimpleDB()
dbRiseTime.inventory.iohandler = ioRiseTime
dbRiseTime.inventory.label = "rise time"
dbRiseTime._configure()
slipFn = LiuCosSlipFn()
slipFn.inventory.dbslip = dbFinalSlip
slipFn.inventory.dbSlipTime = dbSlipTime
slipFn.inventory.dbRiseTime = dbRiseTime
slipFn._configure()
slipFn.preinitialize()
slipFn.verifyConfiguration()
slipFn.initialize()
return
tractionNormal = -data[:, 4]
tractionShearHoriz = -data[:, 5]
tractionShearVert = data[:, 6]
coefStatic = data[:, 9]
coefDyn = data[:, 10]
d0 = data[:, 11]
cohesion = data[:, 12]
weakTime = data[:, 13]
cs = CSCart()
cs._configure()
cs.initialize()
writer = SimpleIOAscii()
writer.inventory.filename = "empty"
writer._configure()
writer.filename("%s_tractions.spatialdb" % sim)
dataOut = {
'points':
points,
'coordsys':
cs,
'data_dim':
2,
'values': [
{
'name': 'traction-shear-leftlateral',
'units': 'Pa',
def _initialize(self):
"""
Initialize fault.
"""
dt = 2.4
from spatialdata.units.Nondimensional import Nondimensional
normalizer = Nondimensional()
normalizer._configure()
# Setup mesh
cs = CSCart()
cs.inventory.spaceDim = 2
cs._configure()
from pylith.meshio.MeshIOAscii import MeshIOAscii
importer = MeshIOAscii()
importer.inventory.filename = "data/tri3.mesh"
importer.inventory.coordsys = cs
importer._configure()
mesh = importer.read(debug=False, interpolate=False)
# Setup quadrature
from pylith.feassemble.FIATSimplex import FIATSimplex
cell = FIATSimplex()
cell.inventory.dimension = 1
cell.inventory.degree = 1
cell.inventory.order = 1
cell._configure()
from pylith.feassemble.Quadrature import Quadrature
quadrature = Quadrature()
quadrature.inventory.cell = cell
quadrature._configure()
# Setup impulses
from spatialdata.spatialdb.SimpleDB import SimpleDB
from spatialdata.spatialdb.SimpleIOAscii import SimpleIOAscii
ioImpulseAmp = SimpleIOAscii()
ioImpulseAmp.inventory.filename = "data/tri3_impulses.spatialdb"
ioImpulseAmp._configure()
dbImpulseAmp = SimpleDB()
dbImpulseAmp.inventory.iohandler = ioImpulseAmp
dbImpulseAmp.inventory.label = "impulse amplitude"
dbImpulseAmp._configure()
# Setup fault
fault = FaultCohesiveImpulses()
fault.inventory.output.inventory.writer._configure()
fault.inventory.output._configure()
fault.inventory.matId = 10
fault.inventory.faultLabel = "fault"
fault.inventory.upDir = [0, 0, 1]
fault.inventory.faultQuadrature = quadrature
fault.inventory.dbImpulseAmp = dbImpulseAmp
fault._configure()
nvertices = fault.numVerticesNoMesh(mesh)
firstFaultVertex = 0
firstLagrangeVertex = nvertices
firstFaultCell = 2*nvertices
fault.adjustTopology(mesh, firstFaultVertex, firstLagrangeVertex,
firstFaultCell)
fault.preinitialize(mesh)
fault.timeStep(dt)
fault.verifyConfiguration()
from pyre.units.time import s
fault.initialize(totalTime=0.0*s, numTimeSteps=1, normalizer=normalizer)
# Setup fields
from pylith.topology.SolutionFields import SolutionFields
fields = SolutionFields(mesh)
fields.add("residual", "residual")
fields.add("dispIncr(t->t+dt)", "displacement_increment")
fields.add("disp(t)", "displacement")
fields.solutionName("dispIncr(t->t+dt)")
residual = fields.get("residual")
residual.subfieldAdd("displacement", cs.spaceDim(), residual.VECTOR)
residual.subfieldAdd("lagrange_multiplier", cs.spaceDim(), residual.VECTOR)
residual.subfieldsSetup()
residual.setupSolnChart()
residual.setupSolnDof(cs.spaceDim())
fault.setupSolnDof(residual)
residual.allocate()
residual.zero()
fields.copyLayout("residual")
return (mesh, fault, fields)
# Check to make sure output included all quadrature points (CellFilterAvg was not used).
if stress.shape[1] == 3:
raise ValueError(
"Found %d stress values for each cell. Expected 12 stress values (stress_xx, stress_yy, and stress_xy at 4 quadrature points) for each cell. Turn off CellFilterAvg in pylithapp.cfg."
% stress.shape[1])
if stress.shape[1] != nqpts * 3:
raise ValueError(
"Found %d stress values for each cell. Expected 12 stress values (stress_xx, stress_yy, and stress_xy at 4 quadrature points) for each cell. Did you turn off CellFilterAvg in pylithapp.cfg?"
% stress.shape[1])
stress = stress.reshape((ncells * nqpts, nvalues))
# Create writer for spatial database file
writer = SimpleIOAscii()
writer.inventory.filename = filenameDB
writer._configure()
values = [
{
'name': "stress-xx",
'units': "Pa",
'data': stress[:, 0]
},
{
'name': "stress-yy",
'units': "Pa",
'data': stress[:, 1]
},
{
def generate(sim, fileRoot, materials):
for material in materials:
filenameH5 = "../output/%s-%s.h5" % (sim, material)
filenameDB = "%s-%s.spatialdb" % (fileRoot, material)
# Open HDF5 file and get coordinates, cells, and stress.
h5 = h5py.File(filenameH5, "r")
vertices = h5['geometry/vertices'][:]
cells = numpy.array(h5['topology/cells'][:], dtype=numpy.int)
# Get stresses from final time step.
stress = h5['cell_fields/stress'][-1, :, :]
h5.close()
# Compute coordinates of quadrature points.
quadCoords = getCellCenters(vertices, cells)
# Create writer for spatial database file
writer = SimpleIOAscii()
writer.inventory.filename = filenameDB
writer._configure()
values = [
{
'name': "stress-xx",
'units': "Pa",
'data': stress[:, 0]
},
{
'name': "stress-yy",
'units': "Pa",
'data': stress[:, 1]
},
{
'name': "stress-zz",
'units': "Pa",
'data': stress[:, 2]
},
{
'name': "stress-xy",
'units': "Pa",
'data': stress[:, 3]
},
{
'name': "stress-yz",
'units': "Pa",
'data': stress[:, 4]
},
{
'name': "stress-xz",
'units': "Pa",
'data': stress[:, 5]
},
]
writer.write({
'points': quadCoords,
'coordsys': cs,
'data_dim': 3,
'values': values
})
return
tractionShearLL = maskO*-5.80*(1.0+numpy.cos(numpy.pi*(r-1400.0)/600.0)) + maskI*-11.60
tractionShearUD = 0*tractionShearLL
tractionNormal = 0*tractionShearLL
cs = CSCart()
cs._configure()
cs.initialize()
dataOut = {'points': points,
'coordsys': cs,
'data_dim': 1,
'values': [{'name': 'traction-shear-leftlateral',
'units': 'MPa',
'data': tractionShearLL},
{'name': 'traction-shear-updip',
'units': 'MPa',
'data': tractionShearUD},
{'name': 'traction-normal',
'units': 'MPa',
'data': tractionNormal},
],
}
writer = SimpleIOAscii()
writer.inventory.filename = "initial_traction.spatialdb"
writer._configure()
writer.write(dataOut)
# End of file
def _makeSpatialdb(self):
"""
Function to generate a set of spatial databases (one for each impulse).
"""
# Create empty arrays for impulse values.
# Only array1 will be modified.
array1 = numpy.zeros( (self.numFaultVertices,), dtype=numpy.float64)
array2 = numpy.zeros( (self.numFaultVertices,), dtype=numpy.float64)
# Set up info for arrays that won't be modified.
if (self.impulseType == "left-lateral-slip"):
info2 = {'name': "fault-opening",
'units': "m",
'data': array2.flatten()}
if (self.spaceDim == 3):
info3 = {'name': "reverse-slip",
'units': "m",
'data': array2.flatten()}
elif (self.impulseType == "fault-opening"):
info2 = {'name': "left-lateral-slip",
'units': "m",
'data': array2.flatten()}
if (self.spaceDim == 3):
info3 = {'name': "reverse-slip",
'units': "m",
'data': array2.flatten()}
elif (self.impulseType == "reverse-slip"):
info2 = {'name': "left-lateral-slip",
'units': "m",
'data': array2.flatten()}
info3 = {'name': "fault-opening",
'units': "m",
'data': array2.flatten()}
# Create root output filename.
suffIndex = self.spatialdbOutputRoot.rfind(".spatialdb")
outputRoot = self.spatialdbOutputRoot
if (suffIndex != -1):
outputRoot = self.spatialdbOutputRoot[:suffIndex - 1]
# Set data dimension.
dataDim = self.spaceDim - 1
# Loop over impulses to generate and modify the appropriate entries.
for impulse in range(self.numFaultVertices):
# Set filename
impulseNum = int(impulse)
impulseString = repr(impulseNum).rjust(self.impulseNumberWidth, '0')
filename = outputRoot + "_i" + impulseString + ".spatialdb"
writer = SimpleIOAscii()
writer.inventory.filename = filename
writer._configure()
# Modify database values.
array1[impulse] = self.impulseValue
if (impulse > 0):
array1[impulse - 1] = -self.impulseValue
if (impulse > 1):
array1[impulse - 2] = 0.0
info1 = {'name': self.impulseType,
'units': "m",
'data': array1.flatten()}
# Create data and write it to a database.
if (self.spaceDim == 2):
data = {'points': self.faultVertices,
'coordsys': self.geometry.coordsys,
'data_dim': dataDim,
'values': [info1, info2]}
else:
data = {'points': self.faultVertices,
'coordsys': self.geometry.coordsys,
'data_dim': dataDim,
'values': [info1, info2, info3]}
writer.write(data)
return
nqpts = qpts.shape[0]
ncells = cells.shape[0]
nvalues = stress.shape[1]/nqpts
# Check to make sure output included all quadrature points (CellFilterAvg was not used).
if stress.shape[1] == 3:
raise ValueError("Found %d stress values for each cell. Expected 12 stress values (stress_xx, stress_yy, and stress_xy at 4 quadrature points) for each cell. Turn off CellFilterAvg in pylithapp.cfg." % stress.shape[1])
if stress.shape[1] != nqpts*3:
raise ValueError("Found %d stress values for each cell. Expected 12 stress values (stress_xx, stress_yy, and stress_xy at 4 quadrature points) for each cell. Did you turn off CellFilterAvg in pylithapp.cfg?" % stress.shape[1])
stress = stress.reshape((ncells*nqpts, nvalues))
# Create writer for spatial database file
writer = SimpleIOAscii()
writer.inventory.filename = filenameDB
writer._configure()
values = [{'name': "stress-xx",
'units': "Pa",
'data': stress[:,0]},
{'name': "stress-yy",
'units': "Pa",
'data': stress[:,1]},
{'name': "stress-xy",
'units': "Pa",
'data': stress[:,2]},
]
if "mantle" in material:
def _initialize(self):
"""
Initialize fault.
"""
dt = 2.4
from spatialdata.units.Nondimensional import Nondimensional
normalizer = Nondimensional()
normalizer._configure()
# Setup mesh
cs = CSCart()
cs.inventory.spaceDim = 2
cs._configure()
from pylith.meshio.MeshIOAscii import MeshIOAscii
importer = MeshIOAscii()
importer.inventory.filename = "data/tri3.mesh"
importer.inventory.coordsys = cs
importer._configure()
mesh = importer.read(debug=False, interpolate=False)
# Setup quadrature
from pylith.feassemble.FIATSimplex import FIATSimplex
cell = FIATSimplex()
cell.inventory.dimension = 1
cell.inventory.degree = 1
cell.inventory.order = 1
cell._configure()
from pylith.feassemble.Quadrature import Quadrature
quadrature = Quadrature()
quadrature.inventory.cell = cell
quadrature._configure()
# Setup rupture info
from spatialdata.spatialdb.SimpleDB import SimpleDB
from spatialdata.spatialdb.SimpleIOAscii import SimpleIOAscii
ioTractions = SimpleIOAscii()
ioTractions.inventory.filename = "data/tri3_initialtractions.spatialdb"
ioTractions._configure()
dbTractions = SimpleDB()
dbTractions.inventory.iohandler = ioTractions
dbTractions.inventory.label = "initial tractions"
dbTractions._configure()
from pylith.faults.TractPerturbation import TractPerturbation
tract = TractPerturbation()
tract.inventory.dbInitial = dbTractions
tract._configure()
ioFriction = SimpleIOAscii()
ioFriction.inventory.filename = "data/tri3_staticfriction.spatialdb"
ioFriction._configure()
dbFriction = SimpleDB()
dbFriction.inventory.iohandler = ioFriction
dbFriction.inventory.label = "friction"
dbFriction._configure()
from pylith.friction.StaticFriction import StaticFriction
friction = StaticFriction()
friction.inventory.label = "Static friction"
friction.inventory.dbProperties = dbFriction
friction._configure()
# Setup fault
fault = FaultCohesiveDyn()
fault.inventory.output.inventory.writer._configure()
fault.inventory.output._configure()
fault.inventory.matId = 10
fault.inventory.faultLabel = "fault"
fault.inventory.upDir = [0, 0, 1]
fault.inventory.faultQuadrature = quadrature
fault.inventory.tract = tract
fault.inventory.friction = friction
fault._configure()
nvertices = fault.numVerticesNoMesh(mesh)
firstFaultVertex = 0
firstLagrangeVertex = nvertices
firstFaultCell = 2*nvertices
fault.adjustTopology(mesh, firstFaultVertex, firstLagrangeVertex,
firstFaultCell)
from pylith.topology.topology import MeshOps_nondimensionalize
MeshOps_nondimensionalize(mesh, normalizer)
fault.preinitialize(mesh)
fault.timeStep(dt)
fault.verifyConfiguration()
from pyre.units.time import s
fault.initialize(totalTime=0.0*s, numTimeSteps=1, normalizer=normalizer)
# Setup fields
from pylith.topology.SolutionFields import SolutionFields
fields = SolutionFields(mesh)
fields.add("residual", "residual")
fields.add("dispIncr(t->t+dt)", "displacement_increment")
fields.add("disp(t)", "displacement")
fields.add("velocity(t)", "velocity")
fields.solutionName("dispIncr(t->t+dt)")
residual = fields.get("residual")
residual.subfieldAdd("displacement", cs.spaceDim(), residual.VECTOR)
residual.subfieldAdd("lagrange_multiplier", cs.spaceDim(), residual.VECTOR)
residual.subfieldsSetup()
residual.setupSolnChart()
residual.setupSolnDof(cs.spaceDim())
fault.setupSolnDof(residual)
residual.allocate()
residual.zero()
fields.copyLayout("residual")
return (mesh, fault, fields)
tractionNormal = -data[:,4]
tractionShearHoriz = -data[:,5]
tractionShearVert = data[:,6]
coefStatic = data[:,9]
coefDyn = data[:,10]
d0 = data[:,11]
cohesion = data[:,12]
weakTime = data[:,13]
cs = CSCart()
cs._configure()
cs.initialize()
writer = SimpleIOAscii()
writer.inventory.filename = "empty"
writer._configure()
writer.filename("%s_tractions.spatialdb" % sim)
dataOut = {'points': points,
'coordsys': cs,
'data_dim': 2,
'values': [{'name': 'traction-shear-leftlateral',
'units': 'Pa',
'data': tractionShearHoriz},
{'name': 'traction-shear-updip',
'units': 'Pa',
'data': tractionShearVert},
{'name': 'traction-normal',
'units': 'Pa',
cs._configure()
cs.initialize()
mask1 = z >= -15.0e+3
Pf = -densityW * gacc * z
Szz = density * gacc * z
Syy = mask1 * (b22 * (Szz + Pf) - 0 * Pf) + ~mask1 * Szz
Sxx = mask1 * (b33 * (Szz + Pf) - 0 * Pf) + ~mask1 * Szz
Sxy = mask1 * (-b23 * (Szz + Pf)) + ~mask1 * 0.0
Syz = 0.0 * z
Sxz = 0.0 * z
writer = SimpleIOAscii()
writer.inventory.filename = "empty"
writer._configure()
# ----------------------------------------------------------------------
# Initial stresses in domain
writer.filename("%s_initial_stress.spatialdb" % sim)
dataOut = {
'points':
points,
'coordsys':
cs,
'data_dim':
1,
'values': [
{
filenameH5 = "output/grav_stress-%s.h5" % material
filenameDB = "grav_stress-%s.spatialdb" % material
# Open HDF5 file and get coordinates, cells, and stress.
h5 = h5py.File(filenameH5, "r")
vertices = h5['geometry/vertices'][:]
cells = numpy.array(h5['topology/cells'][:], dtype=numpy.int)
stress = h5['cell_fields/stress'][0,:,:]
h5.close()
# Get cell centers for output.
cellCoords = vertices[cells,:]
cellCenters = numpy.mean(cellCoords, axis=1)
# Create writer for spatial database file
writer = SimpleIOAscii()
writer.inventory.filename = filenameDB
writer._configure()
writer.write({'points': cellCenters,
'coordsys': cs,
'data_dim': 2,
'values': [{'name': "stress-xx",
'units': "Pa",
'data': stress[:,0]},
{'name': "stress-yy",
'units': "Pa",
'data': stress[:,1]},
{'name': "stress-xy",
'units': "Pa",
'data': stress[:,2]},
]})
def _initialize(self):
"""
Initialize fault.
"""
dt = 2.4
from spatialdata.units.Nondimensional import Nondimensional
normalizer = Nondimensional()
normalizer._configure()
# Setup mesh
cs = CSCart()
cs.inventory.spaceDim = 2
cs._configure()
from pylith.meshio.MeshIOAscii import MeshIOAscii
importer = MeshIOAscii()
importer.inventory.filename = "data/tri3.mesh"
importer.inventory.coordsys = cs
importer._configure()
mesh = importer.read(debug=False, interpolate=False)
# Setup quadrature
from pylith.feassemble.FIATSimplex import FIATSimplex
cell = FIATSimplex()
cell.inventory.dimension = 1
cell.inventory.degree = 1
cell.inventory.order = 1
cell._configure()
from pylith.feassemble.Quadrature import Quadrature
quadrature = Quadrature()
quadrature.inventory.cell = cell
quadrature._configure()
# Setup impulses
from spatialdata.spatialdb.SimpleDB import SimpleDB
from spatialdata.spatialdb.SimpleIOAscii import SimpleIOAscii
ioImpulseAmp = SimpleIOAscii()
ioImpulseAmp.inventory.filename = "data/tri3_impulses.spatialdb"
ioImpulseAmp._configure()
dbImpulseAmp = SimpleDB()
dbImpulseAmp.inventory.iohandler = ioImpulseAmp
dbImpulseAmp.inventory.label = "impulse amplitude"
dbImpulseAmp._configure()
# Setup fault
fault = FaultCohesiveImpulses()
fault.inventory.output.inventory.writer._configure()
fault.inventory.output._configure()
fault.inventory.matId = 10
fault.inventory.faultLabel = "fault"
fault.inventory.upDir = [0, 0, 1]
fault.inventory.faultQuadrature = quadrature
fault.inventory.dbImpulseAmp = dbImpulseAmp
fault._configure()
nvertices = fault.numVerticesNoMesh(mesh)
firstFaultVertex = 0
firstLagrangeVertex = nvertices
firstFaultCell = 2*nvertices
fault.adjustTopology(mesh, firstFaultVertex, firstLagrangeVertex,
firstFaultCell)
fault.preinitialize(mesh)
fault.timeStep(dt)
fault.verifyConfiguration()
from pyre.units.time import s
fault.initialize(totalTime=0.0*s, numTimeSteps=1, normalizer=normalizer)
# Setup fields
from pylith.topology.SolutionFields import SolutionFields
fields = SolutionFields(mesh)
fields.add("residual", "residual")
fields.add("dispIncr(t->t+dt)", "displacement_increment")
fields.add("disp(t)", "displacement")
fields.solutionName("dispIncr(t->t+dt)")
residual = fields.get("residual")
residual.newSection(residual.VERTICES_FIELD, cs.spaceDim())
residual.allocate()
residual.zero()
fields.copyLayout("residual")
return (mesh, fault, fields)
# Background shear tractions are reverse (in 2-D right-lateral is negative)
# because the normal tractions are negative.
tractions_bg_shear = coef_friction*tractions_bg_normal
# Combine traction changes and background tractions
tractions_shear = tractions_bg_shear + tractions_change[:,0]
tractions_normal = tractions_bg_normal + tractions_change[:,1]
# Create coordinate system for spatial database
from spatialdata.geocoords.CSCart import CSCart
cs = CSCart()
cs._configure()
cs.setSpaceDim(2)
# Create writer for spatial database file
from spatialdata.spatialdb.SimpleIOAscii import SimpleIOAscii
writer = SimpleIOAscii()
writer.inventory.filename = "afterslip_tractions.spatialdb"
writer._configure()
writer.write({'points': vertices,
'coordsys': cs,
'data_dim': 1,
'values': [{'name': "traction-shear",
'units': "Pa",
'data': tractions_shear},
{'name': "traction-normal",
'units': "Pa",
'data': tractions_normal}]})
# End of file
mask3 = r > 900.0
weakTime = mask1*r/(0.7*vs) + mask2*(720.0/(0.7*vs) + (r-720)/(0.35*vs)) + mask3*1.0e+9
mask1 = points[:,1] <= -14.999e+3
coefStatic[mask1] = 1.0e+6
mask1 = points[:,1] >= +14.999e+3
coefStatic[mask1] = 1.0e+6
mask1 = points[:,2] <= -14.999e+3
coefStatic[mask1] = 1.0e+6
cs = CSCart()
cs._configure()
cs.initialize()
writer = SimpleIOAscii()
writer.inventory.filename = "empty"
writer._configure()
writer.filename("friction_main.spatialdb")
dataOut = {'points': points,
'coordsys': cs,
'data_dim': 2,
'values': [{'name': 'static-coefficient',
'units': 'None',
'data': coefStatic},
{'name': 'dynamic-coefficient',
'units': 'None',
'data': coefDyn},
{'name': 'slip-weakening-parameter',
'units': 'm',
