Python PerceptMesh.get_field方法代码示例

# 需要导入模块: import PerceptMesh [as 别名]
# 或者: from PerceptMesh import get_field [as 别名]
    def test_fieldFunction_demo_2(self):   
       eMesh = PerceptMesh()
       eMesh.new_mesh(GMeshSpec("3x3x3|bbox:0,0,0,1,1,1"))

       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, 3, 3)
       eval_vec3_print(0.1,0.1,0.1,0.0,ff_coords)
       
       coords_mag_sf = StringFunction("sqrt(x*x + y*y + z*z)" , "coords_mag_sf", 3, 1)
       x = 0.123
       y = 0.234
       z = 0.345
       vv = sqrt(x*x + y*y + z*z)
       v1 = eval_func(x,y,z,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, 3, 1)

       coords_mag_field_function.interpolateFrom(coords_mag_sf)

       eMesh.save_as("./cubehex8_withCoordMag_out.e")

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

# 需要导入模块: import PerceptMesh [as 别名]
# 或者: from PerceptMesh import get_field [as 别名]
    def test_fieldFunction_readMesh_createField_interpolateFrom(self):
       num_x = 3
       num_y = 3
       num_z = 3
       config_mesh = str(num_x) + "x" + str(num_y) + "x" + str(num_z) + "|bbox:0,0,0,1,1,1"

       eMesh = PerceptMesh()
       eMesh.new_mesh(GMeshSpec(config_mesh))
       vectorDimension = 0
       eMesh.add_field("coords_mag_field", FEMMetaData.NODE_RANK, vectorDimension)
       eMesh.commit()

       #p_rank = eMesh.get_bulk_data().parallel_rank()
       #setRank(p_rank)        
          #from Util 
       f_coords = eMesh.get_field("coordinates")

       coords_mag_field = eMesh.get_field("coords_mag_field")
       #VERIFY_OP_ON      Here the unit test does something
       
       ff_coords = FieldFunction("ff_coords", f_coords, eMesh, 3, 3, FieldFunction.SIMPLE_SEARCH)

       #here we could evaluate the function
       #eval_vec3_print(0.1,0.2,0.3,0.0,ff_coords)
       
       coords_mag_sf = StringFunction("sqrt(x*x + y*y + z*z)", "coords_mag_sf", 3, 1)
       coords_mag_field_function = FieldFunction("coords_mag_field_function", coords_mag_field, eMesh, 3, 3, FieldFunction.SIMPLE_SEARCH)
       coords_mag_field_function.interpolateFrom(coords_mag_sf)

       #The following is not doable from Python
      
       checkCoordMag = CheckCoordMag()
       #eMesh.nodalOpLoop(checkCoordMag, coords_mag_field)
       print checkCoordMag.error   

       ff_coords.add_alias("mc")
       sfcm = StringFunction("sqrt(mc[0]*mc[0]+mc[1]*mc[1]+mc[2]*mc[2])", "sfcm", Dimensions(3), Dimensions(1))
      
       tol1 = 1.e-12
      
       vv = eval_vec3(0.1, 0.2, 0.3, 0.0, ff_coords)
       print 
       print "0.1 == vv[0] = ", vv[0], "passed"
       print "0.2 == vv[1] = ", vv[1], "passed"
       print "0.3 == vv[2] = ", vv[2], "passed"

       self.assertAlmostEqual(.1, vv[0], delta=tol1)
       self.assertAlmostEqual(.2, vv[1], delta=tol1)
       self.assertAlmostEqual(.3, vv[2], delta=tol1)

       vv = eval_func(0.1, 0.2, 0.3, 0.0, sfcm)
       v_expect = sqrt(0.1*0.1+0.2*0.2+0.3*0.3)

       if ((vv-v_expect) < tol1):
          print "vv = ", vv, " == v_expect = ", v_expect, "passed"

       coords_mag_field_function.interpolateFrom(sfcm)

