Cubit Python API 16.18
Classes
CubitInterface Namespace Reference

The CubitInterface provides a Python/C++ interface into Cubit. More...

Classes

class   AssemblyItem
  Class to implement assembly tree interface. More...
 
class   Body
  Defines a body object that mostly parallels Cubit's Body class. More...
 
class   CFD_BC_Entity
  Class to implement cfd bc data retrieval. More...
 
class   CubitFailureException
  An exception class to alert the caller when the underlying Cubit function fails. More...
 
class   Curve
  Defines a curve object that mostly parallels Cubit's RefEdge class. More...
 
class   Dir
  Defines a direction object. More...
 
class   Entity
  The base class of all the geometry and mesh types. More...
 
class   GeomEntity
  The base class for specifically the Geometry types (Body, Surface, etc.) More...
 
class   InvalidEntityException
  An exception class to alert the caller that an invalid entity was attempted to be used. Likely the user is attempting to use an Entity who's underlying CubitEntity has been deleted. More...
 
class   InvalidInputException
  An exception class to alert the caller of a function that invalid inputs were entered. More...
 
class   Loc
  Defines a location object. More...
 
class   MeshErrorFeedback
  Class to implement mesh command feedback processing. More...
 
class   Surface
  Defines a surface object that mostly parallels Cubit's RefFace class. More...
 
class   Vertex
  Defines a vertex object that mostly parallels Cubit's RefVertex class. More...
 
class   Volume
  Defines a volume object that mostly parallels Cubit's RefVolume class. More...
 

Functions

System Control and Data
void  set_progress_handler (CubitProgressHandler *progress)
  Register a progress-bar callback handler with Cubit. Deletes the current progress handler if it exists.
 
CubitProgressHandler *  replace_progress_handler (CubitProgressHandler *progress)
  Register a new progress-bar callback handler with Cubit and return the the previous progress-handler without deleting it.
 
void  set_cubit_interrupt (bool interrupt)
  This sets the global flag in Cubit that stops all interruptable processes.
 
void  set_playback_paused_on_error (bool pause)
  Sets whether or not playback is paused when an error occurs.
 
bool  is_playback_paused_on_error ()
  Gets whether or not playback is paused when an error occurs.
 
void  pause_playback ()
  Pause playback.
 
void  stop_playback ()
  Pause playback.
 
void  resume_playback ()
  resume playback.
 
bool  is_playback_paused ()
 
bool  developer_commands_are_enabled ()
  This checks to see whether developer commands are enabled.
 
CubitBaseInterface *  get_interface (std::string interface_name)
  Get the interface of a given name.
 
bool  release_interface (CubitBaseInterface *instance)
  Release the interface with the given name.
 
CubitPluginManager *  plugin_manager ()
 
void  add_filename_to_recent_file_list (std::string &filename)
  Adds the filename to the recent file list.
 
std::string  get_version ()
  Get the Cubit version.
 
std::string  get_revision_date ()
  Get the Cubit revision date.
 
std::string  get_build_number ()
  Get the Cubit build number.
 
std::string  get_acis_version ()
  Get the Acis version number.
 
int  get_acis_version_as_int ()
  Get the Acis version number as an int.
 
std::string  get_exodus_version ()
  Get the Exodus version number.
 
std::string  get_meshgems_version ()
  Get the MeshGems version number.
 
double  get_cubit_digits_setting ()
  Get the Cubit digits setting.
 
std::string  get_graphics_version ()
  Get the VTK version number.
 
std::string  get_python_version ()
  get the python version used in cubit
 
void  print_cmd_options ()
  Used to print the command line options.
 
bool  is_modified ()
  Get the modified status of the model.
 
void  set_modified ()
  Set the status of the model (is_modified() is now false). If you modify the model after you set this flag, it will register true.
 
bool  is_undo_save_needed ()
  Get the status of the model relative to undo checkpointing.
 
void  set_undo_saved ()
  Set the status of the model relative to undo checkpointin.
 
bool  is_performing_undo ()
  Check if an undo command is currently being performed.
 
bool  is_command_echoed ()
  Check the echo flag in cubit.
 
std::string  get_command_from_history (int command_number)
  Get a specific command from Cubit's command history buffer.
 
int  get_command_history_count ()
 
std::string  get_next_command_from_history ()
  Get 'next' command from history buffer.
 
std::string  get_previous_command_from_history ()
  Get 'previous' command from history buffer.
 
bool  is_volume_meshable (int volume_id)
  Check if volume is meshable with current scheme.
 
bool  is_surface_meshable (int surface_id)
  Check if surface is meshable with current scheme.
 
void  journal_commands (bool state)
  Set the journaling flag in cubit.
 
bool  is_command_journaled ()
  Check the journaling flag in cubit.
 
void  write_to_journal (std::string words)
  Write a string to the active journal.
 
void  override_journal_stream (JournalStreamBase *jnl_stream)
  Override the Journal Stream in CUBIT.
 
std::string  get_current_journal_file ()
  Gets the current journal file name.
 
bool  is_working_dir_set ()
  Create BCVizInterface for CompSimUI.
 
bool  cmd (const char *input_string)
  Pass a command string into Cubit.
 
bool  cmd_single (const char *input_string)
  Pass a command string into Cubit.
 
bool  cubit_or_python_cmd (const std::string &input_string)
 
bool  cubit_or_python_cmds (const std::vector< std::string > &input_strings, std::function< void(const std::string &)> &&history)
 
bool  cubit_or_python_cmds_as_file (const std::vector< std::string > &input_strings, std::function< void(const std::string &)> &&history)
 
bool  command_is_python_mode ()
  Gets whether command handling is in python mode.
 
bool  silent_cmd (const char *input_string)
  Pass a command string into Cubit and have it executed without being verbose at the command prompt.
 
bool  was_last_cmd_undoable ()
  Report whether the last executed command was undoable.
 
std::vector< int >  parse_cubit_list (const std::string &type, std::string entity_list_string)
  Parse a Cubit style entity list into a list of integers.
 
std::vector< std::array< double, 3 > >  parse_locations (const std::string &location_str)
 
std::string  string_from_id_list (std::vector< int > ids)
  Parse a list of integers into a Cubit style id list. Includes carriage return and line breaks at column 80.
 
std::string  get_id_string (const std::vector< int > &entity_ids)
  Parse a list of integers into a Cubit style id list. Return string will not include carriage returns or line break.
 
void  print_raw_help (const char *input_line, int order_dependent, int consecutive_dependent)
  Used to print out help when a ?, & or ! is pressed.
 
int  get_error_count ()
  Get the number of errors in the current Cubit session.
 
std::vector< std::string >  get_mesh_error_solutions (int error_code)
  Get the paired list of mesh error solutions and help context cues.
 
void  complete_filename (std::string &line, int &num_chars, bool &found_quote)
  Get the file completion inside a quote based on files in the current directory. This handles completion of directories as well as filtering on specific types (.jou, .g, .sat, etc.)
 
Graphics Manipulation and Data
double  get_view_distance ()
  Get the distance from the camera to the model (from - at)
 
std::array< double, 3 >  get_view_at ()
  Get the camera 'at' point.
 
std::array< double, 3 >  get_view_from ()
  Get the camera 'from' point.
 
std::array< double, 3 >  get_view_up ()
  Get the camera 'up' direction.
 
void  reset_camera ()
  reset the camera in all open windows this includes resetting the view, closing the histogram and color windows and clearing the scalar bar, highlight, and picked entities.
 
void  flush_graphics ()
  Flush the graphics.
 
void  clear_drawing_set (const std::string &set_name)
  Clear a named drawing set (this is for mesh preview)
 
void  unselect_entity (const std::string &entity_type, int entity_id)
  Unselect an entity that is currently selected.
 
int  get_rubberband_shape ()
  Get the current rubberband select mode.
 
bool  is_perspective_on ()
  Get the current perspective mode.
 
bool  is_occlusion_on ()
  Get the current occlusion mode.
 
bool  is_scale_visibility_on ()
  Get the current scale visibility setting.
 
bool  is_mesh_visibility_on ()
  Get the current mesh visibility setting.
 
bool  is_geometry_visibility_on ()
  Get the current geometry visibility setting.
 
bool  is_select_partial_on ()
  Get the current select partial setting.
 
int  get_rendering_mode ()
  Get the current rendering mode.
 
void  set_rendering_mode (int mode)
  Set the current rendering mode.
 
void  clear_highlight ()
  Clear all entity highlights.
 
void  clear_preview ()
  Clear preview graphics without affecting other display settings.
 
void  highlight (const std::string &entity_type, int entity_id)
  Highlight the given entity.
 
std::vector< int >  get_selected_ids ()
  Get a list of the currently selected ids.
 
int  get_selected_id (int index)
  Get the selected id based on an index.
 
std::string  get_selected_type (int index)
  Get the selected type based on an index.
 
const char *  get_pick_type ()
  Get the current pick type.
 
void  set_pick_type (const std::string &pick_type, bool silent=false)
  Set the pick type.
 
void  set_filter_types (int num_types, const std::vector< std::string > filter_types)
  Set the pick filter types.
 
void  add_filter_type (const std::string &filter_type)
  Add a filter type.
 
void  remove_filter_type (const std::string &filter_type)
  Remove a filter type.
 
bool  is_type_filtered (const std::string &filter_type)
  Determine whether a type is filtered.
 
std::vector< std::string >  get_pick_filters ()
  Get a list of the current pick filters.
 
void  clear_picked_list ()
  Clear the picked list.
 
void  step_next_possible_selection ()
  Step to the next possible selection (selected next dialog)
 
void  step_previous_possible_selection ()
  Step to the previous possible selection (selected next dialog)
 
void  print_current_selections ()
  Print the current selections.
 
void  print_currently_selected_entity ()
  Print the current selection.
 
int  current_selection_count ()
  Get the current count of selected items.
 
Mesh Query Support
double  get_mesh_edge_length (int edge_id)
  Get the length of a mesh edge.
 
double  get_meshed_volume_or_area (const std::string &geometry_type, std::vector< int > entity_ids)
  Get the total volume/area of a entity's mesh.
 
int  get_mesh_intervals (const std::string &geometry_type, int entity_id)
  Get the interval count for a specified entity.
 
double  get_mesh_size (const std::string &geometry_type, int entity_id)
  Get the mesh size for a specified entity.
 
double  get_requested_mesh_size (const std::string &geometry_type, int id)
  Get the requested mesh size for a specified entity. This returns a size that has been set specifically on the entity and not averaged from parents.
 
int  has_valid_size (const std::string &geometry_type, int entity_id)
  Get whether an entity has a size. All entities have a size unless the auto sizing is off. If the auto sizing is off, an entity has a size only if it has been set.
 
bool  auto_size_needs_to_be_calculated ()
  Get whether the auto size needs to be calculated. Calculating the auto size may be expensive on complex models. The auto size may be outdated if the model has changed.
 
double  get_default_auto_size ()
  Get auto size needs for the current set of geometry.
 
int  get_requested_mesh_intervals (const std::string &geometry_type, int entity_id)
  Get the interval count for a specified entity as set specifically on that entity.
 
double  get_auto_size (const std::string &geometry_type, std::vector< int > entity_id_list, double size)
  Get the auto size for a given set of enitities. Note, this does not actually set the interval size on the volumes. It simply returns the size that would be set if an 'size auto factor n' command were issued.
 
int  get_element_budget (const std::string &element_type, std::vector< int > entity_id_list, int auto_factor)
  Get the element budget based on current size settings for a list of volumes.
 
std::string  get_exodus_sizing_function_variable_name ()
  Get the exodus sizing function variable name.
 
std::string  get_exodus_sizing_function_file_name ()
  Get the exodus sizing function file name.
 
std::string  get_sizing_function_name (const std::string &entity_type, int surface_id)
  Get the sizing function name for a surface or volume.
 
bool  exodus_sizing_function_file_exists ()
  return whether the exodus sizing funnction file exists
 
bool  get_vol_sphere_params (std::vector< int > sphere_id_list, int &rad_intervals, int &az_intervals, double &bias, double &fract, int &max_smooth_iterations)
  get the current sphere parameters for a sphere volume
 
std::string  get_curve_bias_type (int curve_id)
 
double  get_curve_bias_geometric_factor (int curve_id)
 
double  get_curve_bias_geometric_factor2 (int curve_id)
 
double  get_curve_bias_first_interval_length (int curve_id)
 
double  get_curve_bias_first_interval_fraction (int curve_id)
 
double  get_curve_bias_fine_size (int curve_id)
 
double  get_curve_bias_coarse_size (int curve_id)
 
double  get_curve_bias_first_last_ratio1 (int curve_id)
 
double  get_curve_bias_first_last_ratio2 (int curve_id)
 
double  get_curve_bias_last_first_ratio1 (int curve_id)
 
double  get_curve_bias_last_first_ratio2 (int curve_id)
 
bool  get_curve_bias_from_start (int curve_id, bool &value)
 
bool  get_curve_bias_from_start_set (int curve_id)
 
int  get_curve_bias_start_vertex_id (int curve_id)
 
double  get_curve_mesh_scheme_curvature (int curve_id)
  Get the curvature mesh scheme value of a curve.
 
bool  get_curve_mesh_scheme_stretch_values (int curve_id, double &first_size, double &factor, double &last_size, bool &start, int &vertex_id)
 
std::vector< double >  get_curve_mesh_scheme_pinpoint_locations (int curve_id)
 
void  get_quality_stats (const std::string &entity_type, std::vector< int > id_list, const std::string &metric_name, double single_threshold, bool use_low_threshold, double low_threshold, double high_threshold, double &min_value, double &max_value, double &mean_value, double &std_value, int &min_element_id, int &max_element_id, std::vector< int > &mesh_list, std::string &element_type, int &bad_group_id, bool make_group=false)
  Get the quality stats for a specified entity.
 
std::vector< double >  get_elem_quality_stats (const std::string &entity_type, const std::vector< int > id_list, const std::string &metric_name, const double single_threshold, const bool use_low_threshold, const double low_threshold, const double high_threshold, const bool make_group)
  python callable version of the get_quality_stats without pass by reference arguments. All return values are stuffed into a double array
 
std::vector< double >  get_quality_stats_at_geometry (const std::string &geom_type, const std::string &mesh_type, const std::vector< int > geom_id_list, const int expand_levels, const std::string &metric_name, const double single_threshold, const bool use_low_threshold, const double low_threshold, const double high_threshold, const bool make_group)
  get element quality at a list of geometry entities. Finds all elements with nodes ON/IN the specified geometry and finds the quality of all elements of the specfied element type that are connected. Same arguments and return values as get_elem_quality_stats except a geometry and element type are used as arguments
 
double  get_quality_value (const std::string &mesh_type, int mesh_id, const std::string &metric_name)
  Get the metric value for a specified mesh entity.
 
std::vector< double >  get_quality_values (const std::string &mesh_type, std::vector< int > mesh_ids, const std::string &metric_name)
  Get the metric values for specified mesh entities.
 
std::string  get_mesh_scheme (const std::string &geometry_type, int entity_id)
  Get the mesh scheme for the specified entity.
 
std::string  get_mesh_scheme_firmness (const std::string &geometry_type, int entity_id)
  Get the mesh scheme firmness for the specified entity.
 
std::string  get_mesh_interval_firmness (const std::string &geometry_type, int entity_id)
  Get the mesh interval firmness for the specified entity. This may include influence from connected mesh intervals on connected geometry.
 
std::string  get_requested_mesh_interval_firmness (const std::string &geometry_type, int entity_id)
  Get the mesh interval firmness for the specified entity as set specifically on the entity.
 
std::string  get_mesh_size_type (const std::string &geometry_type, int entity_id)
  Get the mesh size setting type for the specified entity. This may include influence from attached geometry.
 
std::string  get_requested_mesh_size_type (const std::string &geometry_type, int entity_id)
  Get the mesh size setting type for the specified entity as set specifically on the entity.
 
bool  get_tetmesh_proximity_flag (int volume_id)
  Get the proximity flag for tet meshing.
 
int  get_tetmesh_proximity_layers (int volume_id)
  Get the number of proximity layers for tet meshing. This is the number of layers between close surfaces.
 
double  get_tetmesh_growth_factor (int volume_id)
  Get the tetmesh growth factor.
 
bool  get_tetmesh_parallel ()
  Get the parallel flag for tet meshing. Defines whether to use parallel mesher.
 
int  get_tetmesh_num_anisotropic_layers ()
  Get the number of anisotropic tet layers. Global setting.
 
int  get_tetmesh_optimization_level ()
  Get the optimization level for tetmeshing. Global setting.
 
bool  get_tetmesh_insert_mid_nodes ()
  Get the state of the flag to insert midnodes during meshing. Global setting.
 
bool  get_tetmesh_optimize_mid_nodes ()
  Get the state of the flag to optimize midnodes during meshing. Global setting.
 
bool  get_tetmesh_optimize_overconstrained_tets ()
  Get the state of the flag to optimize overconstrained tets. Global setting.
 
bool  get_tetmesh_optimize_overconstrained_edges ()
  Get the state of the flag to optimize overconstrained edges. Global setting.
 
bool  get_tetmesh_minimize_slivers ()
  Get the state of the flag to minimize sliver tets. Global setting.
 
bool  get_tetmesh_minimize_interior_points ()
  Get the state of the flag to minimize interior points in tetmesher. Global setting.
 
bool  get_tetmesh_relax_surface_constraints ()
  Get the state of the flag to relax surface mesh constraints in tetmesher. Global setting.
 
double  get_mesh_geometry_approximation_angle (std::string geometry_type, int entity_id)
  Get the geometry approximation angle set for tri/tet meshing.
 
double  get_trimesh_surface_gradation ()
  Get the global surface mesh gradation set for meshing with MeshGems.
 
double  get_trimesh_volume_gradation ()
  Get the global volume mesh gradation set for meshing with MeshGems.
 
bool  get_trimesh_use_surface_proximity ()
  Get the global trimesh surface proximity setting with MeshGems.
 
double  get_trimesh_surface_proximity_ratio ()
  Get the global trimesh surface proximity max aspect ratio setting with MeshGems.
 
double  get_trimesh_target_min_size (std::string geom_type, int entity_id)
  Get the trimesh target min size for the entity. local setting for surfaces.
 
bool  get_trimesh_geometry_sizing ()
  Get the global geometry sizing flag for trimesher.
 
int  get_trimesh_num_anisotropic_layers ()
  Get the global number of anisotropic layers for trimeshing.
 
bool  get_trimesh_split_overconstrained_edges ()
  Get the global setting for trimesher split over-constrained edges.
 
int  best_edge_to_collapse_interior_node (int node_id)
  Finds the best edge to collapse this node along to remove the interior node.
 
double  get_trimesh_tiny_edge_length ()
  Get the global setting for tiny edge length in trimesher.
 
double  get_trimesh_ridge_angle ()
  Get the global setting for ridge angle in trimesher.
 
bool  is_meshed (const std::string &geometry_type, int entity_id)
  Determines whether a specified entity is meshed.
 
bool  is_merged (const std::string &geometry_type, int entity_id)
  Determines whether a specified entity is merged.
 
std::string  get_smooth_scheme (const std::string &geometry_type, int entity_id)
  Get the smooth scheme for a specified entity.
 
int  get_hex_count ()
  Get the count of hexes in the model.
 
int  get_pyramid_count ()
  Get the count of pyramids in the model.
 
int  get_tet_count ()
  Get the count of tets in the model.
 
int  get_quad_count ()
  Get the count of quads in the model.
 
int  get_tri_count ()
  Get the count of tris in the model.
 
int  get_edge_count ()
  Get the count of edges in the model.
 
int  get_sphere_count ()
  Get the count of sphere elements in the model.
 
int  get_wedge_count ()
  Get the count of wedge elements in the model.
 
int  get_node_count ()
  Get the count of nodes in the model.
 
int  get_element_count ()
  Get the count of elements in the model.
 
int  get_volume_element_count (int volume_id)
  Get the count of elements in a volume.
 
int  get_surface_element_count (int surface_id)
  Get the count of elements in a surface.
 
bool  volume_contains_tets (int volume_id)
  Determine whether a volume contains tets.
 
std::vector< int >  get_hex_sheet (int node_id_1, int node_id_2)
  Get the list of hex elements forming a hex sheet through the given two node ids. The nodes must be adjacent in the connectivity of the hex i.e. they form an edge of the hex.
 
std::string  get_default_element_type ()
  Get the current default setting for the element type that will be used when meshing.
 
Geometry Query Support
bool  is_visible (const std::string &geometry_type, int entity_id)
  Query visibility for a specific entity.
 
bool  is_virtual (const std::string &geometry_type, int entity_id)
  Query virtualality for a specific entity.
 
bool  contains_virtual (const std::string &geometry_type, int entity_id)
  Query virtualality of an entity's children.
 
std::vector< int >  get_source_surfaces (int volume_id)
  Get a list of a volume's sweep source surfaces.
 
std::vector< int >  get_target_surfaces (int volume_id)
  Get a list of a volume's sweep target surfaces.
 
int  get_common_curve_id (int surface_1_id, int surface_2_id)
  Given 2 surfaces, get the common curve id.
 
int  get_common_vertex_id (int curve_1_id, int curve_2_id)
  Given 2 curves, get the common vertex id.
 
std::vector< std::vector< double > >  project_unit_square (std::vector< std::vector< double > > pts, int surface_id, int quad_id, int node00_id, int node10_id)
  Given points in a unit square, map them to the given quad using the orientation info, then project them onto the given surface, and return their projected positions.
 
std::string  get_merge_setting (const std::string &geometry_type, int entity_id)
  Get the merge setting for a specified entity.
 
std::string  get_curve_type (int curve_id)
  Get the curve type for a specified curve.
 
std::string  get_surface_type (int surface_id)
  Get the surface type for a specified surface.
 
std::array< double, 3 >  get_surface_normal (int surface_id)
  Get the surface normal for a specified surface.
 
std::array< double, 3 >  get_surface_normal_at_coord (int surface_id, std::array< double, 3 >)
  Get the surface normal for a specified surface at a location.
 
std::array< double, 3 >  get_surface_centroid (int surface_id)
  Get the surface centroid for a specified surface.
 
std::string  get_surface_sense (int surface_id)
  Get the surface sense for a specified surface.
 
std::vector< std::string >  get_entity_modeler_engine (const std::string &geometry_type, int entity_id)
  Get the modeler engine type for a specified entity.
 
std::string  get_default_geometry_engine ()
  Get the name of the default modeler engine.
 
std::array< double, 10 >  get_bounding_box (const std::string &geometry_type, int entity_id)
  Get the bounding box for a specified entity.
 
std::array< double, 10 >  get_total_bounding_box (const std::string &geometry_type, std::vector< int > entity_list)
  Get the bounding box for a list of entities.
 
std::array< double, 15 >  get_tight_bounding_box (const std::string &geometry_type, std::vector< int > entity_list)
  Get the tight bounding box for a list of entities.
 
double  get_total_volume (std::vector< int > volume_list)
  Get the total volume for a list of volume ids.
 
std::string  get_entity_name (const std::string &entity_type, int entity_id, bool no_default=false)
  Get the name of a specified entity.
 
std::vector< std::string >  get_entity_names (const std::string &entity_type, int entity_id, bool no_default=false, bool first_name_only=false)
  same as get_entity_name but includes all name attributes set on the entity, not just the first one (unless first_name_only is set)
 
bool  set_entity_name (const std::string &entity_type, int entity_id, const std::string &new_name)
  Set the name of a specified entity.
 
std::array< double, 4 >  get_entity_color (const std::string &entity_type, int entity_id)
  Get the color of a specified entity.
 
int  get_entity_color_index (const std::string &entity_type, int entity_id)
 
bool  is_multi_volume (int body_id)
  Query whether a specified body is a multi volume body.
 
bool  is_sheet_body (int volume_id)
  Query whether a specified volume is a sheet body.
 
bool  is_interval_count_odd (int surface_id)
  Query whether a specified surface has an odd loop.
 
bool  is_periodic (const std::string &geometry_type, int entity_id)
  Query whether a specified surface or curve is periodic.
 
bool  is_surface_planer (int surface_id)
  Query whether a specified surface is planer.
 
