CubitInterface Namespace Reference

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

Classes

class
AssemblyItem
Class to implement assembly tree interface.
class
Entity
The base class of all the geometry and mesh types.
class
GeomEntity
The base class for specifically the Geometry types ( Body, Volume, Surface, Curve, Vertex)
class
Body
Defines a body object that mostly parallels Cubit's Body class
class
Volume
Defines a volume object that mostly parallels Cubit's RefVolume class.
class
Surface
Defines a surface object that mostly parallels Cubit's RefFace class.
class
Curve
Defines a curve object that mostly parallels Cubit's RefEdge class.
class
Vertex
Defines a vertex object that mostly parallels Cubit's RefVertex class.
class
CFD_BC_Entity
Class to implement CFD boundary condition data retrieval.
class
Loc
Defines a location object.

class
Dir
Defines a direction object
class
CubitFailureException
An exception class to alert the caller when the underlying Cubit function fails.
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.
class
InvalidInputException
An exception class to alert the caller of a function that invalid inputs were entered.
class
MeshErrorFeedback
Class to implement mesh command feedback processing.

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.
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.
void
add_filename_to_recent_file_list( std::string & filename)
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.
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.
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.
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
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::string
string_from_id_list( std::vector< int > ids)
Parse a list of integers into a Cubit style id list.
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
estimate_curve_mesh_size( int curve_id, double percent_capture)
Return estimated mesh size for a curve such that the sum of edge lengths are within a precentage of the curve length.
double
estimate_curves_mesh_size( const std::string & geometry_type, const std::vector< int > & geom_id, double percent_capture)
Return estimated mesh size for curves related to an entity such that the sum of edge lengths are within a precentage of the curve length. The smallest size for all curves is returned.
size_t
estimate_morph_tet_element_count( const std::vector< int > & volume_ids, double size, bool keep_void)
Return estimated tet element count for volumes.
int
estimate_morph_num_procs( const std::vector< int > & volume_ids, double size)
Return recommended numprocs to run morph on this model at the specified size.
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::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_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.
double
get_tetmesh_growth_factor( int volume_id)
Get the tetmesh growth factor.
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_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)
Get the name of a specified entity.
bool
set_entity_name( const std::string & entity_type, int entity_id, const std::string & new_name)
Set the name of a specified entity.
int
get_entity_color_index( const std::string & entity_type, int entity_id)
Get the color of a specified entity.
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()
int
number_undo_commands()
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)
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)
Get similar curves with the same length.
std::vector< int >
get_similar_surfaces( std::vector< int > surface_ids)
Get similar surfaces with the same area and number of curves.
std::vector< int >
get_similar_volumes( std::vector< int > volume_ids)
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_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.
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_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_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
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< 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_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.
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::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.
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
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)
bool
is_cavity_surface( int surface_id)
return whether the surface is part of a cavity
std::vector< int >
get_cavity_surfaces( int surface_id)
Returns the adjacent surfaces in a cavity 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::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.

Machine Learning Support

std::vector< std::vector< double > >
get_ML_operation_features( std::vector< int > op_types, std::vector< int > entity1_ids, std::vector< int > entity2_ids, std::vector< std::vector< double >> params, double mesh_size)
get machine learning features for a list of cubit operations
std::vector< std::string >
get_ML_operation_feature_types( const int op_type)
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 int op_type)
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 int op_type)
for the given operation type described by get_ML_operation_features, return the expected size of the feature vector
std::string
get_ML_operation_name( const int op_type)
get an ML operation name according from its index
std::vector< std::string >
get_ML_operation( const int op_type, const int entity_id1, const int 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 operation type

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_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_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_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_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.
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)
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)
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.
int
get_displacement_coord_system( int entity_id)
Get the displacement's coordinate system id.
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)
int
get_media_property( int entity_id)
std::vector< std::string >
get_material_name_list()
std::vector< std::string >
get_media_name_list()
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)
double
calculate_timestep_estimate_with_props( std::string entity_type, std::vector< int > entity_id_list, double density, double youngs_modulus, double poissons_ratio)
std::vector< double >
snap_locations_to_geometry( std::vector< double > locations, std::string entity_type, int entity_id, double tol)
std::vector< double >
measure_between_entities( std::string entity_type1, int entity_id1, std::string entity_type2, int entity_id2)
void
remove_overconstrained_tets( std::vector< int > tet_ids)
void
collapse_edges( std::vector< int > edge_ids)
std::vector< int >
gather_surfaces_by_orientation( std::vector< int > seed_surf_ids, std::vector< int > all_surf_ids)
void
set_label_type( const char * entity_type, int label_flag)
int
get_label_type( const char * entity_type)
std::vector< int >
get_coordinate_systems_id_list()
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)
double
get_dbl_sculpt_default( const char * variable)
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)

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< int >
sizing_source_ids()
Functions to support sizing source sizing function.
double
sizing_source_min_size()
double
sizing_source_max_size()
std::array< double, 3 >
sizing_source_scale( int id)
std::array< double, 3 >
sizing_source_rotation_vector( int id)
double
sizing_source_rotation_angle( int id)
std::array< double, 3 >
sizing_source_origin( int id)
double
sizing_source_size( int id)
double
sizing_source_growth_factor( int id)
void
set_capture_color( bool is_captured, std::array< double, 4 > color)
void
draw_curve_capture( const std::string & geometry_type, const std::vector< int > & ids, bool is_captured)
void
draw_curve_capture_from_size( const std::string & geometry_type, const std::vector< int > & ids, double percent_captured, double mesh_size)
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.

Variables

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.
void
destroy()
Closes the current journal file.
void
process_input_files()
C++ only
void
set_playback_handler( ExternalPlaybackHandler * hdlr)
C++ only
ExternalPlaybackHandler *
get_playback_handler()
void
enable_signal_handling( bool on)
initialize/uninitialize signal handling C++ only
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

void add_entities_to_group(
  • int group_id,
  • const std::vector< int > & entity_id,
  • const std::string & entity_type)
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
void add_entity_to_group(
  • int group_id,
  • int entity_id,
  • const std::string & entity_type)
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
void add_filename_to_recent_file_list(
  • std::string & filename)

/brief Adds the filename to the recent file list. /param filename to be added to the recent file list.

bool are_adjacent_surfaces(
  • std::vector< int > surface_ids)
Parameters
  • surface_id
    IDs of surfaces to query
Returns whether the surface are adjacent
CubitInterface::Body body(
  • int id_in)
Parameters
  • id_in
    The ID of the body
Returns The body object
Body brick(
  • double width,
  • double depth,
  • double 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
double calculate_timestep_estimate(
  • std::string entity_type,
  • std::vector< int > entity_ids)

/brief 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.

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)
double calculate_timestep_estimate_with_props(
  • std::string entity_type,
  • std::vector< int > entity_id_list,
  • double density,
  • double youngs_modulus,
  • double poissons_ratio)

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

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)
bool cmd(
  • const char * input_string)

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.

Parameters
  • input_string
    Pointer to a string containing a complete Cubit command
void collapse_edges(
  • std::vector< int > edge_ids)

/brief Collapses specified mesh edges. Calls the command 'meshedit collapse edge <id> [no_compress_ids]'. Extra processing is done to make sure that that collapsing an edge does not cause neighboring triangles to have an aspect ratio smaller than any adjacent triangle before. If so, the collapse is not done on that edge.

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)

/brief Compare the geometry and mesh

void complete_filename(
  • std::string & line,
  • int & num_chars,
  • bool & found_quote)
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
bool contains_virtual(
  • const std::string & geometry_type,
  • int entity_id)
Parameters
  • geom_type
    Specifies the geometry type of the entity
  • entity_id
    Specifies the id of the entity
