Page Comparison

import numpy as np
import meshio

def my_meshio_read_mesh(filename):
    #to avoid that numpy truncate the printed representation of its arrays
    np.set_printoptions(threshold=np.inf)
    mesh=meshio.read(filename)
    return [mesh.points,mesh.cells,mesh.cells_dict]

set filename_python [file join [gid_filesystem::get_folder_standard plugins] Import/meshio/gid_meshio.py]
GiD_Python_Import_File $filename_python
...
set m [GiD_Python_Call gid_meshio.my_meshio_read_mesh $filename_mesh]
...

proc MeshIo::Init { } {
    variable meshio_element_name
    ...   
    set meshio_element_name(point,1) vertex
    set meshio_element_name(line,2) line
    set meshio_element_name(triangle,3) triangle
    set meshio_element_name(quadrilateral,4) quad
    set meshio_element_name(tetrahedra,4) tetra
    set meshio_element_name(hexahedra,8) hexahedron
    set meshio_element_name(prism,6) wedge
    set meshio_element_name(pyramid,5) pyramid
    #quadratic
    set meshio_element_name(line,3) line3
    set meshio_element_name(triangle,6) triangle6
    set meshio_element_name(quadrilateral,8) quad8
    set meshio_element_name(quadrilateral,9) quad9
    set meshio_element_name(tetrahedra,10) tetra10
    set meshio_element_name(hexahedra,20) hexahedron20
    set meshio_element_name(hexahedra,27) hexahedron27
    set meshio_element_name(prism,15) wedge15
    set meshio_element_name(pyramid,13) pyramid13
}

proc MeshIo::TclObjarrayToPythonArrayPoints { node_xyzs } {
    set points ""
    lassign $node_xyzs xs ys zs
    set num_nodes [objarray length $xs]
    for {set i_node 0} {$i_node<$num_nodes} {incr i_node} {
        set x [objarray get $xs $i_node]
        set y [objarray get $ys $i_node]
        set z [objarray get $zs $i_node]
        append points "\[$x,$y,$z\],"
    }
    return "\[$points\]"
}

proc MeshIo::TclObjarrayToPythonArrayConnectivities { element_num_nodes connectivities } {
    set cells ""
    set num_elements [expr [objarray length $connectivities]/$element_num_nodes]
    set i 0
    for {set i_element  0} {$i_element<$num_elements} {incr i_element} {
        set node_ids [list]
        for {set i_node  0} {$i_node<$element_num_nodes} {incr i_node} {
            lappend node_ids [objarray get $connectivities $i]
            incr i
        }
        append cells "\[[join $node_ids ,]\],"
    }
    return "\[$cells\]"
}

proc MeshIo::WritePreUnstructuredMesh { filename } {
    variable meshio_element_name
    MeshIo::Import_gid_meshio_py ;#to load in python the file gid_meshio.py to define its python functions before be called  

    # coordinates
    lassign [GiD_Info mesh nodes -array] node_ids node_xyzs

    set max_id_nodes [objarray get $node_ids end]
    set num_nodes [objarray length [lindex $node_xyzs 0]]
    set new_node_ids ""
    set nodes_renumbered_for_meshio 0
    if { $max_id_nodes != $num_nodes } {
        set nodes_renumbered_for_meshio 1
        set new_node_ids [objarray new_from_to intarray 0 [expr $num_nodes-1]]
    }
    set points [MeshIo::TclObjarrayToPythonArrayPoints $node_xyzs]
    set cells "\["
    foreach element_type {linear triangle quadrilateral tetrahedra pyramid prism hexahedra } {
        set elements_data [lindex [GiD_Info mesh elements $element_type -array2] 0]
        if { [llength $elements_data] } {
            lassign $elements_data element_type_ret element_ids connectivities materials
            set num_elements_block [objarray length $element_ids]
            if { $num_elements_block } {
                if { $nodes_renumbered_for_meshio } {
                    objarray renumber $connectivities $node_ids $new_node_ids
                } else {
                    objarray incr $connectivities -1 ;#meshio is zero based
                }
                set some_element_id [objarray get $element_ids 0]
                set element_num_nodes [llength [GiD_Mesh get element $some_element_id connectivities]]
                set meshio_etype $meshio_element_name($element_type,$element_num_nodes)
                append cells "(\"$meshio_etype\",[MeshIo::TclObjarrayToPythonArrayConnectivities $element_num_nodes $connectivities]),"
            }
        }
    }
    append cells "\]"
    set result [GiD_Python_Call gid_meshio.my_meshio_write_mesh $points $cells $filename]
    return 0
}

import meshio

def my_meshio_write_mesh(points,cells,filename):
    #trick, use ast.literal_eval to convert from string to list representation
    import ast
    points=ast.literal_eval(points)
    cells=ast.literal_eval(cells)
    mesh=meshio.Mesh(points,cells)
    result=mesh.write(filename)
    return result