bool  is_surface_planar (int surface_id)
 
void  get_periodic_data (const std::string &geometry_type, int entity_id, double &returned_interval, std::string &returned_firmness, int &returned_lower_bound, std::string &returned_upper_bound)
  Get the periodic data for a surface or curve.
 
bool  get_undo_enabled ()
  Query whether undo is currently enabled.
 
int  number_undo_commands ()
  Query whether there are any undo commands to execute.
 
std::vector< std::string >  get_aprepro_vars ()
  Gets the current aprepro variable names.
 
std::string  get_aprepro_value_as_string (std::string variable_name)
  Gets the string value of an aprepro variable.
 
bool  get_aprepro_value (std::string variable_name, int &returned_variable_type, double &returned_double_val, std::string &returned_string_val)
  Get the value of an aprepro variable.
 
double  get_aprepro_numeric_value (std::string variable_name)
  get the value of the given aprepro variable
 
bool  get_node_constraint ()
  Query current setting for node constraint (move nodes to geometry)
 
int  get_node_constraint_value ()
  Query current setting for node constraint (move nodes to geometry)
 
double  get_node_constraint_smart_threshold ()
  Query current setting for node constraint smart threshold.
 
std::string  get_node_constraint_smart_metric ()
  Query current setting for node constraint smart metric Currently only for tets. Return either "distortion" of "normalized inradius".
 
std::string  get_vertex_type (int surface_id, int vertex_id)
  Get the Vertex Types for a specified vertex on a specified surface. Vertex types include "side", "end", "reverse", "unknown".
 
std::vector< int >  get_relatives (const std::string &source_geometry_type, int source_id, const std::string &target_geom_type)
  Get the relatives (parents/children) of a specified entity.
 
std::vector< int >  get_adjacent_surfaces (const std::string &geometry_type, int entity_id)
  Get a list of adjacent surfaces to a specified entity.
 
std::vector< int >  get_adjacent_volumes (const std::string &geometry_type, int entity_id)
  Get a list of adjacent volumes to a specified entity.
 
std::vector< int >  get_entities (const std::string &entity_type)
  Get all entities of a specified type (including geometry, mesh, etc...)
 
std::vector< int >  get_list_of_free_ref_entities (const std::string &geometry_type)
  Get all free entities of a given geometry type.
 
int  get_owning_body (const std::string &geometry_type, int entity_id)
  Get the owning body for a specified entity.
 
int  get_owning_volume (const std::string &geometry_type, int entity_id)
  Get the owning volume for a specified entity.
 
int  get_owning_volume_by_name (const std::string &entity_name)
  Get the owning volume for a specified entity.
 
double  get_curve_length (int curve_id)
  Get the length of a specified curve.
 
double  get_arc_length (int curve_id)
  Get the arc length of a specified curve.
 
double  get_distance_from_curve_start (double x_coordinate, double y_coordinate, double z_coordinate, int curve_id)
  Get the distance from a point on a curve to the curve's start point.
 
double  get_curve_radius (int curve_id)
  Get the radius of a specified arc.
 
std::array< double, 3 >  get_curve_center (int curve_id)
  Get the center point of the arc.
 
double  get_surface_area (int surface_id)
  Get the area of a surface.
 
std::vector< int >  get_similar_curves (std::vector< int > curve_ids, double tol=1e-3, bool use_percent_tol=true, bool on_similar_vols=true)
  Get similar curves with the same length.
 
std::vector< int >  get_similar_surfaces (std::vector< int > surface_ids, double tol=1e-3, bool use_percent_tol=true, bool on_similar_vols=true)
  Get similar surfaces with the same area and number of curves.
 
std::vector< int >  get_connected_surfaces (std::vector< int > surf_ids)
  Get a connected set of surfaces to the ones specified.
 
std::vector< int >  get_similar_volumes (std::vector< int > volume_ids, double tol=1e-3, bool use_percent_tol=true)
  Get similar volumes with the same volume and number of faces.
 
std::vector< double >  get_surface_principal_curvatures (int surface_id)
  Get the principal curvatures of a surface at surface mid_point.
 
double  get_volume_area (int volume_id)
  Get the area of a volume.
 
double  get_volume_volume (int vol_id)
  Get the volume of a volume.
 
int  get_num_volume_shells (int volume_id)
  Get the number of shells in this volume.
 
double  get_hydraulic_radius_surface_area (int surface_id)
  Get the area of a hydraulic surface.
 
double  get_hydraulic_radius_volume_area (int volume_id)
  Get the area of a hydraulic volume.
 
std::array< double, 3 >  get_center_point (const std::string &entity_type, int entity_id)
  Get the center point of a specified entity.
 
int  get_valence (int vertex_id)
  Get the valence for a specific vertex.
 
double  get_distance_between (int vertex_id_1, int vertex_id_2)
  Get the distance between two vertices.
 
double  get_distance_between_entities (std::string geom_type_1, int entity_id_1, std::string geom_type_2, int entity_id_2)
  Get the distance between two geom entities.
 
int  is_point_contained (const std::string &geometry_type, int entity_id, const std::array< double, 3 > &xyz_point)
  Determine if given point is inside, outside, on or unknown the given entity. note that this is typically used for volumes or sheet bodies.
 
void  print_surface_summary_stats ()
  Print the surface summary stats to the console.
 
void  print_volume_summary_stats ()
  Print the volume summary stats to the console.
 
int  get_block_count ()
  Get the current number of blocks.
 
int  get_sideset_count ()
  Get the current number of sidesets.
 
int  get_nodeset_count ()
  Get the current number of sidesets.
 
int  get_volume_count ()
  Get the current number of nodesets.
 
int  get_body_count ()
  Get the current number of bodies.
 
int  get_surface_count ()
  Get the current number of surfaces.
 
int  get_vertex_count ()
  Get the current number of vertices.
 
int  get_curve_count ()
  Get the current number of curves.
 
int  get_curve_count_in_volumes (std::vector< int > target_volume_ids)
  Get the current number of curves in the passed-in volumes.
 
std::vector< int >  get_current_ids (const std::string &entity_type)
  Get the current body ids.
 
bool  is_catia_engine_available ()
  Determine whether catia engine is available.
 
bool  is_acis_engine_available ()
 
bool  is_opencascade_engine_available ()
 
std::vector< int >  evaluate_exterior_angle (const std::vector< int > &curve_list, const double test_angle)
  find all curves in the given list with an exterior angle (the angle between surfaces) less than the test angle. This is equivalent to the df parser "exterior_angle" test. (draw curve with exterior_angle >90)
 
double  evaluate_exterior_angle_at_curve (int curve_id, int volume_id)
  return exterior angle at a single curve with respect to a volume
 
double  evaluate_surface_angle_at_vertex (int surf_id, int vert_id)
  return interior angle at a vertex on a specified surface
 
double  get_overlap_max_gap (void)
  Get the max gap setting for calculating surface overlaps.
 
void  set_overlap_max_gap (const double maximum_gap)
  Set the max gap setting for calculating surface overlaps.
 
double  get_overlap_min_gap (void)
  Get the min gap setting for calculating surface overlaps.
 
void  set_overlap_min_gap (const double min_gap)
  Set the min gap setting for calculating surface overlaps.
 
double  get_overlap_max_angle (void)
  Get the max angle setting for calculating surface overlaps.
 
void  set_overlap_max_angle (const double maximum_angle)
  Set the max angle setting for calculating surface overlaps.
 
Geometry Repair Support
void  get_small_surfaces_hydraulic_radius (std::vector< int > target_volume_ids, double mesh_size, std::vector< int > &returned_small_surfaces, std::vector< double > &returned_small_radius)
  Get the list of small hydraulic radius surfaces for a list of volumes.
 
std::vector< int >  get_small_surfaces_HR (std::vector< int > target_volume_ids, double mesh_size)
  Python callable version Get the list of small hydraulic radius surfaces for a list of volumes.
 
void  get_small_volumes_hydraulic_radius (std::vector< int > target_volume_ids, double mesh_size, std::vector< int > &returned_small_volumes, std::vector< double > &returned_small_radius)
  Get the list of small hydraulic radius volumes for a list of volumes.
 
std::vector< int >  get_small_curves (std::vector< int > target_volume_ids, double mesh_size)
  Get the list of small curves for a list of volumes.
 
std::vector< int >  get_smallest_curves (std::vector< int > target_volume_ids, int number_to_return)
  Get a list of the smallest curves in the list of volumes. The number returned is specified by 'num_to_return'.
 
std::vector< int >  get_small_surfaces (std::vector< int > target_volume_ids, double mesh_size)
  Get the list of small surfaces for a list of volumes.
 
bool  is_narrow_surface (int surface_id, double mesh_size)
  return whether the surface is narrow (has a width smaller than mesh_size)
 
std::vector< int >  get_narrow_surfaces (std::vector< int > target_volume_ids, double mesh_size)
  Get the list of narrow surfaces for a list of volumes.
 
std::vector< int >  get_small_and_narrow_surfaces (std::vector< int > target_ids, double small_area, double small_curve_size)
  Get the list of small or narrow surfaces from a list of volumes.
 
std::vector< int >  get_closed_narrow_surfaces (std::vector< int > target_ids, double narrow_size)
  Get the list of closed, narrow surfaces from a list of volumes.
 
std::vector< int >  get_surfs_with_narrow_regions (std::vector< int > target_ids, double narrow_size)
  Get the list of surfaces with narrow regions.
 
std::vector< int >  get_narrow_regions (std::vector< int > target_ids, double narrow_size)
  Get the list of surfaces with narrow regions.
 
std::vector< int >  get_small_volumes (std::vector< int > target_volume_ids, double mesh_size)
  Get the list of small volumes from a list of volumes.
 
bool  is_cylinder_surface (int surface_id)
  return whether the surface is a cylinder
 
bool  is_chamfer_surface (int surface_id, double thickness_threshold)
  return whether the surface is a chamfer
 
std::vector< std::vector< double > >  get_chamfer_surfaces (std::vector< int > target_volume_ids, double thickness_threshold)
  Get the list of chamfer surfaces for a list of volumes.
 
bool  is_blend_surface (int surface_id)
  return whether the surface is a blend
 
std::vector< int >  get_blend_surfaces (std::vector< int > target_volume_ids)
  Get the list of blend surfaces for a list of volumes.
 
std::vector< int >  get_small_radius_blend_surfaces (std::vector< int > target_volume_ids, double max_radius)
  Get the list of blend surfaces for a list of volumes that have a radius of curvature smaller than max_radius.
 
bool  is_close_loop_surface (int surface_id, double mesh_size)
  return whether the has one or more close loops
 
std::vector< int >  get_close_loops (std::vector< int > target_volume_ids, double mesh_size)
  Get the list of close loops (surfaces) for a list of volumes.
 
std::vector< std::vector< double > >  get_close_loops_with_thickness (std::vector< int > target_volume_ids, double mesh_size, int genus)
  Get the list of close loops (surfaces) for a list of volumes also return the corresponding minimum distances for each surface.
 
double  get_close_loop_thickness (int surface_id)
  Get the thickness of a close loop surface.
 
std::vector< std::vector< std::string > >  get_solutions_for_close_loop (int surface_id, double mesh_size)
  Get the solution list for a given close loop surface.
 
std::vector< int >  get_tangential_intersections (std::vector< int > target_volume_ids, double upper_bound, double lower_bound)
  Get the list of bad tangential intersections for a list of volumes.
 
std::vector< int >  get_coincident_vertices (std::vector< int > target_volume_ids, double high_tolerance)
 
std::vector< int >  get_close_vertex_curve_pairs (std::vector< int > target_volume_ids, double high_tolerance)
  Get the list of close vertex-curve pairs (python callable)
 
std::vector< std::vector< std::string > >  get_solutions_for_near_coincident_vertices (int vertex_id_1, int vertex_id_2)
  Get lists of display strings and command strings for near coincident vertices.
 
std::vector< std::vector< std::string > >  get_solutions_for_bad_geometry (std::string geom_type, int geom_id)
  Get lists of display strings and command strings for bad geometry.
 
std::vector< std::vector< std::string > >  get_solutions_for_overlapping_volumes (int volume_id_1, int volume_id_2, double maximum_gap_tolerance, double maximum_gap_angle)
  Get lists of display strings and command strings for overlapping volumes.
 
std::vector< std::vector< std::string > >  get_solutions_for_overlapping_surfaces (int surface_id_1, int surface_id_2)
  Get lists of display strings and command strings for overlapping surfaces.
 
std::vector< std::vector< std::string > >  get_volume_gap_solutions (int surface_id_1, int surface_id_2)
 
std::vector< std::vector< std::string > >  get_solutions_for_near_coincident_vertex_and_curve (int vertex_id, int curve_id)
  Get lists of display strings and command strings for near coincident vertices and curves.
 
std::vector< std::vector< std::string > >  get_solutions_for_near_coincident_vertex_and_surface (int vertex_id, int surface_id)
  Get lists of display strings and command strings for near coincident vertices and surfaces.
 
std::vector< std::vector< std::string > >  get_solutions_for_imprint_merge (int surface_id1, int surface_id2)
  Get lists of display strings and command strings for imprint/merge solutions.
 
std::vector< std::vector< std::string > >  get_solutions_for_forced_sweepability (int volume_id, std::vector< int > &source_surface_id_list, std::vector< int > &target_surface_id_list, double small_curve_size=-1.0)
  This function only works from C++ Get lists of display strings and command strings for forced sweepability solutions
 
std::vector< std::vector< std::string > >  get_solutions_for_volumes (int vol_id, double small_curve_size, double mesh_size)
  Get lists of display, preview and command strings for small volume solutions.
 
std::vector< std::vector< std::string > >  get_solutions_for_classified_volume (std::string classification, int vol_id)
  Get lists of display, preview and command strings for a classified volume.
 
std::vector< std::vector< std::string > >  get_solutions_for_bolt (int bolt_id, int insert_id, int threaded_vol_id)
  get the solutions for a volume classified as a bole. faster than get_solutions_for_classified_volume if the lower volume and insert volumes are alraedy known
 
std::vector< std::vector< std::string > >  get_solutions_for_bolt_hole (int bearing_hole, std::vector< int > threaded_holes)
  get the solutions for a set of concentric holes used as a fastener pilot hole
 
std::vector< std::vector< std::string > >  get_solutions_for_classified_surface (std::string classification, int surf_id)
  Get lists of display, preview and command strings for a classified surface.
 
std::vector< std::vector< std::string > >  get_solutions_for_thin_volume (int vol_id, std::vector< int > near_vols, bool include_weights=false, bool include_type=false)
  Get lists of display, preview and command strings for a volume to reduce to shell.
 
std::vector< std::vector< std::string > >  get_solutions_for_sheet_volumes (std::vector< int > vol_ids, std::vector< double > thickness)
  Get lists of display, preview and command strings to connect sheet bodies.
 
std::vector< std::vector< std::string > >  get_solutions_for_sheet_volume_connection (std::vector< int > vol1_sheets, std::vector< int > vol2_sheets, double thickness1, double thickness2, std::string close_type="", int close_id=0)
  Get lists of display, preview and command strings for two neighboring sheet volume sets. each set should be part of a common parent 3D volume.
 
std::vector< std::vector< std::string > >  get_solutions_for_small_surfaces (int surface_id, double small_curve_size, double mesh_size)
  Get lists of display, preview and command strings for small surface solutions.
 
std::vector< std::vector< std::string > >  get_solutions_for_small_curves (int curve_id, double small_curve_size, double mesh_size)
  Get lists of display, preview and command strings for small curve solutions.
 
std::vector< std::vector< std::string > >  get_solutions_for_sharp_angle_vertex (int vertex_id, double small_curve_size, double mesh_size)
  Get lists of display, preview and command strings for sharp angle solutions.
 
std::vector< std::vector< std::string > >  get_solutions_for_surfaces_with_narrow_regions (int surface_id, double small_curve_size, double mesh_size)
  Get lists of display, preview and command strings for surfaces with narrow regions solutions.
 
std::vector< std::vector< std::string > >  get_solutions_for_cone_surface (int surface_id)
  Get lists of display, preview and command strings for surfaces with defined as cones.
 
bool  get_solutions_for_source_target (int volume_id, std::vector< std::vector< int > > &feasible_source_surface_id_list, std::vector< std::vector< int > > &feasible_target_surface_id_list, std::vector< std::vector< int > > &infeasible_source_surface_id_list, std::vector< std::vector< int > > &infeasible_target_surface_id_list)
  Get a list of suggested sources and target surface ids given a specified volume.
 
void  get_sharp_surface_angles (std::vector< int > target_volume_ids, std::vector< int > &returned_large_surface_angles, std::vector< int > &returned_small_surface_angles, std::vector< double > &returned_large_angles, std::vector< double > &returned_small_angles, double upper_bound, double lower_bound)
  Get the list of sharp surface angles for a list of volumes.
 
void  get_sharp_curve_angles (std::vector< int > target_volume_ids, std::vector< int > &returned_large_curve_angles, std::vector< int > &returned_small_curve_angles, std::vector< double > &returned_large_angles, std::vector< double > &returned_small_angles, double upper_bound, double lower_bound)
  Get the list of sharp curve angles for a list of volumes.
 
std::vector< std::vector< double > >  get_sharp_angle_vertices (std::vector< int > target_volume_ids, double upper_bound, double lower_bound)
  Get the list of vertices at sharp curve angles for a list of volumes returns two parallel arrays. First array are the vertex ids and second are the associated angles at the vertices.
 
bool  is_cone_surface (int surface_id)
  return whether the surface is a cone
 
std::vector< int >  get_cone_surfaces (std::vector< int > target_volume_ids)
  return a list of surfaces that are cones defined by a conic surface and a hard point
 
void  get_bad_geometry (std::vector< int > target_volume_ids, std::vector< int > &returned_body_list, std::vector< int > &returned_volume_list, std::vector< int > &returned_surface_list, std::vector< int > &returned_curve_list)
  This function only works from C++ Get the list of bad geometry for a list of volumes
 
std::vector< std::vector< int > >  get_overlapping_surfaces_in_bodies (std::vector< int > body_ids, bool filter_slivers=false)
  returns a vector of vectors defining surface overlaps The first surface (id) in each vector overlaps with all subsequent surfaces in the vector.
 
void  get_overlapping_surfaces_in_volumes (std::vector< int > target_volume_ids, std::vector< int > &returned_surface_list_1, std::vector< int > &returned_surface_list_2, std::vector< double > &returned_distance_list, std::vector< double > &returned_overlap_area_list, bool filter_slivers=false, bool filter_volume_overlaps=false, int cache_overlaps=0)
  This function only works from C++ Get the list of overlapping surfaces for a list of volumes
 
void  get_overlapping_surfaces (std::vector< int > target_surface_ids, std::vector< int > &returned_surface_list_1, std::vector< int > &returned_surface_list_2, std::vector< double > &returned_distance_list, std::vector< double > &returned_overlap_area_list, bool filter_slivers=false, bool filter_volume_overlaps=false, int cache_overlaps=0)
  This function only works from C++ Get the list of overlapping surfaces for a list of surfaces
 
void  get_overlapping_curves (std::vector< int > target_surface_ids, double min_gap, double max_gap, std::vector< int > &returned_curve_list_1, std::vector< int > &returned_curve_list_2, std::vector< double > &returned_distance_list)
 
void  get_volume_gaps (std::vector< int > target_volume_ids, std::vector< int > &returned_surface_list_1, std::vector< int > &returned_surface_list_2, std::vector< double > &returned_distance_list, std::vector< double > &returned_overlap_area_list, double maximum_gap_tolerance, double maximum_gap_angle, int cache_overlaps=0)
  This function only works from C++ Get the list of gaps for a list of volumes
 
std::vector< VolumeGap get_gaps_between_volumes (std::vector< int > target_volume_ids, double maximum_gap_tolerance, double maximum_gap_angle, int cache_overlaps=0)
 
std::vector< int >  get_overlapping_volumes (std::vector< int > target_volume_ids)
  Get the list of overlapping volumes for a list of volumes.
 
std::vector< int >  get_overlapping_volumes_at_volume (int volume_id, std::vector< int > compare_volumes)
  Get the list of overlapping volumes from the model for a single volume.
 
std::vector< int >  get_overlapping_surfaces_at_surface (int surface_id, std::vector< int > compare_volumes, int cache_overlaps=0)
  Get the list of overlapping surfaces from the model for a single surface.
 
std::vector< int >  get_nearby_entities (std::string gtype, std::vector< int > ent_ids, std::vector< int > compare_ents, double distance)
  Get the list of nearby entities of type curve, surface or volumes from the model for a list of the same entity type.
 
std::vector< int >  get_nearby_volumes_at_volume (int volume_id, std::vector< int > compare_volumes, double distance)
  Get the list of nearby volumes from the model for a single volume.
 
std::vector< int >  get_unmerged_curves_on_shells (std::vector< int > shell_vols, std::vector< double > thickness)
  return a list of curve IDs on the given shell volumes that are in proximity to one of the other shell volumes in the list
 
void  get_mergeable_entities (std::vector< int > target_volume_ids, std::vector< std::vector< int > > &returned_surface_list, std::vector< std::vector< int > > &returned_curve_list, std::vector< std::vector< int > > &returned_vertex_list, double merge_tol=-1)
  This function only works from C++ Get the list of mergeable entities from a list of volumes
 
std::vector< std::vector< int > >  get_mergeable_vertices (std::vector< int > target_volume_ids)
  Get the list of mergeable vertices from a list of volumes/bodies.
 
std::vector< std::vector< int > >  get_mergeable_curves (std::vector< int > target_volume_ids)
  Get the list of mergeable curves from a list of volumes/bodies.
 
std::vector< std::vector< int > >  get_mergeable_surfaces (std::vector< int > target_volume_ids)
  Get the list of mergeable surfaces from a list of volumes/bodies.
 
void  get_closest_vertex_curve_pairs (std::vector< int > target_ids, int &returned_number_to_return, std::vector< int > &returned_vertex_ids, std::vector< int > &returned_curve_ids, std::vector< double > &returned_distances)
  Find the n closest vertex pairs in the model.
 
void  get_smallest_features (std::vector< int > target_ids, int &returned_number_to_return, std::vector< int > &returned_type_1_list, std::vector< int > &returned_type_2_list, std::vector< int > &returned_id_1_list, std::vector< int > &returned_id_2_list, std::vector< double > &returned_distance_list)
  Finds all of the smallest features.
 
double  estimate_merge_tolerance (std::vector< int > target_volume_ids, bool accurate_in=false, bool report_in=false, double low_value_in=-1.0, double high_value_in=-1.0, int number_calculations_in=10, bool return_calculations_in=false, std::vector< double > *merge_tolerance_list=NULL, std::vector< int > *number_of_proximities_list=NULL)
  Estimate a good merge tolerance for the passed-in volumes.
 
void  find_floating_volumes (std::vector< int > target_volume_ids, std::vector< int > &returned_floating_id_list)
  Get the list of volumes with no merged children.
 
void  find_nonmanifold_curves (std::vector< int > target_volume_ids, std::vector< int > &returned_curve_list)
  Get the list of nonmanifold curves in the volume list.
 
void  find_nonmanifold_vertices (std::vector< int > target_volume_ids, std::vector< int > &returned_vertex_list)
  Get the list of nonmanifold vertices in the volume list.
 
void  get_coincident_entity_pairs (std::vector< int > target_volume_ids, std::vector< int > &returned_v_v_vertex_list, std::vector< int > &returned_v_c_vertex_list, std::vector< int > &returned_v_c_curve_list, std::vector< int > &returned_v_s_vertex_list, std::vector< int > &returned_v_s_surf_list, std::vector< double > &returned_vertex_distance_list, std::vector< double > &returned_curve_distance_list, std::vector< double > &returned_surf_distance_list, double low_value, double high_value, bool do_vertex_vertex=true, bool do_vertex_curve=true, bool do_vertex_surf=true, bool filter_same_volume_cases=false)
  Get the list of coincident vertex-vertex, vertex-curve, and vertex-surface pairs and distances from a list of volumes.
 
