Python Output.add_unstruct_mesh方法代码示例

# 需要导入模块: from Danu import Output [as 别名]
# 或者: from Danu.Output import add_unstruct_mesh [as 别名]
class TestConnectivity(unittest.TestCase):

  def setUp(self):
    import os
    import numpy
    import random
    from Danu import Output
    from Danu import UNSTRUCTURED_MESH
    from Danu import HEX_ELEM, HEX_ELEM_ORDER 

    self.filename = 'test-Mesh.h5'
    if  os.path.exists(self.filename):
      os.remove(self.filename)

    self.fh=Output(self.filename,'w')

    self.mesh_name='Test Mesh 3D HEX'
    self.mesh=self.fh.add_unstruct_mesh(self.mesh_name,HEX_ELEM)
    
    self.data_name='Data to Read'
    self.nelem=random.randint(10,2048)
    self.data=numpy.zeros((self.nelem,HEX_ELEM_ORDER),dtype=numpy.int32)
    nc=0
    while nc < self.nelem:
      i=0
      while i < HEX_ELEM_ORDER:
        self.data[nc][i]=random.randint(0,100000)
        i=i+1
      nc=nc+1	

  def tearDown(self):
    import os
    if os.path.exists(self.filename):
      self.fh.close()
      #os.remove(self.filename)

  def test_basic(self):
    import numpy
    import random

    # try to read before a write
    try:
      r_data=self.mesh.read_connectivity()
    except:
      print 'Caught the read before write error'

    self.mesh.write_connectivity(self.data)  
    read_data=self.mesh.read_connectivity()
    self.assertEqual(read_data.all(),self.data.all())

  def test_offset(self):
    import numpy
    import random

    self.mesh.write_connectivity(self.data)  

    offset=self.mesh.connectivity_offset()
    self.assertEqual(offset,0)

# 需要导入模块: from Danu import Output [as 别名]
# 或者: from Danu.Output import add_unstruct_mesh [as 别名]
class TestAttributes(unittest.TestCase):

  def setUp(self):
    import os
    import numpy
    import random
    from Danu import Output
    from Danu import UNSTRUCTURED_MESH
    from Danu import HEX_ELEM, HEX_ELEM_ORDER 

    self.filename = 'test-Mesh.h5'
    if  os.path.exists(self.filename):
      os.remove(self.filename)

    self.fh=Output(self.filename,'w')

    self.mesh_name='Test Mesh 3D HEX'
    self.mesh=self.fh.add_unstruct_mesh(self.mesh_name,HEX_ELEM)
    
    self.n=random.randint(10,2048)
    self.x=numpy.random.random_sample((self.n))
    self.y=numpy.random.random_sample((self.n))
    self.z=numpy.random.random_sample((self.n))
    self.coordinates=[self.x,self.y,self.z]
    self.mesh.write_coordinates(self.x,self.y,self.z)
    self.nelem=random.randint(1024,2048)
    self.data=numpy.zeros((self.nelem,HEX_ELEM_ORDER),dtype=numpy.int32)
    nc=0
    while nc < self.nelem:
      i=0
      while i < HEX_ELEM_ORDER:
        self.data[nc][i]=random.randint(0,100000)
        i=i+1
      nc=nc+1	
    self.mesh.write_connectivity(self.data)

  def tearDown(self):
    import os
    if os.path.exists(self.filename):
      self.fh.close()
      os.remove(self.filename)

  def runTest(self):
    import Danu
    self.assertEqual(self.x.size,self.mesh.nnodes())
    self.assertEqual(Danu.HEX_ELEM_ORDER,self.mesh.elem_order())
    print self.mesh.nelem()