# 需要导入模块: import PerceptMesh [as 别名]
# 或者: from PerceptMesh import get_field [as 别名]
    def test_fieldFunction_point_eval_timing(self):
       num_x = 3
       num_y = 3
       num_z = 3
       config_mesh = str(num_x) + "x" + str(num_y) + "x" + str(num_z) + "|bbox:0,0,0,1,1,1"

       eMesh = PerceptMesh()
       eMesh.new_mesh(GMeshSpec(config_mesh))
       eMesh.commit()

       #FIXME
       #p_size = eMesh.get_bulk_data->parallel_size()

       f_coords = eMesh.get_field("coordinates")

       for iSearchType in range(2):
          if iSearchType == 0:
             search_type = FieldFunction.SIMPLE_SEARCH
             search_type_name = "SIMPLE_SEARCH"
          else:
             search_type = FieldFunction.STK_SEARCH
             search_type_name = "STK_SEARCH"
          ff_coords = FieldFunction("ff_coords", f_coords, eMesh, Dimensions(3), Dimensions(3), search_type)
         
          t1st = time.time()
          val1 = eval_vec3(0.2,0.3,0.4,0.0,ff_coords)
          val1 = eval_vec3(0.2,0.3,0.4,0.0,ff_coords) #evaluated twice???
          t1st = time.time() - t1st

          numIter = 10000
          random.seed(12345)      
          total_time = time.time()
          max_rand = 32767

          for iter in range(numIter):
             num0 = random.randint(1, max_rand)*1.0
             num1 = random.randint(1, max_rand)*1.0
             num2 = random.randint(1, max_rand)*1.0
             pts = array([(num0/max_rand), (num1/max_rand), (num2/max_rand)])
             output_pts = array([0.0,0.0,0.0])
             output_pts = ff_coords.value(pts, output_pts, 0.0)

          total_time = time.time() - total_time

          print "TEST::function::fieldFunction_point_eval_timing: "
          print " for search_type= ", search_type_name
          print "    time for 1st eval= ", t1st
          print "    for ", numIter, "iterations, evaluating field(x,y,z) time = ", total_time
          print "    average per point lookup and eval time = ", (total_time/numIter)

# 需要导入模块: import PerceptMesh [as 别名]
# 或者: from PerceptMesh import get_field [as 别名]
    def test_fieldFunction_demo_1_0_0(self):
       eMesh = PerceptMesh(3)
       eMesh.new_mesh(GMeshSpec("3x3x3|bbox:0,0,0,1,1,1"))
       eMesh.commit()
       eMesh.print_info("fieldFunction_demo_1_0_0", 2)

       f_coords = eMesh.get_field("coordinates")

       ff_coords = FieldFunction("ff_coords", f_coords, eMesh, 3, 3)
       x = 0.123
       y = 0.234
       z = 0.345
       time = 0.0

       eval_vec3_print(x, y, z, time, ff_coords)

# 需要导入模块: import PerceptMesh [as 别名]
# 或者: from PerceptMesh import get_field [as 别名]
    def test_fieldFunction_demo_2(self):   
        eMesh = PerceptMesh()
        eMesh.new_mesh(GMeshSpec("3x3x3|bbox:0,0,0,1,1,1"))      # use a fixture to generate a 3x3x3 hex mesh

        vectorDimension = 0
        # add a field
        eMesh.add_field("coords_mag_field", FEMMetaData.NODE_RANK, vectorDimension)  
        eMesh.commit()

        f_coords = eMesh.get_field("coordinates")                # get pre-existing field
        coords_mag_field = eMesh.get_field("coords_mag_field")   # get the field we just created

        ff_coords = FieldFunction("ff_coords", f_coords, eMesh, 3, 3)  # define a field function
        eval_vec3_print(0.1,0.1,0.1,0.0,ff_coords)  # evaluate and print the field function a point {0.1, 0.1, 0.1} time=0.0

        coords_mag_sf = StringFunction("sqrt(x*x + y*y + z*z)" , "coords_mag_sf", 3, 1)  # define coordinate magnitude function
        x = 0.123
        y = 0.234
        z = 0.345
        vv = sqrt(x*x + y*y + z*z)
        v1 = eval_func(x,y,z,0,coords_mag_sf)
        print "vv = ", vv, "== v1 = ", v1
        self.assertEqual(vv, v1)               # ensure correctness of string function

        # define a field function
        coords_mag_field_function = FieldFunction("coords_mag_field_function", coords_mag_field, eMesh, 3, 1)

        # interpolate the function onto the mesh
        coords_mag_field_function.interpolateFrom(coords_mag_sf)

        eMesh.save_as("./cubehex8_withCoordMag_out.e")

        # demonstrate how to usa an alias
        ff_coords.add_alias("mc")

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