void  get_coincident_vertex_vertex_pairs (std::vector< int > target_volume_ids, std::vector< int > &returned_vertex_pair_list, std::vector< double > &returned_distance_list, double low_value, double threshold_value, bool filter_same_volume_cases=false)
  Get the list of coincident vertex pairs and distances from a list of volumes.
 
void  get_coincident_vertex_curve_pairs (std::vector< int > target_volume_ids, std::vector< int > &returned_vertex_list, std::vector< int > &returned_curve_list, std::vector< double > &returned_distance_list, double low_value, double threshold_value, bool filter_same_volume_cases=false)
  Get the list of coincident vertex/curve pairs and distances from a list of volumes.
 
void  get_coincident_vertex_surface_pairs (std::vector< int > target_volume_ids, std::vector< int > &returned_vertex_list, std::vector< int > &returned_surface_list, std::vector< double > &returned_distance_list, double low_value, double threshold_value, bool filter_same_volume_cases=false)
  Get the list of coincident vertex/surface pairs and distances from a list of volumes.
 
std::vector< std::vector< std::string > >  get_solutions_for_decomposition (const std::vector< int > &volume_list, double exterior_angle, bool do_imprint_merge, bool tolerant_imprint)
  Get the list of possible decompositions.
 
std::vector< std::vector< std::string > >  get_solutions_for_blends (int surface_id)
  Get the solution list for a given blend surface.
 
std::vector< std::vector< int > >  get_blend_chains (int surface_id)
  Returns the blend chains for a surface.
 
std::vector< std::vector< int > >  get_chamfer_chains (int surface_id)
  Returns the chamfer chains for a surface.
 
bool  are_adjacent_surfaces (std::vector< int > surface_ids)
  return whether two or more surfaces share at least one manifold curve (common curve is part of exactly two surfaces)
 
bool  are_adjacent_curves (std::vector< int > curve_ids)
  return whether two or more curves share at least one manifold vertex (common vertex is part of exactly two curves)
 
bool  is_continuous_surface (int surface_id, double angle_tol)
  return whether the surface has any adjacent surfaces that are continuous (exterior angle is 180 degrees +- angle_tol)
 
std::vector< int >  get_continuous_surfaces (int surface_id, double angle_tol)
  Returns the adjacent surfaces that are continuous (exterior angle is 180 degrees +- angle_tol)
 
std::vector< int >  get_continuous_curves (int curve_id, double angle_tol)
  Returns the adjacent curves that are continuous (angle is 180 degrees +- angle_tol)
 
bool  is_cavity_surface (int surface_id)
  return whether the surface is part of a cavity
 
bool  is_hole_surface (int surface_id, double radius_threshold)
  return whether the surface is part of a hole
 
std::vector< int >  get_cavity_surfaces (int surface_id)
  Returns the adjacent surfaces in a cavity for a surface.
 
std::vector< int >  get_hole_surfaces (int surface_id)
  Returns the adjacent surfaces in a hole for a surface.
 
std::vector< std::vector< int > >  get_surface_cavity_collections (const std::vector< int > &volume_list, double hr_threshold, double area_threshold, std::vector< double > &return_cavity_hrs, std::vector< double > &return_cavity_areas)
  Returns the collections of surfaces that comprise holes or cavities in the specified volumes. Filter by hydarulic radius and area of the cavity.
 
std::vector< std::pair< std::vector< int >, double > >  get_surface_hole_collections (const std::vector< int > &volume_list, double radius_threshold)
  Returns the collections of surfaces that comprise holes in the specified volumes. Filter by radius of the hole.
 
std::vector< std::pair< std::vector< int >, double > >  get_blend_chain_collections (const std::vector< int > &volume_list, double radius_threshold)
  Returns the collections of surfaces that comprise blend chains in the specified volumes. Filter by radius threshold.
 
std::vector< std::pair< std::vector< int >, double > >  get_chamfer_chain_collections (const std::vector< int > &volume_list, double thickness_threshold)
  Returns the collections of surfaces that comprise chamfers in the specified volumes. Filter by thickness of chamfer.
 
std::vector< std::vector< std::string > >  get_solutions_for_cavity_surface (int surface_id)
  Get the solution list for a given cavity surface.
 
double  get_merge_tolerance ()
  Get the current merge tolerance value.
 
Blocks, Sidesets, and Nodesets
std::string  get_exodus_entity_name (const std::string entity_type, int entity_id)
  Get the name associated with an exodus entity.
 
std::string  get_exodus_entity_type (std::string entity_type, int entity_id)
  Get the type of an exodus entity.
 
std::string  get_exodus_entity_description (std::string entity_type, int entity_id)
  Get the description associated with an exodus entity.
 
std::vector< double >  get_all_exodus_times (const std::string &filename)
  Open an exodus file and get a vector of all stored time stamps.
 
std::vector< std::string >  get_all_exodus_variable_names (const std::string &filename, const std::string &variable_type)
  Open an exodus file and get a list of all stored variable names.
 
int  get_block_id (std::string entity_type, int entity_id)
  Get the associated block id for a specific curve, surface, or volume.
 
std::vector< int >  get_block_ids (const std::string &mesh_geometry_file_name)
  Get list of block ids from a mesh geometry file.
 
std::vector< int >  get_block_id_list ()
  Get a list of all blocks.
 
std::vector< int >  get_nodeset_id_list ()
  Get a list of all nodesets.
 
std::vector< int >  get_sideset_id_list ()
  Get a list of all sidesets.
 
std::vector< int >  get_bc_id_list (CI_BCTypes bc_type_enum)
  Get a list of all bcs of a specified type.
 
std::string  get_bc_name (CI_BCTypes bc_type_enum, int bc_id)
  Get the name for the specified bc.
 
std::vector< int >  get_nodeset_id_list_for_bc (CI_BCTypes bc_type_enum, int bc_id)
  Get a list of all nodesets the specified bc is applied to.
 
std::vector< int >  get_sideset_id_list_for_bc (CI_BCTypes bc_type_enum, int bc_id)
  Get a list of all sidesets the specified bc is applied to.
 
int  get_next_sideset_id ()
  Get a next available sideset id.
 
int  get_next_nodeset_id ()
  Get a next available nodeset id.
 
int  get_next_block_id ()
  Get a next available block id.
 
std::string  get_copy_nodeset_on_geometry_copy_setting ()
  Get the copy nodeset on geometry copy setting.
 
std::string  get_copy_sideset_on_geometry_copy_setting ()
  Get the copy nodeset on geometry copy setting.
 
std::string  get_copy_block_on_geometry_copy_setting ()
  Get the copy nodeset on geometry copy setting.
 
bool  set_copy_nodeset_on_geometry_copy_setting (std::string val)
  Set the copy nodeset on geometry copy setting "ON", "USE_ORIGINAL", or "OFF".
 
bool  set_copy_sideset_on_geometry_copy_setting (std::string val)
  Set the copy sideset on geometry copy setting "ON", "USE_ORIGINAL", or "OFF".
 
bool  set_copy_block_on_geometry_copy_setting (std::string val)
  Set the copy block on geometry copy setting "ON", "USE_ORIGINAL", or "OFF".
 
void  get_block_children (int block_id, std::vector< int > &returned_group_list, std::vector< int > &returned_node_list, std::vector< int > &returned_sphere_list, std::vector< int > &returned_edge_list, std::vector< int > &returned_tri_list, std::vector< int > &returned_face_list, std::vector< int > &returned_pyramid_list, std::vector< int > &returned_tet_list, std::vector< int > &returned_hex_list, std::vector< int > &returned_wedge_list, std::vector< int > &returned_volume_list, std::vector< int > &returned_surface_list, std::vector< int > &returned_curve_list, std::vector< int > &returned_vertex_list)
  Get lists of any and all possible children of a block.
 
void  get_nodeset_children (int nodeset_id, std::vector< int > &returned_node_list, std::vector< int > &returned_volume_list, std::vector< int > &returned_surface_list, std::vector< int > &returned_curve_list, std::vector< int > &returned_vertex_list)
  get lists of any and all possible children of a nodeset
 
void  get_sideset_children (int sideset_id, std::vector< int > &returned_face_list, std::vector< int > &returned_surface_list, std::vector< int > &returned_curve_list)
  get lists of any and all possible children of a sideset
 
std::vector< int >  get_block_volumes (int block_id)
  Get a list of volume ids associated with a specific block.
 
std::vector< int >  get_block_surfaces (int block_id)
  Get a list of surface associated with a specific block.
 
std::vector< int >  get_block_curves (int block_id)
  Get a list of curve associated with a specific block.
 
std::vector< int >  get_block_vertices (int block_id)
  Get a list of vertices associated with a specific block.
 
bool  get_block_elements_and_nodes (int block_id, std::vector< int > &returned_node_list, std::vector< int > &returned_sphere_list, std::vector< int > &returned_edge_list, std::vector< int > &returned_tri_list, std::vector< int > &returned_face_list, std::vector< int > &returned_pyramid_list, std::vector< int > &returned_wedge_list, std::vector< int > &returned_tet_list, std::vector< int > &returned_hex_list)
  Get lists of the nodes and different element types associated with this block. This function is recursive, meaning that if the block was created pointing to a piece of geometry, it will traverse down and get the mesh entities associated to that geometry.
 
std::vector< int >  get_edges_to_swap (int curve_id)
  Given a curve defining a knife edge between two triangle-meshed surfaces, return a list of edges on triangles at the curve that are good candidates for swapping. A good candidate for swapping means that if swapped, the two triangles at the knife's edge will have a larger interior dihedral angle between them, allowing a larger volume to accommodate tetmeshing.
 
std::vector< int >  get_block_nodes (int block_id)
  Get a list of nodes associated with a specific block.
 
std::vector< int >  get_block_edges (int block_id)
  Get a list of edges associated with a specific block.
 
std::vector< int >  get_block_tris (int block_id)
  Get a list of tris associated with a specific block.
 
std::vector< int >  get_block_faces (int block_id)
  Get a list of faces associated with a specific block.
 
std::vector< int >  get_block_pyramids (int block_id)
  Get a list of pyramids associated with a specific block.
 
std::vector< int >  get_block_wedges (int block_id)
  Get a list of wedges associated with a specific block.
 
std::vector< int >  get_block_tets (int block_id)
  Get a list of tets associated with a specific block.
 
std::vector< int >  get_block_hexes (int block_id)
  Get a list of hexes associated with a specific block.
 
std::vector< int >  get_volume_hexes (int volume_id)
  get the list of any hex elements in a given volume
 
std::vector< int >  get_volume_tets (int volume_id)
  get the list of any tet elements in a given volume
 
std::vector< int >  get_volume_wedges (int volume_id)
  get the list of any wedge elements in a given volume
 
std::vector< int >  get_volume_pyramids (int volume_id)
  get the list of any pyramid elements in a given volume
 
std::vector< int >  get_nodeset_volumes (int nodeset_id)
  Get a list of volume ids associated with a specific nodeset.
 
std::vector< int >  get_nodeset_surfaces (int nodeset_id)
  Get a list of surface ids associated with a specific nodeset.
 
std::vector< int >  get_nodeset_curves (int nodeset_id)
  Get a list of curve ids associated with a specific nodeset.
 
std::vector< int >  get_nodeset_vertices (int nodeset_id)
  Get a list of vertex ids associated with a specific nodeset.
 
std::vector< int >  get_nodeset_nodes (int nodeset_id)
  Get a list of node ids associated with a specific nodeset. This only returns the nodes that were specifically assigned to this nodeset. If the nodeset was created as a piece of geometry, get_nodeset_nodes will not return the nodes on that geometry See also get_nodeset_nodes_inclusive.
 
std::vector< int >  get_nodeset_nodes_inclusive (int nodeset_id)
  Get a list of node ids associated with a specific nodeset. This includes all nodes specifically assigned to the nodeset, as well as nodes associated to a piece of geometry which was used to define the nodeset.
 
std::vector< int >  get_sideset_curves (int sideset_id)
  Get a list of curve ids associated with a specific sideset.
 
std::vector< int >  get_sideset_edges (int sideset_id)
  Get a list of any quads in a sideset.
 
std::vector< int >  get_curve_edges (int curve_id)
  get the list of any edge elements on a given curve
 
std::vector< int >  get_sideset_surfaces (int sideset_id)
  Get a list of any surfaces in a sideset.
 
std::vector< int >  get_sideset_quads (int sideset_id)
  Get a list of any quads in a sideset.
 
std::vector< int >  get_sideset_tris (int sideset_id)
  Get a list of any tris in a sideset.
 
double  get_sideset_area (int sideset_id)
  Get area of the sideset.
 
std::vector< int >  get_surface_quads (int surface_id)
  get the list of any quad elements on a given surface
 
std::vector< int >  get_surface_tris (int surface_id)
  get the list of any tri elements on a given surface
 
int  get_surface_num_loops (int surface_id)
  get the number of loops on the surface
 
std::vector< std::vector< int > >  get_surface_loop_nodes (int surface_id)
  get the ordered list of nodes on the loops of this surface
 
std::string  get_entity_sense (std::string source_type, int source_id, int sideset_id)
  Get the sense of a sideset item.
 
std::string  get_wrt_entity (std::string source_type, int source_id, int sideset_id)
  Get the with-respect-to entity.
 
std::vector< std::string >  get_geometric_owner (std::string mesh_entity_type, std::string mesh_entity_list)
  Get a list of geometric owners given a list of mesh entities.
 
std::vector< std::string >  get_all_geometric_owners (std::string mesh_entity_type, std::string mesh_entity_list)
  Get a list of geometric owners given a list of mesh entities. returns geometric owners of entity as well as all of its child mesh entities.
 
Geometry-Mesh Entity Support
std::vector< int >  get_volume_nodes (int volume_id)
  Get list of node ids owned by a volume.
Excludes nodes owned by bounding surfs, curves and verts.
 
std::vector< int >  get_surface_nodes (int surface_id)
  Get list of node ids owned by a surface.
Excludes nodes owned by bounding curves and verts.
 
std::vector< int >  get_curve_nodes (int curve_id)
  Get list of node ids owned by a curve.
Excludes nodes owned by bounding vertices.
 
int  get_vertex_node (int vertex_id)
  Get the node owned by a vertex.

 
Group Support
int  get_id_from_name (const std::string &name)
  Get id for a named entity.
 
std::vector< int >  get_all_ids_from_name (const std::string &geo_type, const std::string &name)
  Get all ids of a geometry type with the prefix given by string.
 
void  get_group_children (int group_id, std::vector< int > &returned_group_list, std::vector< int > &returned_body_list, std::vector< int > &returned_volume_list, std::vector< int > &returned_surface_list, std::vector< int > &returned_curve_list, std::vector< int > &returned_vertex_list, int &returned_node_count, int &returned_edge_count, int &returned_hex_count, int &returned_quad_count, int &returned_tet_count, int &returned_tri_count, int &returned_wedge_count, int &returned_pyramid_count, int &returned_sphere_count)
  Get group children.
 
std::vector< int >  get_group_groups (int group_id)
  Get group groups (groups that are children of another group)
 
std::vector< int >  get_group_volumes (int group_id)
  Get group volumes (volumes that are children of a group)
 
std::vector< int >  get_group_bodies (int group_id)
  Get group bodies (bodies that are children of a group)
 
std::vector< int >  get_group_surfaces (int group_id)
  Get group surfaces (surfaces that are children of a group)
 
std::vector< int >  get_group_curves (int group_id)
  Get group curves (curves that are children of a group)
 
std::vector< int >  get_group_vertices (int group_id)
  Get group vertices (vertices that are children of a group)
 
std::vector< int >  get_group_nodes (int group_id)
  Get group nodes (nodes that are children of a group)
 
std::vector< int >  get_group_edges (int group_id)
  Get group edges (edges that are children of a group)
 
std::vector< int >  get_group_quads (int group_id)
  Get group quads (quads that are children of a group)
 
std::vector< int >  get_group_tris (int group_id)
  Get group tris (tris that are children of a group)
 
std::vector< int >  get_group_tets (int group_id)
  Get group tets (tets that are children of a group)
 
std::vector< int >  get_group_wedges (int group_id)
  Get group wedges (wedges that are children of a group)
 
std::vector< int >  get_group_pyramids (int group_id)
  Get group pyramids (pyramids that are children of a group)
 
std::vector< int >  get_group_spheres (int group_id)
 
std::vector< int >  get_group_hexes (int group_id)
 
int  get_next_group_id ()
  Get the next available group id from Cubit.
 
void  delete_all_groups ()
  Delete all groups.
 
void  delete_group (int group_id)
  Delete a specific group.
 
void  set_max_group_id (int maximum_group_id)
  Reset Cubit's max group id This is really dangerous to use and exists only to overcome a limitation with Cubit. Cubit keeps track of the next group id to assign. But those ids just keep incrementing in Cubit. Some of the power tools in the Cubit GUI make groups 'under the covers' for various operations. The groups are immediately deleted. But, creating those groups will cause Cubit's group id to increase and downstream journal files may be messed up because those journal files are expecting a certain ID to be available.
 
int  create_new_group ()
  Create a new group.
 
void  remove_entity_from_group (int group_id, int entity_id, const std::string &entity_type)
  Remove a specific entity from a specific group.
 
void  add_entity_to_group (int group_id, int entity_id, const std::string &entity_type)
  Add a specific entity to a specific group.
 
void  add_entities_to_group (int group_id, const std::vector< int > &entity_id, const std::string &entity_type)
  Add a list of entities to a specific group.
 
void  group_list (std::vector< std::string > &name_list, std::vector< int > &returned_id_list)
  Get the names and ids of all the groups (excluding the pick group) that are defined by the current cubit session.
 
std::vector< std::pair< std::string, int > >  group_names_ids ()
  Get the names and ids of all the groups returned in a name/id structure that are defined by the current cubit session.
 
std::vector< int >  get_mesh_group_parent_ids (const std::string &element_type, int element_id)
  Get the group ids which are parents to the indicated mesh element.
 
bool  is_mesh_element_in_group (const std::string &element_type, int element_id)
  Indicates whether a mesh element is in a group.
 
General Purpose Utility
bool  is_part_of_list (int target_id, std::vector< int > id_list)
  Routine to check for the presence of an id in a list of ids.
 
int  get_last_id (const std::string &entity_type)
  Get the id of the last created entity of the given type.
 
bool  entity_exists (const std::string &entity_type, int id)
  return whether an entity of specified ID exists
 
std::string  get_idless_signature (std::string entity_type, int entity_id)
  get the idless signature of a geometric or mesh entity
 
std::string  get_idless_signatures (std::string entity_type, const std::vector< int > &entity_id_list)
  get the idless signatures of a range of geometric or mesh entities
 
Metadata Support
std::string  get_assembly_classification_level ()
  Get Classification Level for metadata.
 
std::string  get_assembly_classification_category ()
  Get Classification Category for metadata.
 
std::string  get_assembly_weapons_category ()
  Get Weapons Category for metadata.
 
std::string  get_assembly_metadata (int volume_id, int data_type)
  Get metadata for a specified volume id.
 
bool  is_assembly_metadata_attached (int volume_id)
  Determine whether metadata is attached to a specified volume.
 
std::string  get_assembly_name (int assembly_id)
  Get the stored name of an assembly node.
 
std::string  get_assembly_path (int assembly_id)
  Get the stored path of an assembly node.
 
std::string  get_assembly_type (int assembly_id)
  Get the stored type of an assembly node.
 
std::string  get_parent_assembly_path (int assembly_id)
  Get the stored path of an assembly node' parent.
 
int  get_assembly_level (int assembly_id)
  Get the stored level of an assembly node.
 
std::string  get_assembly_description (int assembly_id)
  Get the stored description of an assembly node.
 
int  get_assembly_instance (int assembly_id)
  Get the stored instance number of an assembly node.
 
int  get_parent_assembly_instance (int assembly_id)
  Get the stored instance number of an assembly node's instance.
 
std::string  get_assembly_file_format (int assembly_id)
  Get the stored file format of an assembly node.
 
std::string  get_assembly_units (int assembly_id)
  Get the stored units measure of an assembly node.
 
std::string  get_assembly_material_description (int assembly_id)
  Get the stored material description of an assembly part.
 
std::string  get_assembly_material_specification (int assembly_id)
  Get the stored material specification of an assembly part.
 
Mesh Element Queries
int  get_exodus_id (const std::string &entity_type, int entity_id)
  Get the exodus/genesis id for this element.
 
std::string  get_geometry_owner (const std::string &entity_type, int entity_id)
  Get the geometric owner of this mesh element.
 
std::vector< int >  get_connectivity (const std::string &entity_type, int entity_id)
  Get the list of node ids contained within a mesh entity.
 
std::vector< int >  get_expanded_connectivity (const std::string &entity_type, int entity_id)
  Get the list of node ids contained within a mesh entity, including interior nodes.
 
std::vector< int >  get_sub_elements (const std::string &entity_type, int entity_id, int dimension)
  Get the lower dimesion entities associated with a higher dimension entities. For example get the faces associated with a hex or the edges associated with a tri.
 
bool  get_node_exists (int node_id)
  Check the existance of a node.
 
bool  get_element_exists (int element_id)
  Check the existance of an element.
 
std::string  get_element_type (int element_id)
  return the type of a given element
 
int  get_element_type_id (int element_id)
  return the type id of a given element
 
int  get_element_block (int element_id)
  return the block that a given element is in.
 
int  get_global_element_id (const std::string &element_type, int id)
  Given a hex, tet, etc. id, return the global element id.
 
int  get_hex_global_element_id (int hex_id)
  Given a hex id, return the global element id.
 
int  get_tet_global_element_id (int tet_id)
  Given a tet id, return the global element id.
 
int  get_wedge_global_element_id (int wedge_id)
  Given a wedge id, return the global element id.
 
int  get_pyramid_global_element_id (int pyramid_id)
  Given a pyramid id, return the global element id.
 
int  get_tri_global_element_id (int tri_id)
  Given a tri id, return the global element id.
 
int  get_quad_global_element_id (int quad_id)
  Given a quad id, return the global element id.
 
int  get_edge_global_element_id (int edge_id)
  Given a edge id, return the global element id.
 
int  get_sphere_global_element_id (int edge_id)
  Given a sphere id, return the global element id.
 
int  get_node_global_id (int node_id)
  Given a node id, return the global element id that is assigned when the mesh is exported.
 
int  get_closest_node (double x_coordinate, double y_coordinate, double z_coordinate)
  Get the node closest to the given coordinates.
 
std::array< double, 3 >  get_nodal_coordinates (int node_id)
  Get the nodal coordinates for a given node id.
 
std::vector< int >  get_node_faces (int node_id)
 
std::vector< int >  get_node_tris (int node_id)
 
std::vector< int >  get_node_edges (int node_id)
  Get the edge ids that share a node.
 
bool  get_node_position_fixed (int node_id)
  Query "fixedness" state of node. A fixed node is not affecting by smoothing.
 
std::vector< std::pair< int, int > >  get_submap_corner_types (int surface_id)
  Get a list of vertex ids and the corresponding corner vertex types if the surface were defined as submap surface. There are no side affects. This does not actually assign corner types or change the underlying mesh scheme of the surface.
 
std::string  get_sideset_element_type (int sideset_id)
  Get the element type of a sideset.
 
std::string  get_block_element_type (int block_id)
  Get the element type of a block.
 
int  get_exodus_element_count (int entity_id, std::string entity_type)
  Get the number of elements in a exodus entity.
 
int  get_block_attribute_count (int block_id)
  Get the number of attributes in a block.
 
int  get_block_element_attribute_count (int block_id)
  Get the number of attributes in a block element.
 
double  get_block_attribute_value (int block_id, int attribute_index)
  Get a specific block attribute value.
 
std::string  get_block_attribute_name (int block_id, int attribute_index)
  Get a specific block attribute name.
 
std::vector< std::string >  get_block_element_attribute_names (int block_id)
  Get a specific block element attribute name.
 
std::vector< std::string >  get_valid_block_element_types (int block_id)
  Get a list of potential element types for a block.
 
int  get_block_material (int block_id)
  Get the id of the material assigned to the specified block.
 
std::vector< std::vector< int > >  get_blocks_with_materials ()
  Get the block ids and ids of the respective materials assigned to each block.
 