bool convection_is_on_shell_area(

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

bool convection_is_on_solid(
  • int entity_id)

/param entity_id Id of the BC convection /return true if convection is on a solid, otherwise false

Body copy_body(
Parameters
  • [in] init_body
    The Body to be copied
Returns A Body identical to the input Body
Curve create_arc_curve(
  • Vertex v0,
  • Vertex v1,
  • std::array< double, 3 > intermediate_point)
Parameters
  • [in] v0
    The start vertex
  • [in] v1
    The end vertex
  • [in] intermediate_point
    intermideate coord
Returns A Curve object
Curve create_curve(
Parameters
  • [in] v0
    The start vertex
  • [in] v1
    The end vertex
Returns A Curve object
int create_new_group()
  •  
Returns group_id ID of new group
Curve create_spline(
  • std::vector< std::array< double, 3 > > points,
  • int surface_id)
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
Body create_surface(
  • std::vector< Curve > curves)
Parameters
  • [in] curves
    A list of curve objects from which to make the surface
Returns A Body object of the newly created Surface
Vertex create_vertex(
  • double x,
  • double y,
  • double 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
CubitInterface::Curve curve(
  • int id_in)
Parameters
  • id_in
    The ID of the curve
Returns The curve object
Body cylinder(
  • double height,
  • double x_radius,
  • double y_radius,
  • double top_radius)
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
void delete_group(
  • int group_id)
Parameters
  • group_id
    ID of group to delete
bool developer_commands_are_enabled()
  •  
Returns True if developer commands are enabled, otherwise False
void enable_signal_handling(
  • bool on)
Parameters
  • on
    Set to true to initialize signal handling, false to uninitialize.
bool entity_exists(
  • const std::string & entity_type,
  • int id)
Parameters
  • entity_type
    Type of the entity being queried
  • id
    ID of entity
Returns true of false whether entity exists
double estimate_curve_mesh_size(
  • int curve_id,
  • double percent_capture)
Parameters
  • curve_id
    The Curve to estimate mesh size percent_capture The requested percentage of capture for a curve
Returns The length of one mesh edge, or -1 on error.
double estimate_curves_mesh_size(
  • const std::string & geometry_type,
  • const std::vector< int > & geom_id,
  • double percent_capture)
Parameters
  • geometry_type
    The type of geometry entity to esitmate mesh size geom_id The Id of the geometry entity to estimate mesh size percent_capture The requested percentage of capture for a curve
Returns The length of one mesh edge, or -1 on error.
double estimate_merge_tolerance(
  • std::vector< int > target_volume_ids,
  • bool accurate_in,
  • bool report_in,
  • double low_value_in,
  • double high_value_in,
  • int number_calculations_in,
  • bool return_calculations_in,
  • std::vector< double > * merge_tolerance_list,
  • std::vector< int > * number_of_proximities_list)

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.
int estimate_morph_num_procs(
  • const std::vector< int > & volume_ids,
  • double size)
Parameters
  • volume_ids
    The Id of the volumes that will be meshed with morph size The overlay grid size
Returns The recommended number of procs to use for morph
size_t estimate_morph_tet_element_count(
  • const std::vector< int > & volume_ids,
  • double size,
  • bool keep_void)
Parameters
  • volume_ids
    The Id of the volumes to estimate element count size The overlay grid size keep_void Mesh the void space (e.g. air, enclosures, etc.)
Returns The estimated number of tet elements morph will generate
std::vector< int > evaluate_exterior_angle(
  • const std::vector< int > & curve_list,
  • const double test_angle)
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.
double evaluate_exterior_angle_at_curve(
  • int curve_id,
  • int volume_id)
Parameters
  • curve
    id (integer) volume id (integer)
Returns angle in degrees
double evaluate_surface_angle_at_vertex(
  • int surf_id,
  • int vert_id)
Parameters
  • surf
    id (integer) vert id (integer)
Returns angle in degrees
bool exodus_sizing_function_file_exists()
  •  
Returns whether the exodus sizing function file exists
void find_floating_volumes(
  • std::vector< int > target_volume_ids,
  • std::vector< int > & returned_floating_id_list)

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
void find_nonmanifold_curves(
  • std::vector< int > target_volume_ids,
  • std::vector< int > & returned_curve_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
void find_nonmanifold_vertices(
  • std::vector< int > target_volume_ids,
  • std::vector< int > & returned_vertex_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
std::vector< int > gather_surfaces_by_orientation(
  • std::vector< int > seed_surf_ids,
  • std::vector< int > all_surf_ids)

/brief 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.

std::vector< std::string > get_ML_operation(
  • const int op_type,
  • const int entity_id1,
  • const int entity_id2,
  • const std::vector< double > params,
  • const double small_curve_size,
  • const double mesh_size)
Parameters
  • op_type
    operation type (see get_ML_operation_features)
  • entity1_id
    first entity associated with operation (see table)
  • entity2_id
    second entity associated with operation (see table)
  • params
    optional parameters for operation
std::vector< std::string > get_ML_operation_feature_names(
  • const int op_type)
Parameters
  • op_type
    cubit operation id from table in get_ML_operation_features
int get_ML_operation_feature_size(
  • const int op_type)
Parameters
  • op_type
    cubit operation id from table in get_ML_operation_features
std::vector< std::string > get_ML_operation_feature_types(
  • const int op_type)
  1. boolean 1 or 0
  2. categorical usually positive integer representing a unique

continuous could be double or integer describing a continuous range (i.e. number of adjacent curves, area of a surface, etc..)

Parameters
  • op_types
    cubit operation id from table in get_ML_operation_features
std::vector< std::vector< double > > get_ML_operation_features(
  • std::vector< int > op_types,
  • std::vector< int > entity1_ids,
  • std::vector< int > entity2_ids,
  • std::vector< std::vector< double >> params,
  • double mesh_size)
Parameters
  • op_types
    list of cubit operation types. One of the following IDs:

op_type Description Entity1 Entity2 Params

0 Unknown none none 1 Vertex No Operation vertex none 2 Curve No Operation curve none 3 Surface No Operation surface none 4 Volume No Operation volume none 5 Remove Surface surface none 6 Tweak Replace Surface surface surface 7 Composite Surfaces surface surface 8 Collapse Curve curve vertex 9 Tweak Remove Topology Curve curve none 10 Virtual Collapse Curve curve vertex 11 Tweak Remove Topology Surface surface none 12 Blunt Tangency vertex none remove_mat, angle, depth 13 Remove Cone Surface surface none 14 Collapse Angle vertex none real_split, angle, composite_vertex 15 Remove Blend surface none 16 Remove Cavity surface none

Parameters
  • entity1_ids
    list of first entity ids associated with operation (see above table)
  • entity2_ids
    list of second entity associated with operation (see above table)
  • params
    array of parameters the operation needs to execute (see above table)
  • mesh_size
    target mesh size for operation
std::string get_ML_operation_name(
  • const int op_type)
Parameters
  • op_type
    cubit operation id from table in get_ML_operation_features
std::string get_acceleration_combine_type(
  • int entity_id)

/param entity_id Id of the acceleration /return The combine type for the given acceleration

const int * get_acceleration_dof_signs(
  • int entity_id)

/param entity_id Id of the acceleration /return An array of ints which are the dof signs

const double * get_acceleration_dof_values(
  • int entity_id)

/param entity_id Id of the acceleration /return An array of doubles which are the dof values

std::string get_acis_version()
  •  
Returns A string containing the Acis version number
int get_acis_version_as_int()
  •  
Returns An integer containing the Acis version number
std::vector< int > get_adjacent_surfaces(
  • const std::string & geometry_type,
  • int entity_id)

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

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
std::vector< int > get_adjacent_volumes(
  • const std::string & geometry_type,
  • int entity_id)

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

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
std::vector< double > get_all_exodus_times(
  • const std::string & filename)
Parameters
  • filename
    Fully qualified exodus file name
Returns List (python tuple) of time stamps in the exodus file
std::vector< std::string > get_all_exodus_variable_names(
  • const std::string & filename,
  • const std::string & variable_type)
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
std::vector< std::string > get_all_geometric_owners(
  • std::string mesh_entity_type,
  • std::string mesh_entity_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.
double get_aprepro_numeric_value(
  • std::string variable_name)
Returns value as double on failure returns CUBIT_DBL_MAX
bool get_aprepro_value(
  • std::string variable_name,
  • int & returned_variable_type,
  • double & returned_double_val,
  • std::string & returned_string_val)
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)
std::string get_aprepro_value_as_string(
  • std::string variable_name)

/param var_name aprepro variable name /return The string value of the aprepro variable name

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

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

double get_arc_length(
  • int curve_id)
Parameters
  • curve_id
    ID of the curve
Returns Arc length of the curve
std::string get_assembly_classification_category()
  •  
Returns Requested data
std::string get_assembly_classification_level()
  •  
Returns Requested data
std::string get_assembly_description(
  • int assembly_id)
Parameters
  • assembly_id
    Id that identifies the assembly node
Returns Description of the assembly node
std::string get_assembly_file_format(
  • int assembly_id)
Parameters
  • assembly_id
    Id that identifies the assembly node
Returns File Format of the assembly node
int get_assembly_instance(
  • int assembly_id)
Parameters
  • assembly_id
    Id that identifies the assembly node
Returns Instance of the assembly node
int get_assembly_level(
  • int assembly_id)
Parameters
  • assembly_id
    Id that identifies the assembly node
Returns Level of the assembly node - Level == 0 == Root
std::string get_assembly_material_description(
  • int assembly_id)
Parameters
  • assembly_id
    Id that identifies the assembly node
Returns Material Description of the assembly part
std::string get_assembly_material_specification(
  • int assembly_id)
Parameters
  • assembly_id
    Id that identifies the assembly node
Returns Material Specification of the assembly part
std::string get_assembly_metadata(
  • int volume_id,
  • int data_type)
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
std::string get_assembly_name(
  • int assembly_id)
Parameters
  • assembly_id
    Id that identifies the assembly node
Returns Name of the assembly node
std::string get_assembly_path(
  • int assembly_id)
Parameters
  • assembly_id
    Id that identifies the assembly node
Returns Path of the assembly node
std::string get_assembly_type(
  • int assembly_id)
Parameters
  • assembly_id
    Id that identifies the assembly node
Returns Type of the assembly node – 'part' or 'assembly'
std::string get_assembly_units(
  • int assembly_id)
Parameters
  • assembly_id
    Id that identifies the assembly node
Returns Units of the assembly node
std::string get_assembly_weapons_category()
  •  
Returns Requested data
double get_auto_size(
  • const std::string & geometry_type,
  • std::vector< int > entity_id_list,
  • double size)
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
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)

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
std::vector< int > get_bc_id_list(
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
std::string get_bc_name(
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
double get_bc_temperature(

/param bc_type enum of CI_BCTypes. temperature = 4, convection = 7 /param entity_id Id of the BC convection /param 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 /return The value of the specified BC temperature

std::vector< std::vector< int > > get_blend_chains(
  • int surface_id)
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.
std::vector< int > get_blend_surfaces(
  • std::vector< int > target_volume_ids)
Parameters
  • target_volume_ids
    List of volume ids to examine.
Returns List (python tuple) of blend surface ids
int get_block_attribute_count(
  • int block_id)
Parameters
  • block_id
    The block id
Returns Number of attributes in the block
std::string get_block_attribute_name(
  • int block_id,
  • int attribute_index)
Parameters
  • block_id
    The block id
  • index
    The index of the attribute
Returns Attribute name as a std::string
double get_block_attribute_value(
  • int block_id,
  • int attribute_index)
Parameters
  • block_id
    The block id
  • index
    The index of the attribute
Returns List of attributes
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)

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
int get_block_count()
  •  
Returns The number of blocks in the current model, if any
std::vector< int > get_block_curves(
  • int block_id)
Parameters
  • block_id
    User specified id of the desired block
Returns A list (python tuple) of curve ids contained in the block
std::vector< int > get_block_edges(
  • int block_id)
Parameters
  • block_id
    User specified id of the desired block
Returns A list (python tuple) of edge ids contained in the block
int get_block_element_attribute_count(
  • int block_id)
Parameters
  • block_id
    The block id
Returns Number of attributes in the block element
std::vector< std::string > get_block_element_attribute_names(
  • int block_id)
Parameters
  • block_id
    The block id
  • index
    The index of the attribute
Returns Attribute name as a std::string
std::string get_block_element_type(
  • int block_id)
Parameters
  • block_id
    The block id
Returns Element type
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)
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
std::vector< int > get_block_faces(
  • int block_id)
Parameters
  • block_id
    User specified id of the desired block
Returns A list (python tuple) of face ids contained in the block
std::vector< int > get_block_hexes(
  • int block_id)
Parameters
  • block_id
    User specified id of the desired block
Returns A list (python tuple) of hex ids contained in the block
int get_block_id(
  • std::string entity_type,
  • int entity_id)
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
std::vector< int > get_block_id_list()
  •  
Returns List (python tuple) of all active block ids
std::vector< int > get_block_ids(
  • const std::string & mesh_geometry_file_name)
Parameters
  • mesh_geom_file_name
    Fully qualified name of a mesh geometry file
Returns List of block ids in the mesh geometry file
int get_block_material(
  • int block_id)
Returns The material id. If no material has been assigned to the block, returns 0.
std::vector< std::vector< int > > get_blocks_with_materials(
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.
std::vector< int > get_block_nodes(
  • int block_id)
Parameters
  • block_id
    User specified id of the desired block
Returns A list (python tuple) of node ids contained in the block
std::vector< int > get_block_pyramids(
  • int block_id)
Parameters
  • block_id
    User specified id of the desired block
Returns A list (python tuple) of pyramid ids contained in the block
std::vector< int > get_block_surfaces(
  • int block_id)
Parameters
  • block_id
    User specified id of the desired block
Returns A list (python tuple) of surface ids contained in the block
std::vector< int > get_block_tets(
  • int block_id)
Parameters
  • block_id
    User specified id of the desired block
Returns A list (python tuple) of tet ids contained in the block
std::vector< int > get_block_tris(
  • int block_id)
Parameters
  • block_id
    User specified id of the desired block
Returns A list (python tuple) of tri ids contained in the block
std::vector< int > get_block_vertices(
  • int block_id)
Parameters
  • block_id
    User specified id of the desired block
Returns A list (python tuple) of vertex ids contained in the block
std::vector< int > get_block_volumes(
  • int block_id)
Parameters
  • block_id
    User specified id of the desired block
Returns A list (python tuple) of volume ids contained in the block
std::vector< int > get_block_wedges(
  • int block_id)
Parameters
  • block_id
    User specified id of the desired block
Returns A list (python tuple) of wedges ids contained in the block
double get_blunt_tangency_default_depth(
  • int vert_id,
  • double angle,
  • bool add_material)

/brief get default depth value for blunt tangency operation /return depth

int get_body_count()
  •  
Returns The number of bodies in the current model, if any
std::array< double, 10 > get_bounding_box(
  • const std::string & geometry_type,
  • int entity_id)
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
std::string get_build_number()
  •  
Returns A string containing the current Cubit build number
std::vector< int > get_cavity_surfaces(
  • int surface_id)
Parameters
  • surface_id
    that is part of the cavity
Returns A list of surface id's in the cavity (including surface_id).
std::array< double, 3 > get_center_point(
  • const std::string & entity_type,
  • int entity_id)
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
int get_cfd_type(
  • int entity_id)
Parameters
  • entity_id
    ID of the cfd BC
Returns Integer corresponding to the type of cfd, as defined by CI_BCTypes
double get_close_loop_thickness(
  • int surface_id)
Parameters
  • surafce
    id
Returns List (python tuple) of close loop (surface) ids
std::vector< int > get_close_loops(
  • std::vector< int > target_volume_ids,
  • double mesh_size)

'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
std::vector< std::vector< double > > get_close_loops_with_thickness(
  • std::vector< int > target_volume_ids,
  • double mesh_size,
  • int genus)

'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
std::vector< int > get_close_vertex_curve_pairs(
  • std::vector< int > target_volume_ids,
  • double high_tolerance)
Parameters
  • target_volume_list
    List of volumes ids to examine.
Returns Paired list (python tuple) of vertex and curve ids considered coincident
std::vector< int > get_closed_narrow_surfaces(
  • std::vector< int > target_ids,
  • double narrow_size)
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
int get_closest_node(
  • double x_coordinate,
  • double y_coordinate,
  • double z_coordinate)
Parameters
  • x
    coordinate
  • y
    coordinate
  • z
    coordinate
Returns id of closest node, 0 if none found
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)

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.
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,
  • bool do_vertex_curve,
  • bool do_vertex_surf,
  • bool filter_same_volume_cases)

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.
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)

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
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)

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
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)

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
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
std::string get_command_from_history(
  • int command_number)
Returns A string which is the command at the given index
int get_common_curve_id(
  • int surface_1_id,
  • int surface_2_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
int get_common_vertex_id(
  • int curve_1_id,
  • int curve_2_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
std::vector< int > get_cone_surfaces(
  • std::vector< int > target_volume_ids)
Parameters
  • target_volume_ids
    List of volume ids to examine.
std::vector< int > get_connectivity(
  • const std::string & entity_type,
  • int entity_id)
Parameters
  • entity_type
    The mesh element type
  • entity_id
    The mesh element id
Returns List (python tuple) of node ids
std::string get_constraint_dependent_entity_point(
  • int constraint_id)
Parameters
  • constraint_id
    ID of the constraint
Returns A std::string indicating the dependent entity
std::string get_constraint_reference_point(
  • int constraint_id)
Parameters
  • constraint_id
    ID of the constraint
Returns A std::string indicating the reference point
std::string get_constraint_type(
  • int constraint_id)
Parameters
  • constraint_id
    ID of the constraint
Returns A std::string indicating the type – Kinematic, Distributing, Rigidbody
bool get_contact_pair_exterior_state(
  • int entity_id)

/param entity_id Id of the contact pair /return The exterior state of the contact pair

double get_contact_pair_friction_value(
  • int entity_id)

/param entity_id Id of the contact pair /return The friction value of the contact pair

bool get_contact_pair_general_state(
  • int entity_id)

/param entity_id Id of the contact pair /return The general state of the contact pair

bool get_contact_pair_tied_state(
  • int entity_id)

/param entity_id Id of the contact pair /return The tied state of the contact pair

double get_contact_pair_tol_lower_value(
  • int entity_id)

/param entity_id Id of the contact pair /return The tolerance value of the contact pair

double get_contact_pair_tolerance_value(
  • int entity_id)

/param entity_id Id of the contact pair /return The tolerance value of the contact pair

std::vector< int > get_continuous_surfaces(
  • int surface_id,
  • double 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 cavity (including surface_id).
double get_convection_coefficient(

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

std::vector< int > get_coordinate_systems_id_list()
  •  

/brief get a list of coordinate system ids

/return List (python tuple) of ids

std::string get_copy_block_on_geometry_copy_setting()
  •  
Returns copy nodeset setting
std::string get_copy_nodeset_on_geometry_copy_setting()
  •  
Returns copy nodeset setting
std::string get_copy_sideset_on_geometry_copy_setting()
  •  
Returns copy nodeset setting
double get_cubit_digits_setting()
  •  
Returns A double containing the digits. -1 if no digits are set
CubitMessageHandler * get_cubit_message_handler()
  •  
Parameters

  •  

std::string get_current_journal_file()
  •  
Returns The current journal file name.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
std::array< double, 3 > get_curve_center(
  • int curve_id)
Parameters
  • curve_id
    ID of the curve
Returns x, y, z center point of the curve in a vector (python tuple)
int get_curve_count()
  •  
Returns The number of curves in the current model, if any
int get_curve_count_in_volumes(
  • std::vector< int > target_volume_ids)
Returns The number of curves in the volumes
std::vector< int > get_curve_edges(
  • int curve_id)
Parameters
  • curve_id
    User specified id of the desired curve
Returns A list (python tuple) of the edge element ids on the curve
double get_curve_length(
  • int curve_id)
Parameters
  • curve_id
    ID of the curve
Returns Length of the curve
double get_curve_mesh_scheme_curvature(
  • int curve_id)
Parameters
  • curve_id
    Specifies the id of the curve
Returns The curvature mesh scheme value of a curve.
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.
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.
std::vector< int > get_curve_nodes(
  • int curve_id)
Parameters
  • curv_id
    id of curve
Returns List (python tuple) of IDs of nodes owned by the curve
double get_curve_radius(
  • int curve_id)
Parameters
  • curve_id
    ID of the curve
Returns Radius of the curve
std::string get_curve_type(
  • int curve_id)
Parameters
  • curve_id
    ID of the curve
Returns Type of curve
double get_dbl_sculpt_default(
  • const char * variable)

/brief return sculpt default value

std::string get_default_element_type()
  •  
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
std::string get_default_geometry_engine()
  •  
Returns The name of the default modeler engine in the form ACIS, CATIA, OCC, facet
std::string get_displacement_combine_type(
  • int entity_id)

/param entity_id Id of the displacement /return The combine type for the given displacement

int get_displacement_coord_system(
  • int entity_id)

/param entity_id Id of the displacement /return The Id of the displacement's coordinate system

const int * get_displacement_dof_signs(
  • int entity_id)

/param entity_id Id of the displacement /return

const double * get_displacement_dof_values(
  • int entity_id)

/param entity_id Id of the displacement /return

double get_distance_between(
  • int vertex_id_1,
  • int vertex_id_2)
Parameters
  • vertex_id_1
    ID of vertex 1 vertex_id_2 ID of vertex 2
Returns distance
double get_distance_between_entities(
  • std::string geom_type_1,
  • int entity_id_1,
  • std::string geom_type_2,
  • int entity_id_2)
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
double get_distance_from_curve_start(
  • double x_coordinate,
  • double y_coordinate,
  • double z_coordinate,
  • int curve_id)
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
int get_edge_count()
  •  
Returns The number of edges in the model
int get_edge_global_element_id(
  • int edge_id)
Parameters
  • edge_id
    Specifies the id of the edge
Returns The corresponding element id
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)
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
int get_element_block(
  • int element_id)
Parameters
  • element_id
    The element id (i.e. the global element export id)
Returns block_id, the id of the containing block
int get_element_budget(
  • const std::string & element_type,
  • std::vector< int > entity_id_list,
  • int auto_factor)
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
int get_element_count()
  •  
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.
bool get_element_exists(
  • int element_id)
Parameters
  • element_id
    The element id (i.e. the global element export id)
Returns true or false
std::string get_element_type(
  • int element_id)
Parameters
  • element_id
    The element id (i.e. the global element export id)
Returns The type
int get_element_type_id(
  • int element_id)
Parameters
  • element_id
    The element id (i.e. the global element export id)
Returns type_id The hex, tet, wedge, etc. id is returned.
std::vector< int > get_entities(
  • const std::string & entity_type)
Parameters
  • entity_type
    Specifies the type of the entity
Returns A list (python tuple) of ids of the specified geometry type
int get_entity_color_index(
  • const std::string & entity_type,
  • int entity_id)
Parameters
  • entity_type
    Specifies the type of the entity
  • entity_id
    Specifies the id of the entity
Returns The color of the entity
std::vector< std::string > get_entity_modeler_engine(
  • const std::string & geometry_type,
  • int entity_id)
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
std::string get_entity_name(
  • const std::string & entity_type,
  • int entity_id)

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.

Parameters
  • entity_type
    Specifies the type of the entity
  • entity_id
    Specifies the id of the entity
Returns The name of the entity
std::string get_entity_sense(
  • std::string source_type,
  • int source_id,
  • int sideset_id)
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
int get_error_count()
  •  
Returns The number of errors in the Cubit session.
int get_exodus_element_count(
  • int entity_id,
  • std::string entity_type)
Parameters
  • entity_id
    The id of the entity
  • entity_type
    The type of the entity
Returns Number of Elements
std::string get_exodus_entity_description(
  • std::string entity_type,
  • int entity_id)
Parameters
  • entity_type
    "block", "sideset", nodeset"
  • entity_id
    Id of the entity in question
Returns Description of the entity or if none
std::string get_exodus_entity_name(
  • const std::string entity_type,
  • int entity_id)
Parameters
  • entity_type
    "block", "sideset", nodeset"
  • entity_id
    Id of the entity in question
Returns Name of the entity or if none
std::string get_exodus_entity_type(
  • std::string entity_type,
  • int entity_id)
Parameters
  • entity_type
    "block", "sideset", nodeset"
  • entity_id
    Id of the entity in question
Returns Type of the entity or if none. Returns "lite" or
int get_exodus_id(
  • const std::string & entity_type,
  • int entity_id)
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
std::string get_exodus_sizing_function_file_name()
  •  
Returns The sizing function file name
std::string get_exodus_sizing_function_variable_name()
  •  
Returns The sizing function variable name
int get_exodus_variable_count(
  • std::string container_type,
  • int container_id)
Parameters
  • entity_type
    : nodeset, sideset, or block block_id The block id
Returns Number of exodus variables
std::vector< std::string > get_exodus_variable_names(
  • std::string container_type,
  • int container_id)
Parameters
  • entity_type
    : nodeset, sideset, or block block_id The block id
Returns Names of exodus variables
std::string get_exodus_version()
  •  
Returns A string containing the Exodus version number
std::vector< int > get_expanded_connectivity(
  • const std::string & entity_type,
  • int entity_id)
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
std::array< double, 3 > get_force_direction_vector(
  • int entity_id)

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

double get_force_magnitude(
  • int entity_id)

/param entity_id Id of the force /return Magnitude of the given force

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

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

std::vector< std::string > get_geometric_owner(
  • std::string mesh_entity_type,
  • std::string mesh_entity_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.
int get_geometry_node_count(
  • const std::string & entity_type,
  • int entity_id)

/brief Get the node count for a specific geometric entity

/param entity_type The geometry type ("surface", "curve", etc) /param entity_id The entity id /return Number of nodes in the geometry

std::string get_geometry_owner(
  • const std::string & entity_type,
  • int entity_id)
Parameters
  • entity_type
    The mesh element type
  • entity_id
    The mesh element id
Returns Name of owner
int get_global_element_id(
  • const std::string & element_type,
  • int 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
std::string get_graphics_version()
  •  
Returns A string containing the VTK version number
std::vector< int > get_group_bodies(
  • int group_id)

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
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)

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
std::vector< int > get_group_curves(
  • int group_id)

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
std::vector< int > get_group_edges(
  • int group_id)

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
std::vector< int > get_group_groups(
  • int group_id)

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
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
std::vector< int > get_group_nodes(
  • int group_id)

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
std::vector< int > get_group_pyramids(
  • int group_id)

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
std::vector< int > get_group_quads(
  • int group_id)

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
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
std::vector< int > get_group_surfaces(
  • int group_id)

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
std::vector< int > get_group_tets(
  • int group_id)

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
std::vector< int > get_group_tris(
  • int group_id)

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
std::vector< int > get_group_vertices(
  • int group_id)

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
std::vector< int > get_group_volumes(
  • int group_id)

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
std::vector< int > get_group_wedges(
  • int group_id)

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
double get_heatflux_on_area(

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

int get_hex_count()
  •  
Returns The number of hexes in the model
int get_hex_global_element_id(
  • int hex_id)
Parameters
  • hex_id
    Specifies the id of the hex
Returns The corresponding element id
std::vector< int > get_hex_sheet(
  • int node_id_1,
  • int node_id_2)
Returns A list (python tuple) of hex ids in the hex sheet
double get_hydraulic_radius_surface_area(
  • int surface_id)
Parameters
  • surface_id
    ID of the surface
Returns Hydraulic area of the surface
double get_hydraulic_radius_volume_area(
  • int volume_id)
Parameters
  • volume_id
    ID of the volume
Returns Hydraulic area of the volume
int get_id_from_name(
  • const std::string & name)

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

Parameters
  • name
    Name of the entity to examine return Integer representing the entity
std::string get_idless_signature(
  • std::string entity_type,
  • int entity_id)
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)
std::string get_idless_signatures(
  • std::string entity_type,
  • const std::vector< int > & entity_id_list)
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) ...
CubitBaseInterface * get_interface(
  • std::string interface_name)
Parameters
  • interface_name
    the name of interface
int get_label_type(
  • const char * entity_type)

/brief make calls to SVDrawTool::get_label_type

/return label type currently associated with entity_type

int get_last_id(
  • const std::string & entity_type)
Parameters
  • entity_type
    Type of the entity being queried
Returns Integer id of last created entity
std::vector< int > get_list_of_free_ref_entities(
  • const std::string & geometry_type)
Parameters
  • geom_type
    Specifies the geometry type of the free entity
Returns A list (python tuple) of ids of the specified geometry type
std::string get_material_name(
  • int material_id)
Returns A std::string with the material's name.
std::vector< std::string > get_material_name_list()
  •  

/brief Get a list of all defined material names

/return List (python tuple) of all the material names.

double get_material_property(

/brief Get the specified material property value

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

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

/brief Get a list of all defined material names

/return List (python tuple) of all the material names.

int get_media_property(
  • int entity_id)

/brief Get the media property value

/param entity_id Id of the media /return Value of the media property, 0 == FLUID, 1 == POROUS, 2 == SOLID

std::string get_merge_setting(
  • const std::string & geometry_type,
  • int entity_id)
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
double get_merge_tolerance()
  •  
Returns The value of the current merge tolerance
std::vector< std::vector< int > > get_mergeable_curves(
  • std::vector< int > target_volume_ids)

Given a list of volume ids, this will return a list of potentially mergeable curves. The returned lists include lists of the merge partners.

Parameters
  • target_volume_ids
    List of volume ids to examine.
Returns list of lists of mergeable curves (potentially more than a pair) Note: If using python, lists will be python tuples.
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)

Given a list of volume ids, this will return 3 lists of potential merge candidates. The returned lists include lists of the merge partners.

Parameters
  • target_volume_ids
    List of volume ids to examine.
  • surface_list
    User specified list where mergeable surfaces will be stored
  • curve_list
    User specified list where mergeable curves will be stored
  • vertex_list
    User specified list where mergeable vertices will be stored
  • merge_tol
    merge tolerance to determine mergable (optional). Uses the default merge_tolerance if not specified
std::vector< std::vector< int > > get_mergeable_surfaces(
  • std::vector< int > target_volume_ids)

Given a list of volume ids, this will return a list of potentially mergeable surfaces. The returned lists include lists of the merge partners.

Parameters
  • target_volume_ids
    List of volume ids to examine.
Returns list of lists of mergeable surfaces (potentially more than a pair) Note: If using python, lists will be python tuples.
std::vector< std::vector< int > > get_mergeable_vertices(
  • std::vector< int > target_volume_ids)

Given a list of volume ids, this will return a list of potentially mergeable vertices. The returned lists include lists of the merge partners.

Parameters
  • target_volume_ids
    List of volume ids to examine.
Returns list of lists of mergeable vertices (potentially more than a pair) Note: If using python, lists will be python tuples.
double get_mesh_edge_length(
  • int edge_id)
Parameters
  • edge_id
    Specifies the id of the edge
Returns The length of the mesh edge
std::string get_mesh_element_type(
  • const std::string & entity_type,
  • int entity_id)
Parameters
  • entity_type
    The type of entity
  • entity_id
    The id of the entity
Returns Mesh element type for that entity
std::vector< std::string > get_mesh_error_solutions(
  • int error_code)
Parameters
  • error_code
    The error code associated with the error solution
Returns List (python tuple) of 'married' strings. First string is solution text. Second string is help context cue. Third string is command_panel cue.
double get_mesh_geometry_approximation_angle(
  • std::string geometry_type,
  • int entity_id)
Parameters
  • geom_type
    either "surface" or "volume"
  • entity_id
    the entity id
Returns boolean value as to whether or not the proximity flag is set
std::vector< int > get_mesh_group_parent_ids(
  • const std::string & element_type,
  • int element_id)
Parameters
  • element_type
    Mesh type of the element
  • element_id
    ID of the mesh element return List (python tuple) of group ids that contain this mesh element
std::string get_mesh_interval_firmness(
  • const std::string & geometry_type,
  • int entity_id)
Parameters
  • geom_type
    Specifies the geometry type of the entity
  • entity_id
    Specifies the id of the entity
Returns The entity's meshing firmness (HARD, SOFT, LIMP) HARD = set directly SOFT = computed LIMP = not set
int get_mesh_intervals(
  • const std::string & geometry_type,
  • int entity_id)
Parameters
  • geom_type
    Specifies the geometry type of the entity
  • entity_id
    Specifies the id of the entity
Returns The entity's interval count
std::string get_mesh_scheme(
  • const std::string & geometry_type,
  • int entity_id)
Parameters
  • geom_type
    Specifies the geometry type of the entity
  • entity_id
    Specifies the id of the entity
Returns The entity's meshing scheme
std::string get_mesh_scheme_firmness(
  • const std::string & geometry_type,
  • int entity_id)
Parameters
  • geom_type
    Specifies the geometry type of the entity
  • entity_id
    Specifies the id of the entity
Returns The entity's meshing firmness (HARD, LIMP, SOFT)
double get_mesh_size(
  • const std::string & geometry_type,
  • int entity_id)
Parameters
  • geom_type
    Specifies the geometry type of the entity
  • entity_id
    Specifies the id of the entity
Returns The entity's mesh size
std::string get_mesh_size_type(
  • const std::string & geometry_type,
  • int entity_id)
Parameters
  • geom_type
    Specifies the geometry type of the entity
  • entity_id
    Specifies the id of the entity
Returns The entity's mesh size type (USER_SET, CALCULATED, NOT_SET)
double get_meshed_volume_or_area(
  • const std::string & geometry_type,
  • std::vector< int > entity_ids)
Parameters
  • geom_type
    Specifies the type of entity - volume, surface, hex, tet, tri, quad
  • entity_ids
    A list of ids for the entity type
Returns The entity's meshed volume or area
std::string get_meshgems_version()
  •  
Returns A string containing the MeshGems version number
double get_moment_magnitude(
  • int entity_id)

/param entity_id Id of the force /return magnitude of the moment on the given force

std::vector< int > get_narrow_regions(
  • std::vector< int > target_ids,
  • double narrow_size)
Parameters
  • target_volume_ids
    List of volume ids to examine.
  • narrow_size
    Indicate the size that defines 'narrowness'
Returns List (python tuple) of surface ids
std::vector< int > get_narrow_surfaces(
  • std::vector< int > target_volume_ids,
  • double mesh_size)

'Narrow' is a function of the mesh_size passed into the routine. The mesh_size parameter will act as the threshold for determining what 'narrow' is.

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 small surface ids
std::vector< int > get_nearby_volumes_at_volume(
  • int volume_id,
  • std::vector< int > compare_volumes,
  • double distance)
Parameters
  • volume_id
    volume to check.
  • volumes
    to check against. If empty, will check against all volumes in model
  • maximum
    distance betwen volumes. Optional. Use -1 to compute default tolerance
Returns list of volumes that are nearby to volume_id from compare_volumes list
int get_next_block_id()
  •  
Returns Next available block id
std::string get_next_command_from_history()
  •  
Returns A string which is the command
int get_next_nodeset_id()
  •  
Returns Next available nodeset id
int get_next_sideset_id()
  •  
Returns Next available sideset id
std::array< double, 3 > get_nodal_coordinates(
  • int node_id)
Parameters
  • node_id
    The node id
Returns a triple (python tuple) containing the x, y, and z coordinates
bool get_node_constraint()
  •  
Returns True if constrained, otherwise false
int get_node_constraint_value()
  •  
Returns Returns 0 (off), 1(on), 2(smart)
int get_node_count()
  •  
Returns The number of nodes in the model
bool get_node_exists(
  • int node_id)
Parameters
  • node_id
    The node id
Returns true or false
std::vector< int > get_node_faces(
  • int node_id)

|brief Get the face/quad ids that share a node

Parameters
  • node_id
    The node id
Returns List (python tuple) of face/quad ids adjacent the node
int get_node_global_id(
  • int node_id)
Parameters
  • node_id
    Specifies the id of the sphere
Returns The corresponding global node id
bool get_node_position_fixed(
  • int node_id)
Parameters
  • node_id
    The node id
Returns True if constrained, otherwise false
std::vector< int > get_node_tris(
  • int node_id)

|brief Get the tri ids that share a node

Parameters
  • node_id
    The node id
Returns List (python tuple) of tri ids adjacent the node
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)

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

Parameters
  • nodeset_id
    User specified id of the desired nodeset
  • node_list
    User specified list where nodes associated with this nodeset are returned
  • volume_list
    User specified list where volumes associated with this nodeset are returned
  • surface_list
    User specified list where surfaces associated with this nodeset are returned
  • curve_list
    User specified list where curves associated with this nodeset are returned
  • vertex_list
    User specified list where vertices associated with this nodeset are returned
int get_nodeset_count()
  •  
Returns The number of sidesets in the current model, if any
std::vector< int > get_nodeset_curves(
  • int nodeset_id)
Parameters
  • nodeset_id
    User specified id of the desired nodeset
Returns A list (python tuple) of curve ids contained in the nodeset
std::vector< int > get_nodeset_id_list()
  •  
Returns List (python tuple) of all active nodeset ids
std::vector< int > get_nodeset_id_list_for_bc(
Parameters
  • bc_type_in
    Type of bc to query, as defined by enum CI_BCTypes. 1-9 is FEA, 10-30 is CFD
  • bc_id
    ID of the bc to query
Returns A list (python tuple) of nodeset ID's associated with that bc
int get_nodeset_node_count(
  • int nodeset_id)
Parameters
  • nodeset_id
    The nodeset id
Returns Number of nodes in the nodeset
std::vector< int > get_nodeset_nodes(
  • int nodeset_id)
Parameters
  • nodeset_id
    User specified id of the desired nodeset
Returns A list (python tuple) of node ids contained in the nodeset
std::vector< int > get_nodeset_nodes_inclusive(
  • int nodeset_id)
Parameters
  • nodeset_id
    User specified id of the desired nodeset
Returns A list (python tuple) of node ids contained in the nodeset
std::vector< int > get_nodeset_surfaces(
  • int nodeset_id)
Parameters
  • nodeset_id
    User specified id of the desired nodeset
Returns A list (python tuple) of surface ids contained in the nodeset
std::vector< int > get_nodeset_vertices(
  • int nodeset_id)
Parameters
  • nodeset_id
    User specified id of the desired nodeset
Returns A list (python tuple) of vertex ids contained in the nodeset
std::vector< int > get_nodeset_volumes(
  • int nodeset_id)
Parameters
  • nodeset_id
    User specified id of the desired nodeset
Returns A list (python tuple) of volume ids contained in the nodeset
double get_overlap_max_angle(
  • void)
Returns The max angle setting
double get_overlap_max_gap(
  • void)
Returns The max gap setting
double get_overlap_min_gap(
  • void)
Returns The min gap setting
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)

For every occurance of two overlapping curves, two curve ids are returned. Those ids are returned in the indicated lists and are aligned. In other words the first id in curv_list_1 overlaps with the first id in curv_list_2. The second id in curv_list_1 overlaps with the second id in curv_list-2, and so on.

Parameters
  • target_surface_ids
    List of surface ids to examine.
  • min_gap
    minimum overlap distance between curves to return
  • max_gap
    maximum overlap distance between curves to return
  • returned_curve_list_1
    User specified list where the ids of overlapping curves will be returned
  • returned_curve_list_2
    User specified list where the ids of overlapping curves will be returned
  • returned_distance_list
    Corresponding user specified list where distances between curves will be returned
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,
  • bool filter_volume_overlaps,
  • int cache_overlaps)

For every occurance of two overlapping surfaces, two surfaces ids are returned. Those ids are returned in the indicated lists and are aligned. In other words the first id in surf_list_1 overlaps with the first id in surf_list_2. The second id in surf_list_1 overlaps with the second id in surf_list-2, and so on.

Parameters
  • target_surface_ids
    List of surface ids to examine.
  • returned_surface_list_1
    User specified list where the ids of overlapping surfaces will be returned
  • returned_surface_list_2
    User specified list where the ids of overlapping surfaces will be returned
  • returned_distance_list
    Corresponding user specified list where distances between surfaces will be returned
  • returned_overlap_area_list
    Corresponding user specified list where overlap areas between surfaces will be returned
  • filter_slivers
    whether to return filter slivers
  • filter_volume_overlaps
    whether to return surfaces on the same volume
  • cache_overlaps
    speed up overlaps by caching and using previously computed results. Default 0 = no caching. 1 = clear out old values first. 2 = use and add to existing cache
std::vector< int > get_overlapping_surfaces_at_surface(
  • int surface_id,
  • std::vector< int > compare_volumes,
  • int cache_overlaps)
Parameters
  • surface_id
    surface to check.
  • compare_volumes
    volumes to check against. If empty, will check against all volumes in model
Returns list of surfaces that overlap surface_id from compare_volumes list
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,
  • bool filter_volume_overlaps,
  • int cache_overlaps)

For every occurance of two overlapping surfaces, two surfaces ids are returned. Those ids are returned in the indicated lists and are aligned. In other words the first id in surf_list_1 overlaps with the first id in surf_list_2. The second id in surf_list_1 overlaps with the second id in surf_list-2, and so on.

Parameters
  • target_volume_ids
    List of volume ids to examine.
  • surf_list_1
    User specified list where the ids of overlapping surfaces will be returned
  • surf_list_2
    User specified list where the ids of overlapping surfaces will be returned
  • returned_distance_list
    Corresponding user specified list where distances between surfaces will be returned
  • returned_overlap_area_list
    Corresponding user specified list where overlap areas between surfaces will be returned
  • filter_slivers
    whether to return filter slivers
  • filter_volume_overlaps
    whether to return surfaces on the same volume
  • cache_overlaps
    speed up overlaps by caching and using previously computed results. Default 0 = no caching. 1 = clear out old values first. 2 = use and add to existing cache
std::vector< int > get_overlapping_volumes(
  • std::vector< int > target_volume_ids)

For every occurance of two overlapping volumes, two volume ids are returned in volume_list. Modulus 2 of the volume_list should always be 0 (the list should contain an even number of volume ids). The first volume id in the returned list overlaps with the second volume id. The third volume id overlaps with the fourth volume id, and so on.

Parameters
  • target_volume_ids
    List of volume ids to examine.
Returns List (python tuple) of overlapping volumes ids
std::vector< int > get_overlapping_volumes_at_volume(
  • int volume_id,
  • std::vector< int > compare_volumes)
Parameters
  • volume_id
    volume to check.
  • volumes
    to check against. If empty, will check against all volumes in model
Returns list of volumes that overlap volume_id from compare_volumes list
int get_owning_body(
  • const std::string & geometry_type,
  • int entity_id)
Parameters
  • geom_type
    Specifies the geometry type of the entity
  • entity_id
    Specifies the id of the entity
Returns ID of the specified entity's owning body
int get_owning_volume(
  • const std::string & geometry_type,
  • int entity_id)
Parameters
  • geom_type
    Specifies the geometry type of the entity
  • entity_id
    Specifies the id of the entity
Returns ID of the specified entity's owning volume
int get_owning_volume_by_name(
  • const std::string & entity_name)
Parameters
  • entity_name
    Specifies the name (supplied by Cubit) of the entity
Returns ID of the specified entity's owning volume or 0 if name is unknown
void get_owning_volume_ids(
  • const std::string & entity_type,
  • std::vector< int > & entity_list,
  • std::vector< int > & volume_ids)
Parameters
  • entity_type

     

  • entity_list

     

  • vol_ids

     

int get_parent_assembly_instance(
  • int assembly_id)
Parameters
  • assembly_id
    Id that identifies the assembly node
Returns Instance of the assembly node' instance
std::string get_parent_assembly_path(
  • int assembly_id)
Parameters
  • assembly_id
    Id that identifies the assembly node
Returns Path of the assembly node' parent
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)
Parameters
  • geom_type
    Specifies the geometry type of the entity
  • entity_id
    Specifies the id of the entity
  • interval
    User specified variable where interval count for the specified entity is returned
  • firmness
    User specified variable where a firmness of 'hard', 'soft', or 'default' is returned
  • lower_bound
    User specified variable where the lower bound value is returned
  • upper_bound
    User specified variable where the upper bound value is returned
const char * get_pick_type()
  •  
Returns The current pick type of the graphics system
std::string get_pressure_function(
  • int entity_id)

/param entity_id Id of the pressure /return The pressure function

double get_pressure_value(
  • int entity_id)

/param entity_id Id of the pressure /return The value or magnitude of the given pressure

std::string get_previous_command_from_history()
  •  
Returns A string which is the command
int get_pyramid_count()
  •  
Returns The number of pyramids in the model
int get_pyramid_global_element_id(
  • int pyramid_id)
Parameters
  • pyramid_id
    Specifies the id of the pyramid
Returns The corresponding element id
int get_quad_count()
  •  
Returns The number of quads in the model
int get_quad_global_element_id(
  • int quad_id)
Parameters
  • quad_id
    Specifies the id of the quad
Returns The corresponding element 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)
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
  • min_value
    Quality value of the worst element
  • max_value
    Quality value of the best element
  • mean_value
    Average quality value of all elements
  • std_value
    Std deviationvalue of all elements
  • min_element_id
    ID of the worst element
  • max_element_id
    ID of the best element
  • mesh_list
    list of failed elements
  • element_type
    type of failed elements (does not support mixed element types)
  • make_group
    whether to create a group or not
  • bad_group_id
    ID of the created group
  • min_value
    User specified variable where the minimum quality value will be returned
  • max_value
    User specified variable where the maximum quality value will be returned
  • mean_value
    User specified variable where the mean quality value will be returned
  • std_value
    User specified variable where the standard deviation quality value will be returned
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)
Parameters
  • geom_type
    Specifies the geometry type of the entities
  • mesh_type
    Specifies the element type to find quality at geom entities
  • id_list
    Specifies a list of geometry entity ids to work on
  • expand_levels
    Number of element levels from target geometry to expand
  • 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
