def quad_mesh(self, curves): if isinstance(curves[0], Curve): curve_list = ' '.join(str(x.mentat_id) for x in curves) else: curve_list = ' '.join(str(x) for x in curves) pm.py_send('*overlay_mesh', curve_list) pm.py_send('#')
def __exit__(self, H_type, H_value, H_traceback): if self.quitmentat: pm.py_send("*quit yes") self.connection = False if self.disconnect: pm.py_disconnect() self.connection = False
def quad_mesh(self, curves, *args, **kwargs): if isinstance(curves[0], Curve): curve_list = ' '.join(str(x.mentat_id) for x in curves) else: curve_list = ' '.join(str(x) for x in curves) n1 = pm.py_get_int('max_element_id()') pm.py_send('*af_planar_quadmesh %s #' % curve_list) self.options = {} for key, value in kwargs.items(): self.options[key] = value try: element_set = self.options['membership'] #end = ' #' n2 = pm.py_get_int('max_element_id()') #elements = list(range(n1+1,n2+1)) #elem = ' '.join(str(x) for x in elements) elem = str(n1) + ' to ' + str(n2) mentat_command = ' '.join(['*store_elements', element_set, elem]) pm.py_send(mentat_command) except: pass
def create_nodes(template) -> None: """Create a 2D node grid on the xy-plane Parameters ---------- template The unit template parameters """ # Initialisations y = 0 z = 0 # Loop through the nodes in the y-direction for _ in range(0, template.y_n): # Initialise the x-coordinate x = 0 # Loop through the nodes in the x-direction for _ in range(0, template.x_n): # Add the node py_send("*add_nodes {} {} {}".format(x, y, z)) # Increment the x-coordinate x = x + template.e_s # Increment the y-coordinate y = y + template.e_s return
def sweep_all() -> None: """Merge all overlapping nodes """ py_send("*sweep_all") return
def tri_mesh(self, curves): if isinstance(curves[0], Curve): curve_list = ' '.join(str(x.mentat_id) for x in curves) else: curve_list = ' '.join(str(x) for x in curves) pm.py_send('*dt_planar_trimesh', curve_list) pm.py_send('#')
def view_bc() -> None: """Display all boundary conditions """ py_send("*identify_applys") py_send("*redraw") return
def _get_nset_entries(self): pm.py_send('*remove_sets ntemp') pm.py_send('*store_nodes ntemp all_selected') n = pm.py_get_int('nsets()') k = pm.py_get_int('nset_entries(%d)' % n) #pm.py_send('*remove_set_entries ntemp all_existing') return k
def submit(self): self.joblist = [] njobs = pm.py_get_int('njobs()') for j in range(njobs): joblabel = pm.py_get_string('job_name_index(%d)' % j) self.joblist.append(joblabel) self.mentat_id = self.joblist.index(self.label) + 1 pm.py_send('*submit_job %d' % self.mentat_id) # % *monitor_job
def tomentat(self): #reset model pm.py_send("*new_model") pm.py_send("yes") for o in self.objects: o.tomentat()
def add_geom_prop() -> None: """Add plane strain geometrical properties """ py_send("*geometry_type mech_planar_pstrain") py_send("*add_geometry_elements all_existing") return
def add_elements(self, elements): self.elements = elements pm.py_send('*edit_mater %s' % self.label) if type(self.elements) == str: n = self.elements else: n = ' '.join(str(a) for a in self.elements) + ' #' pm.py_send('*add_mater_elements %s' % n)
def add_nodes(self, nodes): self.nodes = nodes pm.py_send('*edit_apply %s' % self.label) if type(self.nodes) == str: n = self.nodes else: n = ' '.join(str(a) for a in self.nodes) + ' #' pm.py_send('*add_apply_nodes %s' % n)
def outMentat(cmd,locals): if cmd[0:3] == '(!)': exec(cmd[3:]) elif cmd[0:3] == '(?)': cmd = eval(cmd[3:]) py_mentat.py_send(cmd) if 'log' in locals: locals['log'].append(cmd) else: py_mentat.py_send(cmd) if 'log' in locals: locals['log'].append(cmd) return
def outMentat(cmd, locals): if cmd[0:3] == '(!)': exec(cmd[3:]) elif cmd[0:3] == '(?)': cmd = eval(cmd[3:]) py_mentat.py_send(cmd) if 'log' in locals: locals['log'].append(cmd) else: py_mentat.py_send(cmd) if 'log' in locals: locals['log'].append(cmd) return
def open_model(fp_id: str) -> None: """Open a model Parameters ---------- fp_id : str The complete file path of the model to be opened """ py_send(r'*open_model "{}"'.format(fp_id)) return
def rem_bc(bc: str) -> None: """Remove a selected boundary condition Parameters ---------- bc : str The name of the boundary condition """ py_send("*edit_apply {}".format(bc)) py_send("*remove_current_apply") return
def save_model(fp_id: str) -> None: """Save a model Parameters ---------- fp_id : str The complete file path of the model to be saved """ py_send("*set_save_formatted off") py_send(r'*save_as_model "{}" yes'.format(fp_id)) return
def quad_tri_mesh(self, curves, max_quad_distortion=0.9, *args, **kwargs): if isinstance(curves[0], Curve): curve_list = ' '.join(str(x.mentat_id) for x in curves) else: curve_list = ' '.join(str(x) for x in curves) n1 = pm.py_get_int('max_element_id()') pm.py_send('*af_set_max_quad_distortion', str(max_quad_distortion)) pm.py_send('*af_planar_quad_trimesh', curve_list) pm.py_send('#') self.options = {} for key, value in kwargs.items(): self.options[key] = value try: element_set = self.options['membership'] end = ' #' n2 = pm.py_get_int('max_element_id()') elements = list(range(n1 + 1, n2 + 1)) elem = ' '.join(str(x) for x in elements) mentat_command = ' '.join( ['*store_elements', element_set, elem, end]) pm.py_send(mentat_command) except: pass
def tomentat(self): pm.py_send('*new_md_table 1 1') pm.py_send('*table_name', self.label) pm.py_send('*set_md_table_type 1', self.category) for point in self.points: p = ' '.join(str(coord) for coord in point) pm.py_send('*table_add', p)
def select(self, objects='Nodes', coordinates=None, distance=None, only=None, clear=False, reset=False): if distance is not None: self.distance = distance if coordinates is not None: self.coordinates = coordinates if only is not None: self.only = only x, y, z = self.coordinates if clear: self.clear() if reset: self.reset() pm.py_send('*select_method_point_dist') pm.py_send('*set_select_distance', str(self.distance)) if only is not None: pm.py_send('*select_filter_%s' % str(only).lower()) pm.py_send('*select_%s %s %s %s' % (objects.lower(), x, y, z))
def rem_connect( template, grid: list, ) -> None: """Remove diagonal connections between internal elements Parameters ---------- template : template The unit template parameters grid : list The representative grid """ # Initialisations n_new = template.n_n # Find the diagonally connected element pairs dp_p, dp_n = rep_grid.find_dia(template, grid) # Loop through the list of element pairs connected diagonally in the positive direction for i in dp_p: # Calculate the x- and y-coordinates of the connecting node x = template.e_s * (i[1] % template.y_e - 1) y = template.e_s * (i[1] // template.x_e) # Add the new node py_send("*add_nodes {} {} 0".format(x, y)) # Increment the new node ID n_new += 1 # Calculate the node ID of the connecting node n = template.x_n * (i[1] // template.x_e) + (i[1] % template.y_e) # Edit the top right element's bottom left node py_send("*edit_elements {}\n {}\n {}\n".format(i[1], n, n_new)) # Loop through the list of element pairs connected diagonally in the negative direction for i in dp_n: # Calculate the x- and y-coordinates of the connecting node x = template.e_s * (i[1] % template.y_e) y = template.e_s * (i[1] // template.x_e) # Add the new node py_send("*add_nodes {} {} 0".format(x, y)) # Increment the new node ID n_new += 1 # Calculate the node ID of the connecting node n = template.x_n * (i[1] // template.x_e) + (i[1] % template.y_e + 1) # Edit the top left element's bottom right node py_send("*edit_elements {}\n {}\n {}\n".format(i[1], n, n_new)) return
def select(self, centroid, nnodes, search_distance=1000, factor=0.5, increase=1.2, axes=[0, 1, 2], extend=False, only=None, clear=False, reset=False): pm.py_echo(0) di = search_distance ni = nnodes + 1 #n_tol = 50 # shrink range to smaller limit #print('ni, nnodes, di', ni, nnodes, di) while factor <= 0.99: while ni > nnodes: self.PD.select(coordinates=np.array(centroid), distance=di, only=only, clear=True, reset=True) ni = self._get_nset_entries() #print('search distance / number nodes / factor (loop):', di, ni, factor) if ni <= nnodes: # or ni <= n_tol break else: d = di di = di * factor ni = nnodes + 1 di = d factor = factor * increase self.PD.select(coordinates=centroid, distance=d, only=only, clear=True, reset=True) n = self._get_nset_entries() #print('search distance / number nodes:', d, n) nodes = self._get_set_entry_list(centroid, nnodes, extend, axes) pm.py_send('*remove_sets ntemp') nodelist = ' '.join(str(x) for x in nodes) pm.py_send('*select_clear_nodes') pm.py_send('*select_reset') pm.py_send('*select_nodes %s #' % nodelist) pm.py_echo(1)
def copy_neighbours(template) -> None: """Surround the current grid with copies of itself Parameters ---------- template The unit template parameters """ # Initialisations x = [ -2 * template.x_s, -template.x_s, 0, template.x_s, 2 * template.x_s, ] y = [ -2 * template.y_s, -template.y_s, 0, template.y_s, 2 * template.y_s, ] n_l = ["n:{}".format(i) for i in range(1, template.n_n + 1)] e_l = ["e:{}".format(i) for i in range(1, template.n_e + 1)] n_l = utility.list_to_str(n_l, " ") e_l = utility.list_to_str(e_l, " ") l = utility.list_to_str([n_l, e_l], " ") # Loop through all y-axis initial coordinates for i in y: # Loop through all x-axis initial coordinates for j in x: # Check if the starting coordinates are the original grid's if i == 0 and j == 0: # Skip this step in the loop continue # Set the origin coordinates of the copy py_send("*set_duplicate_translation x {}".format(j)) py_send("*set_duplicate_translation y {}".format(i)) # Copy the grid py_send("*duplicate_combined") py_send("{} #".format(l)) # Clear all duplicate nodes sweep_neighbours(template) return
def tomentat(self): x,y,z = self.coordinates pm.py_send("*add_nodes %f %f %f" % (x,y,z)) mentat_id = pm.py_get_int('max_node_id()') try: node_set = self.options['membership'] end = ' #' mentat_command = ' '.join(['*store_nodes', node_set, str(mentat_id), end]) pm.py_send(mentat_command) except: pass self.mentat_id = mentat_id
def add_contact_body() -> None: """Add a contact body """ py_send("*new_cbody mesh") py_send("*contact_option state:solid") py_send("*contact_option skip_structural:off") py_send("*add_contact_body_elements all_existing") return
def __enter__(self): if self.killmentat: PROCNAME = "mentatOGL.exe" for proc in psutil.process_iter(): # check whether the process name matches if proc.name() == PROCNAME: proc.kill() if self.startmentat: # connect to mentat #if self.background: # CREATE_NO_WINDOW = 0x08000000 # si = subprocess.STARTUPINFO() # si.dwFlags |= subprocess.STARTF_USESHOWWINDOW #else: # CREATE_NO_WINDOW = 0 # si = None subprocess.Popen(r' '.join(self.callmentat), stdout=subprocess.PIPE, stderr=subprocess.PIPE) #, #startupinfo = si) #creationflags=CREATE_NO_WINDOW) #, stdout=subprocess.PIPE #out,err = p.communicate() while True: try: pm.py_connect("127.0.0.1", 40007) # test connection pm.py_send("test connection") break except: time.sleep(0.25) self.connection = True elif not self.startmentat and not self.connection: pm.py_connect("127.0.0.1", 40007) self.connection = True return self
def tomentat(self): pm.py_send('*prog_use_current_job on *new_job', self.category) pm.py_send('*job_name', self.label) for lc in self.loadcases: if type(lc) == str: label = lc else: label = lc.label pm.py_send('*add_job_loadcases', label) for key, value in self.options.items(): pm.py_send('*job_option %s:%s' % (key, value))
def tomentat(self): if isinstance(self.connectivity[0], Node): conns = ' '.join(str(x.mentat_id) for x in self.connectivity) else: conns = ' '.join(str(x) for x in self.connectivity) cdict = {'Hex (8)': 'hex8', 'Quad (4)': 'quad4', 'Tria (3)': 'tria3'} pm.py_send('*set_element_class', cdict[self.category]) pm.py_send('*add_elements', conns) mentat_id = pm.py_get_int('max_element_id()') try: element_set = self.options['membership'] end = ' #' mentat_command = ' '.join( ['*store_elements', element_set, str(mentat_id), end]) pm.py_send(mentat_command) except: pass self.mentat_id = mentat_id
def subdivide(self,elements,objects='Elements', divisions=[2,2,2], bias_factors=[0,0,0]): self.divisions = divisions self.bias_factors = bias_factors xi = ['u','v','w'] for x,v in zip(xi,self.divisions): pm.py_send('*sub_uvwdiv %s %s' % (x, str(v))) for x,v in zip(xi,self.bias_factors): pm.py_send('*sub_bias_uvwfactors %s %s' % (x, str(v))) sdict = {'Elements':'elements', 'Curves':'curves_real'} if type(elements)!=str: if isinstance(elements[0],Element): element_list = ' '.join(str(x.mentat_id) for x in elements) else: element_list = ' '.join(str(x) for x in elements) else: element_list = elements subdivide_command = '*subdivide_'+sdict[objects]+' '+element_list pm.py_send(subdivide_command)
def new(self, label, node, tied_nodes, dof): if isinstance(tied_nodes[0], Node): tnodes = ' '.join(str(x.mentat_id) for x in tied_nodes) elif tied_nodes[0].lower() == 'next': options = { 'only': 'Surface', 'clear': True, 'reset': True, 'extend': True, 'axes': [0, 1, 2] } if len(tied_nodes) == 3: options_user = tied_nodes[-1] for k, v in options_user.items(): options[k] = v NextNodes().select(centroid=node.coordinates, nnodes=tied_nodes[1], **options) tnodes = ' all_selected' else: tnodes = ' '.join(str(x) for x in tied_nodes) tnodes = tnodes + ' #' if isinstance(node, Node): n = str(node.mentat_id) else: n = str(node) pm.py_send('*new_rbe2') pm.py_send('*rbe2_name', label) pm.py_send('*rbe2_ret_node', n) for i, d in enumerate(dof): if bool(d) is True: pm.py_send('*rbe2_tied_dof %s' % str(i + 1)) pm.py_send('*add_rbe2_tied_nodes', tnodes)