コード例 #1
0
ファイル: Post_Gmsh.py プロジェクト: nunesanderson/EMFET
def integrate_B_surface(pre_proc_data,face_phys_ID,vol_phys_ID,results_path):

#Instances
	operations=Operations()
	mesh_data=pre_proc_data.MeshData
	get_gauss_points_class=GaussPoints()
	file_names=File_names()

#Mesh data
	nodes_coordenates=mesh_data.NodesCoordenates
	elem_tags=mesh_data.ElemTags
	elem_type=mesh_data.ElemType
	elem_nodes=mesh_data.ElemNodes
	number_elements=len(elem_tags)
	xy_plot=list()
	field=list()

#Reads flux file
	flux_results_file_name=file_names.flux_results_file_name()
	full_path=os.path.join(results_path,flux_results_file_name)
	new_flux=read_numeric_file_numpy(full_path)

#Read faces_ID
	faces_ID_file_name=file_names.get_faces_ID_file_name()
	full_path=os.path.join(results_path,faces_ID_file_name)
	data=get_data_from_file(full_path)
	faces_ID=get_file_block("$faces_ID","$Endfaces_ID",0,data,int)

#Read faces_from_to
	from_to_file_name=file_names.faces_from_to_file_name()
	full_path=os.path.join(results_path,from_to_file_name)
	faces_from_to=read_numeric_file_numpy(full_path)

	flux=0
	for elem_counter in xrange(number_elements):
		this_elem_type=elem_type[elem_counter]
		if this_elem_type==2 and elem_tags[elem_counter][0]==face_phys_ID:
			nodes_list_2D= mesh_data.ElemNodes[elem_counter]
			gauss_points=get_gauss_points_class.get_gauss_points(this_elem_type)
			num_gauss_points=len(gauss_points)

#Area and normal vector of the 2D element
			node1=elem_nodes[elem_counter][0]
			node2=elem_nodes[elem_counter][1]
			node3=elem_nodes[elem_counter][2]
			P1=np.array([nodes_coordenates[node1][0],nodes_coordenates[node1][1],nodes_coordenates[node1][2]])
			P2=np.array([nodes_coordenates[node2][0],nodes_coordenates[node2][1],nodes_coordenates[node2][2]])
			P3=np.array([nodes_coordenates[node3][0],nodes_coordenates[node3][1],nodes_coordenates[node3][2]])
			A=P2-P1
			B=P3-P1
			AxB=np.cross(A,B)
			nor=linalg.norm(AxB)
			n=AxB/nor
			area=0.5*nor

#Get the real coordinates of the 2D element Gauss points
			xy_local=list()
			for each_integ_point in xrange(num_gauss_points):
				xyz=operations.convert_local_real(this_elem_type,gauss_points[each_integ_point,0],gauss_points[each_integ_point,1],0,nodes_list_2D,nodes_coordenates)
				xy_local.append(xyz)

#Get the magnetic induction, based on the 3D elements interpolation
			counter=-1
			B_list=list()
			for elem_counter_3D in xrange(number_elements):
				this_elem_type_3D=elem_type[elem_counter_3D]
				nodes_list_3D= mesh_data.ElemNodes[elem_counter_3D]
				if this_elem_type_3D==4:
					counter=counter+1
					if elem_tags[elem_counter_3D][0]==vol_phys_ID and set(nodes_list_2D)<set(nodes_list_3D):
						for xyz in xy_local:

#Convert the real coordinates of the 2D element into local coordinates
							uvp=operations.convert_real_to_local(elem_counter_3D,this_elem_type_3D,xyz[0],xyz[1],xyz[2],nodes_list_3D,nodes_coordenates)
							xy_plot.append(xyz)
							b_at_point=get_B_vector_point_uvp(uvp[0],uvp[1],uvp[2],elem_counter_3D,counter,elem_type,elem_nodes,faces_ID,nodes_coordenates,new_flux,faces_from_to)
							b_at_point=np.array([b_at_point[0,0],b_at_point[1,0],b_at_point[2,0]])
							field.append(b_at_point)
							B_list.append(b_at_point)
						break
#Integration process
			for each_integ_point in xrange(num_gauss_points):
				B=B_list[each_integ_point].dot(n)

				flux=flux+B*area/3.0

	Gmsh_file_name=file_names.get_B_Gmsh_surface_file_name()
	path=os.path.join(results_path,Gmsh_file_name)
	Create_Vector_field(xy_plot,field,path,"B Vector")

	return flux