double get_quality_value(
  • const std::string & mesh_type,
  • int mesh_id,
  • const std::string & metric_name)
Parameters
  • mesh_type
    Specifies the mesh entity type (hex, tet, tri, quad)
  • mesh_id
    Specifies the id of the mesh entity
  • metric_name
    Specifies the name of the metric (skew, taper, jacobian, etc)
Returns The value of the quality metric
std::vector< int > get_relatives(
  • const std::string & source_geometry_type,
  • int source_id,
  • const std::string & target_geom_type)

This can be used to get either ancestors or predecessors for a specific entity. Only one specified entity type is returned with one use of the routine. For example, to get all surface parents associated with Curve 1, 'curve' is the source_geometry_type, '1' is the source_id, and 'surface' is the target_geom_type.

Parameters
  • source_geom_type
    The entity type of the source entity
  • source_id
    The id of the source entity
  • target_geom_type
    The target geometry type
Returns A list (python tuple) of ids of the target geometry type
int get_rendering_mode()
  •  
Returns The current rendering mode of the graphics subsystem
std::string get_requested_mesh_interval_firmness(
  • const std::string & geometry_type,
  • int entity_id)
Parameters
  • geom_type
    Specifies the geometry type of the entity
  • entity_id
    Specifies the id of the entity
Returns The entity's meshing firmness (HARD, SOFT, LIMP) HARD = set directly SOFT = computed LIMP = not set
int get_requested_mesh_intervals(
  • const std::string & geometry_type,
  • int entity_id)
