simnexus 0.1.0__py3-none-any.whl

simnexus/VTK/read_vtk.py

@@ -0,0 +1,329 @@
+
+import pyvista as pv
+from vtk.util.numpy_support import vtk_to_numpy
+import numpy as np
+
+from collections import  namedtuple
+
+from vtk import VTK_EMPTY_CELL, VTK_TRIANGLE, VTK_QUAD
+from vtk import VTK_HEXAHEDRON, VTK_WEDGE, VTK_TETRA
+
+########################
+#   // Linear cells
+#   VTK_EMPTY_CELL = 0,
+#   VTK_VERTEX = 1,
+#   VTK_POLY_VERTEX = 2,
+#   VTK_LINE = 3,          <<<<<<<<<<
+#   VTK_POLY_LINE = 4,
+#   VTK_TRIANGLE = 5,          <<<<<<<<<<
+#   VTK_TRIANGLE_STRIP = 6,
+#   VTK_POLYGON = 7,
+#   VTK_PIXEL = 8,
+#   VTK_QUAD = 9,
+#   VTK_TETRA = 10,          <<<<<<<<<<
+#   VTK_VOXEL = 11,
+#   VTK_HEXAHEDRON = 12,          <<<<<<<<<<
+#   VTK_WEDGE = 13,
+#   VTK_PYRAMID = 14,   # 5 nodes, rectangular base
+#   VTK_PENTAGONAL_PRISM = 15,
+#   VTK_HEXAGONAL_PRISM = 16,
+
+ElProp = namedtuple( 'ElProp', ['vtk_type', 'num_node'], defaults=[0] )
+
+el_props = {
+            0:  ElProp(VTK_EMPTY_CELL, 0),
+            5:  ElProp(VTK_TRIANGLE,   3),
+            9:  ElProp(VTK_QUAD,       4),
+            10: ElProp(VTK_TETRA,      4),
+            12: ElProp(VTK_HEXAHEDRON, 8),
+            13: ElProp(VTK_WEDGE,      6),
+           }
+#MAX_CONN = 8 # increase if needed
+
+
+def print_mesh_data( vtk_file_name ):
+
+    print( '==========================================================' )
+    print( '== MESH DATA for', vtk_file_name )
+    print( '==========================================================' )
+
+    mesh =  pv.read( vtk_file_name )
+
+    print( 'num_points', mesh.n_points )  # nodes for all parts
+    print( 'num_cells', mesh.n_cells )  # for all parts
+
+
+    print( '\n\ndata at nodes:\n', mesh.point_data )  
+    print( '\n\ndata at els:\n', mesh.cell_data )  
+
+    
+    print( '\n\nSOME ARRAY DATA\n' )
+    print( 'points', mesh.points )  # nodes for all parts
+
+    print( 'cells', mesh.cells )  # nodes for all parts
+
+
+    #node_ids = mesh.point_data['NODE_ID']  
+    #print( 'node_ids', node_ids )
+    #print( mesh.point_data['Contact_Forces'] ) # nodes for all parts
+
+    #part_ids = mesh.cell_data['PART_ID'] 
+    #print( part_ids )
+    #el_ids = mesh.cell_data['ELEMENT_ID'] 
+    #print( el_ids )
+    #print( mesh.cell_data['3DELEM_Von_Mises'] )  # nodes for all parts
+
+    cells = mesh.GetCells()
+    num_cell = cells.GetNumberOfCells()
+    cellConns = vtk_to_numpy( cells.GetConnectivityArray() )
+    cellOffsets = vtk_to_numpy( cells.GetOffsetsArray() )
+    cellTypes = vtk_to_numpy( mesh.GetCellTypesArray() )
+    coords = vtk_to_numpy( mesh.GetPoints().GetData() )
+
+    #print( 'part_ids', part_ids )
+    print( 'cellConns', cellConns.shape, cellConns.shape[0]+num_cell, cellConns )
+    print( 'cellTypes', cellTypes.shape, cellTypes )
+    print( 'coords', coords.shape, coords )
+    print( 'cellOffsets', cellOffsets )
+    print( 'cellOffsets', cellOffsets[0] )
+
+    print( '==========================================================' )
+    print( '== END MESH DATA for', vtk_file_name )
+    print( '==========================================================\n\n' )
+
+
+
+def read_mesh_conns( vtk_file_name, required_part_id,
+                     node_data_names=None, el_data_names=None, el_nodal_data_names=None ):
+
+    mesh =  pv.read( vtk_file_name )
+
+    node_ids = mesh.point_data['NODE_ID']  
+
+    part_ids = mesh.cell_data['PART_ID'] 
+    el_ids = mesh.cell_data['ELEMENT_ID'] 
+
+    cells = mesh.GetCells()
+    num_cell = cells.GetNumberOfCells()
+    cellConns = vtk_to_numpy( cells.GetConnectivityArray() )
+    cellOffsets = vtk_to_numpy( cells.GetOffsetsArray() )
+    cellTypes = vtk_to_numpy( mesh.GetCellTypesArray() )
+    coords = vtk_to_numpy( mesh.GetPoints().GetData() )
+
+    if el_data_names :
+        el_data = {}
+        for d_name in el_data_names:
+            el_data[d_name] = mesh.cell_data[ d_name ]
+    else: el_data = None
+    node_data = {'node_ids':node_ids}
+    if node_data_names :
+        for d_name in node_data_names:
+            node_data[d_name] =  mesh.point_data[ d_name ]
+    #else: node_data = None
+
+    if el_nodal_data_names:
+        el_nodal_mesh = mesh.cell_data_to_point_data()
+        #if node_data is None : node_data = {}
+        for d_name in el_nodal_data_names:
+            node_data[d_name] =  el_nodal_mesh.point_data[ d_name ]
+
+    #
+    # Build connectivity matrix for required part
+    #
+
+    subset_el_types = []
+
+    if el_data_names:
+       subset_el_data = {}
+       for d_name in el_data_names:
+           subset_el_data[d_name] = [] 
+    else: subset_el_data = None
+
+    new_conn_offset = 0
+    new_cellCons = np.array( [], dtype=np.int64  )
+    new_cellOffsets = []
+ 
+
+    for i, e_type in enumerate( cellTypes ):
+        if el_ids[i] == 0:
+           pass # internal elements
+        elif part_ids[i] == required_part_id:
+           if e_type in( VTK_TRIANGLE,   VTK_QUAD,VTK_HEXAHEDRON, VTK_WEDGE):
+              num_node = el_props[ e_type ].num_node
+              #assert( num_node <= MAX_CONN )
+              offset = cellOffsets[i]
+              conn = cellConns[ offset: offset+num_node]
+              if e_type == VTK_QUAD and conn[3] == conn[2]:
+                conn = conn[:-1] 
+                e_type = VTK_TRIANGLE 
+
+              subset_el_types.append( e_type )
+
+              new_cellCons = np.append( new_cellCons, conn )
+              new_cellOffsets.append( new_conn_offset )
+              new_conn_offset = new_conn_offset + len(conn)
+
+              if el_data_names:
+                for d_name in el_data_names:
+                  subset_el_data[d_name].append( el_data[d_name][i] )
+
+        else:
+            pass
+
+    return coords, node_data,  \
+           { 'subset_el_data':subset_el_data,
+             'cell_conns':new_cellCons,
+             'cell_offsets': np.array(new_cellOffsets),
+             'el_types': np.array(subset_el_types) }
+
+def compact_nodes( coords, node_data, el_dict ):
+    """
+    Remove nodes not connected to elements (of the part)
+    """
+
+    num_node_all = coords.shape[0]
+
+    used = np.zeros( num_node_all ).astype( bool )
+    new_node_idx  = np.zeros( num_node_all )
+
+    cell_con = el_dict['cell_conns']
+    for idx in cell_con:
+        used[idx]=True
+
+    num_node_new = 0
+    for old_idx in range( num_node_all ):
+        if used[old_idx]:
+            new_node_idx[old_idx] = num_node_new
+            num_node_new += 1
+        else:
+            pass
+
+
+    # data at nodes
+    if node_data is not None:
+        node_data_subset = {}
+        for k in node_data.keys():
+            shape = list( node_data[k].shape )
+            shape[0] = num_node_new
+            node_data_subset[k] = np.zeros( shape, dtype=node_data[k].dtype )
+
+        nidx = 0
+        for old_idx in range( num_node_all ):
+            if used[old_idx]:
+                for k in node_data.keys():
+                    node_data_subset[k] [ nidx ] = node_data[k][ old_idx ]
+                nidx += 1
+            else:
+                pass
+    else:
+        node_data_subset = None
+
+    # reset coords
+    coords_subset = np.zeros( (num_node_new,3), dtype=float ) # NYI 2D
+    nidx = 0
+    for old_idx in range( num_node_all ):
+        if used[old_idx]:
+            coords_subset[nidx] = coords[old_idx] 
+            nidx += 1
+        else:
+            #print( 'idx', old_idx, 'not used' )
+            pass
+
+
+
+    # reset connectivity
+    cell_con = el_dict['cell_conns']
+    cell_off = el_dict['cell_offsets']
+    new_cell_con = np.zeros_like( cell_con)
+    #new_cell_off = np.zeros_like( cell_off ) 
+    for i,n_idx in enumerate( cell_con ):
+        new_cell_con[i] = new_node_idx[n_idx]
+    el_dict['cell_conns'] = new_cell_con
+
+    return coords_subset, node_data_subset 
+
+
+def to_cells( el_types, cell_conns, cell_offsets ):
+
+    cells = {}
+    for etype,ep in el_props.items() :
+        numn = ep.num_node
+        mask = np.where( el_types == etype )
+        oo = cell_offsets[mask]
+        cells[etype] = [cell_conns[k:k+numn] for k in oo]
+    cells = { k:np.array(v) for k,v in cells.items() }
+    return cells
+
+
+def read_part_mesh( vtk_file_name, required_part_id,
+                    node_data_names=None, el_data_names=None, el_nodal_data_names=None ):
+
+    coords, node_data, el_dict = read_mesh_conns( vtk_file_name,
+                                                  required_part_id,
+                                                  node_data_names, el_data_names, el_nodal_data_names )
+
+
+    coords_subset, node_data_subset = compact_nodes( coords, node_data, el_dict )
+
+    cells = to_cells( el_dict['el_types'], el_dict['cell_conns'], el_dict['cell_offsets'] )
+
+    return { 'coords' : coords_subset,
+             'data'   : node_data_subset,
+           },  \
+           { #'conns' : new_subset_el_conns,
+             #'types' : el_dict['el_types'],
+             #'cell_conns' : el_dict['cell_conns'],
+             #'cell_conn_offset' : el_dict['cell_offsets'],
+             'cells' : cells,
+             'data'  : el_dict['subset_el_data'],
+           }
+
+
+def to_lcl_id( trgt_ids, srcs_ids, srcs_vals):
+    """ remap data to follow id sorting in trgt_ids instead of srcs_ids"""
+    idx_for_node_id = np.full( int(trgt_ids.max())+1, -1, dtype=int )
+    for idx,nid in enumerate(srcs_ids):
+        idx_for_node_id [int(nid)] = np.where( trgt_ids==nid )[0][0]
+
+    lcl_vals = np.zeros_like( srcs_vals )
+    #lcl_i = np.zeros_like( trgt_ids )
+    for i,nid in enumerate( srcs_ids ):
+        lcl_vals[ idx_for_node_id[nid] ] = srcs_vals[i]
+        #lcl_i[ idx_for_node_id[nid] ] = nid
+
+    return lcl_vals
+
+
+
+
+if __name__ == '__main__':
+    #fname = 'RUBBER_SEAL_IMPDISP_GEOM_001.vtk'
+    fname = 'test.vtk'
+    #fname = 'test2.vtk'
+    #fname = 'test2_us.vtk'
+
+    required_part_id = 3
+    node_data_names = [ 'NODE_ID' ]
+    el_data_names = [ 'ELEMENT_ID' ]
+
+    print_mesh_data( fname )
+
+    node_data, el_data = \
+           read_part_mesh( fname, required_part_id,
+                           node_data_names = node_data_names,
+                           el_data_names = el_data_names )
+
+    print( '****** NODAL' )
+    print( 'coords:\n', node_data['coords'] )
+    print( 'node_data:\n', node_data['data'])
+
+    print( '****** ELEMENTS' )
+    #print( 'conns:\n', el_data['conns'] )
+    #print( 'cell_conns:\n', el_data['cell_conns'] )
+    for i,e_type in enumerate( el_data['types'] ):
+        co = el_data['cell_conn_offset']
+        num_node = el_props[ e_type ].num_node
+        #print( e_type, co[i], el_data['cell_conns'][ co[i]:co[i]+num_node ] )
+        print( e_type, el_data['cell_conns'][ co[i]:co[i]+num_node ] )
+    print( 'data:\n', el_data['data'] )
+

