Python PerceptMesh.get_fem_meta_data方法代码示例

# 需要导入模块: import PerceptMesh [as 别名]
# 或者: from PerceptMesh import get_fem_meta_data [as 别名]
class LocalFixture:
  
  def __init__(self, num_xyz, num_y, num_z):
    
    self.eMesh = PerceptMesh()
    self.num_x = num_xyz
    self.num_y = num_y
    self.num_z = num_z
    config_mesh = str(self.num_x) + "x" + str(self.num_y) + "x" + str(self.num_z) + "|bbox:-0.5,-0.5,-0.5,0.5,0.5,0.5"

    self.eMesh.new_mesh(GMeshSpec(config_mesh))
    self.eMesh.commit()
    self.metaData = self.eMesh.get_fem_meta_data()
    self.bulkData = self.eMesh.get_bulk_data()
    self.coords_field = self.metaData.get_field("coordinates")
    self.sfx = StringFunction("x", "sfx", Dimensions(3), Dimensions(1))
    self.sfx_res = ConstantFunction(0.0, "sfx_res")

# 需要导入模块: import PerceptMesh [as 别名]
# 或者: from PerceptMesh import get_fem_meta_data [as 别名]
    def test_perceptMesh_walk_nodes(self):
       self.fixture_setup()
       p_size = self.pm.size
       p_rank = self.pm.rank
       if p_size <= 2:
         n = 12
         nx = n
         ny = n

         sidesets_on = 1
         fixture = QuadFixture_4(self.pm, nx, ny, sidesets_on)
         fixture.meta_data.commit()
         fixture.generate_mesh()

         eMesh = PerceptMesh(fixture.meta_data, fixture.bulk_data)
         eMesh.print_info("quad fixture", 2)

         metaData = eMesh.get_fem_meta_data()
         parts = metaData.get_parts()

         nparts = len(parts)
         print "Number of parts = ", nparts

         surface_id = 2
         surface_name = "surface_" + str(surface_id)
         part = eMesh.get_part(surface_name)
         in_surface_selector = Selector(part)
         bulkData = eMesh.get_bulk_data()
         coordField = eMesh.get_coordinates_field()

         if eMesh.get_spatial_dim() == 2:
           buckets_arg = eMesh.edge_rank()
         else:
           buckets_arg = eMesh.face_rank
         buckets = bulkData.buckets(buckets_arg)
         sum = 0.0

# 需要导入模块: import PerceptMesh [as 别名]
# 或者: from PerceptMesh import get_fem_meta_data [as 别名]
    def test_fieldFunction_read_print(self):
       print_info = 0

       x = 3
       y = 3
       z = 3
       config_mesh = str(x) + "x" + str(y) + "x" + str(z) + "|bbox:0,0,0,1,1,1"

       eMesh = PerceptMesh()
       eMesh.new_mesh_read_only(GMeshSpec(config_mesh))

       metaData = eMesh.get_fem_meta_data()
       
       parts = metaData.get_parts()       
       nparts = len(parts)
       
       if print_info == 1:
          print "Number of parts = ", nparts
       fields = metaData.get_fields()
       nfields = len(fields)
       if print_info == 1:
          print "Number of fields = ", nfields      
          for i in range(nfields):
             field = fields[i] 