Parameters
  • geom_type
    Specifies the geometry type of the entity
  • entity_id
    Specifies the id of the entity
Returns The entity's interval count
double get_requested_mesh_size(
  • const std::string & geometry_type,
  • int id)
Parameters
  • geom_type
    Specifies the geometry type of the entity
  • entity_id
    Specifies the id of the entity
Returns The entity's requested mesh size
std::string get_requested_mesh_size_type(
  • const std::string & geometry_type,
  • int entity_id)
Parameters
  • geom_type
    Specifies the geometry type of the entity
  • entity_id
    Specifies the id of the entity
Returns The entity's mesh size type (USER_SET, CALCULATED, NOT_SET)
std::string get_revision_date()
  •  
Returns A string containing Cubit's last date of revision
int get_rubberband_shape()
  •  
Returns 0 for box, 1, for polygon, 2 for circle
int get_selected_id(
  • int index)
Returns An id based on the passed in index
std::vector< int > get_selected_ids()
  •  
Returns A list of the currently selected ids
std::string get_selected_type(
  • int index)
Returns A type based on the passed in index
std::vector< std::vector< double > > get_sharp_angle_vertices(
  • std::vector< int > target_volume_ids,
  • double upper_bound,
  • double lower_bound)

'Sharp' is a function of the upper_bound and lower_bound threshold parameters. The id of vertices is returned. Similar to get_sharp_curve_angles except only vertices are returned with angles above upper_bound and below lower_bound