simnexus/__init__.py

@@ -0,0 +1,5 @@
+__version__ = '0.1.0'
+
+import logging
+logging.getLogger(__name__).addHandler(logging.NullHandler())
+

simnexus/actions.py

@@ -0,0 +1,250 @@
+import os
+from abc import ABC, abstractmethod
+import pandas
+import numpy as np
+
+from simnexus.args import EvalType
+
+import logging
+logger = logging.getLogger(__name__)
+
+from abc import ABC, abstractmethod
+
+from simnexus.util.observer import Subject, notify_observers
+
+from simnexus.variables import Variable
+
+
+class WorkAction(Subject):
+    """
+    Base class for the nodes in the graph.
+    Each action encapsulate an operations on the data stream.
+
+    args:
+        name (str) :
+        cmd (str) :
+        copy_paths (list) : List of file and directories to be copied to work area.
+        lower_bound (float) : Lower bound on output value during design
+        upper_bound (float) : Lower bound on output value during design
+    Returns:
+        Any: outcome of operation
+    """
+
+    def __init__( self, name, cmd=None, copy_paths=[], lower_bound=None, upper_bound=None,
+                  description=None, data_type = EvalType.NOT_SPECIFIED ):
+        """
+        """
+        super().__init__()
+        self.name = name
+        self.cmd = cmd          # backward compatible with simulation
+        self.copy_paths = copy_paths
+        self.upper_bound = upper_bound # backward compatible with simulation
+        self.lower_bound = lower_bound # backward compatible with simulation
+        self.parent = None # typically workflow
+        self.description = description if description is not None else (
+            self.__class__.__doc__.strip() if self.__class__.__doc__ else ""
+        )
+
+        self._results = None
+
+        self.data_type = data_type
+        self._par_dict = {}
+
+    def _collect_arg_pars(self ):
+        self._par_dict = {}
+        for k,v in self.__dict__.items():
+            if isinstance(v, Variable ):
+                self._par_dict[k] = v
+                self.__dict__[k] = v.value
+
+
+    def _set_arg_pars(self, val_dict ):
+
+        for k,v in self._par_dict.items():
+            #breakpoint()
+            if v.name in val_dict:
+                self.__dict__[k] = val_dict[v.name]
+
+    def allow_variables_as_arguments( func ):
+        """ A decorator for the __init__() method allowing you to
+        use variables as arguments constructing this class.
+
+        The  arguments to a class can be declared to be variables,
+        e.g. Action( name=, cmd=, arg1=FloatVariable( 'E', 123.4 ) )
+        to be used as action.solve( {'E':3.} )
+        This requires that the subclass must used the decorators
+        allow_variables_as_arguments and
+        assign_variables_values_to_members as:
+
+        @WorkAction.allow_variables_as_arguments
+
+        def __init__( self, name, cmd=None, v=None ):
+            ...
+
+        @WorkAction.assign_variables_values_to_members
+
+        def solve(self,  val_dict=None ):
+            ...
+                    
+        Child actions are created with the variables.
+
+        You cannot do computations with the variables in
+        __init__() because the values are only set at the end.
+        """
+        def wrapper( self, *args, **kwargs ):
+            v = func( self, *args, **kwargs )
+            self._collect_arg_pars() 
+            return v
+        return wrapper
+
+    def assign_variables_values_to_members( func ):
+        """ A decorator for the solve() method allowing you to
+        use variables as arguments constructing this class."""
+        def wrapper( self, val_dict ):
+            self._set_arg_pars( val_dict )
+            v = func( self, val_dict )
+            return v
+        return wrapper
+
+
+    def _reset_class_member_vals(self,  val_dict):
+        """
+        Reset values of 'action_name.member' in class. val_dict can be {'img_extraction.zoom': 12.3} and
+        if the class hass a member 'zoom' then that will be reset to 12.3
+
+        OUTDATED: use allow_variables_as_arguments and assign_variables_values_to_members decorators
+        """
+        if val_dict is None: return
+        needle = self.name+'.'
+        for variable_name in val_dict:
+            if needle in variable_name and variable_name.rfind( needle ) == 0:
+                subkey = variable_name.replace( needle, '' )
+                if subkey in self.__dict__:
+                    self.__dict__[  subkey] = val_dict[variable_name]
+                else:
+                    exit( f' *** ERROR Key \'{variable_name}\' not found in action \'{self.name}\' ' )
+
+
+    #@notify_observers
+    def _observed_eval(self,  val_dict=None ):
+        """
+        used by the call graph to check if jobs have finished
+
+        returns:
+            dict : { self.name:..., .... } # including items in val_dict
+        """
+        self._results =  val_dict.copy()
+        e = self.solve( val_dict )
+        self._results[self.name] = e
+        self._notify_observers( [self, 'Done'] )
+        return self._results 
+
+    def _observed_eval_async(self, val_dict=None):
+        import multiprocessing
+        import threading
+
+        """
+        Asynchronously run solve in a separate process.
+        Notifies observers only when the process finishes.
+        """
+        def eval_worker(val_dict, result_dict):
+            e = self.solve(val_dict)
+            result_dict[self.name] = e
+
+        def watcher(proc, result_dict):
+            proc.join()
+            # Update self._results in the main process
+            self._results = dict(result_dict)
+            self._notify_observers([self, 'Done'])
+
+        manager = multiprocessing.Manager()
+        result_dict = manager.dict(val_dict.copy() if val_dict else {})
+        p = multiprocessing.Process(target=eval_worker, args=(val_dict, result_dict))
+        p.start()
+        # Start watcher thread to notify when done
+        t = threading.Thread(target=watcher, args=(p, result_dict), daemon=True)
+        t.start()
+        # Return immediately, results will be set when done
+        return None
+
+    @abstractmethod
+    def solve(self,  val_dict: dict = None ) -> dict:
+        """
+        Solve/compute for action or graph.
+        An action will return any computed results.
+
+        A graph will append any computed results to
+        val_dict and return that. 
+        So A.solve( {'v1':1.2} ) may return {'v1':1.2, 'A':3.4},
+        where the 'A':3.4 was added with 'A' the name of the action.
+
+        Arguments:
+            val_dict (dict) : variable values and input of any type.
+        Returns:
+            dict : dict with all results and inputs
+        """
+        assert 0, 'should not be called'
+
+    def variables( self ):
+        """
+        These are the variabls defined for the WorkAction
+        and used in the solve() method.
+        For a graph this would be the variables used in
+        all the children.
+
+        Returns:
+            set : Set of type Variable.
+        """
+        var_set = { v for k,v in self._par_dict.items() }
+        return var_set
+
+    def results(self):
+        return self._results
+
+    def _dump(self,  val_dict=None ):
+        pass
+
+    def outputs(self):
+        """
+        Returns the output type and description of this action.
+
+        Returns:
+            tuple: (data_type, description)
+        """
+        return (self.data_type, self.description)
+
+    def _check_names( self, name_list=[] ):
+        """ Cannot have duplicates -- create a problem with callbacks """
+        if self.name in name_list: exit( f" *** Error Duplicate actions name \'{self.name}\'" )
+        name_list.append( self.name )
+
+    def __str__(self ):
+        r = f'WorkAction: \'{self.name}\' {type(self)}' 
+        return r
+
+
+class MathEvaluation(WorkAction):
+    """
+    Mathematical operation on results.
+
+    args:
+        name (str) :
+        cmd (str) :
+    Returns:
+        Any: outcome of operation
+    """
+
+    #def __init__( self, name, cmd ):
+    #    super().__init__(name, cmd )
+
+    def solve(self,  val_dict=None ):
+        try:
+            v = eval( self.cmd, None, val_dict )
+        except NameError as err:
+            exit( f' *** Could not evaluate action \'{self.name}\'. Error is \'{err}\'. Either a named action was not defined or have not finished.' )
+        except Exception as err:
+            exit( f' *** Error in MathEvaluation \'{self.name}\'. {err}' )
+        return v
+
+
+