proc MeshIo::WritePreUnstructuredMesh2 { filename } {
    MeshIo::Import_gid_meshio_py ;#to load in python the file gid_meshio.py to define its python functions before be called  
    set result [GiD_Python_Call gid_meshio.my_meshio_write_mesh2 $filename]
    return 0
}

import numpy as np
import tohil
import meshio

#to create functions and variables for all tcl available ones
tcl=tohil.import_tcl()

gid_to_meshio_type = {
    "sphere,1":"vertex",
    "point,1":"vertex",
    "line,2":"line",
    "triangle,3":"triangle",
    "quadrilateral,4":"quad",
    "tetrahedra,4":"tetra",
    "hexahedra,8":"hexahedron",
    "prism,6":"wedge",
    "pyramid,5":"pyramid",
    #quadratic
    "line,3":"line3",
    "triangle,6":"triangle6",
    "quadrilateral,8":"quad8",
    "quadrilateral,9":"quad9",
    "tetrahedra,10":"tetra10",
    "hexahedra,20":"hexahedron20",
    "hexahedra,27":"hexahedron27",
    "prism,15":"wedge15",
    "pyramid,13":"pyramid13",
}

def gid_points_to_meshio_points(node_xyzs):
    xs,ys,zs=node_xyzs
    num_nodes=len(xs)
    points=np.empty((num_nodes,3))
    for i_node in range(num_nodes):
        points[i_node]=(float(xs[i_node]),float(ys[i_node]),float(zs[i_node]))
    #points[:, 0] = xs[:]
    #points[:, 1] = ys[:]
    #points[:, 2] = zs[:]
    return points

def gid_elements_to_meshio_cells(element_num_nodes,connectivities):
    cells=[]
    #operator // is for integer division
    num_elements=len(connectivities)//element_num_nodes
    i=0
    for i_element in range(num_elements):
        node_ids=[]
        for i_node in range(element_num_nodes):
            node_ids.append(connectivities[i])
            i+=1
        cells.append(node_ids)
    return cells

def tohil_obj_array_int_to_numpy(items):
    num_items=len(items)
    numpy_array=np.empty(num_items,np.int64)
    for i in range(num_items) :
        numpy_array[i]=int(items[i])
    return numpy_array

def numpy_renumber(connectivities,old_node_ids,new_node_ids):
    fail=0
    length_connectivities=len(connectivities)
    length_old_ids=len(old_node_ids)
    length_new_ids=len(new_node_ids)
    if(length_old_ids==length_new_ids):
        max_old_id=np.max(old_node_ids)
        new_number=np.empty(max_old_id,np.int32)
        for i in range(length_old_ids) :
            new_number[old_node_ids[i]]=new_node_ids[i]
        for i in range(length_connectivities) :
            connectivities[i]=new_number[connectivities[i]]
    else:
        fail=1
    return connectivities

def numpy_incr(connectivities,increment):
    connectivities=connectivities+increment
    return connectivities

#similar to my_meshio_write_mesh but asking GiD data from python and processing this data here
def my_meshio_write_mesh2(filename):
    info_nodes=tuple(tcl.GiD_Info('mesh','nodes','-array'))
    node_ids,node_xyzs=info_nodes
    #tcl.W(node_ids)
    #tcl.W(node_xyzs)
    max_id_nodes=int(node_ids[-1])
    num_nodes=len(node_ids)
    nodes_renumbered_for_meshio=False
    if (max_id_nodes != num_nodes):
        nodes_renumbered_for_meshio=True
        new_node_ids=np.arange(num_nodes)
    points=gid_points_to_meshio_points(node_xyzs)
    cells = []
    for element_type in ['linear','triangle','quadrilateral','tetrahedra','pyramid','prism','hexahedra']:
        info_elements=tuple(tcl.GiD_Info('mesh','elements',element_type,'-array2'))
        if (len(info_elements)):
            #tcl.W(info_elements)
            elements_data=info_elements[0]
            element_type_ret,element_ids_original,connectivities_original,materials=elements_data
            element_ids=tohil_obj_array_int_to_numpy(tuple(element_ids_original))
            connectivities=tohil_obj_array_int_to_numpy(tuple(connectivities_original))
            num_elements_block=len(element_ids)
            if (num_elements_block):
                if (nodes_renumbered_for_meshio):
                    connectivities=numpy_renumber(connectivities,node_ids,new_node_ids)
                else:
                    connectivities=numpy_incr(connectivities,-1)
                some_element_id=element_ids[0]
                element_num_nodes=len(tcl.GiD_Mesh('get','element',some_element_id,'connectivities'))
                key=element_type+','+str(element_num_nodes)
                meshio_etype=gid_to_meshio_type[key]
                cells.append((meshio_etype,gid_elements_to_meshio_cells(element_num_nodes,connectivities)))
    mesh=meshio.Mesh(points,cells)
    result=mesh.write(filename)
    return result