Parameters
  • target_volume_ids
    List of volume ids to examine.
  • upper_bound
    Upper threshold angle
  • lower_bound
    Lower threshold angle
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)

'Sharp' is a function of the upper_bound and lower_bound threshold parameters. The id of curves are returned when any angle associated with a curve is less than the lower_bound or greater than the upper_bound.

Parameters
  • target_volume_ids
    List of volume ids to examine.
  • large_curve_angles
    User specified list where the ids of curves with curve angles will be returned
  • small_curve_angles
    User specified list where the ids of curves with small angles will be returned
  • large_angles
    User specified list where the angles associated with large_curve_angles will be returned. Angles returned are in the same order as the ids returned in large_curve_angles.
  • small_angles
    User specified list where the angles associated with small_curve_angles will be returned. Angles returned are in the same order as the ids returned in small_curve_angles.
  • upper_bound
    Upper threshold angle
  • lower_bound
    Lower threshold angle
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)

'Sharp' is a function of the upper_bound and lower_bound threshold parameters. The id of surfaces are returned when any angle associated with a surface is less than the lower_bound or greater than the upper_bound.

Parameters
  • target_volume_ids
    List of volume ids to examine.
  • large_surface_angles
    User specified list where the ids of surfaces with large angles will be returned
  • small_surface_angles
    User specified list where the ids of surfaces with small angles will be returned
  • large_angles
    User specified list where the angles associated with large_surface_angles will be returned. Angles returned are in the same order as the ids returned in large_surface_angles.
  • small_angles
    User specified list where the angles associated with small_surface_angles will be returned. Angles returned are in the same order as the ids returned in small_surface_angles.
  • upper_bound
    Upper threshold angle
  • lower_bound
    Lower threshold angle
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)

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

Parameters
  • sideset_id
    User specified id of the desired sideset
  • face_list
    User specified list where faces associated with this sideset are returned
  • surface_list
    User specified list where surfaces associated with this sideset are returned
  • curve_list
    User specified list where curves associated with this sideset are returned
int get_sideset_count()
  •  
Returns The number of sidesets in the current model, if any
std::vector< int > get_sideset_curves(
  • int sideset_id)
Parameters
  • sideset_id
    User specified id of the desired sideset
Returns A list (python tuple) of curve ids contained in the sideset
std::string get_sideset_element_type(
  • int sideset_id)
Parameters
  • sideset_id
    The id of the sideset to be queried
Returns Element type
std::vector< int > get_sideset_id_list()
  •  
Returns List (python tuple) of all active sideset ids
std::vector< int > get_sideset_id_list_for_bc(
Parameters
  • bc_type_in
    Type of bc to query, as defined by enum CI_BCTypes. 1-9 is FEA, 10-30 is CFD
  • bc_id
    ID of the bc to query
Returns A list (python tuple) of sideset ID's associated with that bc
std::vector< int > get_sideset_quads(
  • int sideset_id)

A sideset can contain quadrilateral elements.
This function will return those quad elements if they exist. An empty list will be returned if there are no quads in the sideset.

Parameters
  • sideset_id
    User specified id of the desired sideset
Returns A list (python tuple) of the quads in the sideset
std::vector< int > get_sideset_surfaces(
  • int sideset_id)

A sideset can contain surfaces. This function will return those surfaces if they exist. An empty list will be returned if there are no surfaces in the sideset.

Parameters
  • sideset_id
    User specified id of the desired sideset
Returns A list (python tuple) of the surfaces defining the sideset
std::vector< int > get_similar_curves(
  • std::vector< int > curve_ids)
Parameters
  • curve_ids
    IDs of curve to compare against
Returns list of IDs of similar surfaces
std::vector< int > get_similar_surfaces(
  • std::vector< int > surface_ids)
Parameters
  • surface_ids
    IDs of surface to compare against
Returns list of IDs of similar surfaces
std::vector< int > get_similar_volumes(
  • std::vector< int > volume_ids)
Parameters
  • volume_ids
    IDs of volume(s) to compare against
Returns list of IDs of similar volumes
std::string get_sizing_function_name(
  • const std::string & entity_type,
  • int surface_id)
Parameters
  • entity_type
    Type (volume or surface)
  • entity_id
    Id of the entity
Returns The sizing function name (constant, curvature, interval, inverse, linear, super, test, exodus, none)
std::vector< int > get_small_and_narrow_surfaces(
  • std::vector< int > target_ids,
  • double small_area,
  • double small_curve_size)
Parameters
  • target_volume_ids
    List of volume ids to examine.
  • small_area
    Indicate the area threshold
  • small_curve_size
    Indicate size for 'narrowness'
Returns List (python tuple) of small or narrow surface ids
std::vector< int > get_small_curves(
  • std::vector< int > target_volume_ids,
  • double mesh_size)

'Small' 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. in Cubit is valid as input here.
  • mesh_size
    Indicate the mesh size used as the threshold
Returns List (python tuple) of small curve ids
std::vector< int > get_small_radius_blend_surfaces(
  • std::vector< int > target_volume_ids,
  • double max_radius)
Parameters
  • target_volume_ids
    List of volume ids to examine. max_radius maximum radius of curvature for which blend surfaces will be returned if max_radius = 0, then all blend surfaces will be returned.
Returns List (python tuple) of blend surface ids
std::vector< int > get_small_surfaces(
  • std::vector< int > target_volume_ids,
  • double mesh_size)

'Small' 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 small surface ids
std::vector< int > get_small_surfaces_HR(
  • std::vector< int > target_volume_ids,
  • double mesh_size)

'Small' 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 return the list of small hydraulic radius surfaces (same as returned_small_surfaces)
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)

'Small' 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
  • returned_small_surfaces
    ids of small hydraulic radius surfaces will be returned
  • returned_small_radius
    User The hydrualic radius of each small surface will be returned. The order of the radius values is the same as the order of the returned ids.
Returns return the list of small hydraulic radius surfaces (same as returned_small_surfaces)
std::vector< int > get_small_volumes(
  • std::vector< int > target_volume_ids,
  • double mesh_size)

'Small' 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. volumes with volume < 10*mesh_size^3 will be returned.

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 small volume ids
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)

'Small' 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
  • small_volumes
    User specified list where the ids of small volumes will be returned
  • small_radius
    User specified list where the radius of each small volume will be returned. The order of the radius values is the same as the order of the returned ids.
std::vector< int > get_smallest_curves(
  • std::vector< int > target_volume_ids,
  • int number_to_return)
Parameters
  • target_volume_ids
    List of volume ids to examine. in Cubit is valid as input here.
  • num_to_return
    Indicate the number of curves to return
Returns List (python tuple) of smallest curve ids
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)
Parameters
  • target_ids
    The entities to query
  • num_to_return
    number of small features to return
  • type1_list

     

  • type2_list

     

  • id1_list

     

  • id2_list

     

  • distance_list

     

std::string get_smooth_scheme(
  • const std::string & geometry_type,
  • int entity_id)
Parameters
  • geom_type
    Specifies the geometry type of the entity
  • entity_id
    Specifies the id of the entity
Returns The smooth scheme associated with the entity
std::vector< std::vector< std::string > > get_solutions_for_bad_geometry(
  • std::string geom_type,
  • int geom_id)
Parameters
  • geom_type
    "curve", "surface", "volume" or "body"
  • geom_id
    ID of geometry entity
Returns Vector of three string vectors. Vector 1 will contain display strings to be shown to users. Vector 2 will contain Cubit command strings. This second set of strings may contain concatenated strings delimited by '&&&'. In other words, one instance of command string may in fact contain multiple commands separated by the '&&&' sequence. Vector 3 will contain Cubit preview strings. Note: If using this function in python, returned vectors will be python tuples.
std::vector< std::vector< std::string > > get_solutions_for_blends(
  • int surface_id)
Parameters
  • surface_id
    the surface being queried
  • max_radius
    the maximum radius of curvature for which solutions will be returned max_radius=-1 will return solutions for any blend
Returns Vector of three string vectors. Vector 1 will contain display strings to be shown to users. Vector 2 will contain Cubit command strings. Vector 3 will contain Cubit preview strings. Note: If using python, vectors will be python tuples.
std::vector< std::vector< std::string > > get_solutions_for_cavity_surface(
  • int surface_id)