コード例 #2
0
def integrate_B_surface(pre_proc_data, face_phys_ID, vol_phys_ID,
                        results_path):

    #Instances
    operations = Operations()
    mesh_data = pre_proc_data.MeshData
    get_gauss_points_class = GaussPoints()
    file_names = File_names()

    #Mesh data
    nodes_coordenates = mesh_data.NodesCoordenates
    elem_tags = mesh_data.ElemTags
    elem_type = mesh_data.ElemType
    elem_nodes = mesh_data.ElemNodes
    number_elements = len(elem_tags)
    xy_plot = list()
    field = list()

    #Reads flux file
    flux_results_file_name = file_names.flux_results_file_name()
    full_path = os.path.join(results_path, flux_results_file_name)
    new_flux = read_numeric_file_numpy(full_path)

    #Read faces_ID
    faces_ID_file_name = file_names.get_faces_ID_file_name()
    full_path = os.path.join(results_path, faces_ID_file_name)
    data = get_data_from_file(full_path)
    faces_ID = get_file_block("$faces_ID", "$Endfaces_ID", 0, data, int)

    #Read faces_from_to
    from_to_file_name = file_names.faces_from_to_file_name()
    full_path = os.path.join(results_path, from_to_file_name)
    faces_from_to = read_numeric_file_numpy(full_path)

    flux = 0
    for elem_counter in xrange(number_elements):
        this_elem_type = elem_type[elem_counter]
        if this_elem_type == 2 and elem_tags[elem_counter][0] == face_phys_ID:
            nodes_list_2D = mesh_data.ElemNodes[elem_counter]
            gauss_points = get_gauss_points_class.get_gauss_points(
                this_elem_type)
            num_gauss_points = len(gauss_points)

            #Area and normal vector of the 2D element
            node1 = elem_nodes[elem_counter][0]
            node2 = elem_nodes[elem_counter][1]
            node3 = elem_nodes[elem_counter][2]
            P1 = np.array([
                nodes_coordenates[node1][0], nodes_coordenates[node1][1],
                nodes_coordenates[node1][2]
            ])
            P2 = np.array([
                nodes_coordenates[node2][0], nodes_coordenates[node2][1],
                nodes_coordenates[node2][2]
            ])
            P3 = np.array([
                nodes_coordenates[node3][0], nodes_coordenates[node3][1],
                nodes_coordenates[node3][2]
            ])
            A = P2 - P1
            B = P3 - P1
            AxB = np.cross(A, B)
            nor = linalg.norm(AxB)
            n = AxB / nor
            area = 0.5 * nor

            #Get the real coordinates of the 2D element Gauss points
            xy_local = list()
            for each_integ_point in xrange(num_gauss_points):
                xyz = operations.convert_local_real(
                    this_elem_type, gauss_points[each_integ_point, 0],
                    gauss_points[each_integ_point,
                                 1], 0, nodes_list_2D, nodes_coordenates)
                xy_local.append(xyz)

#Get the magnetic induction, based on the 3D elements interpolation
            counter = -1
            B_list = list()
            for elem_counter_3D in xrange(number_elements):
                this_elem_type_3D = elem_type[elem_counter_3D]
                nodes_list_3D = mesh_data.ElemNodes[elem_counter_3D]
                if this_elem_type_3D == 4:
                    counter = counter + 1
                    if elem_tags[elem_counter_3D][0] == vol_phys_ID and set(
                            nodes_list_2D) < set(nodes_list_3D):
                        for xyz in xy_local:

                            #Convert the real coordinates of the 2D element into local coordinates
                            uvp = operations.convert_real_to_local(
                                elem_counter_3D, this_elem_type_3D, xyz[0],
                                xyz[1], xyz[2], nodes_list_3D,
                                nodes_coordenates)
                            xy_plot.append(xyz)
                            b_at_point = get_B_vector_point_uvp(
                                uvp[0], uvp[1], uvp[2], elem_counter_3D,
                                counter, elem_type, elem_nodes, faces_ID,
                                nodes_coordenates, new_flux, faces_from_to)
                            b_at_point = np.array([
                                b_at_point[0, 0], b_at_point[1, 0],
                                b_at_point[2, 0]
                            ])
                            field.append(b_at_point)
                            B_list.append(b_at_point)
                        break


#Integration process
            for each_integ_point in xrange(num_gauss_points):
                B = B_list[each_integ_point].dot(n)

                flux = flux + B * area / 3.0

    Gmsh_file_name = file_names.get_B_Gmsh_surface_file_name()
    path = os.path.join(results_path, Gmsh_file_name)
    Create_Vector_field(xy_plot, field, path, "B Vector")

    return flux