simnexus/args.py

@@ -0,0 +1,56 @@
+
+from enum import Enum, Flag, auto
+from collections import namedtuple
+
+class JobType(Flag):
+    """ OpenFOAM job execution stages """
+    CREATE_MESH = auto()
+    RUN_SIMULATION = auto()
+    POST_PRO = auto()
+    EXTRACT_VTK = auto()
+
+class EvalType(Flag):
+    """ Can be multiple types. Use 'if EvalType.NUMERICAL in self.type:' """
+    NOT_SPECIFIED = auto()  
+    FLOAT = auto()  
+    NUMERICAL = auto()  # float or numpy array
+    FILE = auto()
+    IMAGE = auto()
+
+class Location(Enum):
+    UNKNOWN = 1
+    CELL = 2
+    NODAL = 3
+
+class OptType(Enum):
+    LOCAL_W_GRAD = 1
+    RESTART_LOCAL_W_GRAD= 2
+    DIRECT = 3
+    BRUTE = 4
+
+class MetaType(Enum):
+    LINEAR = 1
+    MLP = 2
+
+class ImgComparison(Enum):
+    PHASH = 1
+    HU_MOMENTS = 2
+    HAUSDORFF = 3
+    PROCRUSTE = 4
+
+    
+OptPar = namedtuple('OptPar', ['step_size', 'epochs', 'alg'],   # epochs should be deleted
+                               defaults=(0.1, 1, OptType.RESTART_LOCAL_W_GRAD) ) 
+
+MetaPar = namedtuple('MetaPar', ['doe_type', 'num_sample', 'factorial_order', 'meta_type' ],
+                               defaults=('lhd', 0, 3, MetaType.MLP ) ) 
+
+DesPar = namedtuple('DesPar', ['obj_func', 'start', 'var_bounds', ],
+                               defaults=(None, None, None ) ) 
+
+RADIOSS_DFLT_FNAME = 'radioss_simnexus_file.k'
+OPT_RESULTS_DIR = 'OptimizationResults'
+ACTIONS_OUTPUT_PATH = 'actions_output.pkl'
+
+DYNA_DFLT_CMD  = 'ls-dyna'
+DYNA_BASE_FILE_NAME = 'dyna_action_inp'