int  get_exodus_variable_count (std::string container_type, int container_id)
  Get the number of exodus variables in a nodeset, sideset, or block.
 
std::vector< std::string >  get_exodus_variable_names (std::string container_type, int container_id)
  Get the names of exodus variables in a nodeset, sideset, or block.
 
int  get_nodeset_node_count (int nodeset_id)
  Get the number of nodes in a nodeset.
 
int  get_geometry_node_count (const std::string &entity_type, int entity_id)
  Get the node count for a specific geometric entity.
 
void  get_owning_volume_ids (const std::string &entity_type, std::vector< int > &entity_list, std::vector< int > &volume_ids)
  Gets the id's of the volumes that are owners of one of the specified entities.
 
std::string  get_mesh_element_type (const std::string &entity_type, int entity_id)
  Get the mesh element type contained in the specified geometry.
 
Boundary Condition Support
bool  is_on_thin_shell (CI_BCTypes bc_type_enum, int entity_id)
  Determine whether a BC is on a thin shell. Valid for temperature, convection and heatflux.
 
bool  temperature_is_on_solid (CI_BCTypes bc_type_enum, int entity_id)
  Determine whether a BC temperature is on a solid. Valid for convection and temperature.
 
bool  convection_is_on_solid (int entity_id)
  Determine whether a BC convection is on a solid. Valid for convection.
 
bool  convection_is_on_shell_area (int entity_id, CI_BCEntityTypes shell_area_enum)
  Determine whether a BC convection is on a shell top or bottom. Valid for convection.
 
double  get_convection_coefficient (int entity_id, CI_BCEntityTypes bc_type_enum)
  Get the convection coefficient.
 
double  get_bc_temperature (CI_BCTypes bc_type_enum, int entity_id, CI_BCEntityTypes temp_type_enum)
  Get the temperature. Valid for convection, temperature.
 
bool  temperature_is_on_shell_area (CI_BCTypes bc_type_enum, CI_BCEntityTypes bc_area_enum, int entity_id)
  Determine whether a BC temperature is on a shell area. Valid for convection and temperature and on top, bottom, gradient, and middle.
 
bool  heatflux_is_on_shell_area (CI_BCEntityTypes bc_area_enum, int entity_id)
  Determine whether a BC heatflux is on a shell area.
 
double  get_heatflux_on_area (CI_BCEntityTypes bc_area_enum, int entity_id)
  Get the heatflux on a specified area.
 
int  get_cfd_type (int entity_id)
  Get the cfd subtype for a specified cfd BC.
 
double  get_contact_pair_friction_value (int entity_id)
  Get the contact pair's friction value.
 
double  get_contact_pair_tolerance_value (int entity_id)
  Get the contact pair's upper bound tolerance value.
 
double  get_contact_pair_tol_lower_value (int entity_id)
  Get the contact pair's lower bound tolerance value.
 
bool  get_contact_pair_tied_state (int entity_id)
  Get the contact pair's tied state.
 
bool  get_contact_pair_general_state (int entity_id)
  Get the contact pair's general state.
 
bool  get_contact_pair_exterior_state (int entity_id)
  Get the contact pair's exterior state.
 
const double *  get_displacement_dof_values (int entity_id)
  This function only available from C++ Get the displacement's dof values
 
const int *  get_displacement_dof_signs (int entity_id)
  This function only available from C++ Get the displacement's dof signs
 
const double *  get_velocity_dof_values (int entity_id)
  This function only available from C++ Get the velocity's dof values
 
const int *  get_velocity_dof_signs (int entity_id)
  This function only available from C++ Get the velocity's dof signs
 
std::string  get_velocity_combine_type (int entity_id)
  Get the velocity's combine type which is "Overwrite", "Average", "SmallestCombine", or "LargestCombine".
 
const double *  get_acceleration_dof_values (int entity_id)
  This function only available from C++ Get the acceleration's dof values
 
const int *  get_acceleration_dof_signs (int entity_id)
  This function only available from C++ Get the acceleration's dof signs
 
std::string  get_acceleration_combine_type (int entity_id)
  Get the acceleration's combine type which is "Overwrite", "Average", "SmallestCombine", or "LargestCombine".
 
std::string  get_displacement_combine_type (int entity_id)
  Get the displacement's combine type which is "Overwrite", "Average", "SmallestCombine", or "LargestCombine".
 
double  get_pressure_value (int entity_id)
  Get the pressure value.
 
std::string  get_pressure_function (int entity_id)
  Get the pressure function.
 
double  get_force_magnitude (int entity_id)
  Get the force magnitude from a force.
 
double  get_moment_magnitude (int entity_id)
  Get the moment magnitude from a force.
 
std::array< double, 3 >  get_force_direction_vector (int entity_id)
  Get the direction vector from a force.
 
std::array< double, 3 >  get_force_moment_vector (int entity_id)
  Get the moment vector from a force.
 
std::string  get_constraint_type (int constraint_id)
  Get the type of a specified constraint.
 
std::string  get_constraint_reference_point (int constraint_id)
  Get the reference point of a specified constraint.
 
std::string  get_constraint_dependent_entity_point (int constraint_id)
  Get the dependent entity of a specified constraint.
 
double  get_material_property (CI_MaterialProperty material_property_enum, int entity_id)
  Get the specified material property value.
 
int  get_media_property (int entity_id)
  Get the media property value.
 
std::vector< std::string >  get_material_name_list ()
  Get a list of all defined material names.
 
std::vector< std::string >  get_media_name_list ()
  Get a list of all defined material names.
 
std::string  get_material_name (int material_id)
  Get the name of the material (or cfd media) with the given id.
 
double  calculate_timestep_estimate (std::string entity_type, std::vector< int > entity_ids)
  Calculates time step estimate on elements of/in entity type: "Tet" or "Hex" or "Volume" or "Block" or "Group" The hexes or tets must belong to a single block and that block must have a material assigned to it. That material must have elastic_modulus, poisson_ratio, and density defined.
 
double  calculate_timestep_estimate_with_props (std::string entity_type, std::vector< int > entity_id_list, double density, double youngs_modulus, double poissons_ratio)
  Calculates time step estimate on elements of/in entity type: "Tet" or "Hex" or "Volume" or "Block" or "Group".
 
double  get_target_timestep ()
  Returns the target timestep threshold used in the timestep density multiplier metric.
 
std::vector< std::array< double, 3 > >  snap_locations_to_geometry (const std::vector< std::array< double, 3 > > &locations, std::string entity_type, int entity_id, double tol)
  Snaps xyz locations to closest point on entity. Then snaps to child curves or vertices within given tolerance. Vertices snapped to before curves.

 
std::vector< double >  measure_between_entities (std::string entity_type1, int entity_id1, std::string entity_type2, int entity_id2)
  returns distance between two geometry entities and their closest points
 
std::vector< int >  gather_surfaces_by_orientation (std::vector< int > seed_surf_ids, std::vector< int > all_surf_ids)
  Gathers connected surfaces to those in 'seed_surf_ids' that use common curves in an opposite sense. For example, if a surface A in 'seed_surf_ids' uses a curve in the FORWARD sense and it can find surface, B, that uses that same curve in a REVERSED sense, it adds B to the list. The search continues with all of surface B's curves.
All the surfaces in 'seed_surf_ids' will be returned. If the user wants to limit the scope of possible surfaces that are searched, 'all_surf_ids' can be populated. If 'all_surf_ids' is empty, all surfaces are candidates. This function can be helpful in finding enclosures when you have a set of non-manifold surfaces.
 
void  set_label_type (const char *entity_type, int label_flag)
  make calls to SVDrawTool::set_label_type

 
int  get_label_type (const char *entity_type)
  make calls to SVDrawTool::get_label_type

 
std::vector< int >  get_coordinate_systems_id_list ()
  get a list of coordinate system ids
 
std::vector< double >  get_n_largest_distances_between_meshes (int n, std::string entity_type1, std::vector< int > ids1, std::string entity_type2, std::vector< int > ids2)
  Finds the 'n' largest distances between two meshes. These distances are from the nodes on the entities of 'ids1' to the elements in 'ids2'. Only triangle and face (quads) element types are supported. It is assumed that the meshes approximately line up.
Each distance is returned with three values:
 
void  compare_geometry_and_mesh (std::vector< int > volume_ids, std::vector< int > block_ids, std::vector< int > hex_ids, std::vector< int > tet_ids, double tolerance, int &returned_unmatched_volumes_count, int &returned_unmatched_elements_count, std::vector< int > &returned_full_matches_group_ids_list, std::vector< int > &returned_partial_matches_group_ids_list, int &returned_volume_curves_group_id)
  Compare the geometry and mesh.
 
double  get_dbl_sculpt_default (const char *variable)
  return sculpt default value
 
int  get_int_sculpt_default (const char *variable)
 
bool  get_bool_sculpt_default (const char *variable)
 
std::string  get_string_sculpt_default (const char *variable)
 
double  get_blunt_tangency_default_depth (int vert_id, double angle, bool add_material)
  get default depth value for blunt tangency operation
 
std::vector< double >  get_reduce_bolt_core_default_dimensions (int vol_id)
  get default dimensions for reduce vol bolt core operation
 
double  get_bolt_diameter (int vol_id)
  get diameter of bolt shank
 
std::vector< double >  get_bolt_axis (int vol_id)
  get axis vector of bolt
 
double  get_bolt_shigley_radius (int vol_id, double angle)
  get the equivalent shigley's frustum radius at the interface surfaces between upper and lower volumes for a bolt
 
std::vector< std::vector< double > >  get_bolt_coordinate_system (std::string geom_type, int id)
  get the local coordinate system for a bolt (or bolt hole)
 
std::vector< int >  get_bolt_clamped_members (int vol_id, std::vector< int > nearby_vols)
  return the clamped members associated with a bolt in order: bearing surface member, sandwiched members (if any), threaded member
 
std::vector< int >  get_bolts_in_clamped_members (std::string geo_type, std::vector< int > clamped_vols, std::vector< int > candidate_bolts)
  return the bolts that are common to the clamped members Note: uses ML classification to determine "bolt" category
 
std::vector< BoltHoleInfo get_bolt_holes_info (std::string geo_type, std::vector< int > clamped_members, double radius_threshold, double gap_threshold)
  return the pilot hole definitions from a list of volumes. Returns a vector of BoltHole structs
 
std::vector< std::vector< int > >  get_bolt_holes (std::string geo_type, std::vector< int > clamped_members, double radius_threshold, double gap_threshold)
  returns the surfaces from upper and lower holes from the specified clamped volumes or blocks. Results can be used directly in the reduce bolt commands.
 
std::vector< int >  get_2D_sheet_volumes (int vol_id)
  get the 2D sheet volumes associated with this 3D thin volume
 
int  get_3D_thin_volume (int vol_id)
  get the 3D sheet volume associated with this 2D sheet volume
 
Boundary Layer Support
int  get_next_boundary_layer_id ()
 
bool  is_boundary_layer_id_available (int boundary_layer_id)
 
std::string  get_boundary_layer_algorithm (int boundary_layer_id)
 
std::vector< int >  get_boundary_layers_by_base (const std::string &base_type, int base_id)
 
std::vector< int >  get_boundary_layers_by_pair (const std::string &base_type, int base_id, int parent_id)
 
bool  get_boundary_layer_uniform_parameters (int boundary_layer_id, double &returned_first_row_height, double &returned_growth_factor, int &returned_number_rows)
 
bool  get_boundary_layer_aspect_first_parameters (int boundary_layer_id, double &returned_first_row_aspect, double &returned_growth_factor, int &returned_number_rows)
 
bool  get_boundary_layer_aspect_last_parameters (int boundary_layer_id, double &returned_first_row_height, int &returned_number_rows, double &returned_last_row_aspect)
 
bool  get_boundary_layer_curve_surface_pairs (int boundary_layer_id, std::vector< int > &returned_curve_list, std::vector< int > &returned_surface_list)
 
bool  get_boundary_layer_surface_volume_pairs (int boundary_layer_id, std::vector< int > &returned_surface_list, std::vector< int > &returned_volume_list)
 
bool  get_boundary_layer_vertex_intersection_types (std::vector< int > &returned_vertex_list, std::vector< int > &returned_surface_list, std::vector< std::string > &returned_types)
 
bool  get_boundary_layer_curve_intersection_types (std::vector< int > &returned_curve_list, std::vector< int > &returned_volume_list, std::vector< std::string > &returned_types)
 
bool  get_boundary_layer_continuity (int boundary_layer_id)
 
std::vector< int >  get_boundary_layer_id_list ()
 
std::vector< CFD_BC_Entity get_all_cfd_bcs ()
 
std::vector< AssemblyItem get_assembly_items ()
 
std::vector< AssemblyItem get_top_level_assembly_items ()
 
std::vector< AssemblyItem get_assembly_children (int assembly_id)
 
std::vector< int >  get_volumes_for_node (std::string node_name, int node_instance)
 
std::vector< MeshErrorFeedback * >  get_mesh_errors ()
 
int  get_mesh_error_count ()
 
Geometry from ids
CubitInterface::Body  body (int id_in)
  Gets the body object from an ID.
 
CubitInterface::Volume  volume (int id_in)
  Gets the volume object from an ID.
 
CubitInterface::Surface  surface (int id_in)
  Gets the surface object from an ID.
 
CubitInterface::Curve  curve (int id_in)
  Gets the curve object from an ID.
 
CubitInterface::Vertex  vertex (int id_in)
  Gets the vertex object from an ID.
 
void  reset ()
  Executes a reset within cubit.
 
Geometry Creation Functions
Body  brick (double width, double depth=-1, double height=-1)
  Creates a brick of specified width, depth, and height.
 
Body  sphere (double radius, int x_cut=0, int y_cut=0, int z_cut=0, double inner_radius=0)
  Creates all or part of a sphere.
 
Body  prism (double height, int sides, double major, double minor)
  Creates a prism of the specified dimensions.
 
Body  pyramid (double height, int sides, double major, double minor, double top=0.0)
  Creates a pyramid of the specified dimensions.
 
Body  cylinder (double height, double x_radius, double y_radius, double top_radius)
  creates a cylinder of the specified dimensions
 
Body  torus (double center_radius, double swept_radius)
  creates a torus of the specified dimensions
 
Vertex  create_vertex (double x=0, double y=0, double z=0)
  Creates a vertex at a x,y,z.
 
Curve  create_curve (Vertex v0, Vertex v1)
  Creates a curve between two vertices.
 
Curve  create_arc_curve (Vertex v0, Vertex v1, std::array< double, 3 > intermediate_point)
  Creates a arc curve using end vertices and an intermediate point.
 
Curve  create_spline (std::vector< std::array< double, 3 > > points, int surface_id)
  create spline through the given 3d points
 
Body  create_surface (std::vector< Curve > curves)
  Creates a surface from boundary curves.
 
std::vector< Body sweep_curve (std::vector< Curve > curves, std::vector< Curve > along_curves, double draft_angle=0, int draft_type=0, bool rigid=false)
  Create a Body or a set of Bodies from a swept curve.
 
Body  copy_body (Body init_body)
  Creates a copy of the input Body.
 
Geometry Manipulation Functions
std::vector< Body tweak_surface_offset (std::vector< Surface > surfaces, std::vector< double > distances)
  Performs a tweak surface offset command.
 
std::vector< CubitInterface::Body tweak_surface_remove (std::vector< Surface > surfaces, bool extend_ajoining=true, bool keep_old=false, bool preview=false)
  Removes a surface from a body and extends the surrounding surfaces if extend_ajoining is true.
 
std::vector< CubitInterface::Body tweak_curve_remove (std::vector< Curve > curves, bool keep_old=false, bool preview=false)
  Removes a curve from a body and extends the surrounding surface to fill the gap.
 
std::vector< Body tweak_curve_offset (std::vector< Curve > curves, std::vector< double > distances, bool keep_old=false, bool preview=false)
  Performs a tweak curve offset command.
 
std::vector< Body tweak_vertex_fillet (std::vector< Vertex > verts, double radius, bool keep_old=false, bool preview=false)
  Performs a tweak vertex fillet command.
 
std::vector< Body subtract (std::vector< CubitInterface::Body > tool_in, std::vector< CubitInterface::Body > from_in, bool imprint_in=false, bool keep_old_in=false)
  Performs a boolean subtract operation.
 
std::vector< Body unite (std::vector< CubitInterface::Body > body_in, bool keep_old_in=false)
  Performs a boolean unite operation.
 
void  move (Entity entity, std::array< double, 3 > vector, bool preview=false)
  Moves the Entity the specified vector.
 
void  scale (Entity entity, double factor, bool preview=false)
  Scales the Entity according to the specified factor.
 
void  reflect (Entity entity, std::array< double, 3 > axis, bool preview=false)
  Reflect the Entity about the specified axis.
 
void  set_nodal_variable (std::vector< int > node_ids, std::string variable_name, std::vector< double > variables)
  Sets nodal variables.
 
void  set_element_variable (std::vector< int > element_ids, std::string variable_name, std::vector< double > variables)
  Sets element variables.
 
Machine Learning Support
bool  load_ML (std::string model_type="all")
  load the machine learning training data
 
void  unload_ML (std::string model_type="all")
  unload the machine learning training data
 
std::vector< std::vector< double > >  get_ML_operation_features (std::vector< std::string > ml_op_names, std::vector< size_t > entity1_ids, std::vector< size_t > entity2_ids, std::vector< std::vector< double > > params, double mesh_size, bool reduced_features=false)
  get machine learning features for a list of cubit operations
 
std::vector< std::vector< double > >  get_ML_predictions (std::vector< std::string > ml_op_names, std::vector< size_t > entity1_ids, std::vector< size_t > entity2_ids, std::vector< std::vector< double > > params, double mesh_size, bool reduced_features=false)
  get machine learning predictions for the list of operations and corresponding entities. This function will load the ML training data if not already loaded. It will first compute features and then run predictions from training data. Uses scikit-learn EDT (Ensembles of Decision Trees) for predictions
 
std::string  get_ML_classification (std::string geom_type, size_t ent_id)
  return the name of the classification category for this surface or volume. uses same methods as get_ML_predictions for volume_no_op or classify_surface. Same as calling get_ML_operation_features + get_ML_predictions with volume_no_op and classify_surface, but returns category with highest probablity.
 
std::vector< std::string >  get_ML_classifications (std::string geom_type, std::vector< size_t > ent_ids)
  same as get_ML_classification, but classifies multiple volumes or surfaces with a single call (more efficient)
 
std::vector< std::string >  get_ML_classification_categories (std::string geom_type)
  return a list of strings representing all possible calssification categories for volumes or surfaces
 
bool  ML_train (std::string geom_type)
  force a new training. Currently implemented for only classification methods, volume_no_op and surface_no_op.
 
std::vector< std::string >  get_ML_operation_feature_types (const std::string ml_op_name, bool reduced_features=false)
  for the given operation type described by get_ML_operation_features, return a vector of strings indicating the type of data for each feature in the vector. Will return one of the following for each index:
 
std::vector< std::string >  get_ML_operation_feature_names (const std::string ml_op_name, bool reduced_features=false)
  for the given operation type described by get_ML_operation_features, return a vector of strings indicating the name of data for each feature in the vector.
 
int  get_ML_operation_feature_size (const std::string ml_op_name, const bool reduced_features=false)
  for the given operation type described by get_ML_operation_features, return the expected size of the feature vector
 
int  get_ML_operation_label_size (const std::string ml_op_name)
  for the given operation type return length of label vector the expected size of the feature vector
 
std::vector< std::string >  get_ML_classification_models ()
  get the available classification ML model names
 
std::vector< std::string >  get_ML_regression_models ()
  get the available regression ML model names
 
int  get_ML_model_ID (std::string)
  get a unique ID for the given operation/model name
 
std::string  get_ML_model_name (int model_ID)
  get the name for the given operation/model ID
 
std::vector< std::string >  get_ML_operation (const std::string op_name, const size_t entity_id1, const size_t entity_id2, const std::vector< double > params, const double small_curve_size, const double mesh_size)
  get the command, display and preview strings for a given ML operation type
 
std::vector< double >  get_ML_feature_importances (const std::string op_name)
  return the vector of feature importances for a given operation type
 
double  get_ML_feature_distance (const std::string op_name, std::vector< double > &f1, std::vector< double > &f2)
  feature distance is defined as a weighted distance between two feature vectors of the same size. Features are weighted on EDT (ensembles of decision trees) importance values.
 
void  set_ML_base_user_dir (const std::string path, const bool print_info=false)
  set the path to any user training data. (classification only)
 

CubitInterface Control

const int  CI_ERROR = -1
 
void  init (const std::vector< std::string > &argv)
  Use init to initialize Cubit. Using a blank list as the input parameter is acceptable.
 
int  destroy ()
  Closes the current journal file.
 
void  ensure_init ()
 
void  report_usage ()
 
void  process_input_files ()
  C++ only
 
void  enable_signal_handling (bool on)
  initialize/uninitialize signal handling C++ only
 
void  print_info (const std::string &message)
  Print a message using the cubit message handler.
 
void  set_cubit_message_handler (CubitMessageHandler *hdlr)
  redirect the output from cubit.
 
CubitMessageHandler *  get_cubit_message_handler ()
  get the default message handler
 
void  set_exit_handler (ExternalExitHandler *hdlr)
  Set the exit handler.
 

Detailed Description

The CubitInterface provides a Python/C++ interface into Cubit.

It provides an object oriented structure that allows a developer to manipulate objects familiar to Cubit such as bodies, volumes, surfaces, etc. It also allows developers to create and manipulate as well as query geometry.

Function Documentation

◆ add_entities_to_group()

void add_entities_to_group ( int  group_id,
const std::vector< int > &  entity_id,
const std::string &  entity_type 
)

Add a list of entities to a specific group.

void add_entities_to_group(int group_id, const std::vector< int > &entity_id, const std::string &entity_type)
Add a list of entities to a specific group.
cubit.add_entities_to_group(3, list, "surface" )
Parameters
group_id ID of group to which the entity will be added
list a vector of IDs of the entities to be added to the group
entity_type Type of the entity to be added to the group. Note that this function is valid only for geometric entities

◆ add_entity_to_group()

void add_entity_to_group ( int  group_id,
int  entity_id,
const std::string &  entity_type 
)

Add a specific entity to a specific group.

void add_entity_to_group(int group_id, int entity_id, const std::string &entity_type)
Add a specific entity to a specific group.
cubit.add_entity_to_group(3, 22, "surface" )
Parameters
group_id ID of group to which the entity will be added
entity_id ID of the entity to be added to the group
entity_type Type of the entity to be added to the group. Note that this function is valid only for geometric entities

◆ add_filename_to_recent_file_list()

void add_filename_to_recent_file_list ( std::string &  filename )

Adds the filename to the recent file list.

Parameters
filename to be added to the recent file list.

◆ add_filter_type()

void add_filter_type ( const std::string &  filter_type )

Add a filter type.

◆ are_adjacent_curves()

bool are_adjacent_curves ( std::vector< int >  curve_ids )

return whether two or more curves share at least one manifold vertex (common vertex is part of exactly two curves)

Parameters
curve_ids IDs of curves to query
Returns
whether the curves are adjacent

◆ are_adjacent_surfaces()

bool are_adjacent_surfaces ( std::vector< int >  surface_ids )

return whether two or more surfaces share at least one manifold curve (common curve is part of exactly two surfaces)

Parameters
surface_ids IDs of surfaces to query
Returns
whether the surface are adjacent

◆ auto_size_needs_to_be_calculated()

bool auto_size_needs_to_be_calculated ( )

Get whether the auto size needs to be calculated. Calculating the auto size may be expensive on complex models. The auto size may be outdated if the model has changed.

◆ best_edge_to_collapse_interior_node()

int best_edge_to_collapse_interior_node ( int  node_id )

Finds the best edge to collapse this node along to remove the interior node.

Returns
int - return the id of the edge, 0 if no edge found

◆ body()

CubitInterface::Body body ( int  id_in )

Gets the body object from an ID.

Parameters
id_in The ID of the body
Returns
The body object

◆ brick()

Body brick ( double  width,
double  depth = -1,
double  height = -1 
)

Creates a brick of specified width, depth, and height.

