Ejemplo n.º 1
0
    def test_constructor(self):
        dim = NondimElasticQuasistatic()
        dim._configure()

        # Default values
        lengthScale = 1.0e+3 * meter
        pressureScale = 3.0e+10 * pascal
        timeScale = 1.0e+2 * year

        # Check defaults
        self.assertEqual(lengthScale, dim.getLengthScale())
        self.assertEqual(pressureScale, dim.getPressureScale())
        self.assertEqual(timeScale, dim.getTimeScale())

        velocityScale = lengthScale / timeScale
        densityScale = pressureScale / velocityScale**2
        self.assertEqual(densityScale, dim.getDensityScale())

        return
Ejemplo n.º 2
0
def check_vertex_fields(testcase, filename, mesh, fieldNames):
  """
  Check properties.
  """
  h5 = h5py.File(filename, "r", driver="sec2")
  
  # Check cells
  cells = h5['topology/cells'][:]
  (ncells, ncorners) = cells.shape
  testcase.assertEqual(mesh['ncells'], ncells)
  testcase.assertEqual(mesh['ncorners'], ncorners)

  # Check vertices
  vertices = h5['geometry/vertices'][:]
  (nvertices, spaceDim) = vertices.shape
  testcase.assertEqual(mesh['nvertices'], nvertices)
  testcase.assertEqual(mesh['spaceDim'], spaceDim)

  # Check fault information
  tolerance = 1.0e-5

  normalizer = NondimElasticQuasistatic()
  normalizer._configure()

  for name in fieldNames:
    valuesE = testcase.calcFaultField(name, vertices)
    values = h5['vertex_fields/%s' % name][:]

    (nstepsE, nverticesE, dimE) = valuesE.shape
    (nsteps, nvertices, dim) = values.shape

    testcase.assertEqual(nstepsE, nsteps)
    testcase.assertEqual(nverticesE, nvertices)
    testcase.assertEqual(dimE, dim)

    scale = 1.0
    if name == "traction_change" or name == "traction":
      scale *= normalizer.pressureScale().value

    for istep in xrange(nsteps):
      for idim in xrange(dim):
        okay = numpy.zeros((nvertices,), dtype=numpy.bool)

        maskR = numpy.abs(valuesE[istep,:,idim]) > 0.0
        ratio = numpy.abs(1.0 - values[istep,maskR,idim]/valuesE[istep,maskR,idim])
        if len(ratio) > 0:
          okay[maskR] = ratio < tolerance

        maskD = ~maskR
        diff = numpy.abs(values[istep,maskD,idim] - valuesE[istep,maskD,idim]) / scale
        if len(diff) > 0:
          okay[maskD] = diff < tolerance

        if numpy.sum(okay) != nvertices:
          print "Error in component %d of field '%s' for timestep %d." % (idim, name, istep)
          print "Expected values:",valuesE
          print "Output values:",values
          print "Expected values (not okay): ",valuesE[istep,~okay,idim]
          print "Computed values (not okay): ",values[istep,~okay,idim]
          print "Coordinates (not okay): ",vertices[~okay,:]
          h5.close()
        testcase.assertEqual(nvertices, numpy.sum(okay))

  h5.close()
  return
Ejemplo n.º 3
0
def check_displacements(testcase, filename, mesh):
    """
  Check displacements.
  """
    h5 = h5py.File(filename, "r", driver="sec2")

    # Check vertices
    vertices = h5['geometry/vertices'][:]
    (nvertices, spaceDim) = vertices.shape
    testcase.assertEqual(mesh['nvertices'], nvertices)
    testcase.assertEqual(mesh['spaceDim'], spaceDim)

    # Check displacement solution
    toleranceAbsMask = 0.1
    tolerance = 1.0e-5

    dispE = testcase.calcDisplacements(vertices)
    disp = h5['vertex_fields/displacement'][:]

    (nstepsE, nverticesE, ncompsE) = dispE.shape
    (nsteps, nvertices, ncomps) = disp.shape
    testcase.assertEqual(nstepsE, nsteps)
    testcase.assertEqual(nverticesE, nvertices)
    testcase.assertEqual(ncompsE, ncomps)

    from spatialdata.units.NondimElasticQuasistatic import NondimElasticQuasistatic
    normalizer = NondimElasticQuasistatic()
    normalizer._configure()

    scale = 1.0
    scale *= normalizer.lengthScale().value

    for istep in xrange(nsteps):
        for icomp in xrange(ncomps):
            okay = numpy.zeros((nvertices, ), dtype=numpy.bool)

            maskR = numpy.abs(dispE[istep, :, icomp]) > toleranceAbsMask
            ratio = numpy.abs(1.0 - disp[istep, maskR, icomp] /
                              dispE[istep, maskR, icomp])
            if len(ratio) > 0:
                okay[maskR] = ratio < tolerance

            maskD = ~maskR
            diff = numpy.abs(disp[istep, maskD, icomp] -
                             dispE[istep, maskD, icomp]) / scale
            if len(diff) > 0:
                okay[maskD] = diff < tolerance

            if numpy.sum(okay) != nvertices:
                print "Error in component %d of displacement field at time step %d." % (
                    icomp, istep)
                print "Expected values: ", dispE[istep, :, :]
                print "Output values: ", disp[istep, :, :]
                print "Expected values (not okay): ", dispE[istep, ~okay,
                                                            icomp]
                print "Computed values (not okay): ", disp[istep, ~okay, icomp]
                print "Relative diff (not okay): ", diff[~okay]
                print "Coordinates (not okay): ", vertices[~okay, :]
                h5.close()
            testcase.assertEqual(nvertices, numpy.sum(okay))

    h5.close()
    return