コード例 #3
0
ファイル: Post_Gmsh.py プロジェクト: nunesanderson/EMFET
def interpolated_along_line(vol_phys_ID,xyz_list,pre_proc_data,results_path):
	operations=Operations()
	mesh_data=pre_proc_data.MeshData
	get_gauss_points_class=GaussPoints()
	shape_functions=ShapeFuncions()
	file_names=File_names()
	#Mesh data
	nodes_coordenates=mesh_data.NodesCoordenates
	elem_tags=mesh_data.ElemTags
	elem_type=mesh_data.ElemType
	elem_nodes=mesh_data.ElemNodes
	number_elements=len(elem_tags)
	xy_plot=list()
	field=list()

	#Reads flux file
	flux_results_file_name=file_names.flux_results_file_name()
	full_path=os.path.join(results_path,flux_results_file_name)
	new_flux=read_numeric_file_numpy(full_path)

	#Read faces_ID
	faces_ID_file_name=file_names.get_faces_ID_file_name()
	full_path=os.path.join(results_path,faces_ID_file_name)
	data=get_data_from_file(full_path)
	faces_ID=get_file_block("$faces_ID","$Endfaces_ID",0,data,int)

	#Read faces_from_to
	from_to_file_name=file_names.faces_from_to_file_name()
	full_path=os.path.join(results_path,from_to_file_name)
	faces_from_to=read_numeric_file_numpy(full_path)

	for xyz in xyz_list:
		counter=-1
		this_element=False
		for elem_counter in range(0,number_elements):
			this_elem_type=elem_type[elem_counter]
			if this_elem_type==4:
				counter=counter+1
				if elem_tags[elem_counter][0] in vol_phys_ID:
					nodes_list= mesh_data.ElemNodes[elem_counter]
					uvp=operations.convert_real_to_local(elem_counter,this_elem_type,xyz[0],xyz[1],xyz[2],nodes_list,nodes_coordenates)
					N=shape_functions.get_node_shape_function(this_elem_type,uvp[0],uvp[1],uvp[2])
					if max(N)<=1.0 and min(N)>=0.0:
						this_element=True

						break
		if this_element:
			b_at_point=get_B_vector_point_uvp(uvp[0],uvp[1],uvp[2],elem_counter,counter,elem_type,elem_nodes,faces_ID,nodes_coordenates,new_flux,faces_from_to)
			b_at_point=np.array([b_at_point[0,0],b_at_point[1,0],b_at_point[2,0]])
			field.append(b_at_point)
		else:
			b_at_point=np.array([0.0,0.0,0.0])
			field.append(b_at_point)

	Gmsh_file_name=file_names.get_B_Gmsh_line_file_name()
	path=os.path.join(results_path,Gmsh_file_name)
	Create_Vector_field(xyz_list,field,path,"B Vector")

	Gmsh_file_name="line_field.txt"
	path=os.path.join(results_path,Gmsh_file_name)
	write_numeric_file_numpy(path,field)
コード例 #4
0
def interpolated_along_line(vol_phys_ID, xyz_list, pre_proc_data,
                            results_path):
    operations = Operations()
    mesh_data = pre_proc_data.MeshData
    get_gauss_points_class = GaussPoints()
    shape_functions = ShapeFuncions()
    file_names = File_names()
    #Mesh data
    nodes_coordenates = mesh_data.NodesCoordenates
    elem_tags = mesh_data.ElemTags
    elem_type = mesh_data.ElemType
    elem_nodes = mesh_data.ElemNodes
    number_elements = len(elem_tags)
    xy_plot = list()
    field = list()

    #Reads flux file
    flux_results_file_name = file_names.flux_results_file_name()
    full_path = os.path.join(results_path, flux_results_file_name)
    new_flux = read_numeric_file_numpy(full_path)

    #Read faces_ID
    faces_ID_file_name = file_names.get_faces_ID_file_name()
    full_path = os.path.join(results_path, faces_ID_file_name)
    data = get_data_from_file(full_path)
    faces_ID = get_file_block("$faces_ID", "$Endfaces_ID", 0, data, int)

    #Read faces_from_to
    from_to_file_name = file_names.faces_from_to_file_name()
    full_path = os.path.join(results_path, from_to_file_name)
    faces_from_to = read_numeric_file_numpy(full_path)

    for xyz in xyz_list:
        counter = -1
        this_element = False
        for elem_counter in range(0, number_elements):
            this_elem_type = elem_type[elem_counter]
            if this_elem_type == 4:
                counter = counter + 1
                if elem_tags[elem_counter][0] in vol_phys_ID:
                    nodes_list = mesh_data.ElemNodes[elem_counter]
                    uvp = operations.convert_real_to_local(
                        elem_counter, this_elem_type, xyz[0], xyz[1], xyz[2],
                        nodes_list, nodes_coordenates)
                    N = shape_functions.get_node_shape_function(
                        this_elem_type, uvp[0], uvp[1], uvp[2])
                    if max(N) <= 1.0 and min(N) >= 0.0:
                        this_element = True

                        break
        if this_element:
            b_at_point = get_B_vector_point_uvp(uvp[0], uvp[1], uvp[2],
                                                elem_counter, counter,
                                                elem_type, elem_nodes,
                                                faces_ID, nodes_coordenates,
                                                new_flux, faces_from_to)
            b_at_point = np.array(
                [b_at_point[0, 0], b_at_point[1, 0], b_at_point[2, 0]])
            field.append(b_at_point)
        else:
            b_at_point = np.array([0.0, 0.0, 0.0])
            field.append(b_at_point)

    Gmsh_file_name = file_names.get_B_Gmsh_line_file_name()
    path = os.path.join(results_path, Gmsh_file_name)
    Create_Vector_field(xyz_list, field, path, "B Vector")

    Gmsh_file_name = "line_field.txt"
    path = os.path.join(results_path, Gmsh_file_name)
    write_numeric_file_numpy(path, field)