Parameters
[in] width The width of the brick being created
[in] depth The depth of the brick being created
[in] height The height of the brick being created
Returns
A Body object of the newly created brick

◆ calculate_timestep_estimate()

double calculate_timestep_estimate ( std::string  entity_type,
std::vector< int >  entity_ids 
)

Calculates time step estimate on elements of/in entity type: "Tet" or "Hex" or "Volume" or "Block" or "Group" The hexes or tets must belong to a single block and that block must have a material assigned to it. That material must have elastic_modulus, poisson_ratio, and density defined.

double cubit.calculate_timestep_estimate("volume" , vol_list)
Parameters
entity_type Specifies the entity type (hex, tet, volume, block, group)
ids Specifies the ids of the entity type
Returns
time step estimate (smallest time step)

◆ calculate_timestep_estimate_with_props()

double calculate_timestep_estimate_with_props ( std::string  entity_type,
std::vector< int >  entity_id_list,
double  density,
double  youngs_modulus,
double  poissons_ratio 
)

Calculates time step estimate on elements of/in entity type: "Tet" or "Hex" or "Volume" or "Block" or "Group".

double cubit.calculate_timestep_estimate_with_props("volume" , vol_list, 2.7, 70, 0.35 )
Parameters
entity_type Specifies the entity type (hex, tet, volume, block, group)
ids Specifies the ids of the entity type
density Specifies the density
youngs_modulus Specifies the Young's modulus
poissons_ratio Specifies the Poisson's ratio
Returns
time step estimate (smallest time step)

◆ clear_drawing_set()

void clear_drawing_set ( const std::string &  set_name )

Clear a named drawing set (this is for mesh preview)

◆ clear_highlight()

void clear_highlight ( )

Clear all entity highlights.

◆ clear_picked_list()

void clear_picked_list ( )

Clear the picked list.

◆ clear_preview()

void clear_preview ( )

Clear preview graphics without affecting other display settings.

◆ cmd()

bool cmd ( const char *  input_string )

Pass a command string into Cubit.

Passing a command into Cubit using this method will result in an immediate execution of the command. The command is passed directly to Cubit without any validation or other checking.

CubitInterface::cmd ("create brick x 10" );
bool cmd(const char *input_string)
Pass a command string into Cubit.
cubit.cmd("brick x 10" )
Parameters
input_string Pointer to a string containing a complete Cubit command

◆ cmd_single()

bool cmd_single ( const char *  input_string )

Pass a command string into Cubit.

Passing a command into Cubit using this method will result in an immediate execution of the command. The command is passed directly to Cubit without any validation or other checking.

CubitInterface::cubit_or_python_cmd ("create brick x 10" );
bool cubit_or_python_cmd(const std::string &input_string)
cubit.cubit_or_python_cmd("brick x 10" )
Parameters
input_string Pointer to a string containing a complete Cubit command

◆ command_is_python_mode()

bool command_is_python_mode ( )

Gets whether command handling is in python mode.

◆ compare_geometry_and_mesh()

void compare_geometry_and_mesh ( std::vector< int >  volume_ids,
std::vector< int >  block_ids,
std::vector< int >  hex_ids,
std::vector< int >  tet_ids,
double  tolerance,
int &  returned_unmatched_volumes_count,
int &  returned_unmatched_elements_count,
std::vector< int > &  returned_full_matches_group_ids_list,
std::vector< int > &  returned_partial_matches_group_ids_list,
int &  returned_volume_curves_group_id 
)

Compare the geometry and mesh.

◆ complete_filename()

void complete_filename ( std::string &  line,
int &  num_chars,
bool &  found_quote 
)

Get the file completion inside a quote based on files in the current directory. This handles completion of directories as well as filtering on specific types (.jou, .g, .sat, etc.)

Parameters
line [in/out] the line to be completed and the completed line num_chars [out] the number of characters added to the input line. If 0 there are multiple completions found_quote [out] if the end of quote was found

◆ contains_virtual()

bool contains_virtual ( const std::string &  geometry_type,
int  entity_id 
)

Query virtualality of an entity's children.

if (CubitInterface::contains_virtual ("surface" , 134)) . . .
bool contains_virtual(const std::string &geometry_type, int entity_id)
Query virtualality of an entity's children.
if cubit.contains_virtual("surface" , 134)):
Parameters
geom_type Specifies the geometry type of the entity
entity_id Specifies the id of the entity

◆ convection_is_on_shell_area()

bool convection_is_on_shell_area ( int  entity_id,
CI_BCEntityTypes  shell_area_enum 
)

Determine whether a BC convection is on a shell top or bottom. Valid for convection.

Parameters
entity_id Id of the BC convection
shell_area enum of BCEntityTypes. Use 7 to check if on top, 8 to check if on bottom
Returns
true if convection is on the shell area, otherwise false

◆ convection_is_on_solid()

bool convection_is_on_solid ( int  entity_id )

Determine whether a BC convection is on a solid. Valid for convection.

Parameters
entity_id Id of the BC convection
Returns
true if convection is on a solid, otherwise false

◆ copy_body()

Body copy_body ( Body  init_body )

Creates a copy of the input Body .

Parameters
[in] init_body The Body to be copied
Returns
A Body identical to the input Body

◆ create_arc_curve()

Curve create_arc_curve ( Vertex  v0,
Vertex  v1,
std::array< double, 3 >  intermediate_point 
)

Creates a arc curve using end vertices and an intermediate point.

Parameters
[in] v0 The start vertex
[in] v1 The end vertex
[in] intermediate_point intermideate coord
Returns
A Curve object

◆ create_curve()

Curve create_curve ( Vertex  v0,
Vertex  v1 
)

Creates a curve between two vertices.

Parameters
[in] v0 The start vertex
[in] v1 The end vertex
Returns
A Curve object

◆ create_new_group()

int create_new_group ( )

Create a new group.

Returns
group_id ID of new group

◆ create_spline()

Curve create_spline ( std::vector< std::array< double, 3 > >  points,
int  surface_id 
)

create spline through the given 3d points

Parameters
[in] coordinates of points on the spline, in order
[in] id of the surface on which to create the spline
Returns
the created curve object

◆ create_surface()

Body create_surface ( std::vector< Curve curves )

Creates a surface from boundary curves.

Parameters
[in] curves A list of curve objects from which to make the surface
Returns
A Body object of the newly created Surface

◆ create_vertex()

Vertex create_vertex ( double  x = 0,
double  y = 0,
double  z = 0 
)

Creates a vertex at a x,y,z.

Parameters
[in] x The x location of the vertex (default to 0)
[in] y The y location of the vertex (default to 0)
[in] z The z location of the vertex (default to 0)
Returns
A Vertex object

◆ cubit_or_python_cmd()

bool cubit_or_python_cmd ( const std::string &  input_string )

◆ cubit_or_python_cmds()

bool cubit_or_python_cmds ( const std::vector< std::string > &  input_strings,
std::function< void(const std::string &)> &&  history 
)

◆ cubit_or_python_cmds_as_file()

bool cubit_or_python_cmds_as_file ( const std::vector< std::string > &  input_strings,
std::function< void(const std::string &)> &&  history 
)

◆ current_selection_count()

int current_selection_count ( )

Get the current count of selected items.

◆ curve()

CubitInterface::Curve curve ( int  id_in )

Gets the curve object from an ID.

Parameters
id_in The ID of the curve
Returns
The curve object

◆ cylinder()

Body cylinder ( double  height,
double  x_radius,
double  y_radius,
double  top_radius 
)

creates a cylinder of the specified dimensions

Parameters
[in] hi the height of the cylinder
[in] r1 radius in the x direction
[in] r2 radius in the y direction
[in] r3 used to adjust the top. If set to 0, will produce a cone. If set to the larger of r1 or r2 it will create a straight cylinder.
Returns
A body object of the newly created cylinder

◆ delete_all_groups()

void delete_all_groups ( )

Delete all groups.

◆ delete_group()

void delete_group ( int  group_id )

Delete a specific group.

Parameters
group_id ID of group to delete

◆ destroy()

int destroy ( )

Closes the current journal file.

◆ developer_commands_are_enabled()

bool developer_commands_are_enabled ( )

This checks to see whether developer commands are enabled.

Returns
True if developer commands are enabled, otherwise False

◆ enable_signal_handling()

void enable_signal_handling ( bool  on )

initialize/uninitialize signal handling C++ only

Parameters
on Set to true to initialize signal handling, false to uninitialize.

◆ ensure_init()

void ensure_init ( )

◆ entity_exists()

bool entity_exists ( const std::string &  entity_type,
int  id 
)

return whether an entity of specified ID exists

bool exists = CubitInterface::entity_exists ("surface" , 12);
bool entity_exists(const std::string &entity_type, int id)
return whether an entity of specified ID exists
Parameters
entity_type Type of the entity being queried
id ID of entity
Returns
true of false whether entity exists

◆ estimate_merge_tolerance()

double estimate_merge_tolerance ( std::vector< int >  target_volume_ids,
bool  accurate_in = false,
bool  report_in = false,
double  low_value_in = -1.0,
double  high_value_in = -1.0,
int  number_calculations_in = 10,
bool  return_calculations_in = false,
std::vector< double > *  merge_tolerance_list = NULL,
std::vector< int > *  number_of_proximities_list = NULL 
)

Estimate a good merge tolerance for the passed-in volumes.

Given a list of volumes try to estimate a good merge tolerance.

Parameters
target_volume_ids List of volumes ids to examine.
accurate_in Flag specifying whether to do a lengthier, more accurate calculation.
report_in Flag specifying whether to report results to the command line.
lo_val_in Low value of range to search for merge tolerance.
hi_val_in High value of range to search for merge tolerance.
num_calculations_in Number of intervals to split search range up into.
return_calculations_in Flag specifying whether to return the number of proximities at each step.
merge_tols List containing merge tolerance at each step of calculation.
num_proximities List containing number of proximities at each step of calculation.

◆ evaluate_exterior_angle()

std::vector< int > evaluate_exterior_angle ( const std::vector< int > &  curve_list,
const double  test_angle 
)

find all curves in the given list with an exterior angle (the angle between surfaces) less than the test angle. This is equivalent to the df parser "exterior_angle" test. (draw curve with exterior_angle >90)

Parameters
curve_list a list of curve ids (integers)
test_angle the value (in degrees) that will be used in testing the exterior angle
Returns
A list (python tuple) of curve ids that meet the angle test.

◆ evaluate_exterior_angle_at_curve()

double evaluate_exterior_angle_at_curve ( int  curve_id,
int  volume_id 
)

return exterior angle at a single curve with respect to a volume

Parameters
curve id (integer) volume id (integer)
Returns
angle in degrees

◆ evaluate_surface_angle_at_vertex()

double evaluate_surface_angle_at_vertex ( int  surf_id,
int  vert_id 
)

return interior angle at a vertex on a specified surface

Parameters
surf id (integer) vert id (integer)
Returns
angle in degrees

◆ exodus_sizing_function_file_exists()

bool exodus_sizing_function_file_exists ( )

return whether the exodus sizing funnction file exists

Returns
whether the exodus sizing function file exists

◆ find_floating_volumes()

void find_floating_volumes ( std::vector< int >  target_volume_ids,
std::vector< int > &  returned_floating_id_list 
)

Get the list of volumes with no merged children.

Given a list of volumes find all of the volumes that are not attached to any other entity through a merge.

Parameters
target_volume_ids List of volumes ids to examine.
volume_list User specified list where the ids of floating volumes are returned

◆ find_nonmanifold_curves()

void find_nonmanifold_curves ( std::vector< int >  target_volume_ids,
std::vector< int > &  returned_curve_list 
)

Get the list of nonmanifold curves in the volume list.

Given a list of volumes find all of the nonmanifold curves. This is found by seeing if there is at least one merged face attached to any merged curve. If there exist merged curves that don't belong to merged faces it represents a nonmanifold case.

Parameters
target_volume_ids List of volumes ids to examine.
curve_list User specified list where the ids of nonmanifold curves are returned

◆ find_nonmanifold_vertices()

void find_nonmanifold_vertices ( std::vector< int >  target_volume_ids,
std::vector< int > &  returned_vertex_list 
)

Get the list of nonmanifold vertices in the volume list.

Given a list of volumes find all of the nonmanifold vertices. This is found by seeing if there is at least one merged curve attached to any merged vertex. If there exist merged vertices that don't belong to merged curves it represents a nonmanifold case.

Parameters
target_volume_ids List of volumes ids to examine.
vertex_list User specified list where the ids of nonmanifold vertices are returned

◆ flush_graphics()

void flush_graphics ( )

Flush the graphics.

◆ gather_surfaces_by_orientation()

std::vector< int > gather_surfaces_by_orientation ( std::vector< int >  seed_surf_ids,
std::vector< int >  all_surf_ids 
)

Gathers connected surfaces to those in 'seed_surf_ids' that use common curves in an opposite sense. For example, if a surface A in 'seed_surf_ids' uses a curve in the FORWARD sense and it can find surface, B, that uses that same curve in a REVERSED sense, it adds B to the list. The search continues with all of surface B's curves.
All the surfaces in 'seed_surf_ids' will be returned. If the user wants to limit the scope of possible surfaces that are searched, 'all_surf_ids' can be populated. If 'all_surf_ids' is empty, all surfaces are candidates. This function can be helpful in finding enclosures when you have a set of non-manifold surfaces.

seed_surf_ids = [ 15, 19, 24, 88 ]
all_surf_ids = [ 15, 19, 24, 88, 26, 104, 44, 23, 95, 342, 533, 23, ... ]
orientation_surfs = cubit.gather_surfaces_by_orientation( seed_surf_ids, all_surf_ids )

◆ get_2D_sheet_volumes()

std::vector< int > get_2D_sheet_volumes ( int  vol_id )

get the 2D sheet volumes associated with this 3D thin volume

Parameters
vol_id volume ID. Should represent a 3D thin volume
Returns
ids of the 2D sheet volumes associated with the 3D thin volume

◆ get_3D_thin_volume()

int get_3D_thin_volume ( int  vol_id )

get the 3D sheet volume associated with this 2D sheet volume

Parameters
vol_id volume ID. Should represent a 2D sheet volume
Returns
id of the 3D thin volume associated with the 2D sheet volume

◆ get_acceleration_combine_type()

std::string get_acceleration_combine_type ( int  entity_id )

Get the acceleration's combine type which is "Overwrite", "Average", "SmallestCombine", or "LargestCombine".

Parameters
entity_id Id of the acceleration
Returns
The combine type for the given acceleration

◆ get_acceleration_dof_signs()

const int * get_acceleration_dof_signs ( int  entity_id )

This function only available from C++ Get the acceleration's dof signs

Parameters
entity_id Id of the acceleration
Returns
An array of ints which are the dof signs

◆ get_acceleration_dof_values()

const double * get_acceleration_dof_values ( int  entity_id )

This function only available from C++ Get the acceleration's dof values

Parameters
entity_id Id of the acceleration
Returns
An array of doubles which are the dof values

◆ get_acis_version()

std::string get_acis_version ( )

Get the Acis version number.

Returns
A string containing the Acis version number

◆ get_acis_version_as_int()

int get_acis_version_as_int ( )

Get the Acis version number as an int.

Returns
An integer containing the Acis version number

◆ get_adjacent_surfaces()

std::vector< int > get_adjacent_surfaces ( const std::string &  geometry_type,
int  entity_id 
)

Get a list of adjacent surfaces to a specified entity.

For a specified entity, find all surfaces that own the entity and surfaces that touch the surface that owns this entity.

std::vector<int> surface_id_list;
surface_id_list = CubitInterface::get_adjacent_surfaces ("curve" , 22);
std::vector< int > get_adjacent_surfaces(const std::string &geometry_type, int entity_id)
Get a list of adjacent surfaces to a specified entity.
surface_id_list = cubit.get_adjacent_surfaces("curve" , 22)
Parameters
geom_type Specifies the geometry type of the entity
entity_id Specifies the id of the entity
Returns
A list (python tuple) of surfaces ids

◆ get_adjacent_volumes()

std::vector< int > get_adjacent_volumes ( const std::string &  geometry_type,
int  entity_id 
)

Get a list of adjacent volumes to a specified entity.

For a specified entity, find all volumes that own the entity and volumes that touch the volume that owns this entity.

std::vector<int> volume_id_list;
volume_id_list = CubitInterface::get_adjacent_volumes ("curve" , 22);
std::vector< int > get_adjacent_volumes(const std::string &geometry_type, int entity_id)
Get a list of adjacent volumes to a specified entity.
volume_id_list = cubit.get_adjacent_volumes("curve" , 22)
Parameters
geom_type Specifies the geometry type of the entity
entity_id Specifies the id of the entity
Returns
A list (python tuple) of volume ids

◆ get_all_cfd_bcs()

std::vector< CFD_BC_Entity > get_all_cfd_bcs ( )

◆ get_all_exodus_times()

std::vector< double > get_all_exodus_times ( const std::string &  filename )

Open an exodus file and get a vector of all stored time stamps.

Parameters
filename Fully qualified exodus file name
Returns
List (python tuple) of time stamps in the exodus file

◆ get_all_exodus_variable_names()

std::vector< std::string > get_all_exodus_variable_names ( const std::string &  filename,
const std::string &  variable_type 
)

Open an exodus file and get a list of all stored variable names.

Parameters
filename Fully qualified exodus file name
type Variable type - 'g', 'n', or 'e'
Returns
List (python tuple) of variable names in the exodus file

◆ get_all_geometric_owners()

std::vector< std::string > get_all_geometric_owners ( std::string  mesh_entity_type,
std::string  mesh_entity_list 
)

Get a list of geometric owners given a list of mesh entities. returns geometric owners of entity as well as all of its child mesh entities.

std::vector<std::string> owner_list;
owner_list = CubitInterface::get_all_geometric_owners ("quad" , id_list);
std::vector< std::string > get_all_geometric_owners(std::string mesh_entity_type, std::string mesh_entity_list)
Get a list of geometric owners given a list of mesh entities. returns geometric owners of entity as w...
owner_list = cubit.get_all_geometric_owners("quad" , id_list)
Parameters
mesh_entity_type The type of mesh entity. Works for 'quad, 'face', 'tri', 'hex', 'tet', 'edge', 'node'
mesh_entity_list A string containing space delimited ids, Cubit command form (i.e. 'all', '1 to 8', '1 2 3', etc)
Returns
A list (python tuple) of geometry owners in the form of 'surface x', 'curve y', etc.

◆ get_all_ids_from_name()

std::vector< int > get_all_ids_from_name ( const std::string &  geo_type,
const std::string &  name 
)

Get all ids of a geometry type with the prefix given by string.

std::vector<int> entity_ids = CubitInterface::get_all_ids_from_name ("volume" , "member_2" );
std::vector< int > get_all_ids_from_name(const std::string &geo_type, const std::string &name)
Get all ids of a geometry type with the prefix given by string.
entity_ids = cubit.get_all_ids_from_name("volume" , "member_2" )
Parameters
geo_type type of geometry entity (vertex, curve, surface, volume) name Prefix of entity name return vector of integers representing the entities that have the given name as a prefix

◆ get_aprepro_numeric_value()

double get_aprepro_numeric_value ( std::string  variable_name )

get the value of the given aprepro variable

Returns
value as double on failure returns CUBIT_DBL_MAX

◆ get_aprepro_value()

bool get_aprepro_value ( std::string  variable_name,
int &  returned_variable_type,
double &  returned_double_val,
std::string &  returned_string_val 
)

Get the value of an aprepro variable.

Parameters
var_name aprepro variable name
var_type return 0, 1 or 3 where 0=undefined 1=double/int 2=string
dval return integer or double value if var_type=1
sval return string if var_type=2
Returns
1 = success, 0 = failure (no such variable name)

◆ get_aprepro_value_as_string()

std::string get_aprepro_value_as_string ( std::string  variable_name )

Gets the string value of an aprepro variable.

Parameters
var_name aprepro variable name
Returns
The string value of the aprepro variable name

◆ get_aprepro_vars()

std::vector< std::string > get_aprepro_vars ( )

Gets the current aprepro variable names.

Returns
A list (python tuple) of the current aprepro variable names

◆ get_arc_length()

double get_arc_length ( int  curve_id )

Get the arc length of a specified curve.

Parameters
curve_id ID of the curve
Returns
Arc length of the curve

◆ get_assembly_children()

std::vector< AssemblyItem > get_assembly_children ( int  assembly_id )

◆ get_assembly_classification_category()

std::string get_assembly_classification_category ( )

Get Classification Category for metadata.

Returns
Requested data

◆ get_assembly_classification_level()

std::string get_assembly_classification_level ( )

Get Classification Level for metadata.

Returns
Requested data

◆ get_assembly_description()

std::string get_assembly_description ( int  assembly_id )

Get the stored description of an assembly node.

Parameters
assembly_id Id that identifies the assembly node
Returns
Description of the assembly node

◆ get_assembly_file_format()

std::string get_assembly_file_format ( int  assembly_id )

Get the stored file format of an assembly node.

Parameters
assembly_id Id that identifies the assembly node
Returns
File Format of the assembly node

◆ get_assembly_instance()

int get_assembly_instance ( int  assembly_id )

Get the stored instance number of an assembly node.

Parameters
assembly_id Id that identifies the assembly node
Returns
Instance of the assembly node

◆ get_assembly_items()

std::vector< AssemblyItem > get_assembly_items ( )

◆ get_assembly_level()

int get_assembly_level ( int  assembly_id )

Get the stored level of an assembly node.

Parameters
assembly_id Id that identifies the assembly node
Returns
Level of the assembly node - Level == 0 == Root

◆ get_assembly_material_description()

std::string get_assembly_material_description ( int  assembly_id )

Get the stored material description of an assembly part.

Parameters
assembly_id Id that identifies the assembly node
Returns
Material Description of the assembly part

◆ get_assembly_material_specification()

std::string get_assembly_material_specification ( int  assembly_id )

Get the stored material specification of an assembly part.

Parameters
assembly_id Id that identifies the assembly node
Returns
Material Specification of the assembly part

◆ get_assembly_metadata()

std::string get_assembly_metadata ( int  volume_id,
int  data_type 
)

Get metadata for a specified volume id.

Parameters
volume_id ID of the volume
data_type Magic number representing the type of assembly information to return. 1 = Part Number, 2 = Description, 3 = Material Description 4 = Material Specification, 5 = Assembly Path, 6 = Original File
Returns
Requested data

◆ get_assembly_name()

std::string get_assembly_name ( int  assembly_id )

Get the stored name of an assembly node.

Parameters
assembly_id Id that identifies the assembly node
Returns
Name of the assembly node

◆ get_assembly_path()

std::string get_assembly_path ( int  assembly_id )

Get the stored path of an assembly node.

Parameters
assembly_id Id that identifies the assembly node
Returns
Path of the assembly node

◆ get_assembly_type()

std::string get_assembly_type ( int  assembly_id )

Get the stored type of an assembly node.

Parameters
assembly_id Id that identifies the assembly node
Returns
Type of the assembly node – 'part' or 'assembly'

◆ get_assembly_units()

std::string get_assembly_units ( int  assembly_id )

Get the stored units measure of an assembly node.

Parameters
assembly_id Id that identifies the assembly node
Returns
Units of the assembly node

◆ get_assembly_weapons_category()

std::string get_assembly_weapons_category ( )

Get Weapons Category for metadata.

Returns
Requested data

◆ get_auto_size()

double get_auto_size ( const std::string &  geometry_type,
std::vector< int >  entity_id_list,
double  size 
)

Get the auto size for a given set of enitities. Note, this does not actually set the interval size on the volumes. It simply returns the size that would be set if an 'size auto factor n' command were issued.

Parameters
entity_type Specifies the geometry type of the entity
enitty_id_list List (vector) of entity ids
size The auto factor for the AutoSizeTool
Returns
The interval size from the AutoSizeTool

◆ get_bad_geometry()

void get_bad_geometry ( std::vector< int >  target_volume_ids,
std::vector< int > &  returned_body_list,
std::vector< int > &  returned_volume_list,
std::vector< int > &  returned_surface_list,
std::vector< int > &  returned_curve_list 
)

This function only works from C++ Get the list of bad geometry for a list of volumes

