Python OutputManager.initialize方法代码示例

# 需要导入模块: from pylith.meshio.OutputManager import OutputManager [as 别名]
# 或者: from pylith.meshio.OutputManager.OutputManager import initialize [as 别名]
  def test_initialize(self):
    """
    Test initialize().
    """
    # No quadrature
    output = OutputManager()
    output.inventory.writer.inventory.filename = "test.vtk"
    output.inventory.writer._configure()
    output._configure()
    dataProvider = TestProvider()
    output.preinitialize(dataProvider)
    output.initialize(self.normalizer)

    # With quadrature
    from pylith.feassemble.FIATLagrange import FIATLagrange
    from pylith.feassemble.Quadrature import Quadrature
    cell = FIATLagrange()
    cell.inventory.dimension = 3
    cell.inventory.degree = 2
    cell.inventory.order = 2
    cell._configure()

    quadrature = Quadrature()
    quadrature.inventory.cell = cell
    quadrature._configure()
    
    output = OutputManager()
    output.inventory.writer.inventory.filename = "test.vtk"
    output.inventory.writer._configure()
    output._configure()
    dataProvider = TestProvider()
    output.preinitialize(dataProvider)
    output.initialize(self.normalizer, quadrature)
    return

# 需要导入模块: from pylith.meshio.OutputManager import OutputManager [as 别名]
# 或者: from pylith.meshio.OutputManager.OutputManager import initialize [as 别名]
  def test_distribute(self):
    """
    Test distribute()
    """
    generator = MeshGenSimple()
    generator.interpolate = True
    generator.setBoundary(generator.createCubeBoundary())
    mesh = generator.create()

    from pylith.meshio.OutputManager import OutputManager
    io = OutputManager()
    io._configure()
    io.writer._configure()
    io.writer.filename = 'mesh.vtk'
    from spatialdata.geocoords.CSCart import CSCart
    io.coordsys = CSCart()
    mesh.coordsys = CSCart()
    self.mesh = mesh

    from pyre.units.time import s
    io.preinitialize(self)
    io.initialize()
    io.writeInfo()

    from pylith.topology.Distributor import Distributor
    distributor = Distributor()
    distributor.partitioner = "chaco"
    newMesh = distributor.distribute(mesh)
    self.mesh = newMesh
    io.writer.filename = 'newMesh.vtk'
    io.writeInfo()
    return

# 需要导入模块: from pylith.meshio.OutputManager import OutputManager [as 别名]
# 或者: from pylith.meshio.OutputManager.OutputManager import initialize [as 别名]
  def test_openclose(self):
    """
    Test open() and close().
    """
    output = OutputManager()
    output.inventory.writer.inventory.filename = "output.vtk"
    output.inventory.writer._configure()
    output._configure()
    dataProvider = TestProvider()
    output.preinitialize(dataProvider)
    output.initialize(self.normalizer)

    output.open(totalTime=5.0, numTimeSteps=2)
    output.close()
    return

# 需要导入模块: from pylith.meshio.OutputManager import OutputManager [as 别名]
# 或者: from pylith.meshio.OutputManager.OutputManager import initialize [as 别名]
  def test_estimateNumSteps(self):
    """
    Test _estimateNumSteps().
    """
    from pyre.units.time import second

    output = OutputManager()
    output.inventory.outputFreq = "skip"
    output.inventory.skip = 2
    output._configure()

    numTimeSteps = 0
    totalTime = 1.0*second
    self.assertEqual(0, output._estimateNumSteps(totalTime, numTimeSteps))

    numTimeSteps = 4
    totalTime = 1.0*second
    self.assertEqual(2, output._estimateNumSteps(totalTime, numTimeSteps))

    numTimeSteps = 2
    totalTime = 1.0*second
    self.assertEqual(1, output._estimateNumSteps(totalTime, numTimeSteps))

    output = OutputManager()
    output.inventory.outputFreq = "time_step"
    output.inventory.dt = 2.0*second
    output._configure()
    dataProvider = TestProvider()
    output.preinitialize(dataProvider)
    output.initialize(self.normalizer)

    numTimeSteps = 0
    totalTime = 1.0*second
    self.assertEqual(0, output._estimateNumSteps(totalTime, numTimeSteps))

    numTimeSteps = 4
    totalTime = 1.0*second
    self.assertEqual(1, output._estimateNumSteps(totalTime, numTimeSteps))

    numTimeSteps = 2
    totalTime = 2.0*second
    self.assertEqual(2, output._estimateNumSteps(totalTime, numTimeSteps))
    return