Parameters
  • surface_id
    the surface being queries
Returns Vector of three string vectors. Vector 1 will contain display strings to be shown to users. Vector 2 will contain Cubit command strings. Vector 3 will contain Cubit preview strings. Note: If using python, vectors will be python tuples.
std::vector< std::vector< std::string > > get_solutions_for_classified_volume(
  • std::string classification,
  • int vol_id)
Parameters
  • classification
    string defining the classification type: "bolt", "nut", "washer", "spring", "ball", "race", "pin", "gear", "other"
  • vol_id

     

Returns Vector of three string vectors. Vector 1 will contain display strings to be shown to users. Vector 2 will contain Cubit command strings. Vector 3 will contain Cubit preview strings. Vector 4 will contain operation strings for machine learning Note: If using this function in python, returned vectors will be python tuples.
std::vector< std::vector< std::string > > get_solutions_for_close_loop(
  • int surface_id,
  • double mesh_size)
Parameters
  • surface_id
    the surface being queried
  • mesh_size
    Indicate size for 'narrowness'
Returns Vector of three string vectors. Vector 1 will contain display strings to be shown to users. Vector 2 will contain Cubit command strings. Vector 3 will contain Cubit preview strings. Note: If using python, vectors will be python tuples.
std::vector< std::vector< std::string > > get_solutions_for_cone_surface(
  • int surface_id)
Parameters
  • surface_id
    cone surface
std::vector< std::string > get_solutions_for_decomposition(
  • const std::vector< int > & volume_list,
  • double exterior_angle,
  • bool do_imprint_merge,
  • bool tolerant_imprint)
Parameters
  • volume_list
    List of volumes to query
  • exterior_angle
    Threshold value for the exterior angle
  • do_imprint_merge
    Set to true (1) if you want the imprint and merge to be done
  • tol_imprint
    Set to true (1) if you want to do a tolerant imprint
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)
Parameters
  • volume_id
    id of volume source_surface_id_list list of source surface ids target_surface_id_list list of target surface ids small_curve_size optional paramtere to specify small curve size
Returns Vector of two string vectors. Vector 1 will contain display strings to be shown to users. Vector 2 will contain Cubit command strings. Vector 3 will contain Cubit preview strings. Note: If using this function in python, returned vectors will be python tuples.
std::vector< std::vector< std::string > > get_solutions_for_imprint_merge(
  • int surface_id1,
  • int surface_id2)
Parameters
  • surface_id1
    overlapping surface 1 surface_id2 overlapping surface 2
Returns Vector of three string vectors. Vector 1 will contain display strings to be shown to users. Vector 2 will contain Cubit command strings. This second set of strings may contain concatenated strings delimited by '&&&'. In other words, one instance of command string may in fact contain multiple commands separated by the '&&&' sequence. Vector 3 will contain Cubit preview strings. Note: If using this function in python, returned vectors will be python tuples.
std::vector< std::vector< std::string > > get_solutions_for_near_coincident_vertex_and_curve(
  • int vertex_id,
  • int curve_id)
Parameters
  • vertex_id
    ID of the vertex
  • curve_id
    ID of the curve
Returns Vector of three string vectors. Vector 1 will contain display strings to be shown to users. Vector 2 will contain Cubit command strings. This second set of strings may contain concatenated strings delimited by '&&&'. In other words, one instance of command string may in fact contain multiple commands separated by the '&&&' sequence. Vector 3 will contain Cubit preview strings. Note: If using this function in python, returned vectors will be python tuples.
std::vector< std::vector< std::string > > get_solutions_for_near_coincident_vertex_and_surface(
  • int vertex_id,
  • int surface_id)
Parameters
  • vertex_id
    ID of the vertex
  • surface_id
    ID of the surface
Returns Vector of three string vectors. Vector 1 will contain display strings to be shown to users. Vector 2 will contain Cubit command strings. This second set of strings may contain concatenated strings delimited by '&&&'. In other words, one instance of command string may in fact contain multiple commands separated by the '&&&' sequence. Vector 3 will contain Cubit preview strings. Note: If using this function in python, returned vectors will be python tuples.
std::vector< std::vector< std::string > > get_solutions_for_near_coincident_vertices(
  • int vertex_id_1,
  • int vertex_id_2)
Parameters
  • target_vertex_ids
    Vertex list
  • high_tolerance
    The upper threshold tolerance value
Returns Vector of three string vectors. Vector 1 will contain display strings to be shown to users. Vector 2 will contain Cubit command strings. This second set of strings may contain concatenated strings delimited by '&&&'. In other words, one instance of command string may in fact contain multiple commands separated by the '&&&' sequence. Vector 3 will contain Cubit preview strings. Note: If using this function in python, returned vectors will be python tuples.
std::vector< std::vector< std::string > > get_solutions_for_overlapping_surfaces(
  • int surface_id_1,
  • int surface_id_2)
Parameters
  • id
    of surface 1
  • id
    of surface 2
Returns Vector of three string vectors. Vector 1 will contain display strings to be shown to users. Vector 2 will contain Cubit command strings. This second set of strings may contain concatenated strings delimited by '&&&'. In other words, one instance of command string may in fact contain multiple commands separated by the '&&&' sequence. Vector 3 will contain Cubit preview strings. Note: If using this function in python, returned vectors will be python tuples.
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)
Parameters
  • id
    of volume 1
  • id
    of volume 2
Returns Vector of three string vectors. Vector 1 will contain display strings to be shown to users. Vector 2 will contain Cubit command strings. This second set of strings may contain concatenated strings delimited by '&&&'. In other words, one instance of command string may in fact contain multiple commands separated by the '&&&' sequence. Vector 3 will contain Cubit preview strings. Note: If using this function in python, returned vectors will be python tuples.
std::vector< std::vector< std::string > > get_solutions_for_sharp_angle_vertex(
  • int vertex_id,
  • double small_curve_size,
  • double mesh_size)
Parameters
  • vertex_id
    vertex with sharp angle
  • small_curve_size
    Threshold value used to determine what 'small' is
  • mesh_size
    Element size of the model
Returns Vector of three string vectors. Vector 1 will contain display strings to be shown to users. Vector 2 will contain Cubit command strings. Vector 3 will contain Cubit preview strings. Vector 4 will contain operation strings for machine learning Note: If using this function in python, returned vectors will be python tuples.
std::vector< std::vector< std::string > > get_solutions_for_small_curves(
  • int curve_id,
  • double small_curve_size,
  • double mesh_size)
Parameters
  • curve_id
    Small curve
  • small_curve_size
    Threshold value used to determine what 'small' is
  • mesh_size
    Element size of the model
Returns Vector of three string vectors. Vector 1 will contain display strings to be shown to users. Vector 2 will contain Cubit command strings. Vector 3 will contain Cubit preview strings. Vector 4 will contain operation strings for machine learning Note: If using this function in python, returned vectors will be python tuples.
std::vector< std::vector< std::string > > get_solutions_for_small_surfaces(
  • int surface_id,
  • double small_curve_size,
  • double mesh_size)
Parameters
  • surface_id
    Small surface
  • small_curve_size
    Threshold value used to determine what 'small' is
  • mesh_size
    Element size of the model
Returns Vector of three string vectors. Vector 1 will contain display strings to be shown to users. Vector 2 will contain Cubit command strings. Vector 3 will contain Cubit preview strings. Vector 4 will contain operation strings for machine learning Note: If using this function in python, returned vectors will be python tuples.
std::vector< std::vector< std::string > > get_solutions_for_surfaces_with_narrow_regions(
  • int surface_id,
  • double small_curve_size,
  • double mesh_size)
Parameters
  • surface_id
    Small surface
  • small_curve_size
    Threshold value used to determine what 'small' is
  • mesh_size
    Element size of the model
Returns Vector of three string vectors. Vector 1 will contain display strings to be shown to users. Vector 2 will contain Cubit command strings. Vector 3 will contain Cubit preview strings. Note: If using this function in python, returned vectors will be python tuples.
std::vector< std::vector< std::string > > get_solutions_for_volumes(
  • int vol_id,
  • double small_curve_size,
  • double mesh_size)
Parameters
  • vol_id

     

  • small_curve_size
    Threshold value used to determine what 'small' is
  • mesh_size
    Element size of the model
Returns Vector of three string vectors. Vector 1 will contain display strings to be shown to users. Vector 2 will contain Cubit command strings. Vector 3 will contain Cubit preview strings. Vector 4 will contain operation strings for machine learning Note: If using this function in python, returned vectors will be python tuples.
std::vector< int > get_source_surfaces(
  • int volume_id)
Parameters
  • volume_id
    Specifies the volume id
Returns List (python tuple) of surface ids
int get_sphere_count()
  •  
Returns The number of spheres in the model
int get_sphere_global_element_id(
  • int edge_id)
Parameters
  • sphere_id
    Specifies the id of the sphere
Returns The corresponding element id
std::vector< int > get_sub_elements(
  • const std::string & entity_type,
  • int entity_id,
  • int dimension)
Parameters
  • entity_type
    The mesh element type of the higher dimension entity
  • entity_id
    The mesh element id
  • dimension
    The dimension of the desired sub entities
Returns List (python tuple) of ids of the desired dimension
std::vector< std::pair< int, int > > get_submap_corner_types(
  • int surface_id)
Parameters
  • the
    id of the surface
Returns a vector of pairs of <id, corner_type> The corner_types are defined as follows

UNSET_TYPE = -1, END_TYPE = 1, SIDE_TYPE, CORNER_TYPE, REVERSAL_TYPE, TRIANGLE_TYPE, NON_TRIANGLE_TYPE };

double get_surface_area(
  • int surface_id)
Parameters
  • surface_id
    ID of the surface
Returns Area of the 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)
Parameters
  • volume_list
    List of volumes to query
  • hr_threshold
    return cavities with computed hydraulic radius less than hr_threshold. Where hr = 4*Area/Perimeter. Use hr_threshold < 0.0 to return all cavities
  • area_threshold
    return cavities with computed surface area less than area_threshold. Use area_threshold < 0.0 to return all cavities
  • return
    a vector of cavity areas corresponding to the return cavity id lists
Returns A list of lists of surface id's grouped by their individual cavity or hole
std::array< double, 3 > get_surface_centroid(
  • int surface_id)
Parameters
  • surface_id
    ID of the surface
Returns surface centroid
int get_surface_count()
  •  
Returns The number of surfaces in the current model, if any
int get_surface_element_count(
  • int surface_id)
Returns The number of quads, and triangles in a surface. NOTE: This count does not distinguish between elements which have been put into a block or not.
std::vector< std::vector< int > > get_surface_loop_nodes(
  • int surface_id)
Parameters
  • surface_id
    User specified id of the desired surface
Returns A list of lists (python tuple of tuples) one list per loop first loop is the external
std::vector< int > get_surface_nodes(
  • int surface_id)
Parameters
  • surf_id
    id of surface
Returns List (python tuple) of IDs of nodes owned by the surface
std::array< double, 3 > get_surface_normal(
  • int surface_id)
Parameters
  • surface_id
    ID of the surface
Returns surface normal at the center
std::array< double, 3 > get_surface_normal_at_coord(
  • int surface_id,
  • std::array< double, 3 >)
Parameters
  • surface_id
    ID of the surface
  • coord
    array of x,y,z location on surface
Returns surface normal at coord
int get_surface_num_loops(
  • int surface_id)
Parameters
  • surface_id
    User specified id of the desired surface
Returns number of loops on the surface
std::vector< double > get_surface_principal_curvatures(
  • int surface_id)
Parameters
  • surface_id
    ID of the surface
Returns two scalars that are the principal curvatures at midpoint
std::vector< int > get_surface_quads(
  • int surface_id)
Parameters
  • surface_id
    User specified id of the desired surface
Returns A list (python tuple) of the quad ids on the surface
std::string get_surface_sense(
  • int surface_id)
Parameters
  • surface_id
    ID of the surface
Returns surface sense as "Reversed" or "Forward" or "Both"
std::vector< int > get_surface_tris(
  • int surface_id)
Parameters
  • surface_id
    User specified id of the desired surface
Returns A list (python tuple) of the tri ids on the surface
std::string get_surface_type(
  • int surface_id)
Parameters
  • surface_id
    ID of the surface
Returns Type of surface
std::vector< int > get_surfs_with_narrow_regions(
  • std::vector< int > target_ids,
  • double narrow_size)
Parameters
  • target_volume_ids
    List of volume ids to examine.
  • narrow_size
    Indicate the size that defines 'narrowness'
Returns List (python tuple) of surface ids
std::vector< int > get_tangential_intersections(
  • std::vector< int > target_volume_ids,
  • double upper_bound,
  • double lower_bound)

'Bad' is a function of the upper_bound and lower_bound threshold parameters. The id of surfaces are returned when any tangential angle associated with a surface is less than the lower_bound or greater than the upper_bound.

Parameters
  • target_volume_ids
    List of volume ids to examine.
  • upper_bound
    Upper threshold angle
  • lower_bound
    Lower threshold angle