Bad geometry can be any number of problems associated with poorly defined ACIS geometry.

Parameters
target_volume_ids List of volume ids to examine.
body_list User specified list where ids of bad bodies will be returned
volume_list User specified list where ids of bad volumes will be returned
surface_list User specified list where ids of bad surfaces will be returned
curve_list User specified list where ids of bad curves will be returned

◆ get_bc_id_list()

std::vector< int > get_bc_id_list ( CI_BCTypes  bc_type_enum )

Get a list of all bcs of a specified type.

Parameters
bc_type_in as an enum defined by CI_BCTypes. 1-9 is FEA, 10-30 is CFD
Returns
List (python tuple) of all active bc ids

◆ get_bc_name()

std::string get_bc_name ( CI_BCTypes  bc_type_enum,
int  bc_id 
)

Get the name for the specified bc.

Parameters
bc_type_in type of bc, as defined by enum CI_BCTypes. 1-9 is FEA, 10-30 is CFD
bc_id ID of the desired bc.
Returns
The bc name

◆ get_bc_temperature()

double get_bc_temperature ( CI_BCTypes  bc_type_enum,
int  entity_id,
CI_BCEntityTypes  temp_type_enum 
)

Get the temperature. Valid for convection, temperature.

Parameters
bc_type enum of CI_BCTypes. temperature = 4, convection = 7
entity_id Id of the BC convection
temp_type enum of CI_BCEntityTypes (normal, shell top, shell bottom). For convection, 2 if on solid, 7 if on top, 8 if on bottom. For temperature, 3 if on solid, 7 for top, 8 for bottom, 9 for gradient, 10 for middle
Returns
The value of the specified BC temperature

◆ get_blend_chain_collections()

std::vector< std::pair< std::vector< int >, double > > get_blend_chain_collections ( const std::vector< int > &  volume_list,
double  radius_threshold 
)

Returns the collections of surfaces that comprise blend chains in the specified volumes. Filter by radius threshold.

Parameters
volume_list List of volumes to query
radius_threshold resturn only blend chains less than radius_threshold
return_radii return a vector of blend chain radii corresponding to the return blend chains lists
Returns
A list of lists of surface id's grouped by their individual blend chain

◆ get_blend_chains()

std::vector< std::vector< int > > get_blend_chains ( int  surface_id )

Returns the blend chains for a surface.

Parameters
surface_id surface to retrieve the blend chains from
Returns
A list of lists of id's in each blend chain. Note: If using python, lists will be python tuples.

◆ get_blend_surfaces()

std::vector< int > get_blend_surfaces ( std::vector< int >  target_volume_ids )

Get the list of blend surfaces for a list of volumes.

Parameters
target_volume_ids List of volume ids to examine.
Returns
List (python tuple) of blend surface ids

◆ get_block_attribute_count()

int get_block_attribute_count ( int  block_id )

Get the number of attributes in a block.

Parameters
block_id The block id
Returns
Number of attributes in the block

◆ get_block_attribute_name()

std::string get_block_attribute_name ( int  block_id,
int  attribute_index 
)

Get a specific block attribute name.

Parameters
block_id The block id
index The index of the attribute
Returns
Attribute name as a std::string

◆ get_block_attribute_value()

double get_block_attribute_value ( int  block_id,
int  attribute_index 
)

Get a specific block attribute value.

Parameters
block_id The block id
index The index of the attribute
Returns
List of attributes

◆ get_block_children()

void get_block_children ( int  block_id,
std::vector< int > &  returned_group_list,
std::vector< int > &  returned_node_list,
std::vector< int > &  returned_sphere_list,
std::vector< int > &  returned_edge_list,
std::vector< int > &  returned_tri_list,
std::vector< int > &  returned_face_list,
std::vector< int > &  returned_pyramid_list,
std::vector< int > &  returned_tet_list,
std::vector< int > &  returned_hex_list,
std::vector< int > &  returned_wedge_list,
std::vector< int > &  returned_volume_list,
std::vector< int > &  returned_surface_list,
std::vector< int > &  returned_curve_list,
std::vector< int > &  returned_vertex_list 
)

Get lists of any and all possible children of a block.

A block can contain a variety of entity types. This routine will return all contents of a specified block.

Parameters
block_id ID of block to examine
group_list User specified list where groups associated with this block are returned
node_list User specified list where nodes associated with this block are returned
edge_list User specified list where edges associated with this block are returned
tri_list User specified list where tris associated with this block are returned
face_list User specified list where faces associated with this block are returned
pyramid_list User specified list where pyramids associated with this block are returned
tet_list User specified list where tets associated with this block are returned
hex_list User specified list where hexes associated with this block are returned
volume_list User specified list where volumes associated with this block are returned
surface_list User specified list where surfaces associated with this block are returned
curve_list User specified list where curves associated with this block are returned
vertex_list User specified list where vertices associated with this block are returned

◆ get_block_count()

int get_block_count ( )

Get the current number of blocks.

Returns
The number of blocks in the current model, if any

◆ get_block_curves()

std::vector< int > get_block_curves ( int  block_id )

Get a list of curve associated with a specific block.

Parameters
block_id User specified id of the desired block
Returns
A list (python tuple) of curve ids contained in the block

◆ get_block_edges()

std::vector< int > get_block_edges ( int  block_id )

Get a list of edges associated with a specific block.

Parameters
block_id User specified id of the desired block
Returns
A list (python tuple) of edge ids contained in the block

◆ get_block_element_attribute_count()

int get_block_element_attribute_count ( int  block_id )

Get the number of attributes in a block element.

Parameters
block_id The block id
Returns
Number of attributes in the block element

◆ get_block_element_attribute_names()

std::vector< std::string > get_block_element_attribute_names ( int  block_id )

Get a specific block element attribute name.

Parameters
block_id The block id
index The index of the attribute
Returns
Attribute name as a std::string

◆ get_block_element_type()

std::string get_block_element_type ( int  block_id )

Get the element type of a block.

Parameters
block_id The block id
Returns
Element type

◆ get_block_elements_and_nodes()

bool get_block_elements_and_nodes ( int  block_id,
std::vector< int > &  returned_node_list,
std::vector< int > &  returned_sphere_list,
std::vector< int > &  returned_edge_list,
std::vector< int > &  returned_tri_list,
std::vector< int > &  returned_face_list,
std::vector< int > &  returned_pyramid_list,
std::vector< int > &  returned_wedge_list,
std::vector< int > &  returned_tet_list,
std::vector< int > &  returned_hex_list 
)

Get lists of the nodes and different element types associated with this block. This function is recursive, meaning that if the block was created pointing to a piece of geometry, it will traverse down and get the mesh entities associated to that geometry.

Parameters
block_id User specified id of the desired block A list (python tuple) of node ids contained in the block A list (python tuple) of edge ids contained in the block A list (python tuple) of tri ids contained in the block A list (python tuple) of quad ids contained in the block A list (python tuple) of pyramid ids contained in the block A list (python tuple) of wedge ids contained in the block A list (python tuple) of tet ids contained in the block A list (python tuple) of hex ids contained in the block
Returns
true for success, otherwise false

◆ get_block_faces()

std::vector< int > get_block_faces ( int  block_id )

Get a list of faces associated with a specific block.

Parameters
block_id User specified id of the desired block
Returns
A list (python tuple) of face ids contained in the block

◆ get_block_hexes()

std::vector< int > get_block_hexes ( int  block_id )

Get a list of hexes associated with a specific block.

Parameters
block_id User specified id of the desired block
Returns
A list (python tuple) of hex ids contained in the block

◆ get_block_id()

int get_block_id ( std::string  entity_type,
int  entity_id 
)

Get the associated block id for a specific curve, surface, or volume.

int block_id = CubitInterface::get_block_id ("surface" , 33);
int get_block_id(std::string entity_type, int entity_id)
Get the associated block id for a specific curve, surface, or volume.
block_id = cubit.get_block_id("surface" , 33)
Parameters
entity_type Type of entity
entity_id Id of entity in question
Returns
Block id associated with this entity or zero (0) if none

◆ get_block_id_list()

std::vector< int > get_block_id_list ( )

Get a list of all blocks.

Returns
List (python tuple) of all active block ids

◆ get_block_ids()

std::vector< int > get_block_ids ( const std::string &  mesh_geometry_file_name )

Get list of block ids from a mesh geometry file.

Parameters
mesh_geom_file_name Fully qualified name of a mesh geometry file
Returns
List of block ids in the mesh geometry file

◆ get_block_material()

int get_block_material ( int  block_id )

Get the id of the material assigned to the specified block.

Returns
The material id. If no material has been assigned to the block, returns 0.

◆ get_block_nodes()

std::vector< int > get_block_nodes ( int  block_id )

Get a list of nodes associated with a specific block.

Parameters
block_id User specified id of the desired block
Returns
A list (python tuple) of node ids contained in the block

◆ get_block_pyramids()

std::vector< int > get_block_pyramids ( int  block_id )

Get a list of pyramids associated with a specific block.

Parameters
block_id User specified id of the desired block
Returns
A list (python tuple) of pyramid ids contained in the block

◆ get_block_surfaces()

std::vector< int > get_block_surfaces ( int  block_id )

Get a list of surface associated with a specific block.

Parameters
block_id User specified id of the desired block
Returns
A list (python tuple) of surface ids contained in the block

◆ get_block_tets()

std::vector< int > get_block_tets ( int  block_id )

Get a list of tets associated with a specific block.

Parameters
block_id User specified id of the desired block
Returns
A list (python tuple) of tet ids contained in the block

◆ get_block_tris()

std::vector< int > get_block_tris ( int  block_id )

Get a list of tris associated with a specific block.

Parameters
block_id User specified id of the desired block
Returns
A list (python tuple) of tri ids contained in the block

◆ get_block_vertices()

std::vector< int > get_block_vertices ( int  block_id )

Get a list of vertices associated with a specific block.

Parameters
block_id User specified id of the desired block
Returns
A list (python tuple) of vertex ids contained in the block

◆ get_block_volumes()

std::vector< int > get_block_volumes ( int  block_id )

Get a list of volume ids associated with a specific block.

Parameters
block_id User specified id of the desired block
Returns
A list (python tuple) of volume ids contained in the block

◆ get_block_wedges()

std::vector< int > get_block_wedges ( int  block_id )

Get a list of wedges associated with a specific block.

Parameters
block_id User specified id of the desired block
Returns
A list (python tuple) of wedges ids contained in the block

◆ get_blocks_with_materials()

std::vector< std::vector< int > > get_blocks_with_materials ( )

Get the block ids and ids of the respective materials assigned to each block.

Returns
List of tuples ([block_1_id, material_1_id], [block_2_id, material_2_id], ...) for each block, whether or not it has a material. If no material has been assigned to the block, returns 0.

◆ get_blunt_tangency_default_depth()

double get_blunt_tangency_default_depth ( int  vert_id,
double  angle,
bool  add_material 
)

get default depth value for blunt tangency operation

Returns
depth

◆ get_body_count()

int get_body_count ( )

Get the current number of bodies.

Returns
The number of bodies in the current model, if any

◆ get_bolt_axis()

std::vector< double > get_bolt_axis ( int  vol_id )

get axis vector of bolt