# 需要导入模块: import PerceptMesh [as 别名]
# 或者: from PerceptMesh import get_field [as 别名]
    def test_fieldFunction_demo_1(self):
       gms = Gmesh_STKmesh_Fixture(MPI.COMM_WORLD, "3x3x3|bbox:0,0,0,1,1,1")
       print "gms = ", gms
       print "gms= end"

       eMesh = PerceptMesh()
       eMesh.new_mesh(GMeshSpec("3x3x3|bbox:0,0,0,1,1,1"))
       eMesh.commit()

       f_coords = eMesh.get_field("coordinates")
       ff_coords = FieldFunction("ff_coords", f_coords, eMesh, 3, 3)

       x = 0.123
       y = 0.234
       z = 0.345
       time = 0.0
       eval_vec3_print(x,y,z,time,ff_coords)

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

      if p_size <= 2:
        eMesh = PerceptMesh(2)
        eMesh.open("./exodus_files/time-dep.e")
        eMesh.commit()

        Tnd_field = eMesh.get_field("Tnd")

        # // entity data setter/getters
        eMesh.read_database_at_time(0.0)
        node = eMesh.get_node(2,2)
        self.assertTrue(node != 0)
        t0 = eMesh.get_field_data(Tnd_field, node)
        self.assertTrue(t0 == 0.0)
        eMesh.read_database_at_time(1.0)
        t1 = eMesh.get_field_data(Tnd_field, node)
        self.assertTrue(t1 == 11.0)
        
        print "t0= " , t0, " t1= " , t1

# 需要导入模块: import PerceptMesh [as 别名]
# 或者: from PerceptMesh import get_field [as 别名]
    def test_fieldFunction_point_eval_verify(self):
       num_x = 3
       num_y = 3
       num_z = 3
       config_mesh = str(num_x) + "x" + str(num_y) + "x" + str(num_z) + "|bbox:0,0,0,1,1,1"

       eMesh = PerceptMesh()
       eMesh.new_mesh(GMeshSpec(config_mesh))
       eMesh.commit()

       f_coords = eMesh.get_field("coordinates") 
       
       ff_coords = FieldFunction("ff_coords", f_coords, eMesh, Dimensions(3), Dimensions(3), FieldFunction.SIMPLE_SEARCH)

       val1 = eval_vec3_print(0.2,0.3,0.4,0.0,ff_coords)

       bulkData = eMesh.get_bulk_data()

       try:
          val10 = eval_print_vec3(1.2, 1.3, 1.4, 0.0, ff_coords)
       except:
          print "expected to catch this exception: "

       pts = array([0.2, 0.3, 0.4])
       output_pts = array([0.0, 0.0, 0.0])
       output_pts = ff_coords.value(pts, output_pts)
       
       tol = 1.e-9
         
       print "output(0) = ", pts[0], " == output_pts(0) = ", output_pts[0]
       print "output(1) = ", pts[1], " == output_pts(1) = ", output_pts[1]
       print "output(2) = ", pts[2], " == output_pts(2) = ", output_pts[2]

       self.assertAlmostEqual(pts[0], output_pts[0], delta = tol)
       self.assertAlmostEqual(pts[1], output_pts[1], delta = tol)
       self.assertAlmostEqual(pts[2], output_pts[2], delta = tol)