# 需要导入模块: from Danu import Output [as 别名]
# 或者: from Danu.Output import add_unstruct_mesh [as 别名]
class TestMeshWriteCoordinates(unittest.TestCase):

  def setUp(self):
    import os
    from Danu import Output
    from Danu import UNSTRUCTURED_MESH, STRUCTURED_MESH
    from Danu import LINE_ELEM, TRI_ELEM, QUAD_ELEM, TET_ELEM, HEX_ELEM 

    self.filename = 'test-Mesh.h5'
    self.fh       = Output(self.filename,'w')

    self.mesh_count = 0
    self.mesh_names = []

    self.valid_mesh_types = [UNSTRUCTURED_MESH, STRUCTURED_MESH]
    self.valid_mesh_elems1 = [LINE_ELEM]
    self.valid_mesh_elems2 = [TRI_ELEM, QUAD_ELEM]
    self.valid_mesh_elems3 = [TET_ELEM, HEX_ELEM]

  def tearDown(self):
    if os.path.exists(self.filename):
      self.fh.close()
      os.remove(self.filename)

  def test_write_coordinates_1D(self):
    import numpy
    import random
    from Danu import LINE_ELEM

    mesh_name = '1D Mesh'
    nnodes=random.randint(128,1024)
    mesh = self.fh.add_unstruct_mesh(mesh_name,LINE_ELEM)
    xcoordinates = numpy.random.random_sample((nnodes))
    try:
      mesh.write_coordinates()
      raise RuntimeError, "Failed to raise exception"
    except:
      print "Caught null argument exception"

    try:
      mesh.write_coordinates(1)
      raise RuntimeError, "Failed to raise exception"
    except:
      print "Caught invalid data type"

    mesh.write_coordinates(xcoordinates)

# 需要导入模块: from Danu import Output [as 别名]
# 或者: from Danu.Output import add_unstruct_mesh [as 别名]
class TestOutputMesh(unittest.TestCase):
  
  def setUp(self):
    from Danu import LINE_ELEM, TRI_ELEM, QUAD_ELEM, TET_ELEM, HEX_ELEM

    self.filename = 'test-Output.h5'
    self.fh       = Output(self.filename,'w')

    self.mesh_count = 0
    self.mesh_names = []

    self.valid_elems = [LINE_ELEM, TRI_ELEM, QUAD_ELEM, TET_ELEM, HEX_ELEM]

  def tearDown(self):
    if os.path.exists(self.filename):
      self.fh.close()
      os.remove(self.filename)

  def get_random_elem(self):
    from random import choice
    return choice(self.valid_elems)

  def test_add_mesh_u(self):
    # Require and element type
    try:
      self.fh.add_unstruct_mesh('Test Mesh') 
    except RuntimeError:
      print 'Caught the invalid mesh value'
    # Test all avail mesh types  
    for elem in self.valid_elems:
      mesh_name = 'Test Mesh ' + str(elem)
      self.fh.add_unstruct_mesh(mesh_name,elem)
    # Try to add an existing mesh
    elem = self.valid_elems[0]
    mesh_name = 'Test Mesh ' + str(elem)
    try:
      self.fh.add_unstruct_mesh(mesh_name,elem)
    except:
      print 'Caught the exception when mesh already exists'

  def test_mesh_exists(self):
    import random
    import string
    mesh_name = ''.join(random.choice(string.letters) for i in xrange(16))
    self.assertEqual(self.fh.mesh_exists(mesh_name),0,'Failed to query DNE mesh correctly')
    mesh_name = 'Test Mesh'
    elem = self.get_random_elem()
    mesh = self.fh.add_unstruct_mesh(mesh_name,elem)
    self.assertFalse(mesh is NoneType, 'Failed to add random mesh type')
    self.assertTrue(self.fh.mesh_exists(mesh_name), 'Failed to locate existing mesh')

  def test_mesh_count(self):
    import random
    self.assertEqual(self.mesh_count,self.fh.mesh_count(), 'Failed to return correct mesh count')
    num_mesh = random.randint(1,32)
    m = 1
    while m <= num_mesh:
      elem = self.get_random_elem()
      mesh_name = 'Test Mesh ' + str(m)
      self.fh.add_unstruct_mesh(mesh_name,elem)
      self.mesh_count = self.mesh_count + 1
      m = m + 1
    self.assertEqual(self.mesh_count,self.fh.mesh_count(), 'Failed to return correct mesh count')

  def test_mesh_list(self):
    import random
    mesh_list = self.fh.mesh_list()
    self.assertEqual(len(mesh_list),self.mesh_count, 'Incorrect mesh list length')
    num_mesh = random.randint(1,32)
    m = 1
    while m <= num_mesh:
      elem = self.get_random_elem()
      mesh_name = 'Test Mesh ' + str(m)
      self.fh.add_unstruct_mesh(mesh_name,elem)
      self.mesh_count = self.mesh_count + 1
      self.mesh_names.append(mesh_name)
      m = m + 1
    mesh_list = self.fh.mesh_list()
    for name in mesh_list:
      self.assertTrue(name in self.mesh_names)