Parameters
vol_id volume ID. Should represent bolt geometry
Returns
normalized axis vector of bolt ([0,0,0] if invalid volume or couldn't determine)

◆ get_bolt_clamped_members()

std::vector< int > get_bolt_clamped_members ( int  vol_id,
std::vector< int >  nearby_vols 
)

return the clamped members associated with a bolt in order: bearing surface member, sandwiched members (if any), threaded member

Parameters
vol_id volume ID. Should represent bolt geometry
nearby_vols (optional) list of volumes to select from. If empty, it will compute these, however is less efficient
Returns
list of ordered clamped members as volume IDs

◆ get_bolt_coordinate_system()

std::vector< std::vector< double > > get_bolt_coordinate_system ( std::string  geom_type,
int  id 
)

get the local coordinate system for a bolt (or bolt hole)

Parameters
geom_type either "bolt" or "hole". geometry we are returning the coordinate from
id id of a bolt volume or id of one of the surfaces in the hole geometry
Returns
coordinate system as three point defined as double vectors
coord_system = cubit.get_bolt_coord_system("bolt" , bolt_id)
origin = coord_system[0]
z_point = coord_system[1]
xz_point = coord_system[2]

◆ get_bolt_diameter()

double get_bolt_diameter ( int  vol_id )

get diameter of bolt shank

Parameters
vol_id volume ID. Should represent bolt geometry
Returns
diameter of bolt (0 if invalid volume or couldn't determine)

◆ get_bolt_holes()

std::vector< std::vector< int > > get_bolt_holes ( std::string  geo_type,
std::vector< int >  clamped_members,
double  radius_threshold,
double  gap_threshold 
)

returns the surfaces from upper and lower holes from the specified clamped volumes or blocks. Results can be used directly in the reduce bolt commands.

Parameters
geo_type "volume" or "block"
clamped_members list of volume IDs that may have one or more concentic holes used as pilot holes for fasteners
radius_threshold looks for holes with radius less than or equal to this value
gap_threshold looks for concentric holes at neighboring volumes that are closer than this value
Returns
pair of lists of surfaces. First list contains the upper holes and the second contains the lower holes. Only one surface per hole is included in the list. There will be at least one coaxial hole surface in in the lower that matches the upper. For case of sandwiched volumes, there may be additional lower.

◆ get_bolt_holes_info()

std::vector< BoltHoleInfo > get_bolt_holes_info ( std::string  geo_type,
std::vector< int >  clamped_members,
double  radius_threshold,
double  gap_threshold 
)

return the pilot hole definitions from a list of volumes. Returns a vector of BoltHole structs

Parameters
geo_type "volume" or "block"
clamped_members list of volume IDs that may have one or more concentic holes used as pilot holes for fasteners
radius_threshold looks for holes with radius less than or equal to this value
gap_threshold looks for concentric holes at neighboring volumes that are closer than this value
Returns
list of BoltHoleInfo structs. Describes the ordered list of hole surfaces, diameters, axis and associated clamped volumes

◆ get_bolt_shigley_radius()

double get_bolt_shigley_radius ( int  vol_id,
double  angle 
)

get the equivalent shigley's frustum radius at the interface surfaces between upper and lower volumes for a bolt

Parameters
vol_id volume ID. Should represent bolt geometry
angle Angle used to define the Shigley's frustum. 30 degrees is standard
Returns
radius of a circle at the bolt. (-1 if error)

◆ get_bolts_in_clamped_members()

std::vector< int > get_bolts_in_clamped_members ( std::string  geo_type,
std::vector< int >  clamped_vols,
std::vector< int >  candidate_bolts 
)

return the bolts that are common to the clamped members Note: uses ML classification to determine "bolt" category

Parameters
geo_type "volume" or "block".
clamped_vols list of volume or block IDs that are clamped by one or more bolts
candidate_bolts optional list of bolts to choose from. Note that the ML classification will be run on nearby volumes to determine if they are bolts. This vector is useful if the classification of parts has already been done and there are known list of bolts in the volume. Avoids having to recompute ML classifications.
Returns
list of volume IDs that are classified as bolts that clamp the given volumes or blocks.

◆ get_bool_sculpt_default()

bool get_bool_sculpt_default ( const char *  variable )

◆ get_boundary_layer_algorithm()

std::string get_boundary_layer_algorithm ( int  boundary_layer_id )

◆ get_boundary_layer_aspect_first_parameters()

bool get_boundary_layer_aspect_first_parameters ( int  boundary_layer_id,
double &  returned_first_row_aspect,
double &  returned_growth_factor,
int &  returned_number_rows 
)

◆ get_boundary_layer_aspect_last_parameters()

bool get_boundary_layer_aspect_last_parameters ( int  boundary_layer_id,
double &  returned_first_row_height,
int &  returned_number_rows,
double &  returned_last_row_aspect 
)

◆ get_boundary_layer_continuity()

bool get_boundary_layer_continuity ( int  boundary_layer_id )

◆ get_boundary_layer_curve_intersection_types()

bool get_boundary_layer_curve_intersection_types ( std::vector< int > &  returned_curve_list,
std::vector< int > &  returned_volume_list,
std::vector< std::string > &  returned_types 
)

◆ get_boundary_layer_curve_surface_pairs()

bool get_boundary_layer_curve_surface_pairs ( int  boundary_layer_id,
std::vector< int > &  returned_curve_list,
std::vector< int > &  returned_surface_list 
)

◆ get_boundary_layer_id_list()

std::vector< int > get_boundary_layer_id_list ( )

◆ get_boundary_layer_surface_volume_pairs()

bool get_boundary_layer_surface_volume_pairs ( int  boundary_layer_id,
std::vector< int > &  returned_surface_list,
std::vector< int > &  returned_volume_list 
)

◆ get_boundary_layer_uniform_parameters()

bool get_boundary_layer_uniform_parameters ( int  boundary_layer_id,
double &  returned_first_row_height,
double &  returned_growth_factor,
int &  returned_number_rows 
)

◆ get_boundary_layer_vertex_intersection_types()

bool get_boundary_layer_vertex_intersection_types ( std::vector< int > &  returned_vertex_list,
std::vector< int > &  returned_surface_list,
std::vector< std::string > &  returned_types 
)

◆ get_boundary_layers_by_base()

std::vector< int > get_boundary_layers_by_base ( const std::string &  base_type,
int  base_id 
)

◆ get_boundary_layers_by_pair()

std::vector< int > get_boundary_layers_by_pair ( const std::string &  base_type,
int  base_id,
int  parent_id 
)

◆ get_bounding_box()

std::array< double, 10 > get_bounding_box ( const std::string &  geometry_type,
int  entity_id 
)

Get the bounding box for a specified entity.

std::array<double, 10> vector_list;
vector_list = CubitInterface::get_bounding_box ("surface" , 22);
std::array< double, 10 > get_bounding_box(const std::string &geometry_type, int entity_id)
Get the bounding box for a specified entity.
vector_list = cubit.get_bounding_box("surface" , 22)
Parameters
geom_type Specifies the geometry type of the entity
entity_id Specifies the id of the entity
Returns
A vector (python tuple) of coordinates describing the entity's bounding box. Ten (10) values will be: [0] = minx [1] = maxx [2] = boxx range [3] = miny [4] = maxy [5] = boxy range [6] = minz [7] = maxz [8] = boxz range [9] = box diagonal length

◆ get_build_number()

std::string get_build_number ( )

Get the Cubit build number.

Returns
A string containing the current Cubit build number

◆ get_cavity_surfaces()

std::vector< int > get_cavity_surfaces ( int  surface_id )

Returns the adjacent surfaces in a cavity for a surface.

Parameters
surface_id that is part of the cavity
Returns
A list of surface id's in the cavity (including surface_id).

◆ get_center_point()

std::array< double, 3 > get_center_point ( const std::string &  entity_type,
int  entity_id 
)

Get the center point of a specified entity.

std::array<double,3> center_point;
center_point = CubitInterface::get_center_point ("surface" , 22);
std::array< double, 3 > get_center_point(const std::string &entity_type, int entity_id)
Get the center point of a specified entity.
center_point = cubit.get_center_point("surface" , 22)
Parameters
entity_type Specifies the geometry type of the entity
entity_id Specifies the id of the entity
Returns
Vector (python tuple) of doubles representing x y z

◆ get_cfd_type()

int get_cfd_type ( int  entity_id )

Get the cfd subtype for a specified cfd BC.

Parameters
entity_id ID of the cfd BC
Returns
Integer corresponding to the type of cfd, as defined by CI_BCTypes

◆ get_chamfer_chain_collections()

std::vector< std::pair< std::vector< int >, double > > get_chamfer_chain_collections ( const std::vector< int > &  volume_list,
double  thickness_threshold 
)

Returns the collections of surfaces that comprise chamfers in the specified volumes. Filter by thickness of chamfer.

Parameters
volume_list List of volumes to query
radius_threshold resturn only chamfer chains less than thickness_threshold
return_radii return a vector of chamfer chain radii corresponding to the return chamfer chains lists
Returns
A list of lists of surface id's grouped by their individual chamfer_chain

◆ get_chamfer_chains()

std::vector< std::vector< int > > get_chamfer_chains ( int  surface_id )

Returns the chamfer chains for a surface.

Parameters
surface_id surface to retrieve the chamfer chains from
Returns
A list of lists of id's in each chamfer chain. Note: If using python, lists will be python tuples.

◆ get_chamfer_surfaces()

std::vector< std::vector< double > > get_chamfer_surfaces ( std::vector< int >  target_volume_ids,
double  thickness_threshold 
)

Get the list of chamfer surfaces for a list of volumes.

Parameters
target_volume_ids List of volume ids to examine.
thickness_threshold max thickness criteria for chamfer
Returns
List (python tuple) of chamfer surface ids (as doubles) and their thicknesses

◆ get_close_loop_thickness()

double get_close_loop_thickness ( int  surface_id )

Get the thickness of a close loop surface.

Parameters
surafce id
Returns
List (python tuple) of close loop (surface) ids

◆ get_close_loops()

std::vector< int > get_close_loops ( std::vector< int >  target_volume_ids,
double  mesh_size 
)

Get the list of close loops (surfaces) for a list of volumes.

'Small' or 'Close' is a function of the mesh_size passed into the routine. The mesh_size parameter will act as the threshold for determining what 'small' is. A small entity is one that has an edge length smaller than mesh_size.

Parameters
target_volume_ids List of volume ids to examine.
mesh_size Indicate the mesh size used as the threshold
Returns
List (python tuple) of close loop (surface) ids

◆ get_close_loops_with_thickness()

std::vector< std::vector< double > > get_close_loops_with_thickness ( std::vector< int >  target_volume_ids,
double  mesh_size,
int  genus 
)

Get the list of close loops (surfaces) for a list of volumes also return the corresponding minimum distances for each surface.

'Small' or 'Close' is a function of the mesh_size passed into the routine. The mesh_size parameter will act as the threshold for determining what 'small' is. A small entity is one that has an edge length smaller than mesh_size.

Parameters
target_volume_ids List of volume ids to examine.
mesh_size Indicate the mesh size used as the threshold
genus Indicate the genus of the surfaces requested. Genus is defined as the number of loops on the surface minus 1. To return any genus surface in the volume(s), use genus < 0
Returns
List (python tuple) of close loop (surface) ids

◆ get_close_vertex_curve_pairs()

std::vector< int > get_close_vertex_curve_pairs ( std::vector< int >  target_volume_ids,
double  high_tolerance 
)

Get the list of close vertex-curve pairs (python callable)

Parameters
target_volume_list List of volumes ids to examine.
Returns
Paired list (python tuple) of vertex and curve ids considered coincident

◆ get_closed_narrow_surfaces()

std::vector< int > get_closed_narrow_surfaces ( std::vector< int >  target_ids,
double  narrow_size 
)

Get the list of closed, narrow surfaces from a list of volumes.

Parameters
target_volume_ids List of volume ids to examine.
narrow_size Indicate the narrow size threshold
Returns
List (python tuple) of close, narrow surface ids

◆ get_closest_node()

int get_closest_node ( double  x_coordinate,
double  y_coordinate,
double  z_coordinate 
)

Get the node closest to the given coordinates.

Parameters
x coordinate
y coordinate
z coordinate
Returns
id of closest node, 0 if none found

◆ get_closest_vertex_curve_pairs()

void get_closest_vertex_curve_pairs ( std::vector< int >  target_ids,
int &  returned_number_to_return,
std::vector< int > &  returned_vertex_ids,
std::vector< int > &  returned_curve_ids,
std::vector< double > &  returned_distances 
)

Find the n closest vertex pairs in the model.

Given a list of volumes find the n closest vertex curve pairs. The checks will be done on a surface by surface basis so that only curve-vertex pairs within a given surface will be returned. This function is for finding the smallest features within the surfaces of the model.

Parameters
target_ids List of volumes ids to examine.
num_to_return Number of vertex curve pairs to return.
vert_ids Ids of returned vertices.
curve_ids Ids of returned curves.
distances Vertex-curve pair distances.

◆ get_coincident_entity_pairs()

void get_coincident_entity_pairs ( std::vector< int >  target_volume_ids,
std::vector< int > &  returned_v_v_vertex_list,
std::vector< int > &  returned_v_c_vertex_list,
std::vector< int > &  returned_v_c_curve_list,
std::vector< int > &  returned_v_s_vertex_list,
std::vector< int > &  returned_v_s_surf_list,
std::vector< double > &  returned_vertex_distance_list,
std::vector< double > &  returned_curve_distance_list,
std::vector< double > &  returned_surf_distance_list,
double  low_value,
double  high_value,
bool  do_vertex_vertex = true,
bool  do_vertex_curve = true,
bool  do_vertex_surf = true,
bool  filter_same_volume_cases = false 
)

Get the list of coincident vertex-vertex, vertex-curve, and vertex-surface pairs and distances from a list of volumes.

Given a list of volumes get lists of coincident vertex-vertex, vertex-curve, and vertex-surface pairs and their distances based on the passed-in thresholds. The returned lists will be exactly double the size of the distance lists. For each distance, 2 entities will be associated at the same relative place in the list.

Parameters
target_volume_ids List of volumes ids to examine.
do_vertex_vertex Parameter specifying whether to do vertex-vertex check.
do_vertex_curve Parameter specifying whether to do vertex-curve check.
do_vertex_surf Parameter specifying whether to do vertex-surface check.
v_v_vertex_list User specified list where the ids of coincident vertex pairs are returned
v_c_vertex_list User specified list where the ids of the vertices of coincident vertex-curve pairs are returned
v_c_curve_list User specified list where the ids of the curves of coincident vertex-curve pairs are returned
v_s_vertex_list User specified list where the ids of the vertices of coincident vertex-surface pairs are returned
v_s_surf_list User specified list where the ids of the surfaces of coincident vertex-surface pairs are returned
vertex_distance_list User specified list where the vertex-vertex distance values will be returned
curve_distance_list User specified list where the vertex-curve distance values will be returned
surf_distance_list User specified list where the vertex-surface distance values will be returned
low_value User specified low threshold value
hi_value User specified high threshold value
filter_same_volume_cases Parameter specifying whether to weed out entity pairs that are in the same volume.

◆ get_coincident_vertex_curve_pairs()

void get_coincident_vertex_curve_pairs ( std::vector< int >  target_volume_ids,
std::vector< int > &  returned_vertex_list,
std::vector< int > &  returned_curve_list,
std::vector< double > &  returned_distance_list,
double  low_value,
double  threshold_value,
bool  filter_same_volume_cases = false 
)

Get the list of coincident vertex/curve pairs and distances from a list of volumes.

Given a list of volumes get a list of coincident vertex/curve pairs and their distances based on the current merge tolerance value and a threshold value. The returned lists will be of equal length and matched by order.

Parameters
target_volume_ids List of vertices ids to examine.
vertex_list User specified list for the ids of coincident vertices
curve_list User specified list for the ids of coincident curves
distance_list User specified list where the distance values will be returned
threshold_value User specified threshold value

◆ get_coincident_vertex_surface_pairs()

void get_coincident_vertex_surface_pairs ( std::vector< int >  target_volume_ids,
std::vector< int > &  returned_vertex_list,
std::vector< int > &  returned_surface_list,
std::vector< double > &  returned_distance_list,
double  low_value,
double  threshold_value,
bool  filter_same_volume_cases = false 
)

Get the list of coincident vertex/surface pairs and distances from a list of volumes.

Given a list of volumes get a list of coincident vertex/pairs pairs and their distances based on the current merge tolerance value and a threshold value. The returned lists will be of equal length and matched by order.

Parameters
target_volume_ids List of vertices ids to examine.
vertex_list User specified list for the ids of coincident vertices
surface_list User specified list for the ids of coincident surfaces
distance_list User specified list where the distance values will be returned
threshold_value User specified threshold value

◆ get_coincident_vertex_vertex_pairs()

void get_coincident_vertex_vertex_pairs ( std::vector< int >  target_volume_ids,
std::vector< int > &  returned_vertex_pair_list,
std::vector< double > &  returned_distance_list,
double  low_value,
double  threshold_value,
bool  filter_same_volume_cases = false 
)

Get the list of coincident vertex pairs and distances from a list of volumes.

Given a list of volumes get a list of coincident vertex pairs and their distances based on the current merge tolerance value and a threshold. The returned vertex list will be exactly double the size of the distance list. For each distance, 2 vertices will be associated at the same relative place in the list.

Parameters
target_volume_ids List of volumes ids to examine.
vertex_pair_list User specified list where the ids of coincident vertex pairs be returned
distance_list User specified list where the distance values will be returned
threshold_value User specified threshold value

◆ get_coincident_vertices()

std::vector< int > get_coincident_vertices ( std::vector< int >  target_volume_ids,
double  high_tolerance 
)

Get the list of coincident vertex pairs

Parameters
target_volume_list List of volumes ids to examine.
Returns
Paired list (python tuple) of vertex ids considered coincident

◆ get_command_from_history()

std::string get_command_from_history ( int  command_number )

Get a specific command from Cubit's command history buffer.

Returns
A string which is the command at the given index

◆ get_command_history_count()

int get_command_history_count ( )

◆ get_common_curve_id()

int get_common_curve_id ( int  surface_1_id,
int  surface_2_id 
)

Given 2 surfaces, get the common curve id.

Parameters
surface_1_id The id of one of the surfaces
surface_2_id The id of the other surface
Returns
The id of the curve common to the two surfaces

◆ get_common_vertex_id()

int get_common_vertex_id ( int  curve_1_id,
int  curve_2_id 
)

Given 2 curves, get the common vertex id.

Parameters
curve_1_id The id of one of the curves
curve_2_id The id of the other curves
Returns
The id of the vertex common to the two curves, 0 if there is none

◆ get_cone_surfaces()

std::vector< int > get_cone_surfaces ( std::vector< int >  target_volume_ids )

return a list of surfaces that are cones defined by a conic surface and a hard point

Parameters
target_volume_ids List of volume ids to examine.

◆ get_connected_surfaces()

std::vector< int > get_connected_surfaces ( std::vector< int >  surf_ids )

Get a connected set of surfaces to the ones specified.

Given the surfaces ids specified, finds all connected surfaces. The surfaces are first grouped into 'patches' of connected surfaces (surfaces sharing common curves). In all cases below, merged surfaces are excluded.
Depending on the patches, the ensuing behavior is:

  1. If a single patch is passed in, all connected surfaces are found, excluding any merged surfaces.
  2. If two patches are passed in, get all surfaces between the two patches.
  3. If more than one patch is found, return an empty list.
Parameters
surface_ids IDs of surfaces to start with
Returns
list of IDs of connected surfaces

◆ get_connectivity()

std::vector< int > get_connectivity ( const std::string &  entity_type,
int  entity_id 
)

Get the list of node ids contained within a mesh entity.

std::vector<int> node_id_list;
node_id_list = CubitInterface::get_connectivity ("hex" , 221);
std::vector< int > get_connectivity(const std::string &entity_type, int entity_id)
Get the list of node ids contained within a mesh entity.
node_id_list = cubit.get_connectivity("hex" , 221)
Parameters
entity_type The mesh element type
entity_id The mesh element id
Returns
List (python tuple) of node ids

◆ get_constraint_dependent_entity_point()

std::string get_constraint_dependent_entity_point ( int  constraint_id )

Get the dependent entity of a specified constraint.

Parameters
constraint_id ID of the constraint
Returns
A std::string indicating the dependent entity

◆ get_constraint_reference_point()

std::string get_constraint_reference_point ( int  constraint_id )

Get the reference point of a specified constraint.

Parameters
constraint_id ID of the constraint
Returns
A std::string indicating the reference point

◆ get_constraint_type()

std::string get_constraint_type ( int  constraint_id )

Get the type of a specified constraint.

Parameters
constraint_id ID of the constraint
Returns
A std::string indicating the type – Kinematic, Distributing, Rigidbody

◆ get_contact_pair_exterior_state()

bool get_contact_pair_exterior_state ( int  entity_id )

Get the contact pair's exterior state.

Parameters
entity_id Id of the contact pair
Returns
The exterior state of the contact pair

◆ get_contact_pair_friction_value()

double get_contact_pair_friction_value ( int  entity_id )

Get the contact pair's friction value.

Parameters
entity_id Id of the contact pair
Returns
The friction value of the contact pair

◆ get_contact_pair_general_state()

bool get_contact_pair_general_state ( int  entity_id )

Get the contact pair's general state.

Parameters
entity_id Id of the contact pair
Returns
The general state of the contact pair

◆ get_contact_pair_tied_state()

bool get_contact_pair_tied_state ( int  entity_id )

Get the contact pair's tied state.

Parameters
entity_id Id of the contact pair
Returns
The tied state of the contact pair

◆ get_contact_pair_tol_lower_value()

double get_contact_pair_tol_lower_value ( int  entity_id )

Get the contact pair's lower bound tolerance value.

Parameters
entity_id Id of the contact pair
Returns
The tolerance value of the contact pair

◆ get_contact_pair_tolerance_value()

double get_contact_pair_tolerance_value ( int  entity_id )

Get the contact pair's upper bound tolerance value.

Parameters
entity_id Id of the contact pair
Returns
The tolerance value of the contact pair

◆ get_continuous_curves()

std::vector< int > get_continuous_curves ( int  curve_id,
double  angle_tol 
)

Returns the adjacent curves that are continuous (angle is 180 degrees +- angle_tol)

Parameters
curve_id that is part of the cavity
angle_tol angle tolerance for continuity
Returns
A list of curve id's in the continuous set (including curve_id).

◆ get_continuous_surfaces()

std::vector< int > get_continuous_surfaces ( int  surface_id,
double  angle_tol 
)

Returns the adjacent surfaces that are continuous (exterior angle is 180 degrees +- angle_tol)

Parameters
surface_id that is part of the cavity
angle_tol angle tolerance for continuity
Returns
A list of surface id's in the continuous set (including surface_id).

◆ get_convection_coefficient()

double get_convection_coefficient ( int  entity_id,
CI_BCEntityTypes  bc_type_enum 
)

Get the convection coefficient.

Parameters
entity_id Id of the BC convection
cc_type enum of CI_BCEntityTypes (1-normal, 5-shell top, 6-shell bottom)
Returns
The value of the convection coefficient

◆ get_coordinate_systems_id_list()

std::vector< int > get_coordinate_systems_id_list ( )

get a list of coordinate system ids

Returns
List (python tuple) of ids

◆ get_copy_block_on_geometry_copy_setting()

std::string get_copy_block_on_geometry_copy_setting ( )

Get the copy nodeset on geometry copy setting.

Returns
copy nodeset setting

◆ get_copy_nodeset_on_geometry_copy_setting()

std::string get_copy_nodeset_on_geometry_copy_setting ( )

Get the copy nodeset on geometry copy setting.

Returns
copy nodeset setting

◆ get_copy_sideset_on_geometry_copy_setting()

std::string get_copy_sideset_on_geometry_copy_setting ( )

Get the copy nodeset on geometry copy setting.

Returns
copy nodeset setting

◆ get_cubit_digits_setting()

double get_cubit_digits_setting ( )

Get the Cubit digits setting.

Returns
A double containing the digits. -1 if no digits are set

◆ get_cubit_message_handler()

CubitMessageHandler * get_cubit_message_handler ( )

get the default message handler

◆ get_current_ids()

std::vector< int > get_current_ids ( const std::string &  entity_type )

Get the current body ids.

Returns
The body IDs in the current model, if any

◆ get_current_journal_file()

std::string get_current_journal_file ( )

Gets the current journal file name.

Returns
The current journal file name.

◆ get_curve_bias_coarse_size()

double get_curve_bias_coarse_size ( int  curve_id )

Get the bias coarse size of a curve

Parameters
curve_id Specifies the id of the curve
Returns
The bias coarse size of the curve.

◆ get_curve_bias_fine_size()

double get_curve_bias_fine_size ( int  curve_id )

Get the bias fine size of a curve

Parameters
curve_id Specifies the id of the curve
Returns
The bias fine size of the curve.

◆ get_curve_bias_first_interval_fraction()

double get_curve_bias_first_interval_fraction ( int  curve_id )

Get the bias first interval fraction of a curve

Parameters
curve_id Specifies the id of the curve
Returns
The bias first interval fraction of the curve.

◆ get_curve_bias_first_interval_length()

double get_curve_bias_first_interval_length ( int  curve_id )

Get the bias first interval length of a curve

Parameters
curve_id Specifies the id of the curve
Returns
The bias first interval length of the curve.

◆ get_curve_bias_first_last_ratio1()

double get_curve_bias_first_last_ratio1 ( int  curve_id )

Get the bias first/last ratio at start of a curve

Parameters
curve_id Specifies the id of the curve
Returns
The bias coarse size of the curve.

◆ get_curve_bias_first_last_ratio2()

double get_curve_bias_first_last_ratio2 ( int  curve_id )

Get the bias first/last ratio at end of a curve

Parameters
curve_id Specifies the id of the curve
Returns
The bias coarse size of the curve.

◆ get_curve_bias_from_start()

bool get_curve_bias_from_start ( int  curve_id,
bool &  value 
)

Get whether the bias is from the start of a curve

Parameters
curve_id Specifies the id of the curve
value Returns whether the bias is from the start of the curve.
Returns
True/False A curve with the curve_id exists.

◆ get_curve_bias_from_start_set()

bool get_curve_bias_from_start_set ( int  curve_id )

Get whether the bias from the start of a curve settings has been set

Parameters
curve_id Specifies the id of the curve
value Returns whether the bias from the start of the curve settings has been set.
Returns
True/False A curve with the curve_id exists.

◆ get_curve_bias_geometric_factor()

double get_curve_bias_geometric_factor ( int  curve_id )

Get the first bias geometric factor of a curve

Parameters
curve_id Specifies the id of the curve
Returns
The bias geometric factor of the curve.

◆ get_curve_bias_geometric_factor2()

double get_curve_bias_geometric_factor2 ( int  curve_id )

Get the second bias geometric factor of a curve

Parameters
curve_id Specifies the id of the curve
Returns
The bias geometric factor of the curve.

◆ get_curve_bias_last_first_ratio1()

double get_curve_bias_last_first_ratio1 ( int  curve_id )

Get the bias last/first ratio at start of a curve

Parameters
curve_id Specifies the id of the curve
Returns
The bias coarse size of the curve.

◆ get_curve_bias_last_first_ratio2()

double get_curve_bias_last_first_ratio2 ( int  curve_id )

Get the bias last/first ratio at end of a curve

Parameters
curve_id Specifies the id of the curve
Returns
The bias coarse size of the curve.

◆ get_curve_bias_start_vertex_id()

int get_curve_bias_start_vertex_id ( int  curve_id )

Get the bias start vertex id of a curve

Parameters
curve_id Specifies the id of the curve
Returns
The bias start vertex id of a curve.

◆ get_curve_bias_type()

std::string get_curve_bias_type ( int  curve_id )

Get the bias type of a curve

Parameters
curve_id Specifies the id of the curve
Returns
The bias type of the curve.

◆ get_curve_center()

std::array< double, 3 > get_curve_center ( int  curve_id )

Get the center point of the arc.

Parameters
curve_id ID of the curve
Returns
x, y, z center point of the curve in a vector (python tuple)

◆ get_curve_count()

int get_curve_count ( )

Get the current number of curves.

Returns
The number of curves in the current model, if any

◆ get_curve_count_in_volumes()

int get_curve_count_in_volumes ( std::vector< int >  target_volume_ids )

Get the current number of curves in the passed-in volumes.

Returns
The number of curves in the volumes

◆ get_curve_edges()

std::vector< int > get_curve_edges ( int  curve_id )

get the list of any edge elements on a given curve

Parameters
curve_id User specified id of the desired curve
Returns
A list (python tuple) of the edge element ids on the curve

◆ get_curve_length()

double get_curve_length ( int  curve_id )

Get the length of a specified curve.

Parameters
curve_id ID of the curve
Returns
Length of the curve

◆ get_curve_mesh_scheme_curvature()

double get_curve_mesh_scheme_curvature ( int  curve_id )

Get the curvature mesh scheme value of a curve.

Parameters
curve_id Specifies the id of the curve
Returns
The curvature mesh scheme value of a curve.

◆ get_curve_mesh_scheme_pinpoint_locations()

std::vector< double > get_curve_mesh_scheme_pinpoint_locations ( int  curve_id )

Get the pinpoint mesh scheme locations of a curve

Parameters
curve_id Specifies the id of the curve
Returns
The pinpoint mesh scheme locations for a curve.

◆ get_curve_mesh_scheme_stretch_values()

bool get_curve_mesh_scheme_stretch_values ( int  curve_id,
double &  first_size,
double &  factor,
double &  last_size,
bool &  start,
int &  vertex_id 
)

Get the stretch mesh scheme values of a curve

Parameters
curve_id Specifies the id of the curve
first_size Returns the first_size
factor Returns the factor
last_size Returns the last_size
start Returns whether the scheme is from the start of the curve.
vertex_id Returns the vertex id used for the start of the scheme.
Returns
True/False A curve with the curve_id exists.

◆ get_curve_nodes()

std::vector< int > get_curve_nodes ( int  curve_id )

Get list of node ids owned by a curve.
Excludes nodes owned by bounding vertices.

int curv_id = 12;
vector<int> curve_nodes = CubitInterface::get_curve_nodes (curv_id);
std::vector< int > get_curve_nodes(int curve_id)
Get list of node ids owned by a curve. Excludes nodes owned by bounding vertices.
Parameters
curv_id id of curve
Returns
List (python tuple) of IDs of nodes owned by the curve

◆ get_curve_radius()

double get_curve_radius ( int  curve_id )

Get the radius of a specified arc.

Parameters
curve_id ID of the curve
Returns
Radius of the curve. If the curve is not an arc, the radius returned is the radius of curvature at the curve's midpoint. If the curve is linear, zero is returned.

◆ get_curve_type()

std::string get_curve_type ( int  curve_id )

Get the curve type for a specified curve.

Parameters
curve_id ID of the curve
Returns
Type of curve

◆ get_dbl_sculpt_default()

double get_dbl_sculpt_default ( const char *  variable )

return sculpt default value

◆ get_default_auto_size()

double get_default_auto_size ( )

Get auto size needs for the current set of geometry.

◆ get_default_element_type()

std::string get_default_element_type ( )

Get the current default setting for the element type that will be used when meshing.

Returns
A string indicating the default mesh type:
  • "tri" indicates a tri/tet mesh default
  • "hex" indicates a quad/hex mesh default
  • "none" indicates no default has been assigned

◆ get_default_geometry_engine()

std::string get_default_geometry_engine ( )

Get the name of the default modeler engine.

std::string engine;
std::string get_default_geometry_engine()
Get the name of the default modeler engine.
engine = cubit.get_default_geometry_engine()
Returns
The name of the default modeler engine in the form ACIS, CATIA, OCC, facet

◆ get_displacement_combine_type()

std::string get_displacement_combine_type ( int  entity_id )

Get the displacement's combine type which is "Overwrite", "Average", "SmallestCombine", or "LargestCombine".

Parameters
entity_id Id of the displacement
Returns
The combine type for the given displacement

◆ get_displacement_dof_signs()

const int * get_displacement_dof_signs ( int  entity_id )

This function only available from C++ Get the displacement's dof signs

Parameters
entity_id Id of the displacement
Returns

◆ get_displacement_dof_values()

const double * get_displacement_dof_values ( int  entity_id )

This function only available from C++ Get the displacement's dof values

Parameters
entity_id Id of the displacement
Returns

◆ get_distance_between()

double get_distance_between ( int  vertex_id_1,
int  vertex_id_2 
)

Get the distance between two vertices.

Parameters
vertex_id_1 ID of vertex 1 vertex_id_2 ID of vertex 2
Returns
distance

◆ get_distance_between_entities()

double get_distance_between_entities ( std::string  geom_type_1,
int  entity_id_1,
std::string  geom_type_2,
int  entity_id_2 
)

Get the distance between two geom entities.

Parameters
geom_type_1 geometry type of entity 1: "vertex", "curve", "surface", "volume" entity_id_1 ID of entity 1 geom_type_2 geometry type of entity 2: "vertex", "curve", "surface", "volume" entity_id_2 ID of entity 2
Returns
distance

◆ get_distance_from_curve_start()

double get_distance_from_curve_start ( double  x_coordinate,
double  y_coordinate,
double  z_coordinate,
int  curve_id 
)

Get the distance from a point on a curve to the curve's start point.

Parameters
x value of the point to measure
y value of the point to measure
z value of the point to measure
curve_id ID of the curve
Returns
Distance from the xyz to the curve start

◆ get_edge_count()

int get_edge_count ( )

Get the count of edges in the model.

Returns
The number of edges in the model

◆ get_edge_global_element_id()

int get_edge_global_element_id ( int  edge_id )

Given a edge id, return the global element id.

int get_edge_global_element_id(int edge_id)
Given a edge id, return the global element id.
Parameters
edge_id Specifies the id of the edge
Returns
The corresponding element id

◆ get_edges_to_swap()

std::vector< int > get_edges_to_swap ( int  curve_id )

Given a curve defining a knife edge between two triangle-meshed surfaces, return a list of edges on triangles at the curve that are good candidates for swapping. A good candidate for swapping means that if swapped, the two triangles at the knife's edge will have a larger interior dihedral angle between them, allowing a larger volume to accommodate tetmeshing.

Parameters
curve_id User-specified id of the curve
Returns
A list (python tuple) of edge ids contained

◆ get_elem_quality_stats()

std::vector< double > get_elem_quality_stats ( const std::string &  entity_type,
const std::vector< int >  id_list,
const std::string &  metric_name,
const double  single_threshold,
const bool  use_low_threshold,
const double  low_threshold,
const double  high_threshold,
const bool  make_group 
)

python callable version of the get_quality_stats without pass by reference arguments. All return values are stuffed into a double array

std::vector<int> id_list = {223, 226, 256};
double single_threshold = 0.2;
bool use_low_threshold = false ;
double low_threshold = 0.0;
double high_threshold = 0.0;
bool make_group = true ;
std::vector<double>
quality_data = CubitInterface::get_elem_quality_stats ("hex" , id_list, "scaled jacobian" ,
single_threshold, use_low_threshold,
low_threshold, high_threshold,
make_group);
double min_value = quality_data[0];
double max_value = quality_data[1];
double mean_value = quality_data[2];
double std_value = quality_data[3];
int min_element_id = (int)quality_data[4];
int max_element_id = (int)quality_data[5];
int element_type = (int)quality_data[6];
int bad_group_id = (int)quality_data[7];
int num_elems = (int)quality_data[8];
std::vector<int> elem_ids(num_elems);
for (int i=9, j=0; i<quality_data.size(); i++, j++)
elem_ids[j] = (int )quality_data[i];
std::vector< double > get_elem_quality_stats(const std::string &entity_type, const std::vector< int > id_list, const std::string &metric_name, const double single_threshold, const bool use_low_threshold, const double low_threshold, const double high_threshold, const bool make_group)
python callable version of the get_quality_stats without pass by reference arguments....
Parameters
entity_type Specifies the geometry type of the entity
id_list Specifies a list of ids to work on
metric_name Specify the metric used to determine the quality
single_threshold Quality threshold value
use_low_threshold use threshold as lower or upper bound
low_threshold Quality threshold when using a lower and upper range
high_threshold Quality threshold when using a lower and upper range
Returns
[0] min_value [1] max_value [2] mean_value [3] std_value [4] min_element_id [5] max_element_id [6] element_type 0 = edge, 1 = tri, 2 = quad, 3 = tet, 4 = hex [7] bad_group_id [8] size of mesh_list [9]...[n-1] mesh_list

◆ get_element_block()

int get_element_block ( int  element_id )

return the block that a given element is in.

Parameters
element_id The element id (i.e. the global element export id)
Returns
block_id, the id of the containing block

◆ get_element_budget()

int get_element_budget ( const std::string &  element_type,
std::vector< int >  entity_id_list,
int  auto_factor 
)

Get the element budget based on current size settings for a list of volumes.

Parameters
element_type "hex" or "tet"
entity_id_list List (vector) of volume ids
auto_factor The current auto size factor value
Returns
The approximate number of elements that will be generated

◆ get_element_count()

int get_element_count ( )

Get the count of elements in the model.

Returns
The number of quad, hex, tet, tri, wedge, edge, spheres, etc. which have been assigned to a block, given a global element id, and will be exported.

◆ get_element_exists()

bool get_element_exists ( int  element_id )

Check the existance of an element.

Parameters
element_id The element id (i.e. the global element export id)
Returns
true or false

◆ get_element_type()

std::string get_element_type ( int  element_id )

return the type of a given element

Parameters
element_id The element id (i.e. the global element export id)
Returns
The type

◆ get_element_type_id()

int get_element_type_id ( int  element_id )

return the type id of a given element

Parameters
element_id The element id (i.e. the global element export id)
Returns
type_id The hex, tet, wedge, etc. id is returned.

◆ get_entities()

std::vector< int > get_entities ( const std::string &  entity_type )

Get all entities of a specified type (including geometry, mesh, etc...)

std::vector<int> entity_id_list;
entity_id_list = CubitInterface::get_entities ("volume" );
std::vector< int > get_entities(const std::string &entity_type)
Get all entities of a specified type (including geometry, mesh, etc...)
entity_id_list = cubit.get_entities("volume" )
Parameters
entity_type Specifies the type of the entity
Returns
A list (python tuple) of ids of the specified geometry type

◆ get_entity_color()

std::array< double, 4 > get_entity_color ( const std::string &  entity_type,
int  entity_id 
)

Get the color of a specified entity.

std::array<int,4> color_rgb = CubitInterface::get_entity_color ("curve" , 33);
std::array< double, 4 > get_entity_color(const std::string &entity_type, int entity_id)
Get the color of a specified entity.
color = cubit.get_entity_color("curve" , 33)
Parameters
entity_type Specifies the type of the entity
entity_id Specifies the id of the entity
Returns
The color of the entity

◆ get_entity_color_index()

int get_entity_color_index ( const std::string &  entity_type,
int  entity_id 
)

◆ get_entity_modeler_engine()

std::vector< std::string > get_entity_modeler_engine ( const std::string &  geometry_type,
int  entity_id 
)

Get the modeler engine type for a specified entity.

std::vector<std::string> engine_list;
engine_list = CubitInterface::get_entity_modeler_engine ("surface" , 47);
std::vector< std::string > get_entity_modeler_engine(const std::string &geometry_type, int entity_id)
Get the modeler engine type for a specified entity.
engine_list = cubit.get_entity_modeler_engine("surface" , 47)
Parameters
geom_type Specifies the geometry type of the entity
entity_id Specifies the id of the entity
Returns
A vector (python tuple) of modeler engines associated with this entity

◆ get_entity_name()

std::string get_entity_name ( const std::string &  entity_type,
int  entity_id,
bool  no_default = false 
)

Get the name of a specified entity.

Names returned are of two types: 1) user defined names which are actually stored in Cubit when the name is defined, and 2) 'default' names supplied by Cubit at run-time which are not stored in Cubit. The second variety of name cannot be used to query Cubit.

