def test_database(self):
locs = numpy.array([[3.5, 0.1, 0.8], [8.0, -0.4, 1.8]], numpy.float64)
cs = CSCart()
cs._configure()
queryVals = ["two", "one"]
dataE = numpy.array([[0.0220, 1.04], [0.0222, 1.02]], numpy.float64)
errE = [0, 0]
db = self._db
db.open()
db.queryVals(queryVals)
data = numpy.zeros(dataE.shape, dtype=numpy.float64)
err = []
nlocs = locs.shape[0]
for i in xrange(nlocs):
e = db.query(data[i, :], locs[i, :], cs)
err.append(e)
db.close()
self.assertEqual(len(errE), len(err))
for vE, v in zip(errE, err):
self.assertEqual(vE, v)
self.assertEqual(len(dataE.shape), len(data.shape))
for dE, d in zip(dataE.shape, data.shape):
self.assertEqual(dE, d)
for vE, v in zip(numpy.reshape(dataE, -1), numpy.reshape(data, -1)):
self.assertAlmostEqual(vE, v, 6)
return
def test_database(self):
locs = numpy.array([[1.0, 2.0, 3.0], [5.6, 4.2, 8.6]], numpy.float64)
from spatialdata.geocoords.CSCart import CSCart
cs = CSCart()
cs._configure()
queryVals = ["three", "one"]
dataE = numpy.array([[3.3e-2, 1.1], [3.3e-2, 1.1]], numpy.float64)
errE = [0, 0]
db = self._db
db.open()
db.setQueryValues(queryVals)
data = numpy.zeros(dataE.shape, dtype=numpy.float64)
err = []
nlocs = locs.shape[0]
for i in range(nlocs):
e = db.query(data[i, :], locs[i, :], cs)
err.append(e)
db.close()
self.assertEqual(len(errE), len(err))
for vE, v in zip(errE, err):
self.assertEqual(vE, v)
self.assertEqual(len(dataE.shape), len(data.shape))
for dE, d in zip(dataE.shape, data.shape):
self.assertEqual(dE, d)
for vE, v in zip(numpy.reshape(dataE, -1), numpy.reshape(data, -1)):
self.assertAlmostEqual(vE, v, 6)
def test_databasemulti(self):
locs = numpy.array([[2.3, -0.1, 1.8], [2.0, 0.4, -2.0]], numpy.float64)
cs = CSCart()
cs._configure()
queryVals = ["two", "one"]
dataE = numpy.array([[0.0207, 1.17], [0.0209, 1.15]], numpy.float64)
errE = numpy.array([0, 0], numpy.int32)
db = self._db
db.open()
db.queryVals(queryVals)
data = numpy.zeros(dataE.shape, dtype=numpy.float64)
err = numpy.zeros(errE.shape, dtype=numpy.int32)
db.multiquery(data, err, locs, cs)
db.close()
self.assertEqual(len(errE), len(err))
for vE, v in zip(errE, err):
self.assertEqual(vE, v)
self.assertEqual(len(dataE.shape), len(data.shape))
for dE, d in zip(dataE.shape, data.shape):
self.assertEqual(dE, d)
for vE, v in zip(numpy.reshape(dataE, -1), numpy.reshape(data, -1)):
self.assertAlmostEqual(vE, v, 6)
return
def run(self):
"""Generate the database.
"""
# Domain
# Extend beyond mesh boundaries to avoid problems with linear interpolations.
x = numpy.arange(-6000.0, 6000.1, 2000.0)
y = numpy.arange(-6000.0, 6000.1, 2000.0)
z = numpy.arange(-10000.0, 2000.1, 2000.0)
(x3, y3, z3) = numpy.meshgrid(x, y, z)
nptsX = x.shape[0]
nptsY = y.shape[0]
nptsZ = z.shape[0]
xyz = numpy.zeros((nptsX * nptsY * nptsZ, 3), dtype=numpy.float64)
xyz[:, 0] = x3.ravel()
xyz[:, 1] = y3.ravel()
xyz[:, 2] = z3.ravel()
from axialstrain_genmaxwell_soln import AnalyticalSoln
soln = AnalyticalSoln()
disp = soln.initial_displacement(xyz)
from spatialdata.geocoords.CSCart import CSCart
cs = CSCart()
cs.inventory.spaceDim = 3
cs._configure()
data = {
'x':
x,
'y':
y,
'z':
z,
'points':
xyz,
'coordsys':
cs,
'data_dim':
3,
'values': [{
'name': "initial_amplitude_x",
'units': "m",
'data': disp[0, :, 0].ravel()
}, {
'name': "initial_amplitude_y",
'units': "m",
'data': disp[0, :, 1].ravel()
}, {
'name': "initial_amplitude_z",
'units': "m",
'data': disp[0, :, 2].ravel()
}]
}
from spatialdata.spatialdb.SimpleGridAscii import SimpleGridAscii
io = SimpleGridAscii()
io.inventory.filename = "axialstrain_genmaxwell_bc.spatialdb"
io._configure()
io.write(data)
return
def __init__(self):
"""
Constructor.
"""
self.availableFields = \
{'vertex': \
{'info': ["vertex info"],
'data': ["vertex data 1",
"vertex data 2"]},
'cell': \
{'info': ["cell info"],
'data': ["cell data"]}}
filename = "data/twohex8.txt"
from pylith.meshio.MeshIOAscii import MeshIOAscii
iohandler = MeshIOAscii()
iohandler.inventory.filename = filename
from spatialdata.geocoords.CSCart import CSCart
iohandler.inventory.coordsys = CSCart()
iohandler._configure()
from spatialdata.units.Nondimensional import Nondimensional
normalizer = Nondimensional()
normalizer._configure()
mesh = iohandler.read(debug=False, interpolate=False)
from pylith.topology.Fields import Fields
fields = Fields(mesh)
self.mesh = mesh
self.fields = fields
return
def setUp(self):
from pylith.meshio.MeshIOAscii import MeshIOAscii
iohandler = MeshIOAscii()
filename = "data/twohex8.txt"
from spatialdata.units.Nondimensional import Nondimensional
normalizer = Nondimensional()
normalizer._configure()
from spatialdata.geocoords.CSCart import CSCart
iohandler.inventory.filename = filename
iohandler.inventory.coordsys = CSCart()
iohandler._configure()
mesh = iohandler.read(debug=False, interpolate=False)
from pylith.topology.SolutionFields import SolutionFields
fields = SolutionFields(mesh)
name = "disp(t)"
fields.add(name, "displacement")
fields.solutionName(name)
field = fields.get(name)
field.subfieldAdd("displacement", mesh.dimension(), field.VECTOR)
field.subfieldsSetup()
field.newSection(field.VERTICES_FIELD, mesh.dimension())
field.allocate()
self.mesh = mesh
self.fields = fields
self.normalizer = normalizer
return
def test_database(self):
locs = numpy.array([[1.0, 2.0, 3.0], [5.6, 4.2, 8.6]], numpy.float64)
from spatialdata.geocoords.CSCart import CSCart
cs = CSCart()
gacc = 9.80665
dataE = numpy.array([[0.0, 0.0, -gacc], [0.0, 0.0, -gacc]],
numpy.float64)
errE = [0, 0]
db = self._db
db.open()
data = numpy.zeros(dataE.shape, dtype=numpy.float64)
err = []
nlocs = locs.shape[0]
for i in xrange(nlocs):
e = db.query(data[i, :], locs[i, :], cs)
err.append(e)
db.close()
self.assertEqual(len(errE), len(err))
for vE, v in zip(errE, err):
self.assertEqual(vE, v)
self.assertEqual(len(dataE.shape), len(data.shape))
for dE, d in zip(dataE.shape, data.shape):
self.assertEqual(dE, d)
for vE, v in zip(numpy.reshape(dataE, -1), numpy.reshape(data, -1)):
self.assertAlmostEqual(vE, v, 6)
return
def test_databasemulti(self):
locs = numpy.array([[1.0, 2.0, 3.0], [5.6, 4.2, 8.6]], numpy.float64)
cs = CSCart()
cs._configure()
queryVals = ["two", "one"]
dataE = numpy.array([[4.7, 6.3]] * 2, numpy.float64)
errE = numpy.array([0, 0], numpy.int32)
db = self._db
db.open()
db.setQueryValues(queryVals)
data = numpy.zeros(dataE.shape, dtype=numpy.float64)
err = numpy.zeros(errE.shape, dtype=numpy.int32)
db.multiquery(data, err, locs, cs)
db.close()
self.assertEqual(len(errE), len(err))
for vE, v in zip(errE, err):
self.assertEqual(vE, v)
self.assertEqual(len(dataE.shape), len(data.shape))
for dE, d in zip(dataE.shape, data.shape):
self.assertEqual(dE, d)
for vE, v in zip(numpy.reshape(dataE, -1), numpy.reshape(data, -1)):
self.assertAlmostEqual(vE, v, 6)
def setUp(self):
"""
Setup mesh and associated field.
"""
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/tri3.mesh"
importer.inventory.coordsys = cs
importer._configure()
self.mesh = importer.read(debug=False, interpolate=False)
from pylith.topology.SolutionFields import SolutionFields
fields = SolutionFields(self.mesh)
fields.add("disp t+dt", "displacement")
fields.solutionName("disp t+dt")
solution = fields.solution()
solution.newSection(solution.VERTICES_FIELD, self.mesh.dimension())
solution.allocate()
solution.zero()
self.fields = fields
self.jacobian = Jacobian(solution)
return
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 test_readwrite(self):
"""
Test write() and read().
"""
filenameIn = "data/mesh2Din3D.txt"
filenameOut = "data/mesh2Din3D_test.txt"
from spatialdata.geocoords.CSCart import CSCart
cs = CSCart()
cs._configure()
io = MeshIOAscii()
io.inventory.filename = filenameIn
io.inventory.coordsys = cs
io._configure()
from spatialdata.units.Nondimensional import Nondimensional
normalizer = Nondimensional()
mesh = io.read(debug=False, interpolate=True)
io.filename(filenameOut)
io.write(mesh)
fileE = open(filenameIn, "r")
linesE = fileE.readlines()
fileE.close()
fileT = open(filenameOut, "r")
linesT = fileT.readlines()
fileT.close()
self.assertEqual(len(linesE), len(linesT))
for (lineE, lineT) in zip(linesE, linesT):
self.assertEqual(lineE, lineT)
return
def _runTest(self, filenameIn, filenameOut, filenameOutE, faultGroup=None):
from spatialdata.geocoords.CSCart import CSCart
cs = CSCart()
cs._configure()
from pylith.meshio.MeshIOAscii import MeshIOAscii
io = MeshIOAscii()
io.inventory.filename = filenameIn
io.inventory.coordsys = cs
io._configure()
mesh = io.read(debug=False, interpolate=True)
if not faultGroup is None:
from pylith.faults.FaultCohesiveKin import FaultCohesiveKin
fault = FaultCohesiveKin()
fault.inventory.matId = 10
fault.inventory.faultLabel = faultGroup
fault._configure()
nvertices = fault.numVerticesNoMesh(mesh)
firstFaultVertex = 0
firstLagrangeVertex = nvertices
firstFaultCell = 2 * nvertices
fault.adjustTopology(mesh, firstFaultVertex, firstLagrangeVertex,
firstFaultCell)
from pylith.topology.RefineUniform import RefineUniform
refiner = RefineUniform()
meshRefined = refiner.refine(mesh)
return
def run(self):
"""Generate the database.
"""
# Domain
x1 = numpy.arange(-1.0, 11.01, 1.0)
y1 = numpy.arange(-1.0, 11.01, 1.0)
x, y = numpy.meshgrid(x1, y1)
xy = numpy.zeros((len(x1) * len(y1), 2), dtype=numpy.float64)
xy[:, 0] = x.ravel()
xy[:, 1] = y.ravel()
from terzaghi_soln import AnalyticalSoln
soln = AnalyticalSoln()
disp = soln.initial_displacement(xy)
pres = soln.initial_pressure(xy)
trace_strain = soln.initial_trace_strain(xy)
from spatialdata.geocoords.CSCart import CSCart
cs = CSCart()
cs.inventory.spaceDim = 2
cs._configure()
data = {
'x':
x1,
'y':
y1,
'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])
}, {
'name': "pressure",
'units': "Pa",
'data': numpy.ravel(pres[0, :])
}, {
'name': "trace_strain",
'units': "none",
'data': numpy.ravel(trace_strain[0, :])
}]
}
from spatialdata.spatialdb.SimpleGridAscii import SimpleGridAscii
io = SimpleGridAscii()
io.inventory.filename = "terzaghi_ic.spatialdb"
io._configure()
io.write(data)
return
def test_accessors(self):
cs = CSCart()
cs.inventory.units = "km"
cs.inventory.spaceDim = 2
cs._configure()
self.assertEqual(1.0e+3, cs.getToMeters())
self.assertEqual(2, cs.getSpaceDim())
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_cart(self):
from spatialdata.geocoords.CSCart import CSCart
csKm = CSCart()
csKm.inventory.units = "km"
csKm.inventory.spaceDim = 2
csKm._configure()
csM = CSCart()
csM.inventory.units = "m"
csM.inventory.spaceDim = 2
csM._configure()
from spatialdata.geocoords.Converter import convert
xy = numpy.array(xyKm)
convert(xy, csM, csKm)
xyM = xyKm * 1.0e+3
self.assertEqual(len(xyM.shape), len(xy.shape))
for (xyE, xyT) in zip(numpy.reshape(xyM, -1), numpy.reshape(xy, -1)):
self.assertAlmostEqual(xyE, xyT, 4)
def test_initialize(self):
from spatialdata.geocoords.CSCart import CSCart
cs = CSCart()
cs.inventory.units = "km"
cs.inventory.spaceDim = 2
cs._configure()
cs.initialize()
self.assertEqual(1.0e+3, cs.toMeters())
self.assertEqual(2, cs.spaceDim())
return
def _initialize(self):
"""
Initialize DirichletBoundary boundary condition.
"""
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/tri3.mesh"
importer.inventory.coordsys = cs
importer._configure()
mesh = importer.read(debug=False, interpolate=False)
from spatialdata.spatialdb.SimpleDB import SimpleDB
db = SimpleDB()
db.inventory.label = "TestDirichletBoundary tri3"
db.inventory.iohandler.inventory.filename = "data/tri3_disp.spatialdb"
db.inventory.iohandler._configure()
db._configure()
from spatialdata.spatialdb.SimpleDB import SimpleDB
dbRate = SimpleDB()
dbRate.inventory.label = "TestDirichletBoundary tri3"
dbRate.inventory.iohandler.inventory.filename = "data/tri3_vel.spatialdb"
dbRate.inventory.iohandler._configure()
dbRate._configure()
from pylith.bc.DirichletBoundary import DirichletBoundary
bc = DirichletBoundary()
bc.inventory.output._configure()
bc.inventory.output.writer._configure()
bc.inventory.label = "bc"
bc.inventory.bcDOF = [1]
bc.inventory.dbInitial = db
bc.inventory.dbRate = dbRate
bc._configure()
bc.preinitialize(mesh)
bc.initialize(totalTime=0.0, numTimeSteps=1, normalizer=normalizer)
# Setup field
from pylith.topology.Field import Field
field = Field(mesh)
field.newSection(field.VERTICES_FIELD, cs.spaceDim())
return (mesh, bc, field)
def test_coordsys(self):
"""
Test coordsys().
"""
from spatialdata.geocoords.CSCart import CSCart
cs = CSCart()
cs.inventory.spaceDim = 2
cs._configure()
mesh = Mesh()
mesh.coordsys(cs)
self.assertEqual(cs.spaceDim(), mesh.coordsys().spaceDim())
return
def test(self):
"""
Test GenSimpleDBApp with 1-D data in 2-D space.
"""
from spatialdata.spatialdb.generator.GenSimpleDBApp import GenSimpleDBApp
from spatialdata.geocoords.CSCart import CSCart
from spatialdata.spatialdb.SimpleDB import SimpleDB
app = GenSimpleDBApp()
app.run()
# Test write using query
db = SimpleDB()
db.inventory.iohandler.inventory.filename = "data/gen1Din2D.spatialdb"
db.inventory.iohandler._configure()
db.inventory.label = "test"
db.inventory.queryType = "nearest"
db._configure()
qlocs = numpy.array([[-2.0, 2.0], [3.0, -4.0], [0.0, 0.7]],
numpy.float64)
dataE = numpy.array([[-0.15, 3.45], [2.4, 6.4], [-0.6, 3.45]],
numpy.float64)
errE = [0, 0, 0]
from spatialdata.geocoords.CSCart import CSCart
cs = CSCart()
cs.inventory.spaceDim = 2
cs._configure()
db.open()
db.setQueryValues(["two", "one"])
data = numpy.zeros(dataE.shape, dtype=numpy.float64)
err = []
nlocs = qlocs.shape[0]
for i in range(nlocs):
e = db.query(data[i, :], qlocs[i, :], cs)
err.append(e)
db.close()
self.assertEqual(len(errE), len(err))
for vE, v in zip(errE, err):
self.assertEqual(vE, v)
self.assertEqual(len(dataE.shape), len(data.shape))
for dE, d in zip(dataE.shape, data.shape):
self.assertEqual(dE, d)
for vE, v in zip(numpy.reshape(dataE, -1), numpy.reshape(data, -1)):
self.assertAlmostEqual(vE, v, 6)
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
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 axialstrainrate_genmaxwell_soln import AnalyticalSoln
soln = AnalyticalSoln()
disp = soln.initial_displacement(xy)
velocity_time = soln.bc_rate_time(xy)/year.value
velocity = soln.bc_velocity(xy)*year.value
from spatialdata.geocoords.CSCart import CSCart
cs = CSCart()
cs.inventory.spaceDim = 2
cs._configure()
data = {'points': xy,
'coordsys': cs,
'data_dim': 2,
'values': [{'name': "initial_amplitude_x",
'units': "m",
'data': disp[0, :, 0].ravel()},
{'name': "initial_amplitude_y",
'units': "m",
'data': disp[0, :, 1].ravel()},
{'name': "rate_amplitude_x",
'units': "m/year",
'data': velocity[0, :, 0].ravel()},
{'name': "rate_amplitude_y",
'units': "m/year",
'data': velocity[0, :, 1].ravel()},
{'name': "rate_start_time",
'units': "year",
'data': velocity_time[0, :, 0].ravel()},
]}
from spatialdata.spatialdb.SimpleIOAscii import createWriter
io = createWriter("axialstrainrate_genmaxwell_disp.spatialdb")
io.write(data)
io = createWriter("axialstrainrate_genmaxwell_bc.spatialdb")
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 axialdisp_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': "initial_amplitude_x",
'units': "m",
'data': numpy.ravel(disp[0, :, 0])
}, {
'name': "initial_amplitude_y",
'units': "m",
'data': numpy.ravel(disp[0, :, 1])
}]
}
from spatialdata.spatialdb.SimpleIOAscii import createWriter
io = createWriter("axialdisp_bc.spatialdb")
io.write(data)
data["values"][0]["name"] = "displacement_x"
data["values"][1]["name"] = "displacement_y"
io = createWriter("axialdisp_ic.spatialdb")
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 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_readwrite(self):
"""
Test read().
"""
filenameGmvIn = "data/cube2_ascii.gmv"
filenamePsetIn = "data/cube2_ascii.pset"
filenameOut = "data/cube2_test.txt"
filenameE = "data/cube2.txt"
from spatialdata.geocoords.CSCart import CSCart
cs = CSCart()
cs._configure()
# For now, we only test reading the file. We would like to write
# the file and compare against the original.
io = MeshIOLagrit()
io.inventory.filenameGmv = filenameGmvIn
io.inventory.filenamePset = filenamePsetIn
io._configure()
from spatialdata.units.Nondimensional import Nondimensional
normalizer = Nondimensional()
mesh = io.read(debug=False, interpolate=True)
testhandler = MeshIOAscii()
testhandler.filename(filenameOut)
testhandler.coordsys = cs
testhandler.write(mesh)
fileE = open(filenameE, "r")
linesE = fileE.readlines()
fileE.close()
fileT = open(filenameOut, "r")
linesT = fileT.readlines()
fileT.close()
self.assertEqual(len(linesE), len(linesT))
for (lineE, lineT) in zip(linesE, linesT):
self.assertEqual(lineE, lineT)
return
def _getMesh(self):
"""
Get mesh from file.
"""
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/tri3.mesh"
importer.inventory.coordsys = cs
importer._configure()
mesh = importer.read(debug=False, interpolate=False)
return mesh
def setUp(self):
"""
Setup mesh and associated field.
"""
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/tri3.mesh"
importer.inventory.coordsys = cs
importer._configure()
self.mesh = importer.read(debug=False, interpolate=False)
self.fields = Fields(self.mesh)
return
def test_readwrite(self):
"""
Test read().
"""
filenameIn = "data/twohex8.exo"
filenameOut = "data/twohex8_test.txt"
filenameE = "data/twohex8.txt"
from spatialdata.geocoords.CSCart import CSCart
cs = CSCart()
cs._configure()
# For now, we only test reading the file.
io = MeshIOCubit()
io.inventory.filename = filenameIn
io.inventory.useNames = False
io._configure()
from spatialdata.units.Nondimensional import Nondimensional
normalizer = Nondimensional()
mesh = io.read(debug=False, interpolate=True)
testhandler = MeshIOAscii()
testhandler.filename(filenameOut)
testhandler.coordsys = cs
testhandler.write(mesh)
fileE = open(filenameE, "r")
linesE = fileE.readlines()
fileE.close()
fileT = open(filenameOut, "r")
linesT = fileT.readlines()
fileT.close()
self.assertEqual(len(linesE), len(linesT))
for (lineE, lineT) in zip(linesE, linesT):
self.assertEqual(lineE, lineT)
return