Returns List (python tuple) of surface ids associated with bad tangential angles
std::vector< int > get_target_surfaces(
  • int volume_id)
Parameters
  • volume_id
    Specifies the volume id
Returns List (python tuple) of surface ids
int get_tet_count()
  •  
Returns The number of tets in the model
int get_tet_global_element_id(
  • int tet_id)
Parameters
  • tet_id
    Specifies the id of the tet
Returns The corresponding element id
double get_tetmesh_growth_factor(
  • int volume_id)
Returns the volume gradation
bool get_tetmesh_proximity_flag(
  • int volume_id)
Parameters
  • volume_id
    the volume id
Returns boolean value as to whether or not the proximity flag is set
int get_tetmesh_proximity_layers(
  • int volume_id)
Parameters
  • volume_id
    the volume id
Returns boolean value as to whether or not the proximity flag is set
std::array< double, 15 > get_tight_bounding_box(
  • const std::string & geometry_type,
  • std::vector< int > entity_list)
Parameters
  • geom_type
    Specifies the geometry type of the entity
  • entity_list
    List of ids associated with geom_type
Returns A vector (python tuple) of coordinates and axis (0-2) center (3-5, 6-8, 9-11) u, v, x normalized coordinate axis of the box (12-14) length in u, v, w
std::array< double, 10 > get_total_bounding_box(
  • const std::string & geometry_type,
  • std::vector< int > entity_list)
Parameters
  • geom_type
    Specifies the geometry type of the entity
  • entity_list
    List of ids associated with geom_type
Returns An array of coordinates for the entity's bounding box. Ten (10) values will be returned. [ x-min, x-max, x-range, y-min, y-max, y-range, z-min, z-max, z-range, diagonal].
double get_total_volume(
  • std::vector< int > volume_list)
Parameters
  • volume_list
    List of volume ids
Returns The total volume of all volumes indicated in the id list
int get_tri_count()
  •  
Returns The number of tris in the model
int get_tri_global_element_id(
  • int tri_id)
Parameters
  • tri_id
    Specifies the id of the tri
Returns The corresponding element id
double get_trimesh_surface_gradation()
  •  
Returns the surface gradation
double get_trimesh_volume_gradation()
  •  
Returns the volume gradation
bool get_undo_enabled()
  •  

/brief Query whether undo is currently enabled

/return True if undo is enabled, otherwise false

int get_valence(
  • int vertex_id)
Parameters
  • vertex_id
    ID of vertex
std::vector< std::string > get_valid_block_element_types(
  • int block_id)
Parameters
  • block_id
    The block id
Returns List (python tuple) of potential element types
std::string get_velocity_combine_type(
  • int entity_id)

/param entity_id Id of the velocity /return The combine type for the given velocity

const int * get_velocity_dof_signs(
  • int entity_id)

/param entity_id Id of the velocity /return

const double * get_velocity_dof_values(
  • int entity_id)

/param entity_id Id of the velocity /return

std::string get_version()
  •  
Returns A string containing the current version of Cubit
int get_vertex_count()
  •  
Returns The number of vertices in the current model, if any
int get_vertex_node(
  • int vertex_id)
Parameters
  • vert_id
    id of vertex
Returns ID of node owned by the vertex. returns -1 of doesn't exist
std::string get_vertex_type(
  • int surface_id,
  • int vertex_id)
Parameters
  • surface_id
    Id of the surface associated with the vertex
  • vertex_id
    Id of the vertex
Returns The type – "side", "end", "reverse", or "unknown"
std::array< double, 3 > get_view_at()
  •  
Returns The xyz coordinates of the camera's current position
double get_view_distance()
  •  
Returns Distance from the camera to the model
std::array< double, 3 > get_view_from()
  •  
Returns The xyz coordinates of the camera's from position
std::array< double, 3 > get_view_up()
  •  
Returns The xyz coordinates of the camera's up direction
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)
Parameters
  • sphere_id_list
    list of volume ids (should be spheres)
  • rad_intervals
    number of radial intervals (around circle)
  • az_intervals
    number of intervals from inner mapped box to surface
  • bias
    bias from inner mapped box to surface (<1 increases size to boundary)
  • fract
    fraction of radius to use as size of interior mapped box
  • max_smooth_iterations
    max number of smooth iterations to perform after meshing
double get_volume_area(
  • int volume_id)
Parameters
  • volume_id
    ID of the volume
Returns Area of the volume
int get_volume_count()
  •  
Returns The number of nodesets in the current model, if any
int get_volume_element_count(
  • int volume_id)
Returns The number of hexes, tets, pyramids, and wedges in a volume. NOTE: This count does not distinguish between elements which have been put into a block or not.
std::vector< std::vector< std::string > > get_volume_gap_solutions(
  • int surface_id_1,
  • int surface_id_2)

Get lists of display strings and command strings for gaps

Parameters
  • id
    of surface 1
  • id
    of surface 2
Returns Vector of three string vectors. Vector 1 will contain display strings to be shown to users. Vector 2 will contain Cubit command strings. This second set of strings may contain concatenated strings delimited by '&&&'. In other words, one instance of command string may in fact contain multiple commands separated by the '&&&' sequence. Vector 3 will contain Cubit preview strings. Note: If using this function in python, returned vectors will be python tuples.
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)

For every occurance of a gap, two surfaces ids are returned. Those ids are returned in the indicated lists and are aligned. In other words the first id in surf_list_1 overlaps with the first id in surf_list_2. The second id in surf_list_1 overlaps with the second id in surf_list-2, and so on.

Parameters
  • target_volume_ids
    List of volume ids to examine.
  • surf_list_1
    User specified list where the ids of the gap surfaces will be returned
  • surf_list_2
    User specified list where the ids of the gap surfaces will be returned
  • distance_list
    User specified list where the distance between the gap surface will be returned
  • max_gap_tolerance
    User specified tolerance used to find the gaps.
  • cache_overlaps
    speed up overlaps by caching and using previously computed results. Default 0 = no caching. 1 = clear out old values first. 2 = use and add to existing cache
std::vector< int > get_volume_hexes(
  • int volume_id)
Parameters
  • volume_id
    User specified id of the desired volume
Returns A list (python tuple) of the hex ids in the volume
std::vector< int > get_volume_nodes(
  • int volume_id)
Parameters
  • vol_id
    id of volume
Returns List (python tuple) of IDs of nodes owned by the volume
std::vector< int > get_volume_tets(
  • int volume_id)
Parameters
  • volume_id
    User specified id of the desired volume
Returns A list (python tuple) of the tet ids in the volume
int get_wedge_global_element_id(
  • int wedge_id)
Parameters
  • wedge_id
    Specifies the id of the wedge
Returns The corresponding element id
std::string get_wrt_entity(
  • std::string source_type,
  • int source_id,
  • int sideset_id)
Parameters
  • source_type
    Item type - could be 'face', 'quad' or 'tri'
  • source_id
    ID of entity
  • sideset_id
    ID of the sideset
Returns 'with-respect-to' entity of the source_type/source_id in specified sideset
void group_list(
  • std::vector< std::string > & name_list,
  • std::vector< int > & returned_id_list)
Parameters
  • name_list
    User specified list where the active group names will be returned
  • id_list
    User specified list where the ids of all active groups will be returned
std::vector< std::pair< std::string, int > > group_names_ids()
  •  

return A list of std::pair<std::string, int> structure instances