std::string name = CubitInterface::get_entity_name ("vertex" , 22);
std::string get_entity_name(const std::string &entity_type, int entity_id, bool no_default=false)
Get the name of a specified entity.
name = cubit.get_entity_name("vertex" , 22)
Parameters
entity_type Specifies the type of the entity
entity_id Specifies the id of the entity
no_default True to return an empty string if no name is set
Returns
The name of the entity

◆ get_entity_names()

std::vector< std::string > get_entity_names ( const std::string &  entity_type,
int  entity_id,
bool  no_default = false,
bool  first_name_only = false 
)

same as get_entity_name but includes all name attributes set on the entity, not just the first one (unless first_name_only is set)

◆ get_entity_sense()

std::string get_entity_sense ( std::string  source_type,
int  source_id,
int  sideset_id 
)

Get the sense of a sideset item.

std::string sense;
sense = CubitInterface::get_entity_sense ("face" , 332, 2);
std::string get_entity_sense(std::string source_type, int source_id, int sideset_id)
Get the sense of a sideset item.
sense = cubit.get_entity_sense("face" , 332, 2)
Parameters
source_type Item type - could be 'face', 'quad' or 'tri'
source_id ID of entity
sideset_id ID of the sideset
Returns
Sense of the source_type/source_id in specified sideset

◆ get_error_count()

int get_error_count ( )

Get the number of errors in the current Cubit session.

Returns
The number of errors in the Cubit session.

◆ get_exodus_element_count()

int get_exodus_element_count ( int  entity_id,
std::string  entity_type 
)

Get the number of elements in a exodus entity.

int element_count = CubitInterface::get_exodus_element_count (2, "sideset" );
int get_exodus_element_count(int entity_id, std::string entity_type)
Get the number of elements in a exodus entity.
element_count = cubit.get_exodus_element_count(2, "sideset" )
Parameters
entity_id The id of the entity
entity_type The type of the entity
Returns
Number of Elements

◆ get_exodus_entity_description()

std::string get_exodus_entity_description ( std::string  entity_type,
int  entity_id 
)

Get the description associated with an exodus entity.

std::string entity_description;
entity_description = CubitInterface::get_exodus_entity_description ("sideset" , 33);
std::string get_exodus_entity_description(std::string entity_type, int entity_id)
Get the description associated with an exodus entity.
entity_description = cubit.get_exodus_entity_description("sideset" , 33)
Parameters
entity_type "block", "sideset", nodeset" @param entity_id Id of the entity in question \return Description of the entity or "" if none

◆ get_exodus_entity_name()

std::string get_exodus_entity_name ( const std::string  entity_type,
int  entity_id 
)

Get the name associated with an exodus entity.

std::string entity_name;
entity_name = CubitInterface::get_exodus_entity_name ("sideset" , 33);
std::string get_exodus_entity_name(const std::string entity_type, int entity_id)
Get the name associated with an exodus entity.
entity_name = cubit.get_exodus_entity_name("sideset" , 33)
Parameters
entity_type "block", "sideset", nodeset" @param entity_id Id of the entity in question \return Name of the entity or "" if none

◆ get_exodus_entity_type()

std::string get_exodus_entity_type ( std::string  entity_type,
int  entity_id 
)

Get the type of an exodus entity.

std::string entity_description;
entity_description = CubitInterface::get_exodus_entity_description ("sideset" , 33);
entity_description = cubit.get_exodus_entity_type("sideset" , 33)
Parameters
entity_type "block", "sideset", nodeset" @param entity_id Id of the entity in question \return Type of the entity or "" if none. Returns "lite" or ""

◆ get_exodus_id()

int get_exodus_id ( const std::string &  entity_type,
int  entity_id 
)

Get the exodus/genesis id for this element.

int exodus_id = CubitInterface::get_exodus_id ("hex" , 221);
int get_exodus_id(const std::string &entity_type, int entity_id)
Get the exodus/genesis id for this element.
exodus_id = cubit.get_exodus_id("hex" , 221)
Parameters
entity_type The mesh element type
entity_id The mesh element id
Returns
Exodus id of the element if element has been written out, otherwise 0

◆ get_exodus_sizing_function_file_name()

std::string get_exodus_sizing_function_file_name ( )

Get the exodus sizing function file name.

Returns
The sizing function file name

◆ get_exodus_sizing_function_variable_name()

std::string get_exodus_sizing_function_variable_name ( )

Get the exodus sizing function variable name.

Returns
The sizing function variable name

◆ get_exodus_variable_count()

int get_exodus_variable_count ( std::string  container_type,
int  container_id 
)

Get the number of exodus variables in a nodeset, sideset, or block.

Parameters
entity_type : nodeset, sideset, or block block_id The block id
Returns
Number of exodus variables

◆ get_exodus_variable_names()

std::vector< std::string > get_exodus_variable_names ( std::string  container_type,
int  container_id 
)

Get the names of exodus variables in a nodeset, sideset, or block.

Parameters
entity_type : nodeset, sideset, or block block_id The block id
Returns
Names of exodus variables

◆ get_exodus_version()

std::string get_exodus_version ( )

Get the Exodus version number.

Returns
A string containing the Exodus version number

◆ get_expanded_connectivity()

std::vector< int > get_expanded_connectivity ( const std::string &  entity_type,
int  entity_id 
)

Get the list of node ids contained within a mesh entity, including interior nodes.

std::vector<int> node_id_list;
node_id_list = CubitInterface::get__expanded_connectivity("hex" , 221);
node_id_list = cubit.get__expanded_connectivity("hex" , 221)
Parameters
entity_type The mesh element type
entity_id The mesh element id
Returns
List (python tuple) of all node ids associated with the element, including interior nodes

◆ get_force_direction_vector()

std::array< double, 3 > get_force_direction_vector ( int  entity_id )

Get the direction vector from a force.

Parameters
entity_id Id of the force
Returns
A vector (python tuple) [x,y,z] of the direction the given force is acting

◆ get_force_magnitude()

double get_force_magnitude ( int  entity_id )

Get the force magnitude from a force.

Parameters
entity_id Id of the force
Returns
Magnitude of the given force

◆ get_force_moment_vector()

std::array< double, 3 > get_force_moment_vector ( int  entity_id )

Get the moment vector from a force.

Parameters
entity_id Id of the force
Returns
A vector (python tuple) [x,y,z] of the direction of the moment for the given force

◆ get_gaps_between_volumes()

std::vector< VolumeGap > get_gaps_between_volumes ( std::vector< int >  target_volume_ids,
double  maximum_gap_tolerance,
double  maximum_gap_angle,
int  cache_overlaps = 0 
)

◆ get_geometric_owner()

std::vector< std::string > get_geometric_owner ( std::string  mesh_entity_type,
std::string  mesh_entity_list 
)

Get a list of geometric owners given a list of mesh entities.

std::vector<std::string> owner_list;
owner_list = CubitInterface::get_geometric_owner ("quad" , id_list);
std::vector< std::string > get_geometric_owner(std::string mesh_entity_type, std::string mesh_entity_list)
Get a list of geometric owners given a list of mesh entities.
owner_list = cubit.get_geometric_owner("quad" , id_list)
Parameters
mesh_entity_type The type of mesh entity. Works for 'quad, 'face', 'tri', 'hex', 'tet', 'edge', 'node'
mesh_entity_list A string containing space delimited ids, Cubit command form (i.e. 'all', '1 to 8', '1 2 3', etc)
Returns
A list (python tuple) of geometry owners in the form of 'surface x', 'curve y', etc.

◆ get_geometry_node_count()

int get_geometry_node_count ( const std::string &  entity_type,
int  entity_id 
)

Get the node count for a specific geometric entity.

Parameters
entity_type The geometry type ("surface", "curve", etc)
entity_id The entity id
Returns
Number of nodes in the geometry

◆ get_geometry_owner()

std::string get_geometry_owner ( const std::string &  entity_type,
int  entity_id 
)

Get the geometric owner of this mesh element.

std::string geom_owner = CubitInterface::get_geometry_owner ("hex" , 221);
std::string get_geometry_owner(const std::string &entity_type, int entity_id)
Get the geometric owner of this mesh element.
geom_owner = cubit.get_geometry_owner("hex" , 221)
Parameters
entity_type The mesh element type
entity_id The mesh element id
Returns
Name of owner

◆ get_global_element_id()

int get_global_element_id ( const std::string &  element_type,
int  id 
)

Given a hex, tet, etc. id, return the global element id.

int gid = CubitInterface::get_global_element_id ("hex" , 22);
int get_global_element_id(const std::string &element_type, int id)
Given a hex, tet, etc. id, return the global element id.
Parameters
id Specifies the id of the hex, tet, etc. elem_type the type of the entity ("hex", "tet", "wedge", "pyramid", "tri", "face", "quad", "edge", or "sphere")
Returns
The corresponding element id

◆ get_graphics_version()

std::string get_graphics_version ( )

Get the VTK version number.

Returns
A string containing the VTK version number

◆ get_group_bodies()

std::vector< int > get_group_bodies ( int  group_id )

Get group bodies (bodies that are children of a group)

This routine returns a list of bodies that are contained in a specified group.

Parameters
group_id ID of the group to examine return List (python tuple) of bodies ids contained in the specified group

◆ get_group_children()

void get_group_children ( int  group_id,
std::vector< int > &  returned_group_list,
std::vector< int > &  returned_body_list,
std::vector< int > &  returned_volume_list,
std::vector< int > &  returned_surface_list,
std::vector< int > &  returned_curve_list,
std::vector< int > &  returned_vertex_list,
int &  returned_node_count,
int &  returned_edge_count,
int &  returned_hex_count,
int &  returned_quad_count,
int &  returned_tet_count,
int &  returned_tri_count,
int &  returned_wedge_count,
int &  returned_pyramid_count,
int &  returned_sphere_count 
)

Get group children.

This routine returns a list for each geometry entity type in the group. Since groups may contain both geometry and mesh entities, this routine also returns the count of any mesh entity contained in the group. For groups contained in the group, the group_list will only contain one generation. In other words, if this routine is examining Group ABC, and Group ABC contains Group XYZ and Group XYZ happens to contain other groups (which in turn may contain other groups) this routine will only return the id of Group XYZ.

Parameters
group_id ID of the group to examine
group_list User specified list where group ids will be returned
body_list User specified list where body ids will be returned
volume_list User specified list where volume ids will be returned
surface_list User specified list where surface ids will be returned
curve_list User specified list where curve ids will be returned
vertex_list User specified list where vertex ids will be returned
node_count User specified variable where the number of nodes will be returned
edge_count User specified variable where the number of edges will be returned
hex_count User specified variable where the number of hexes will be returned
quad_count User specified variable where the number of quads will be returned
tet_count User specified variable where the number of tets will be returned
tri_count User specified variable where the number of tris will be returned

◆ get_group_curves()

std::vector< int > get_group_curves ( int  group_id )

Get group curves (curves that are children of a group)

This routine returns a list of curves that are contained in a specified group.

Parameters
group_id ID of the group to examine return List (python tuple) of curve ids contained in the specified group

◆ get_group_edges()

std::vector< int > get_group_edges ( int  group_id )

Get group edges (edges that are children of a group)

This routine returns a list of edges that are contained in a specified group.

Parameters
group_id ID of the group to examine return List (python tuple) of edge ids contained in the specified group

◆ get_group_groups()

std::vector< int > get_group_groups ( int  group_id )

Get group groups (groups that are children of another group)

This routine returns a list a groups that are contained in a specified group.

Parameters
group_id ID of the group to examine return List (python tuple) of group ids contained in the specified group

◆ get_group_hexes()

std::vector< int > get_group_hexes ( int  group_id )

Get group hexes (hexes that are children of a group)

This routine returns a list of hexes that are contained in a specified group.

Parameters
group_id ID of the group to examine return List (python tuple) of hex ids contained in the specified group

◆ get_group_nodes()

std::vector< int > get_group_nodes ( int  group_id )

Get group nodes (nodes that are children of a group)

This routine returns a list of nodes that are contained in a specified group.

Parameters
group_id ID of the group to examine return List (python tuple) of node ids contained in the specified group

◆ get_group_pyramids()

std::vector< int > get_group_pyramids ( int  group_id )

Get group pyramids (pyramids that are children of a group)

This routine returns a list of pyramids that are contained in a specified group.

Parameters
group_id ID of the group to examine return List (python tuple) of pyramid ids contained in the specified group

◆ get_group_quads()

std::vector< int > get_group_quads ( int  group_id )

Get group quads (quads that are children of a group)

This routine returns a list of quads that are contained in a specified group.

Parameters
group_id ID of the group to examine return List (python tuple) of quad ids contained in the specified group

◆ get_group_spheres()

std::vector< int > get_group_spheres ( int  group_id )

Get group spheres (sphere elements that are children of a group)

This routine returns a list of spheres that are contained in a specified group.

Parameters
group_id ID of the group to examine return List (python tuple) of sphere ids contained in the specified group

◆ get_group_surfaces()

std::vector< int > get_group_surfaces ( int  group_id )

Get group surfaces (surfaces that are children of a group)

This routine returns a list of surfaces that are contained in a specified group.

Parameters
group_id ID of the group to examine return List (python tuple) of surface ids contained in the specified group

◆ get_group_tets()

std::vector< int > get_group_tets ( int  group_id )

Get group tets (tets that are children of a group)

This routine returns a list of tets that are contained in a specified group.

Parameters
group_id ID of the group to examine return List (python tuple) of tet ids contained in the specified group

◆ get_group_tris()

std::vector< int > get_group_tris ( int  group_id )

Get group tris (tris that are children of a group)

This routine returns a list of tris that are contained in a specified group.

Parameters
group_id ID of the group to examine return List (python tuple) of tri ids contained in the specified group

◆ get_group_vertices()

std::vector< int > get_group_vertices ( int  group_id )

Get group vertices (vertices that are children of a group)

This routine returns a list of vertices that are contained in a specified group.

Parameters
group_id ID of the group to examine return List (python tuple) of vertex ids contained in the specified group

◆ get_group_volumes()

std::vector< int > get_group_volumes ( int  group_id )

Get group volumes (volumes that are children of a group)

This routine returns a list of volumes that are contained in a specified group.

Parameters
group_id ID of the group to examine return List (python tuple) of volume ids contained in the specified group

◆ get_group_wedges()

std::vector< int > get_group_wedges ( int  group_id )

Get group wedges (wedges that are children of a group)

This routine returns a list of wedges that are contained in a specified group.

Parameters
group_id ID of the group to examine return List (python tuple) of wedge ids contained in the specified group

◆ get_heatflux_on_area()

double get_heatflux_on_area ( CI_BCEntityTypes  bc_area_enum,
int  entity_id 
)

Get the heatflux on a specified area.

Parameters
bc_area enum of CI_BCEntityTypes. If on solid, use 4. If on thin shell, use 7 for top, 8 for bottom
entity_id ID of the heatflux
Returns
The value or magnitude of the specified heatflux

◆ get_hex_count()

int get_hex_count ( )

Get the count of hexes in the model.

Returns
The number of hexes in the model

◆ get_hex_global_element_id()

int get_hex_global_element_id ( int  hex_id )

Given a hex id, return the global element id.

int get_hex_global_element_id(int hex_id)
Given a hex id, return the global element id.
Parameters
hex_id Specifies the id of the hex
Returns
The corresponding element id

◆ get_hex_sheet()

std::vector< int > get_hex_sheet ( int  node_id_1,
int  node_id_2 
)

Get the list of hex elements forming a hex sheet through the given two node ids. The nodes must be adjacent in the connectivity of the hex i.e. they form an edge of the hex.

Returns
A list (python tuple) of hex ids in the hex sheet

◆ get_hole_surfaces()

std::vector< int > get_hole_surfaces ( int  surface_id )

Returns the adjacent surfaces in a hole for a surface.

Parameters
surface_id that is part of the hole
Returns
A list of surface id's in the hole (including surface_id).

◆ get_hydraulic_radius_surface_area()

double get_hydraulic_radius_surface_area ( int  surface_id )

Get the area of a hydraulic surface.

Parameters
surface_id ID of the surface
Returns
Hydraulic area of the surface

◆ get_hydraulic_radius_volume_area()

double get_hydraulic_radius_volume_area ( int  volume_id )

Get the area of a hydraulic volume.

Parameters
volume_id ID of the volume
Returns
Hydraulic area of the volume

◆ get_id_from_name()

int get_id_from_name ( const std::string &  name )

Get id for a named entity.

This routine returns an integer id for the entity whose name is passed in.

int entity_id = CubitInterface::get_id_from_name ("member_2" );
int get_id_from_name(const std::string &name)
Get id for a named entity.
entity_id = cubit.get_id_from_name("member_2" )
Parameters
name Name of the entity to examine return Integer representing the entity

◆ get_id_string()

std::string get_id_string ( const std::vector< int > &  entity_ids )

Parse a list of integers into a Cubit style id list. Return string will not include carriage returns or line break.

std::vector<int> entity_ids = {1, 2, 3, 4};
std::string id_string = CubitInterface::get_id_string (entity_ids);
// id_string is "1 to 4";
std::string get_id_string(const std::vector< int > &entity_ids)
Parse a list of integers into a Cubit style id list. Return string will not include carriage returns ...
entity_ids = [1,2,3,4]
id_string = cubit.get_all_ids_from_name(entity_ids)
# id_string is '1 to 4'
Parameters
entity_ids vector of integers return A string representing the id list without line breaks

◆ get_idless_signature()

std::string get_idless_signature ( std::string  entity_type,
int  entity_id 
)

get the idless signature of a geometric or mesh entity

Parameters
type the type of the requested entity
id the id of the requested entity
Returns
the idless signature i.e. curve at (1 1 0 ordinal 2)

◆ get_idless_signatures()

std::string get_idless_signatures ( std::string  entity_type,
const std::vector< int > &  entity_id_list 
)

get the idless signatures of a range of geometric or mesh entities

Parameters
type the type of the requested entity
idlist a list of ids
Returns
the idless signature i.e. curve at (1 1 0 ordinal 2) curve at (0 0 1 ordinal 1) ...

◆ get_int_sculpt_default()

int get_int_sculpt_default ( const char *  variable )

◆ get_interface()

CubitBaseInterface * get_interface ( std::string  interface_name )

Get the interface of a given name.

Parameters
interface_name the name of interface

◆ get_label_type()

int get_label_type ( const char *  entity_type )

make calls to SVDrawTool::get_label_type

Returns
label type currently associated with entity_type

◆ get_last_id()

int get_last_id ( const std::string &  entity_type )

Get the id of the last created entity of the given type.

int last_id = CubitInterface::get_last_id ("surface" );
int get_last_id(const std::string &entity_type)
Get the id of the last created entity of the given type.
last_id = cubit.get_last_id("surface" )
Parameters
entity_type Type of the entity being queried
Returns
Integer id of last created entity

◆ get_list_of_free_ref_entities()

std::vector< int > get_list_of_free_ref_entities ( const std::string &  geometry_type )

Get all free entities of a given geometry type.

std::vector<int> free_curve_id_list;
free_curve_id_list = CubitInterface::get_list_of_free_ref_entities ("curve" );
std::vector< int > get_list_of_free_ref_entities(const std::string &geometry_type)
Get all free entities of a given geometry type.
free_curve_id_list = cubit.get_list_of_free_ref_entities("curve" )
Parameters
geom_type Specifies the geometry type of the free entity
Returns
A list (python tuple) of ids of the specified geometry type

◆ get_material_name()

std::string get_material_name ( int  material_id )

Get the name of the material (or cfd media) with the given id.

Returns
A std::string with the material's name.

◆ get_material_name_list()

std::vector< std::string > get_material_name_list ( )

Get a list of all defined material names.

Returns
List (python tuple) of all the material names.

◆ get_material_property()

double get_material_property ( CI_MaterialProperty  material_property_enum,
int  entity_id 
)

Get the specified material property value.

Parameters
mp enum of CI_MaterialProperty. 0-Elastic Modulus, 1-Shear Modulus, 2-Poisson Ratio, 3-Density, 4-Specific Heat, 5-Conductivity
entity_id Id of the material
Returns
Value of the specified property for that material

◆ get_media_name_list()

std::vector< std::string > get_media_name_list ( )

Get a list of all defined material names.

Returns
List (python tuple) of all the material names.

◆ get_media_property()

int get_media_property ( int  entity_id )

Get the media property value.

Parameters
entity_id Id of the media
Returns
Value of the media property, 0 == FLUID, 1 == POROUS, 2 == SOLID

◆ get_merge_setting()

std::string get_merge_setting ( const std::string &  geometry_type,
int  entity_id 
)

Get the merge setting for a specified entity.

std::string merge_setting = CubitInterface::get_merge_setting ("surface" , 33);
std::string get_merge_setting(const std::string &geometry_type, int entity_id)
Get the merge setting for a specified entity.
merge_setting = cubit.get_merge_setting("surface" , 33)
Parameters
geom_type Specifies the geometry type of the entity
entity_id Specifies the id of the entity
Returns
A text string that indicates the merge setting for the entity

◆ get_merge_tolerance()

double get_merge_tolerance ( )

Get the current merge tolerance value.

Returns
The value of the current merge tolerance

◆ get_mergeable_curves()