# 需要导入模块: import PerceptMesh [as 别名]
# 或者: from PerceptMesh import get_fem_meta_data [as 别名]
    def test_high_level_interface(self):
      self.fixture_setup()
      p_size = parallel_machine_size(self.pm)

      if p_size <= 2:
        eMesh = PerceptMesh(2)
        eMesh.open("./exodus_files/quad_fixture.e")

        vectorDimension = 0
        eMesh.add_field("coords_mag_field", FEMMetaData.NODE_RANK, vectorDimension)
        eMesh.commit()

        f_coords = eMesh.get_field("coordinates")
        coords_mag_field = eMesh.get_field("coords_mag_field")

        ff_coords = FieldFunction("ff_coords", f_coords, eMesh, 2, 2)
        #eval_vec3_print(0.1,0.1,0.1,0.0,ff_coords)

        coords_mag_sf = StringFunction("sqrt(x*x + y*y )" , "coords_mag_sf", 2, 1)
        x = 0.123
        y = 0.234
        vv = sqrt(x*x + y*y )
        v1 = eval_func2(x,y,0,coords_mag_sf)
        print "vv = ", vv, "== v1 = ", v1
        self.assertEqual(vv, v1)

        coords_mag_field_function = FieldFunction("coords_mag_field_function", coords_mag_field, eMesh, 2, 1)

        coords_mag_field_function.interpolateFrom(coords_mag_sf)

        eMesh.save_as("./exodus_files/quad_fixture_with_coords_mag.e")

        ff_coords.add_alias("mc")

        sfcm = StringFunction("sqrt(mc[0]*mc[0]+mc[1]*mc[1]+mc[2]*mc[2])", "sfcm", 3, 1)

        add_newlines = True
        eMesh.print_info("quad fixture", 2, add_newlines)

        self.assertTrue(eMesh.get_spatial_dim() == 2)
        self.assertTrue(eMesh.get_number_elements() == 12*12)
        self.assertTrue(eMesh.get_number_nodes() == 13*13)

        self.assertTrue(eMesh.get_parallel_size() == p_size)

        self.assertTrue(eMesh.get_bulk_data() != 0)
        self.assertTrue(eMesh.get_fem_meta_data() != 0)

        # // entity data setter/getters
        node = eMesh.get_node(1)
        self.assertTrue(node != 0)
        cm1 = eMesh.get_field_data(coords_mag_field, node)
        co1 = [0,0]
        co1[0] = eMesh.get_field_data(f_coords, node, 0)
        co1[1] = eMesh.get_field_data(f_coords, node, 1)
        print "cm1= ", cm1, " co1= ", co1
        eMesh.set_field_data(123.0, f_coords, node, 0)
        co1[0] = eMesh.get_field_data(f_coords, node, 0)
        print " co1= ", co1
        
        element = eMesh.get_element(1)
        self.assertTrue(element != 0)

        element1 = eMesh.get_entity(eMesh.element_rank(), 1)
        self.assertTrue(element == element1)
        
        #/// find node closest to given point
        node = eMesh.get_node(0,0)
        self.assertTrue(node != 0)

        #/// find element that contains given point
        element = eMesh.get_element(0.01, 0.01)
        self.assertTrue(element != 0)

# 需要导入模块: import PerceptMesh [as 别名]
# 或者: from PerceptMesh import get_fem_meta_data [as 别名]
rates=[0]*(num_meshes-1)*num_norms
print "rates= ", rates

#####################################################################################

# B) loop over meshes and compute errors

for i in range(0,num_meshes):
    pMesh = PerceptMesh(2)
    pMesh.open(mesh_files[i])
    pMesh.commit()

    spatial_dim=pMesh.get_spatial_dim()
    # TODO: check that this matches the StringFunction exact solution

    metaData = pMesh.get_fem_meta_data()
    bulkData = pMesh.get_bulk_data()
    
    nodal_field = metaData.get_field(nodal_fields[0])
    ff_Tnd = FieldFunction(nodal_fields[0], nodal_field, bulkData, Dimensions(spatial_dim), Dimensions(1))

    error_string = [exact_soln_name[0]+" - "+nodal_fields[0]];
    error_name = [nodal_fields[0]+"_err"]
    sf_Terr = StringFunction(error_string[0], error_name[0], Dimensions(spatial_dim), Dimensions(1))

    numSteps = pMesh.get_database_time_step_count()
    pMesh.read_database_at_step(numSteps)

    # DEBUG
    print numSteps, pMesh.get_current_database_step(), pMesh.get_current_database_time()