# 需要导入模块: import PerceptMesh [as 别名]
# 或者: from PerceptMesh import get_field [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_field [as 别名]
    def test_fieldFunction_multiplePoints(self):
       print "start..."
       num_x = 3
       num_y = 3
       num_z = 3
       config_mesh = str(num_x) + "x" + str(num_y) + "x" + str(num_z) + "|bbox:0,0,0,1,1,1"

       eMesh = PerceptMesh()
       eMesh.new_mesh(GMeshSpec(config_mesh))
       vectorDimension = 0
       eMesh.add_field("coords_mag_field", FEMMetaData.NODE_RANK, vectorDimension)
       eMesh.commit()
       f_coords = eMesh.get_field("coordinates")
       ff_coords = FieldFunction("ff_coords", f_coords, eMesh, Dimensions(3), Dimensions(3), FieldFunction.SIMPLE_SEARCH)
       val1 = eval_vec3(0.2, 0.3, 0.4, 0.0, ff_coords)
       print "val1= ", val1
     
       points = zeros(shape=(4,3))
       output_expect = zeros(shape=(4,3))    
       output = zeros(shape=(4,3))
       
       print "here 1"
       i = 0 
       for xyzt in self.testpoints:
          x = xyzt[0]
          y = xyzt[1]
          z = xyzt[2]
          t = xyzt[3]
          points[i][0] = x
          points[i][1] = y
          points[i][2] = z

          vec = eval_vec3(x,y,z,t,ff_coords)

          tol0 = fabs(1.e-5*x)
          tol1 = fabs(1.e-5*y)
          tol2 = fabs(1.e-5*z)

          print "vec(0) = ", vec[0], " == x = ", x
          print "vec(1) = ", vec[1], " == y = ", y
          print "vec(2) = ", vec[2], " == z = ", z
          
          self.assertAlmostEqual(x, vec[0], delta=tol0)
          self.assertAlmostEqual(y, vec[1], delta=tol1)
          self.assertAlmostEqual(z, vec[2], delta=tol2)         

          output_expect[i][0] = x
          output_expect[i][1] = y
          output_expect[i][2] = z
          i = i + 1

       print "field_op: NPTS= 4"
       ff_coords.setDomainDimensions(Dimensions(3))
       ff_coords.setCodomainDimensions(Dimensions(3))
       #output = ff_coords.evaluate(points)
       # pass in the output array to ensure result is properly dimensioned
       output = ff_coords.value(points, output)
       print "here 2, output= ", output
 
       for j in range(4): #NLM
           output_expect_j = output_expect[j][0]
           output_j = output[j][0]

           tol = 1.e-5*(fabs(output_expect_j))
           print "output[j] = ", output_j, " == output_expect[j] = ", output_expect_j  , " points[j] = ", points[j]
           self.assertAlmostEqual(output_j, output_expect_j, delta = tol) 
       print "start...done"

# 需要导入模块: import PerceptMesh [as 别名]
# 或者: from PerceptMesh import get_field [as 别名]
    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"]
    print "error_string= ", error_string
    sf_Terr = StringFunction(error_string[0], error_name[0], Dimensions(spatial_dim), Dimensions(1))

    numSteps = pMesh.get_database_time_step_count()
    print "numSteps= ", numSteps, " nodal_fields[0]= ", nodal_fields[0]
    pMesh.read_database_at_step(numSteps)


    p_field = pMesh.get_field("P")
    node = pMesh.get_node(1)
    p1 = pMesh.get_field_data(p_field, node)
    print "p1= " , p1

    p21 = eval_func2(2,1,0,ff_Tnd)
    p21_ex = eval_func2(2,1,0,sf_ex[0])
    err =  eval_func2(2,1,0,sf_Terr)
    print "p21 = ", p21, p21_ex, err

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

    cubDegree = 2
    lInfNorm = LInfNorm(bulkData)
    lInfNorm.setCubDegree(cubDegree)