Python PerceptMesh.get_spatial_dim方法代码示例

# 需要导入模块: import PerceptMesh [as 别名]
# 或者: from PerceptMesh import get_spatial_dim [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_spatial_dim [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_spatial_dim [as 别名]
dofs_are_elems=True;
dofs=[0]*num_meshes

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)