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
示例#2
0
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)
示例#5
0
    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
示例#6
0
  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
示例#8
0
  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
示例#9
0
    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
示例#10
0
  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
示例#11
0
  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
示例#12
0
    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
示例#13
0
  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
示例#14
0
    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
示例#15
0
  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
示例#16
0
    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
示例#17
0
  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
示例#18
0
  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
示例#19
0
    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
示例#20
0
  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
示例#21
0
  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
示例#23
0
  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
示例#24
0
    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
示例#25
0
    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
示例#26
0
    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
示例#27
0
    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
示例#28
0
    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
示例#29
0
  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
示例#30
0
  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
示例#31
0
# 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',
示例#33
0
    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
示例#34
0
  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)
示例#35
0
  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
示例#36
0
# 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:
示例#37
0
    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',
示例#39
0
  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)
示例#40
0
    # 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]
        },
        {
示例#41
0
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
示例#42
0
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
示例#43
0
文件: gfgen.py 项目: jjle/pylith
  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
示例#44
0
  
  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:
示例#45
0
  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': [
        {
示例#48
0
  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]},
                       ]})
示例#49
0
  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)
示例#50
0
# 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
示例#51
0
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',