bool heatflux_is_on_shell_area(

/param bc_area enum of CI_BCEntityTypes. Use 7 to check if on top, 8 to check if on bottom /param entity_id Id of the BC /return true if BC heatflux is on specified shell area, otherwise false

void init(
  • const std::vector< std::string > & argv)
Parameters
  • argv
    List of start-up directives. A blank list such as [''] will suffice. See Cubit Help for details
bool is_assembly_metadata_attached(
  • int volume_id)
Parameters
  • volume_id
    ID of the volume
Returns True if metadata exists, otherwise false
bool is_blend_surface(
  • int surface_id)
Parameters
  • surface_id
    ID ofsurface
Returns whether the surface is a blend
bool is_catia_engine_available()
  •  
Returns True if catia engine is available, otherwise false
bool is_cavity_surface(
  • int surface_id)
Parameters
  • surface_id
    ID ofsurface
Returns whether the surface is part of a cavity
bool is_close_loop_surface(
  • int surface_id,
  • double mesh_size)
Parameters
  • surface_id
    ID ofsurface
  • mesh_size
    Indicate the mesh size used as the threshold
Returns whether the surface has one or more close loops
bool is_command_echoed()
  •  
Returns A boolean indicating whether commands should be echoed in Cubit
bool is_command_journaled()
  •  
Returns A boolean indicating whether commands are journaled by Cubit
bool is_cone_surface(
  • int surface_id)
Parameters
  • surface_id
    ID ofsurface
Returns whether the surface is a cone
bool is_continuous_surface(
  • int surface_id,
  • double angle_tol)
Parameters
  • surface_id
    ID ofsurface
  • angle_tol
    angle tolerance for continuity
Returns whether the surface has adjacent continuous surfaces
bool is_cylinder_surface(
  • int surface_id)
Parameters
  • surface_id
    ID ofsurface
Returns whether the surface is a cylinder
bool is_geometry_visibility_on()
  •  
Returns True if scale is visible, otherwise false
bool is_interval_count_odd(
  • int surface_id)
Parameters
  • surface_id
    Id of the surface
Returns True if surface is/contains an odd looop, otherwise false.
bool is_merged(
  • const std::string & geometry_type,
  • int entity_id)
Parameters
  • geom_type
    Specifies the geometry type of the entity
  • entity_id
    Specifies the id of the entity
bool is_mesh_element_in_group(
  • const std::string & element_type,
  • int element_id)
Parameters
  • element_type
    Mesh type of the element
  • element_id
    ID of the mesh element return True if in a group, otherwise false
bool is_mesh_visibility_on()
  •  
Returns True if scale is visible, otherwise false
bool is_meshed(
  • const std::string & geometry_type,
  • int entity_id)
Parameters
  • geom_type
    Specifies the geometry type of the entity
  • entity_id
    Specifies the id of the entity
bool is_modified()
  •  
Returns A boolean indicating whether the model has been modified
bool is_multi_volume(
  • int body_id)
Parameters
  • body_id
    Id of the body
Returns True if body contains multiple volumes, otherwise false.
bool is_narrow_surface(
  • int surface_id,
  • double mesh_size)
Parameters
  • surface_id
    ID ofsurface
  • mesh_size
    threshold used to determine if is narrow
Returns whether the surface is narrow
bool is_occlusion_on()
  •  
Returns True if occlusion is on, otherwise false
bool is_on_thin_shell(

/param bc_type_in enum of CI_BCTypes. temperature = 4, convection = 7, heatflux = 8 /param entity_id Id of the BC /return true if BC is on thin shell element, otherwise false

bool is_part_of_list(
  • int target_id,
  • std::vector< int > id_list)
Parameters
  • target_id
    Target id
  • id_list
    List of ids
Returns True if target_id is member of id_list, otherwise false
bool is_performing_undo()
  •  
Returns True or false.
bool is_periodic(
  • const std::string & geometry_type,
  • int entity_id)
Parameters
  • geom_type
    Specifies the geometry type of the entity
  • entity_id
    Specifies the id of the entity
Returns True is entity is periodic, otherwise false
bool is_perspective_on()
  •  
Returns True if perspective is on, otherwise false
bool is_playback_paused_on_error()
  •  
Returns True if playback should be paused when an error occurs.
int is_point_contained(
  • const std::string & geometry_type,
  • int entity_id,
  • const std::array< double, 3 > & xyz_point)
Parameters
  • geom_type
    string defining geometry type (volume or body) id ID of the geometric entity point xyz triplet defining the point (note that it must be std::array<double,3>
Returns -1 failure, 0 outside, 1, inside, 2 on
bool is_scale_visibility_on()
  •  
Returns True if scale is visible, otherwise false
bool is_select_partial_on()
  •  
Returns True if partial select is on, otherwise false
bool is_sheet_body(
  • int volume_id)
Parameters
  • volume_id
    Id of the volume
Returns True if volume is a sheet body, otherwise false
bool is_surface_planer(
  • int surface_id)
Parameters
  • surface_id
    Specifies the id of the surface
Returns True is surface is planer, otherwise false
bool is_undo_save_needed()
  •  
Returns A boolean indicating whether the model has been modified
bool is_virtual(
  • const std::string & geometry_type,
  • int entity_id)
Parameters
  • geom_type
    Specifies the geometry type of the entity
  • entity_id
    Specifies the id of the entity
bool is_visible(
  • const std::string & geometry_type,
  • int entity_id)
Parameters
  • geom_type
    Specifies the geometry type of the entity
  • entity_id
    Specifies the id of the entity
bool is_volume_meshable(
  • int volume_id)
Returns A boolean indicating whether volume is meshable with current scheme
bool is_working_dir_set()
  •  
Returns

was the -workingdir passed in from the command line

Returns boolean value indicating whether -working dir was set
void journal_commands(
  • bool state)
Parameters
  • state
    A boolean that turns journaling on (1) and off (0)
std::vector< double > measure_between_entities(
  • std::string entity_type1,
  • int entity_id1,
  • std::string entity_type2,
  • int entity_id2)

/brief returns distance between two geometry entities and their closest points

Parameters
  • entity_type1
    type of first entity
  • entity_id1
    id of first entity
  • entity_type2
    type of second entity
  • entity_id2
    id of second entity
void move(
  • Entity entity,
  • std::array< double, 3 > vector,
  • bool preview)
Parameters
  • [in] entity
    The Entity to be moved
  • [in] vector
    The vector the Entity will be moved
  • [in] preview
    Flag to show the preview or not, default is false
int number_undo_commands()
  •  

/brief Query whether there are any undo commands to execute

/return The number of commands in the undo stack

void override_journal_stream(
  • JournalStreamBase * jnl_stream)
Returns
std::vector< int > parse_cubit_list(
  • const std::string & type,
  • std::string entity_list_string)

Users are allowed to input many variations of entities and IDs for any given command. This routine parses the input and returns a regular list of valid IDs for the specified entity type. For example: parse_cubit_list('surface', '1 to 12') parse_cubit_list('surface', 'with name "myname*"') parse_cubit_list('surface', 'in volume 5 to 23')

Parameters
  • type
    The specific entity type represented by the list of entities
  • int_list
    The string that contains the entity list
Returns A vector (python tuple) of validated integers
void print_raw_help(
  • const char * input_line,
  • int order_dependent,
  • int consecutive_dependent)
Parameters
  • input_line
    The current command line being typed by the user
  • order_dependent
    Is set to '1' if the key pressed is not &, otherwise '0'
  • consecutive_dependent
    Is set to '1' if the pressed is '?', otherwise '0'
Body prism(
  • double height,
  • int sides,
  • double major,
  • double minor)
Parameters
  • [in] height
    The height of the prism
  • [in] sides
    The number of sides of the prism
  • [in] major
    The major radius
  • [in] minor
    The minor radius
Returns A Body object of the newly created prism
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)
Parameters
  • pts
    The x,y (abstract u,v) coordinates of the input points. Should be in [0,1].
  • surf_id
    The surface.
  • quad_id
    The quad.
  • node00_id
    The id of the node of the quad corresponding to an input point with coordinates (0,0)
  • node10_id
    The id of the node of the quad corresponding to an input point with coordinates (1,0)
Returns Return the position on the surface of each input node, in the same order as the input was given
Body pyramid(
  • double height,
  • int sides,
  • double major,
  • double minor,
  • double top)
Parameters
  • [in] height
    The height of the pyramid
  • [in] sides
    The number of sides of the pyramid
  • [in] major
    The major radius
  • [in] minor
    The minor radius
  • [in] top
    determines size for the top of the pyramid. Defaults to 0, meaning it will go to a point
Returns A Body object of the newly created pyramid
void reflect(
  • Entity entity,
  • std::array< double, 3 > axis,
  • bool preview)
Parameters
  • [in] entity
    The Entity to be reflected
  • [in] axis
    The axis to be reflected about
  • [in] preview
    Flag to show the preview or not, default is false
bool release_interface(
  • CubitBaseInterface * instance)
Parameters
  • interface_name
    the name of interface
void remove_entity_from_group(
  • int group_id,
  • int entity_id,
  • const std::string & entity_type)
Parameters
  • group_id
    ID of group from which the entity will be removed
  • entity_id
    ID of the entity to be removed from the group
  • entity_type
    Type of the entity to be removed from the group. Note that only geometric entities can be removed
void remove_overconstrained_tets(
  • std::vector< int > tet_ids)

/brief Deletes over-constrained tets (tets with all four corner nodes and and two triangles on the same surface). The tet is deleted and two triangles are created from the back sides of the tet. For tets with mid-edge nodes, the tet is only removed if after removal, the mid-edge node on the back of the tet
can be snapped to the surface without causing adjacent tets to have an inradius smaller than the tet we are removing.

CubitProgressHandler * replace_progress_handler(
  • CubitProgressHandler * progress)
Parameters
  • progress
    A pointer to a CubitProgressHandler instance
Returns pointer to previous progress handler
void scale(
  • Entity entity,
  • double factor,
  • bool preview)
Parameters
  • [in] entity
    The Entity to be scaled
  • [in] factor
    The scale factor
  • [in] preview
    Flag to show the preview or not, default is false
bool set_copy_block_on_geometry_copy_setting(
  • std::string val)
Returns success/fail setting the setting
bool set_copy_nodeset_on_geometry_copy_setting(
  • std::string val)
Returns success/fail setting the setting
bool set_copy_sideset_on_geometry_copy_setting(
  • std::string val)
Returns success/fail setting the setting
void set_cubit_interrupt(
  • bool interrupt)
Parameters
  • interrupt
    Boolean set to TRUE if process is to be stopped
void set_cubit_message_handler(
  • CubitMessageHandler * hdlr)
Parameters

  •  

bool set_entity_name(
  • const std::string & entity_type,
  • int entity_id,
  • const std::string & new_name)
Parameters
  • entity_type
    Specifies the type of the entity
  • entity_id
    Specifies the id of the entity
  • new_name
    Specifies what the name of the entity should be changed to
Returns true if entity was found and rename, otherwise false.
void set_exit_handler(
  • ExternalExitHandler * hdlr)
Parameters
  • An
    instance of a class that inherits from ExternalExitHandler
void set_label_type(
  • const char * entity_type,
  • int label_flag)

/brief make calls to SVDrawTool::set_label_type

/return none.

void set_max_group_id(
  • int maximum_group_id)

When using this call the user must ensure the group max_group_id is under their control. Typically, a user will create a group, use it, then immediately delete it. This call will only work if the max_group_id is the same as Cubit's max group id. If it is Cubit's max id will be reset. If not, nothing will happen.

Parameters
  • max_id
    ID of group to make 'max'
void set_overlap_max_angle(
  • const double maximum_angle)
Parameters
  • max
    angle
Returns
void set_overlap_max_gap(
  • const double maximum_gap)
Parameters
  • max
    gap
Returns
void set_overlap_min_gap(
  • const double min_gap)
Parameters
  • min_gap

     

Returns
void set_playback_handler(
  • ExternalPlaybackHandler * hdlr)
Parameters

  •  

void set_playback_paused_on_error(
  • bool pause)
Parameters
  • pause
    True if playback should be paused when an error occurs.
void set_progress_handler(
  • CubitProgressHandler * progress)
Parameters
  • progress
    A pointer to a CubitProgressHandler instance
void set_rendering_mode(
  • int mode)
Parameters
  • mode
    Integer associated with the rendering mode. Options are 1,7,2,8, or 5
bool silent_cmd(
  • const char * input_string)

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.

Parameters
  • input_string
    Pointer to a string containing a complete Cubit command
std::vector< double > snap_locations_to_geometry(
  • std::vector< double > locations,
  • std::string entity_type,
  • int entity_id,
  • double tol)

/brief Snaps xyz locations to closest point on entity. Then snaps to child curves or vertices within given tolerance. Vertices snapped to before curves.

Body sphere(
  • double radius,
  • int x_cut,
  • int y_cut,
  • int z_cut,
  • double inner_radius)
Parameters
  • [in] radius
    The radius of the sphere
  • [in] x_cut
    If 1, cuts sphere by yz plane (default to 0)
  • [in] y_cut
    If 1, cuts sphere by xz plane (default to 0)
  • [in] z_cut
    If 1, cuts sphere by xy plane (default to 0)
  • [in] inner_radius
    The inside radius if the sphere is hollow (default to 0)
Returns A Body object of the newly created sphere
std::string string_from_id_list(
  • std::vector< int > ids)

For example: string_from_id_list(<1, 2, 3, 4, 5, 6, 7, 8>) returns '1 to 8' example: string_from_id_list(<1, 2, 3, 100, 5, 6, 7, 8>) returns '1 to 3, 5 to 8, 100'

Parameters
  • ids
    The vector of integer ids
Returns A string representing the id list
std::vector< Body > subtract(
Parameters
  • [in] tool_in
    List of Body objects to subtract
  • [in] from_in
    List of Body objects to be subtracted from
  • [in] imprint_in
    Flag to set the imprint (defaults to false)
  • [in] keep_old_in
    Flag to keep the old volume (defaults to false)
Returns A list of changed body objects
CubitInterface::Surface surface(
  • int id_in)
Parameters
  • id_in
    The ID of the surface
Returns The surface object
std::vector< Body > sweep_curve(
  • std::vector< Curve > curves,
  • std::vector< Curve > along_curves,
  • double draft_angle,
  • int draft_type,
  • bool rigid)
Parameters
  • [in] curves
    A list of curves to sweep
  • [in] along_curves
    A list of curves to sweep along
  • [in] draft_angle
    The sweep draft angle (default to 0)
  • [in] draft_type
    The draft type (default to 0) 0 => extended (draws two straight tangent lines from the ends of each segment until they intersect) 1 => rounded (create rounded corner between segments) 2 => natural (extends the shapes along their natural curve) ***
  • [in] rigid
    The inside radius if the sphere is hollow (default to False)
Returns A List of newly created Bodies
bool temperature_is_on_shell_area(

/param bc_type enum of CI_BCTypes. temperature = 4, convection = 7 /param bc_area enum of CI_BCEntityTypes. Use 7 for top, 8 for bottom, 9 for gradient, 10 for middle /param entity_id Id of the BC /return true if BC temperature is on the shell area, otherwise false

bool temperature_is_on_solid(

/param bc_type_in enum of CI_BCTypes. temperature = 4, convection = 7 /param entity_id Id of the BC /return true if BC temperature is on a solid, otherwise false

Body torus(
  • double center_radius,
  • double swept_radius)
Parameters
  • [in] r1
    radius from center to center of circle to be swept (r1>r2)
  • [in] r2
    radius of circle swept to create torus (r1>r2)
Returns A Body object of the newly created torus
std::vector< Body > tweak_curve_offset(
  • std::vector< Curve > curves,
  • std::vector< double > distances,
  • bool keep_old,
  • bool preview)
Parameters
  • [in] curves
    A list of curve objects to offset
  • [in] distances
    A list of distances associated with the offset for each curve
  • [in] keep_old
    Keep the old body (defaults to false)
  • [in] preview
    Flag to show the preview (defaults to false)
Returns A list of changed body objects
std::vector< CubitInterface::Body > tweak_curve_remove(
  • std::vector< Curve > curves,
  • bool keep_old,
  • bool preview)

Removes a curve from a body

Parameters
  • [in] surfaces
    A list of the curves to be removed
  • [in] keep_old
    Keep the old body (defaults to false)
  • [in] preview
    Flag to show the preview (defaults to false)
Returns A list of changed body objects
std::vector< Body > tweak_surface_offset(
  • std::vector< Surface > surfaces,
  • std::vector< double > distances)
Parameters
  • surfaces
    A list of surface objects to offset
  • distances
    A list of distances associated with the offset for each surface
Returns A list of the body objects of the modified bodies
std::vector< CubitInterface::Body > tweak_surface_remove(
  • std::vector< Surface > surfaces,
  • bool extend_ajoining,
  • bool keep_old,
  • bool preview)

Removes a surface from a body

Parameters
  • [in] surfaces
    The surfaces to be removed
  • [in] extend_ajoining
    Extend the ajoining surfaces (default to true)
  • [in] keep_old
    Keep the old body (default to false)
  • [in] preview
    Flag to show the preview or not (default to false)
Returns A list of changed body objects
std::vector< Body > tweak_vertex_fillet(
  • std::vector< Vertex > verts,
  • double radius,
  • bool keep_old,
  • bool preview)
Parameters
  • [in] verts
    A list of vertex objects to fillet
  • [in] r0
    radius of the fillet
  • [in] keep_old
    Keep the old body (defaults to false)
  • [in] preview
    Flag to show the preview (defaults to false)
Returns A list of changed body objects
std::vector< Body > unite(
Parameters
  • [in] body_in
    A list of body objects to unite
  • [in] keep_old_in
    Flag to keep old bodies (defaults to false)
Returns A list of changed bodies
void unselect_entity(
  • const std::string & entity_type,
  • int entity_id)

Unselecting an entity will unhighlight it in the graphics window and remove it from the global pick list.

Parameters
  • entity_type
    The type of the entity to be unselected
  • entity_id
    The ID of the entity to be unselected
CubitInterface::Vertex vertex(
  • int id_in)
Parameters
  • id_in
    The ID of the vertex
Returns The vertex object
CubitInterface::Volume volume(
  • int id_in)
Parameters
  • id_in
    The ID of the volume
Returns The volume object
bool volume_contains_tets(
  • int volume_id)
Returns bool
bool was_last_cmd_undoable()
  •  
Returns true if the last executed command was undoable
void write_to_journal(
  • std::string words)

words string to write to journal file

Returns A boolean indicating whether commands are journaled by Cubit