# 需要导入模块: from pylith.meshio.OutputManager import OutputManager [as 别名]
# 或者: from pylith.meshio.OutputManager.OutputManager import initialize [as 别名]
 def test_writeInfo(self):
   """
   Test writeInfo().
   """
   output = OutputManager()
   output.inventory.writer.inventory.filename = "output.vtk"
   output.inventory.writer._configure()
   output.inventory.vertexInfoFields = ["vertex info"]
   output.inventory.cellInfoFields = ["cell info"]
   output._configure()
   
   dataProvider = TestProvider()
   output.preinitialize(dataProvider)
   output.initialize(self.normalizer)
   
   output.open(totalTime=5.0, numTimeSteps=2)
   output.writeInfo()
   output.close()
   return

# 需要导入模块: from pylith.meshio.OutputManager import OutputManager [as 别名]
# 或者: from pylith.meshio.OutputManager.OutputManager import initialize [as 别名]
  def test_writeData(self):
    """
    Test writeData().
    """
    output = OutputManager()
    output.inventory.writer.inventory.filename = "output.vtk"
    output.inventory.writer.inventory.timeFormat = "%3.1f"
    output.inventory.writer._configure()
    output.inventory.vertexDataFields = ["vertex data 2",
                                         "vertex data 1"]
    output.inventory.cellDataFields = ["cell data"]
    output._configure()
    
    dataProvider = TestProvider()
    output.preinitialize(dataProvider)
    output.initialize(self.normalizer)

    output.open(totalTime=5.0, numTimeSteps=2)
    output.writeData(2.0, dataProvider.fields)
    output.close()
    return

# 需要导入模块: from pylith.meshio.OutputManager import OutputManager [as 别名]
# 或者: from pylith.meshio.OutputManager.OutputManager import initialize [as 别名]
  def test_checkWrite(self):
    """
    Test _checkWrite().
    """
    dataProvider = TestProvider()

    # Default values should be true
    output = OutputManager()
    output.inventory.writer._configure()
    output._configure()
    output.preinitialize(dataProvider)
    output.initialize(self.normalizer)
    self.assertEqual(True, output._checkWrite(0.0))
    self.assertEqual(True, output._checkWrite(3.234e+8))

    # Check writing based on time
    output = OutputManager()
    output.inventory.writer._configure()
    output._configure()
    output.preinitialize(dataProvider)
    output.initialize(self.normalizer)

    output.inventory.outputFreq = "time_step"
    t = 0.0
    dt = output.dtN
    self.assertEqual(True, output._checkWrite(t))
    self.assertEqual(False, output._checkWrite(t))
    self.assertEqual(False, output._checkWrite(t + 0.8*dt))
    t += dt
    self.assertEqual(True, output._checkWrite(t))
    t = 2*dt
    self.assertEqual(True, output._checkWrite(t))
    
    # Check writing based on number of steps
    output = OutputManager()
    output.inventory.writer._configure()
    output.inventory.outputFreq = "skip"
    output.inventory.skip = 1
    output._configure()
    output.preinitialize(dataProvider)
    output.initialize(self.normalizer)
    t = 0.0
    dt = 1.0
    self.assertEqual(True, output._checkWrite(t))
    t += dt
    self.assertEqual(False, output._checkWrite(t))
    t += dt
    self.assertEqual(True, output._checkWrite(t))
    output.inventory.skip = 2
    t += dt
    self.assertEqual(False, output._checkWrite(t))
    t += dt
    self.assertEqual(False, output._checkWrite(t))
    t += dt
    self.assertEqual(True, output._checkWrite(t))
    
    return