cgma
GeometryModifyTool Class Reference

Interface class for modifying geometry. More...

#include <GeometryModifyTool.hpp>

List of all members.

Public Member Functions

 ~GeometryModifyTool ()
 Destructor.
Bodysphere (double radius, int x_shift=0, int y_shift=0, int z_shift=0, double inner_radius=0, bool delete_side=false)
 Creates a sphere.
Bodybrick (double wid, double dep, double hi)
 Creates a brick (cube).
Bodybrick (const CubitVector &center, const CubitVector axes[3], const CubitVector &extension)
 Creates a brick (cube).
Bodyprism (double height, int sides, double major, double minor)
 Creates a brick (cube).
Bodypyramid (double height, int sides, double major, double minor, double top=0.0)
 Creates a pyramid.
Bodycylinder (double hi, double r1, double r2, double r3)
 Creates a clyinder.
Bodytorus (double r1, double r2)
 Creates a torus.
Bodyplanar_sheet (const CubitVector &p1, const CubitVector &p2, const CubitVector &p3, const CubitVector &p4)
 Creates a planar surface from using four vertices.
Bodyplanar_sheet (const CubitVector &center, const CubitVector axes[2], double width, double height)
 Creates a surface from using four vertices.
Bodyplanar_sheet (const CubitPlane &plane, const CubitBox &bounding_box, int extension_type=0, double extension=0.0)
 Creates a surface from a plane and bounding box.
Bodycreate_body (VolumeFacets &volume, std::map< FacetShapes *, RefEntity * > &entity_map, const FacetPointSet &points, int interp_order)
 Creates a volume from facet data.
CubitStatus scale (Body *&entity, const CubitVector &point, const CubitVector &factors, bool check_to_transform=true, bool preview=false, bool reset_preview=true)
 Scale a body non-uniformly. (x,y,z directions)
Bodycopy_body (Body *body_ptr, std::map< RefEntity *, RefEntity * > *old_to_new_map=NULL)
 Copy a Body.
RefEntitycopy_refentity (RefEntity *old_entity)
 Copy a RefEntity.
CubitStatus reverse (DLIList< Body * > &body_list)
 Turn bodies inside-out.
CubitStatus reverse (DLIList< RefFace * > &ref_face_list)
 Reverse the given faces using the solid modeller (flip normals)
CubitStatus align_entities (RefFace *my_face, RefFace *target_face, DLIList< RefEntity * > &entities_to_move, bool reverse, CubitVector &my_center, CubitVector &axis_of_rot, CubitVector &target_center, double &angle, bool preview)
 Compute the transformation required to align my_face with target_face with respect to reference_body_ptr. Then perform the transformation on all entities in entities_to_move.
CubitStatus align_entities (DLIList< RefEntity * > &entities_to_move, CubitVector &position_to_align, CubitVector &position_to_align_to, CubitVector &axis_origin, CubitVector &axis_of_rot, double &angle_of_rotation, bool preview)
 Aligns entities by rotating about them about axis from one point to another.
CubitStatus align_entities (DLIList< RefEntity * > &reference_entities, DLIList< RefEntity * > &entities_to_move, CubitVector align_to_vec, CubitVector &my_center, CubitVector &axis_of_rot, double &angle, bool preview)
 Aligns a the normal of a surface or a line to a plane.
CubitStatus chop (DLIList< Body * > &bodies, DLIList< Body * > &intersectBodies, DLIList< Body * > &outsideBodies, Body *&leftoversBody, bool keep_old=false, bool nonreg=false)
 Intersects and subtracts the two bodies in the list.
CubitStatus hollow (DLIList< Body * > &bodies, DLIList< RefFace * > faces_to_remove, DLIList< Body * > &new_bodies, double depth)
CubitStatus thicken (DLIList< Body * > &bodies, DLIList< Body * > &new_bodies, double depth, bool both=false)
 Thickens a sheet body (surface) into a solid body. Can do both directions.
CubitStatus unite (DLIList< Body * > &bodies, DLIList< Body * > &newBodies, bool keep_old=false)
 Boolean unite.
CubitStatus unite (DLIList< BodySM * > &body_sm_list, DLIList< BodySM * > &new_body_sm_list, bool keep_old=false)
 Boolean unite.
CubitStatus subtract (DLIList< Body * > &tool_body_list, DLIList< Body * > &from_bodies, DLIList< Body * > &new_bodies, bool imprint=false, bool keep_old=false)
 Boolean subtract.
CubitStatus subtract (Body *tool_body, DLIList< Body * > &from_bodies, DLIList< Body * > &new_bodies, bool imprint=false, bool keep_old=false)
 Boolean subtract. Subtracts the tool from all the blanks.
CubitStatus validate_normals (DLIList< Body * > &bodies, RefFace *surf_ref, bool reverse)
 Checks for consistent normals across body. Uses surf_ref as a reference surface. All other surfaces in volume should have normal point in likewise direction (in or out of volume).
CubitStatus intersect (Body *tool_body_ptr, DLIList< Body * > &from_bodies, DLIList< Body * > &new_bodies, bool keep_old=false, bool preview=false)
 Boolean intersect.
CubitStatus intersect (DLIList< Body * > &from_bodies, DLIList< Body * > &new_bodies, bool keep_old=false, bool preview=false)
 Boolean intersect.
CubitStatus section (DLIList< Body * > &section_body_list, const CubitVector &point_1, const CubitVector &point_2, const CubitVector &point_3, DLIList< Body * > &new_body_list, CubitBoolean keep_normal_side, CubitBoolean keep_old=CUBIT_FALSE)
 Cuts body with plane, throwing away one side.
CubitStatus split_periodic (Body *body_ptr, Body *&new_body_ptr)
 Splits periodic curves and surfaces.
CubitStatus stitch (DLIList< Body * > &bodies_to_stitch, DLIList< Body * > &result_list, bool tighten_gaps, double tolerance=-1.0)
 Stitches sheet bodies at common edges to form larger sheet body or solid.
CubitStatus discover_topology (RefFace *ref_face_ptr, CubitVector &pos, double &step_size, int num_subdivisions)
 Beta function.
CubitStatus imprint_and_merge_curves (RefEdge *curve1, RefEdge *curve2, DLIList< RefVertex * > &vert_list, double divergence_angle, DLIList< DLIList< RefEdge * > * > &curves_to_merge1, DLIList< DLIList< RefEdge * > * > &curves_to_merge2, DLIList< DLIList< RefEdge * > * > &prev_curve_merge_lists, DLIList< DLIList< RefFace * > * > &prev_surf_merge_lists)
void march_path_to_discover_horizontal (CubitVector &start_pos, CubitVector &sweep_dir, RefFace *start_face, CubitVector &march_dir, double &step_size, DLIList< CubitVector > &final_points, DLIList< RefFace * > &ending_faces)
 Beta function.
void march_path_to_discover_vertical (CubitVector &start_pos, CubitVector &sweep_dir, RefFace *start_face, CubitVector &march_dir, double &step_size, DLIList< CubitVector > &final_points, DLIList< RefFace * > &ending_faces)
void march_using_planes (CubitVector &point_on_surf, RefFace *surf, CubitVector &march_dir, double step_size, DLIList< CubitVector > &horizontal_points, DLIList< CubitVector > &vertical_points)
void trace_out_curves (Body *plane_body, CubitVector &start_point, CubitVector &march_dir, double step_size, DLIList< CubitVector > &horizontal_points, DLIList< CubitVector > &vertical_points)
void subdivide_pie (CubitVector &dir1, CubitVector &dir2, int num_subdivisions, DLIList< CubitVector > &all_directions)
 Beta function.
CubitStatus split_surface (RefFace *ref_face_ptr, DLIList< CubitVector * > &locations, DLIList< DLIList< CubitVector * > * > &vec_lists, CubitBoolean preview_flg=CUBIT_FALSE, CubitBoolean create_ref_edges_flg=CUBIT_FALSE, CubitBoolean clear_previous_previews=CUBIT_TRUE)
 Splits a surface with a curve defined by positions.
CubitStatus split_surface (DLIList< RefFace * > &ref_face_list, DLIList< CubitVector * > &locations, DLIList< DLIList< DLIList< CubitVector * > * > * > &list_of_vec_lists, CubitBoolean preview_flg=CUBIT_FALSE, CubitBoolean create_ref_edges_flg=CUBIT_FALSE, CubitBoolean clear_previous_previews=CUBIT_TRUE)
 Splits MULTIPLE surfaces with a curves defined by positions.
CubitStatus split_surfaces_extend (DLIList< RefFace * > &ref_face_list, DLIList< RefVertex * > &ref_vertex_list, CubitBoolean preview_flg=CUBIT_FALSE, CubitBoolean create_ref_edges_flg=CUBIT_FALSE)
 Splits surfaces by extending curves at the end of hardlines across the surface.
CubitStatus split_surfaces (DLIList< RefFace * > &ref_face_list, int num_segs, double fraction, double distance, RefEdge *from_curve_ptr, DLIList< RefVertex * > &corner_vertex_list, DLIList< RefVertex * > &through_vertex_list, RefEdge *curve_dir_ptr=NULL, CubitBoolean preview_flg=CUBIT_FALSE, CubitBoolean create_ref_edges_flg=CUBIT_FALSE)
 Splits a surface or connected set of surfaces in one direction.
CubitStatus split_surfaces_offset (DLIList< RefFace * > &ref_face_list, DLIList< RefEdge * > &edge_list, int num_segs, double distance, CubitBoolean partition_flg=CUBIT_FALSE, CubitBoolean blunt_flg=CUBIT_FALSE, CubitBoolean preview_flg=CUBIT_FALSE, CubitBoolean create_ref_edges_flg=CUBIT_FALSE)
 Splits surfaces a specified distance from curves.
CubitStatus auto_mid_surface (DLIList< Body * > &body_list_in, DLIList< Body * > &body_list_out, DLIList< Body * > &old_bodies_midsurfaced, DLIList< double > &thickness_list, double lower_tol, double upper_tol, CubitBoolean delete_midsurfaced, CubitBoolean preview)
 Create a midsurface from a volume.
CubitStatus webcut_with_cylinder (DLIList< Body * > &webcut_body_list, double radius, const CubitVector &axis, const CubitVector &center, DLIList< Body * > &results_list, DLIList< Body * > &neighboring_bodies, ImprintType imprint_type=NO_IMPRINT, CubitBoolean merge=CUBIT_FALSE, CubitBoolean preview=CUBIT_FALSE)
 Webcuts bodies with a cylinder.
CubitStatus webcut_with_Cone (DLIList< Body * > &webcut_body_list, DLIList< BodySM * > &webcut_bodySM_list, double outer_radius, double top_radius, CubitVector &Axispt1, CubitVector &Axispt2, DLIList< Body * > &results_list, DLIList< Body * > &neighboring_bodies, ImprintType imprint_type=NO_IMPRINT, CubitBoolean merge=CUBIT_FALSE, CubitBoolean preview=CUBIT_FALSE)
 Webcuts bodies with a cone.
CubitStatus webcut_with_brick (DLIList< Body * > &webcut_body_list, const CubitVector &center, const CubitVector axes[3], const CubitVector &extension, DLIList< Body * > &results_list, DLIList< Body * > &neighbor_list, ImprintType imprint_type=NO_IMPRINT, CubitBoolean merge=CUBIT_FALSE, CubitBoolean preview=CUBIT_FALSE)
 Webcuts bodies with a brick (cube).
CubitStatus webcut_with_planar_sheet (DLIList< Body * > &webcut_body_list, const CubitVector &center, const CubitVector axes[2], double width, double height, DLIList< Body * > &results_list, DLIList< Body * > &neighbor_list, ImprintType imprint_type=NO_IMPRINT, CubitBoolean merge=CUBIT_FALSE, CubitBoolean preview=CUBIT_FALSE)
 Webcuts bodies with a planar sheet.
CubitStatus webcut_with_plane (DLIList< Body * > &webcut_body_list, const CubitVector &vector1, const CubitVector &vector2, const CubitVector &vector3, DLIList< Body * > &results_list, DLIList< Body * > &neighbor_list, ImprintType imprint_type=NO_IMPRINT, CubitBoolean merge=CUBIT_FALSE, CubitBoolean preview=CUBIT_FALSE)
 Webcuts bodies with a plane.
CubitStatus webcut_with_surface (DLIList< Body * > &webcut_body_list, RefFace *refFace, DLIList< Body * > &results_list, DLIList< Body * > &neighbor_list, ImprintType imprint_type=NO_IMPRINT, CubitBoolean merge=CUBIT_FALSE, CubitBoolean preview=CUBIT_FALSE)
 Webcuts bodies with a surface -- must be planar.
CubitStatus webcut_with_curve_loop (DLIList< Body * > &webcut_body_list, DLIList< RefEdge * > &refedge_list, DLIList< Body * > &results_list, DLIList< Body * > &neighbor_list, ImprintType imprint_type=NO_IMPRINT, CubitBoolean merge=CUBIT_FALSE, CubitBoolean preview=CUBIT_FALSE)
 Webcuts bodies with a surface defined by a curve loop.
CubitStatus webcut_with_sheet (DLIList< Body * > &webcut_body_list, Body *sheet_body, DLIList< Body * > &new_bodies, DLIList< Body * > &neighbor_list, ImprintType imprint_type=NO_IMPRINT, CubitBoolean merge=CUBIT_FALSE, CubitBoolean preview=CUBIT_FALSE)
 Webcut bodies using a surface, need to be planar.
CubitStatus webcut_with_body (DLIList< Body * > &webcut_body_list, Body *body, DLIList< Body * > &results_list, DLIList< Body * > &neighbor_list, ImprintType imprint_type=NO_IMPRINT, CubitBoolean merge=CUBIT_FALSE, CubitBoolean preview=CUBIT_FALSE)
 Webcuts bodies with a tool body.
CubitStatus webcut_with_extended_sheet (DLIList< Body * > &webcut_body_list, DLIList< RefFace * > &ref_face_list, DLIList< Body * > &new_bodies, DLIList< Body * > &neighbor_list, int &num_cut, ImprintType imprint_type=NO_IMPRINT, CubitBoolean merge=CUBIT_FALSE, CubitBoolean preview=CUBIT_FALSE)
 Webcuts bodies by with an extended surface(s).
CubitStatus webcut_with_sweep_surfaces_rotated (DLIList< Body * > &webcut_body_list, DLIList< RefFace * > &tool_faces, CubitVector &point, CubitVector &sweep_axis, double angle, RefFace *stop_surf, bool up_to_next, DLIList< Body * > &new_bodies, DLIList< Body * > &neighbor_list, ImprintType imprint_type=NO_IMPRINT, CubitBoolean merge=false, CubitBoolean preview=false)
 Webcuts bodies with a tool solid created by rotating surfaces about an axis.
CubitStatus webcut_with_sweep_curves_rotated (DLIList< Body * > &webcut_body_list, DLIList< RefEdge * > &tool_curves, CubitVector &point, CubitVector &sweep_axis, double angle, RefFace *stop_surf, DLIList< Body * > &new_bodies, DLIList< Body * > &neighbor_list, ImprintType imprint_type=NO_IMPRINT, CubitBoolean merge=false, CubitBoolean preview=false)
 Webcuts bodies with a tool surface created by rotating curves about an axis.
CubitStatus webcut_with_sweep_surfaces (DLIList< Body * > &webcut_body_list, DLIList< RefFace * > &tool_faces, const CubitVector sweep_vector, bool sweep_perp, bool through_all, bool outward, bool up_to_next, RefFace *stop_surf, RefEdge *edge_to_sweep_along, DLIList< Body * > &new_bodies, DLIList< Body * > &neighbor_list, ImprintType imprint_type=NO_IMPRINT, CubitBoolean merge=false, CubitBoolean preview=false)
 Webcuts bodies with a tool solid created by sweeping surfaces along a vector.
CubitStatus webcut_with_sweep_curves (DLIList< Body * > &webcut_body_list, DLIList< RefEdge * > &tool_curves, const CubitVector sweep_vector, bool through_all, RefFace *stop_surf, RefEdge *edge_to_sweep_along, DLIList< Body * > &new_bodies, DLIList< Body * > &neighbor_list, ImprintType imprint_type=NO_IMPRINT, CubitBoolean merge=false, CubitBoolean preview=false)
 Webcuts bodies with a tool surface created by sweeping curves along a vector.
CubitStatus remove_topology (DLIList< RefEdge * > &ref_edge_list, DLIList< RefFace * > &ref_face_list, double backoff_distance, double small_curve_size, DLIList< Body * > &new_body_list, CubitBoolean propagate, CubitBoolean preview)
 Removes small topology; i.e, curves and surfaces.
CubitStatus offset_curves (DLIList< RefEdge * > &ref_edge_list, DLIList< RefEdge * > &output_edge_list, double offset_distance, const CubitVector &offset_direction, int gap_type=1)
 Creates curves offset from a chain of curves. The offset direction is.
CubitStatus trim_curve (RefEdge *trim_curve, const CubitVector &trim_vector, const CubitVector &keep_vector)
 Trims or extends a curve, up to the trim_vector. If trimming, the.
CubitStatus imprint (DLIList< Body * > &from_body_list, DLIList< Body * > &new_body_list, CubitBoolean keep_old=CUBIT_FALSE)
 Imprints a group of bodies with one another.
CubitStatus imprint (DLIList< Body * > &body_list, DLIList< RefEdge * > &ref_edge_list, DLIList< Body * > &new_body_list, CubitBoolean keep_old_body=CUBIT_FALSE, CubitBoolean show_messages=CUBIT_TRUE)
 Imprints a list of Bodies with a list of RefEdges. Useful for.
CubitStatus imprint (DLIList< RefFace * > &ref_face_list, DLIList< RefEdge * > &ref_edge_list, DLIList< Body * > &new_body_list, CubitBoolean keep_old_body=CUBIT_FALSE)
 Imprints a list of RefFaces with a list of RefEdges. This is.
CubitStatus imprint (DLIList< Surface * > &surface_list, DLIList< DLIList< Curve * > * > &curve_lists_list, Body *&new_body, CubitBoolean keep_old_body=CUBIT_FALSE, CubitBoolean expand=CUBIT_TRUE)
 Imprints a list of Surfaces with list of Curves, sorted per.
CubitStatus imprint (DLIList< Body * > &body_list, DLIList< CubitVector > &vector_list, DLIList< Body * > &new_body_list, CubitBoolean keep_old_body=CUBIT_FALSE, CubitBoolean merge=CUBIT_FALSE)
 Imprints a list of bodies to a list of locations.
CubitStatus imprint_projected_edges (DLIList< RefFace * > &ref_face_list, DLIList< RefEdge * > &ref_edge_list, DLIList< Body * > &new_body_list, CubitBoolean keep_old_body, CubitBoolean keep_free_edges)
 Imprints a list of RefFaces with a list of projected RefEdges.
CubitStatus imprint_projected_edges (DLIList< RefFace * > &ref_face_list, DLIList< Body * > &body_list, DLIList< RefEdge * > &ref_edge_list, DLIList< Body * > &new_body_list, CubitBoolean keep_old_body, CubitBoolean keep_free_edges)
 Imprints a list of Bodies with a list of RefEdges which are projected to a list of RefFaces.
CubitStatus tolerant_imprint (DLIList< RefFace * > &ref_faces, DLIList< RefEdge * > &ref_edge_list, DLIList< Body * > &new_bodies, bool merge=false)
 Tolerantly imprintings a list of curves on a list of surfaces. Should be used when you have sloppy/out-of-tolerance geometry.
CubitStatus tolerant_imprint (RefFace *ref_face, DLIList< RefEdge * > &ref_edge_list, Body *&new_body, bool merge=false)
 Tolerantly imprintings a list of curves onto a single surface. Should be used when you have sloppy/out-of-tolerance geometry.
CubitStatus tolerant_imprint (DLIList< Body * > &bodies, DLIList< Body * > &new_bodies, double overlap_tol, double imprint_tol, bool merge=false)
 Imprints bodies onto one another. Should be used when you have sloppy/out- of-tolerance geometry.
CubitStatus project_edges (DLIList< RefFace * > &ref_face_list, DLIList< RefEdge * > &ref_edge_list_in, DLIList< RefEdge * > &ref_edge_list_new, CubitBoolean trim_projected=CUBIT_FALSE)
 Projects list RefEdges onto a list of RefFaces.
CubitStatus regularize_body (Body *body_ptr, Body *&new_body)
 Removes all unnessesary faces, curves, vertices from a body.
CubitStatus regularize_refentity (RefEntity *old_entity_ptr, Body *&new_body_ptr)
 Removes all unnessesary faces, curves, vertices and associated data from a refentity.
CubitStatus test_regularize_refentity (RefEntity *old_entity_ptr)
 Tests if a RefEntity can have any unncessary child entities removed, or simplified away.
CubitStatus split_free_curve (RefEdge *ref_edge, DLIList< CubitVector > &split_locations, DLIList< RefEdge * > &new_ref_edges)
CubitStatus split_body (Body *body_ptr, DLIList< Body * > &new_bodies) const
 Separates multi-volume bodies into single-volume bodies.
CubitStatus separate_surfaces (DLIList< RefFace * > &ref_face_list, DLIList< Body * > &new_bodies)
 Separates surfaces from sheet bodies into separate bodies. Connected.
double get_resultant_angle_score (RefFace *narrow_face, RefFace *other_face, RefEdge *common_edge)
double get_neighbor_type_score (RefEdge *common_edge, RefFace *other_face, double small_curve_size, int &neighbor_is_narrow_or_small)
double get_dihedral_angle_score (RefFace *f1, RefFace *f2, RefEdge *common_edge)
double get_edge_type_score (RefEdge *common_edge, double small_curve_size)
double get_diff_from_multiple_of_90 (double angle)
void split_surface_with_narrow_region (RefFace *face, DLIList< CubitVector > &split_pos1_list, DLIList< CubitVector > &split_pos2_list)
RefVertexmake_RefVertex (CubitVector const &point, int color=CUBIT_DEFAULT_COLOR_INDEX) const
 Creates a point from an x,y,z location.
RefVertexmake_RefVertex (RefVertex *vertex) const
Bodymake_Body (Surface *surface) const
 Creates a sheet body from a surface.
RefEdgemake_RefEdge (GeometryType ref_edge_type, RefVertex *ref_vertex_1, RefVertex *ref_vertex_2, DLIList< CubitVector * > &vector_list, RefFace *reffaca_ptr=NULL) const
 Creates a curve from two or more points.
RefEdgemake_RefEdge (RefVertex *ref_vertex_1, RefVertex *ref_vertex_2, RefFace *ref_face_ptr, RefVertex const *ref_vertex_3=NULL) const
 Creates a curve from two or more points, on a surface.
RefEdgemake_RefEdge (RefEdge *ref_edge, bool copy_attribs=true, std::map< RefEntity *, RefEntity * > *old_to_new_map=NULL) const
 Create a curve from an existing curve.
RefEdgemake_RefEdge (GeometryType ref_edge_type, RefVertex *ref_vertex_1, RefVertex *ref_vertex_2, CubitVector const *intermediate_point=NULL) const
 Create a curve, i.e. ellipse, parabola, straight, or arc curves.
RefEdgemake_elliptical_RefEdge (RefVertex *vert1, RefVertex *vert2, CubitVector center_point, double start_angle, double end_angle, CubitSense sense) const
RefFacemake_RefFace (RefFace *from_ref_face, std::map< RefEntity *, RefEntity * > *old_to_new_map=NULL) const
 Create a surface from an existing one.
Bodymake_extended_sheet (DLIList< RefFace * > &ref_face_list, CubitBox *clip_box_ptr=NULL, bool preview=false) const
 This function creates a sheet body by extending the input surfaces.
RefFacemake_RefFace (GeometryType ref_face_type, DLIList< RefEdge * > &ref_edge_list, bool is_free_face, RefFace *ref_face_ptr=NULL, bool check_edges=true) const
 Creates a surface from bounding curves.
Bodymake_Body (DLIList< RefVolume * > &ref_volume_list) const
 Creates a body from a list of volumes.
Bodymake_Body (RefFace *from_ref_face, std::map< RefEntity *, RefEntity * > *old_to_new_map=NULL) const
 Creates a body from a surface.
Bodymake_Body (GeometryType ref_face_type, DLIList< RefEdge * > &ref_edge_list, RefFace *ref_face_ptr=NULL) const
 Creates a body from a surface created from a list of curves.
CubitStatus sweep_translational (DLIList< RefEntity * > &ref_ent_list, const CubitVector &sweep_vector, double draft_angle, int draft_type, CubitBoolean switchside, CubitBoolean rigid, CubitBoolean anchor_entity, CubitBoolean keep_old, DLIList< Body * > &output_body_list)
 Create bodies by sweeping curves or surfaces along a vector.
CubitStatus sweep_helical (DLIList< RefEntity * > &ref_ent_list, CubitVector &location, CubitVector &direction, double &thread_distance, double &angle, bool right_handed, CubitBoolean anchor_entity, CubitBoolean keep_old, DLIList< Body * > &output_body_list)
CubitStatus sweep_curve_target (CubitPlane ref_plane, DLIList< RefEntity * > &ref_ent_list)
CubitStatus sweep_curve_target (DLIList< RefEdge * > &curve_list, Body *target_body, DLIList< Body * > &out_bodies, CubitVector direction, CubitPlane stop_plane, bool unite)
CubitStatus sweep_surface_target (RefFace *face, Body *target_body, CubitVector distance, CubitPlane stop_plane, double magnitude=0.0)
CubitStatus sweep_surface_target (CubitPlane ref_plane, DLIList< RefEntity * > &ref_ent_list)
CubitStatus sweep_perpendicular (DLIList< RefEntity * > &ref_ent_list, double distance, double draft_angle, int draft_type, CubitBoolean switchside, CubitBoolean rigid, CubitBoolean anchor_entity, CubitBoolean keep_old, DLIList< Body * > &output_body_list)
CubitStatus sweep_rotational (DLIList< RefEntity * > &ref_ent_list, const CubitVector &point, const CubitVector &direction, double angle, DLIList< Body * > &output_body_list, CubitBoolean anchor_entity, CubitBoolean keep_old, int steps=0, double draft_angle=0.0, int draft_type=0, CubitBoolean switchside=CUBIT_FALSE, CubitBoolean make_solid=CUBIT_FALSE, CubitBoolean rigid=CUBIT_FALSE)
 Creates bodies by sweeping surfaces or curves about an axis.
CubitStatus sweep_along_curve (DLIList< RefEntity * > &ref_ent_list, DLIList< RefEdge * > &ref_edge_list, DLIList< Body * > &output_body_list, CubitBoolean anchor_entity, CubitBoolean keep_old, double draft_angle=0.0, int draft_type=0, CubitBoolean rigid=CUBIT_FALSE)
 Creates bodies by sweeping surfaces or curves along a curve.
CubitStatus tweak_bend (DLIList< Body * > &bend_bodies, DLIList< Body * > &new_body_list, CubitVector &neutral_root, CubitVector &bend_axis, CubitVector &bend_direction, double radius, double angle, DLIList< CubitVector > &bend_regions, double width=-1, CubitBoolean center_bend=CUBIT_FALSE, int num_points=0, CubitBoolean keep_old_body=CUBIT_FALSE, CubitBoolean preview=CUBIT_FALSE)
 Currently unsupported.
CubitStatus tweak_chamfer (DLIList< RefEdge * > &ref_edge_list, double left_offset, DLIList< Body * > &new_body_list, double right_offset=-1.0, CubitBoolean keep_old_body=CUBIT_FALSE, CubitBoolean preview=CUBIT_FALSE)
 Chamfer curves on solid and sheet bodies.
CubitStatus tweak_chamfer (DLIList< RefVertex * > &ref_vertex_list, double offset1, DLIList< Body * > &new_body_list, RefEdge *edge1=NULL, double offset2=-1.0, RefEdge *edge2=NULL, double offset3=-1.0, RefEdge *edge3=NULL, CubitBoolean keep_old_body=CUBIT_FALSE, CubitBoolean preview=CUBIT_FALSE)
 Chamfer vertices on solid or sheet bodies.
CubitStatus tweak_fillet (DLIList< RefEdge * > &ref_edge_list, double radius, DLIList< Body * > &new_body_list, CubitBoolean keep_old_body=CUBIT_FALSE, CubitBoolean preview=CUBIT_FALSE)
 Creates a round fillet (or blend) at the given curves on solid or sheet bodies.
CubitStatus tweak_fillet (RefEdge *ref_edge_ptr, double start_radius, double end_radius, Body *&new_body_ptr, CubitBoolean keep_old_body=CUBIT_FALSE, CubitBoolean preview=CUBIT_FALSE)
 Creates a round fillet (or blend) at the given curve.
CubitStatus tweak_fillet (DLIList< RefVertex * > &ref_vertex_list, double radius, DLIList< Body * > &new_body_list, CubitBoolean keep_old_body=CUBIT_FALSE, CubitBoolean preview=CUBIT_FALSE)
 Create a round fillet (or blend) at the given vertices on sheet bodies.
CubitStatus tweak_move (DLIList< RefFace * > &ref_face_list, const CubitVector &delta, DLIList< Body * > &new_body_list, CubitBoolean keep_old_body=CUBIT_FALSE, CubitBoolean preview=CUBIT_FALSE)
 Tweak specified faces of a volume or volumes along a vector.
CubitStatus tweak_move (DLIList< RefEdge * > &ref_edge_list, const CubitVector &delta, DLIList< Body * > &new_body_list, CubitBoolean keep_old_body=CUBIT_FALSE, CubitBoolean preview=CUBIT_FALSE)
 Tweak specified curves of a sheet body along a vector.
CubitStatus tweak_offset (DLIList< RefFace * > &ref_face_list, double offset_distance, DLIList< RefFace * > *add_ref_face_list_ptr, DLIList< double > *add_offset_list_ptr, DLIList< Body * > &new_body_list, CubitBoolean keep_old_body=CUBIT_FALSE, CubitBoolean preview=CUBIT_FALSE)
 Offsets a surface(s) on a volume(s).
CubitStatus tweak_offset (DLIList< RefEdge * > &ref_edge_list, double offset_distance, DLIList< RefEdge * > *add_ref_face_list_ptr, DLIList< double > *add_offset_list_ptr, DLIList< Body * > &new_body_list, CubitBoolean keep_old_body=CUBIT_FALSE, CubitBoolean preview=CUBIT_FALSE)
 Offset curves on sheet bodies.
CubitStatus tweak_remove_individually (DLIList< RefFace * > &ref_face_list, DLIList< Body * > &new_body_list, CubitBoolean keep_surface=CUBIT_FALSE, CubitBoolean keep_old_body=CUBIT_FALSE, CubitBoolean preview=CUBIT_FALSE)
 Performs tweak_remove operation on surfaces individually.
CubitStatus tweak_remove_together (DLIList< RefFace * > &ref_face_list, DLIList< Body * > &new_body_list, CubitBoolean extend_adjoining=CUBIT_TRUE, CubitBoolean keep_surface=CUBIT_FALSE, CubitBoolean keep_old_body=CUBIT_FALSE, CubitBoolean preview=CUBIT_FALSE)
 Performs tweak_remove operation on surfaces collectively.
CubitStatus tweak_remove (DLIList< RefEdge * > &ref_edge_list, DLIList< Body * > &new_body_list, CubitBoolean keep_old_body=CUBIT_FALSE, CubitBoolean preview=CUBIT_FALSE)
 Removes a surface from a volume, extending neighboring surfaces.
CubitStatus tweak_target (DLIList< RefFace * > &ref_face_list, DLIList< RefFace * > &target_face_list, DLIList< Body * > &new_body_list, CubitBoolean extend_flg=CUBIT_TRUE, CubitPlane *limit_plane=NULL, CubitBoolean reverse_flg=CUBIT_FALSE, CubitBoolean keep_old_body=CUBIT_FALSE, CubitBoolean preview=CUBIT_FALSE)
 Extends (tweaks) surfaces up to a target surface.
CubitStatus tweak_target (DLIList< RefFace * > &ref_face_list, CubitPlane &plane, DLIList< Body * > &new_body_list, CubitBoolean reverse_flg=CUBIT_FALSE, CubitBoolean keep_old_body=CUBIT_FALSE, CubitBoolean preview=CUBIT_FALSE)
 Extends (tweaks) surfaces up to a target plane.
CubitStatus tweak_target (DLIList< RefEdge * > &ref_edge_list, DLIList< RefFace * > &target_face_list, DLIList< Body * > &new_body_list, CubitBoolean extend_flg=CUBIT_TRUE, CubitPlane *limit_plane=NULL, CubitBoolean reverse_flg=CUBIT_FALSE, CubitBoolean keep_old_body=CUBIT_FALSE, CubitBoolean preview=CUBIT_FALSE, double max_area_increase=0)
 Extends (tweaks) curves up to a target surface.
CubitStatus tweak_target (DLIList< RefEdge * > &ref_edge_list, CubitPlane &plane, DLIList< Body * > &new_body_list, CubitBoolean reverse_flg=CUBIT_FALSE, CubitBoolean keep_old_body=CUBIT_FALSE, CubitBoolean preview=CUBIT_FALSE)
CubitStatus tweak_target (DLIList< RefEdge * > &ref_edge_list, DLIList< RefEdge * > &target_edge_list, DLIList< Body * > &new_body_list, CubitBoolean extend_flg=CUBIT_TRUE, CubitPlane *limit_plane=NULL, CubitBoolean reverse_flg=CUBIT_FALSE, CubitBoolean keep_old_body=CUBIT_FALSE, CubitBoolean preview=CUBIT_FALSE, double max_area_increase=0)
 Extends (tweaks) curves up to a target plane.
CubitStatus tweak_target (RefVertex *ref_vertex_ptr, DLIList< RefFace * > &modify_ref_face_list, CubitVector &target_loc, Body *&new_Body_ptr, CubitBoolean keep_old_body=CUBIT_FALSE, CubitBoolean preview=CUBIT_FALSE)
 Tweak specified vertex of a sheet body to a given location.
CubitStatus remove_curve_slivers (DLIList< Body * > &bodies, double lengthlimit)
 Converts edges smaller than 'lengthlimit' into tolerant (or fat) vertices. only.
CubitStatus create_net_surface (DLIList< Surface * > &ref_face_list, BodySM *&new_body, DLIList< DLIList< CubitVector * > * > &vec_lists_u, DLIList< DLIList< CubitVector * > * > &vec_lists_v, double net_tol=1e-3, CubitBoolean heal=CUBIT_TRUE)
 Create a surface using arrays of points in u and v directions.
CubitStatus create_net_surface (DLIList< RefEdge * > &u_curves, DLIList< RefEdge * > &v_curves, double net_tol=1e-3, CubitBoolean heal=CUBIT_TRUE)
 Create a surface using curves in u and v directions.
CubitStatus create_offset_surface (RefFace *ref_face_ptr, double offset_distance)
 Creates an offset surface some distance from a surface.
CubitStatus create_offset_sheet (DLIList< RefFace * > &ref_face_list, double offset_distance, DLIList< RefFace * > *add_ref_face_list_ptr, DLIList< double > *add_offset_list_ptr, DLIList< Body * > &new_body_list, CubitBoolean preview=CUBIT_FALSE)
 Create a body(s) by offsetting the given surfaces.
CubitStatus create_offset_body (Body *body_ptr, Body *&new_body, double offset_distance)
 Create a body by offsetting all the surface of the body.
CubitStatus create_skin_surface (DLIList< RefEdge * > &ref_edges, Body *&new_body, DLIList< RefEdge * > &guides)
 Create a sheet body skinning (lofting) a series of curves.
CubitStatus loft_surfaces_to_body (DLIList< RefFace * > &surfaces, DLIList< double > &takeoff_factor_list, DLIList< RefFace * > &takeoff_vector_surface_list, DLIList< CubitVector > &surface_takeoff_vector_list, DLIList< RefEdge * > &takeoff_vector_curve_list, DLIList< CubitVector > &curve_takeoff_vector_list, DLIList< RefEdge * > &guides, DLIList< RefVertex * > &match_vertices_list, Body *&new_body, CubitBoolean global_guides, CubitBoolean closed, CubitBoolean show_matching_curves, CubitBoolean preview)
CubitStatus create_surface_curve (DLIList< RefEntity * > curve_entity, DLIList< RefEntity * > target_entity, CubitVector sweep_direction=CubitVector(0, 0, 0), CubitBoolean distance_flag=CUBIT_FALSE)
Bodycreate_rectangle_surface (double width, double height, CubitVector plane)
Bodycreate_parallelogram_surface (RefVertex *v1, RefVertex *v2, RefVertex *v3)
Bodycreate_circle_surface (double radius, CubitVector plane)
Bodycreate_circle_surface (RefVertex *v1, RefVertex *v2, RefVertex *v3)
Bodycreate_circle_surface (RefVertex *v1, RefVertex *v2, CubitVector center_point)
Bodycreate_ellipse_surface (RefVertex *v1, RefVertex *v2, CubitVector center_point)
Bodycreate_ellipse_surface (double major_radius, double minor_radius, CubitVector plane)
CubitStatus idealize_hole_slot_geometry (DLIList< RefEntity * > idealize_entity, DLIList< RefEntity * > exclude_entity, double arc_radius, double slot_arc_radius, double slot_length, CubitBoolean preview=CUBIT_FALSE)
CubitStatus idealize_fillet_geometry (DLIList< RefEntity * > idealize_entity, DLIList< RefEntity * > exclude_entity, double fillet_rad, CubitBoolean internal_flg, CubitBoolean external_flg, CubitBoolean preview=CUBIT_FALSE)
CubitStatus create_surface_doubler (DLIList< RefEntity * > doubler_entity, DLIList< RefEntity * > target_entity, DLIList< Body * > &body_list_out, CubitBoolean internal_flg=CUBIT_FALSE, CubitBoolean extend_flg=CUBIT_TRUE, CubitPlane *limit_plane=NULL, CubitVector sweep_direction=CubitVector(0, 0, 0), CubitBoolean preview=CUBIT_FALSE)
CubitStatus create_surface (DLIList< CubitVector * > &vec_list, Body *&new_body, RefFace *ref_face_ptr, CubitBoolean project_points)
 Fits an analytic spline surface through positions.
CubitStatus create_surface (DLIList< RefVertex * > &vert_list, Body *&new_body, RefFace *on_surface=NULL)
CubitStatus create_weld_surface (CubitVector &root, RefFace *ref_face1, double leg1, RefFace *ref_face2, double leg2, Body *&new_body)
 Creates a simple triangular weld surface.
CubitStatus create_solid_bodies_from_surfs (DLIList< RefFace * > &ref_face_list, DLIList< Body * > &new_bodies, CubitBoolean keep_old=CUBIT_FALSE, CubitBoolean heal=CUBIT_TRUE, CubitBoolean sheet=CUBIT_FALSE) const
 Creates a body out of the specified surfaces.
CubitStatus surface_intersection (RefFace *ref_face1, RefFace *ref_face2, DLIList< RefEdge * > &ref_edge_list)
 Create curves from the intersection of two surfaces.
RefEdgecreate_arc (const CubitVector &position, double radius, double start_angle, double end_angle, CubitVector plane, CubitBoolean preview=CUBIT_FALSE)
RefEdgecreate_arc_radius (RefVertex *ref_vertex1, RefVertex *ref_vertex2, const CubitVector &normal, double radius, CubitBoolean other_arc=CUBIT_FALSE, CubitBoolean full=CUBIT_FALSE, CubitBoolean preview=CUBIT_FALSE)
RefEdgecreate_arc_three (RefVertex *ref_vertex1, RefVertex *ref_vertex2, RefVertex *ref_vertex3, CubitBoolean full=CUBIT_FALSE, CubitBoolean preview=CUBIT_FALSE)
 Create an arc curve from three points.
RefEdgecreate_arc_three (RefEdge *ref_edge1, RefEdge *ref_edge2, RefEdge *ref_edge3, CubitBoolean full=CUBIT_FALSE, CubitBoolean preview=CUBIT_FALSE)
 Create an arc curve tangent to three curves.
RefEdgecreate_arc_center_edge (RefVertex *ref_vertex1, RefVertex *ref_vertex2, RefVertex *ref_vertex3, const CubitVector &normal, double radius=CUBIT_DBL_MAX, CubitBoolean full=CUBIT_FALSE, CubitBoolean preview=CUBIT_FALSE)
 Create an arc curve from two points and a center point. If full option is specified, a full circle is created.
CubitStatus create_curve_combine (DLIList< RefEdge * > &ref_edge_list, RefEdge *&new_ref_edge_ptr)
 Create a curve that is a combination of the specified curves.
CubitStatus create_curve_helix (CubitVector &location, CubitVector &direction, CubitVector &start_point, double &thread_distance, double &angle, bool right_handed, RefEdge *&new_ref_edge_ptr)
CubitBoolean same_modify_engine (DLIList< TopologyEntity * > &topo_list) const
 Check to determine if all entities are of the same geometry engine.
CubitBoolean same_modify_engine (DLIList< RefEntity * > &ref_entity_list, CubitBoolean check_children=CUBIT_FALSE) const
 Check to determine if all entities are of the same geometry engine as active geometry engine.
GeometryModifyEnginecommon_modify_engine (DLIList< RefFace * > &faces, DLIList< RefEdge * > &edges, DLIList< Surface * > &surfaces, DLIList< Curve * > &curves, CubitBoolean allow_composites=CUBIT_FALSE) const
 Determines if specified RefFaces and RefEdges are of the same geometry engine. Returns common engine, if any, and underlying surfaces and curves.
CubitStatus unmerge_and_return_merge_partners (RefVertex *input_vertex, DLIList< DLIList< RefVertex * > * > &vert_merge_lists, DLIList< DLIList< RefEdge * > * > &curve_merge_lists, DLIList< DLIList< RefFace * > * > &surf_merge_lists)
void add_gme (GeometryModifyEngine *gme_ptr)
 Add a geometry modify engine to the list.
CubitStatus remove_gme (GeometryModifyEngine *gme_ptr)
 < remove a geometry modify engine from the list; returns CUBIT_FAILURE if it wasn't in the list.
void get_gme_list (DLIList< GeometryModifyEngine * > &gme_list)
 Returns a list of GeometryModifyEngines.
GeometryModifyEngineget_gme () const
 Gets the current active GeometryModifyEngine.
GeometryModifyEngineget_engine (TopologyBridge *tb_ptr) const
 Gets the GeometryModifyEngine of this entity.
GeometryModifyEngineget_engine (TopologyEntity *te_ptr, TopologyBridge **bridge=0) const
 Gets the GeometryModifyEngine of this entity.
CubitStatus get_offset_intersections (RefEdge *ref_edge1, RefEdge *ref_edge2, DLIList< CubitVector > &intersection_list, double offset, CubitBoolean ext_first=CUBIT_TRUE)
 Finds the intersections of a certain distance (offset) between two curves.
CubitStatus get_offset_intersections (RefEdge *ref_edge_ptr, RefFace *ref_face_ptr, DLIList< CubitVector > &intersection_list, double offset=0.0, CubitBoolean ext_surf=CUBIT_TRUE)
 Finds intersections (points) of the curve and surface.
CubitStatus get_mid_plane (RefFace *ref_face_1, RefFace *ref_face_2, Body *body_to_trim_to, DLIList< RefFace * > &mid_plane_surfs) const
 From two surface, create a midplane, then trim it with a body.
CubitStatus get_mid_surface (RefFace *ref_face_1, RefFace *ref_face_2, Body *body_to_trim_to, DLIList< RefFace * > &mid_plane_surfs) const
 Given 2 surfaces, this returns trimmed surfaces of the midsurface (this is an ALPHA feature).
CubitStatus set_default_gme (GeometryModifyEngine *GMEPtr)
 Sets the active geometry engine.
GeometryModifyEnginegroup_bodies_by_engine (DLIList< Body * > &remaining_bodies, DLIList< Body * > &engine_bodies, DLIList< BodySM * > &engine_body_sms) const
 Groups Bodies with the same underlying geometry engine into a list.
bool contains_composites (DLIList< TopologyBridge * > &bridge_list) const
bool contains_partitions (DLIList< TopologyBridge * > &bridge_list) const
bool contains_partitions (DLIList< Body * > &list) const
bool contains_composites (DLIList< Body * > &list) const
CubitStatus finish_sm_op (DLIList< Body * > &input_bodies, DLIList< BodySM * > &new_bodies, DLIList< Body * > &result_bodies, bool print_info=true) const
 Internal use only.

Static Public Member Functions

static GeometryModifyToolinstance (GeometryModifyEngine *GMEPtr=NULL)
static void delete_instance ()
static void set_group_imprint (CubitBoolean flag)
 Sets group imprint flag.
static CubitBoolean get_group_imprint ()
 Gets group imprint flag.
static void set_all_edges_imprint (CubitBoolean flag)
 Sets all edges imprint flag.
static CubitBoolean get_all_edges_imprint ()
 Gets all edges imprint flag.
static void boolean_regularize (CubitBoolean flag)
 Gets boolean regularize flag.
static CubitBoolean boolean_regularize ()
 Sets boolean regularize flag.
static CubitBoolean unite_mixed_models ()
 Gets unite mixed models flag.
static void unite_mixed_models (CubitBoolean flag)
 Sets unite mixed models flag.
static CubitBoolean get_new_ids ()
 Gets new ids flag.
static void set_new_ids (CubitBoolean flag)
 Sets new ids flag.
static CubitBoolean get_old_names ()
 Gets old names flag.
static void set_old_names (CubitBoolean flag)
 Sets old names flag.
static void initialize_settings ()
 Initializes all the settings in GeometryModifyTool to defaults.
static RefEntityget_copy_entity ()
 Gets the entity being copied, if any.
static void set_copy_entity (RefEntity *ent)
 Sets the entity being copied.
static void set_sep_after_webcut_setting (CubitBoolean val)
 Sets sepAfterWebcut variable.
static CubitBoolean get_sep_after_webcut_setting ()
 Gets sepAfterWebcut variable.
static CubitStatus prepare_for_copy (RefEntity *ref_ents, TopologyBridge *&top_bridge)
static CubitStatus finish_copy (TopologyBridge *&new_bridge, TopologyBridge *old_bridge)
static CubitStatus clean_up_from_copy_failure (TopologyBridge *old_bridge)

Protected Member Functions

 GeometryModifyTool (GeometryModifyEngine *GMEPtr)
GeometryModifyEnginemake_RefEdge_common (RefVertex *start_vertex, RefVertex *end_vertex, TBPoint *&start_point, TBPoint *&end_point, RefFace *ref_face=0, Surface **surface=0) const
CubitStatus okay_to_modify (DLIList< Body * > &bodies, const char *op) const
GeometryModifyEnginecommon_modify_engine (DLIList< Body * > &bodies, DLIList< BodySM * > &bodysms) const
GeometryModifyEnginecommon_modify_engine (DLIList< RefFace * > &faces, DLIList< Surface * > &surfaces, CubitBoolean allow_composites=CUBIT_FALSE) const
GeometryModifyEnginecommon_modify_engine (DLIList< RefEdge * > &edges, DLIList< Curve * > &curves, CubitBoolean allow_composites=CUBIT_FALSE) const
GeometryModifyEnginecommon_modify_engine (DLIList< RefVertex * > &vertices, DLIList< TBPoint * > &points, CubitBoolean allow_composites=CUBIT_FALSE) const
GeometryModifyEnginecommon_modify_engine (DLIList< TopologyEntity * > &topology_list, DLIList< TopologyBridge * > &engine_bridges, CubitBoolean allow_composites=CUBIT_FALSE) const
GeometryModifyEnginetweak_setup (DLIList< RefFace * > &input_faces, const char *tweak_function_name, DLIList< Body * > &old_bodies_out, DLIList< Surface * > &surfaces_out, CubitBoolean allow_composites=CUBIT_FALSE)
GeometryModifyEnginetweak_setup (DLIList< RefEdge * > &input_edges, const char *tweak_function_name, DLIList< Body * > &old_bodies_out, DLIList< Curve * > &curves_out, CubitBoolean allow_composites=CUBIT_FALSE)
GeometryModifyEnginetweak_setup (DLIList< RefVertex * > &input_vertices, const char *name, DLIList< Body * > &output_bodies, DLIList< TBPoint * > &output_points, CubitBoolean allow_composites=CUBIT_FALSE)
CubitStatus sweep_setup (const char *sweep_function_name, DLIList< RefEntity * > &entity_list, DLIList< Body * > &body_list, GeometryModifyEngine *&engine, CubitBoolean &changed_new_ids, DLIList< GeometryEntity * > &geom_list, bool keep_old, DLIList< RefEdge * > *edge_list=0, DLIList< Curve * > *curve_list=0)
CubitStatus imprint_singly (DLIList< Body * > &body_list, DLIList< Body * > &new_bodies, CubitBoolean keep_old)
void remove_dead_entity_names (RefEntity *entity) const
Bodyupdate_body (Body *body) const

Private Member Functions

void get_merged_curve_and_surface_ids (DLIList< Body * > &bodies, DLIList< int > &merged_surface_ids, DLIList< int > &merged_curve_ids) const
CubitStatus match_v1_to_c1 (RefVertex *&v1, RefVertex *&v2, RefVertex *c1_v1, RefVertex *c1_v2, RefVertex *c2_v1, RefVertex *c2_v2)
CubitStatus find_best_curves_to_merge (DLIList< RefEdge * > *&curves_from_curve1, DLIList< RefEdge * > *&curves_from_curve2, RefEdge *&curve1, RefEdge *&curve2)
CubitStatus unmerge_and_return_merge_partners (RefEdge *input_curve, DLIList< DLIList< RefEdge * > * > &curve_merge_lists, DLIList< DLIList< RefFace * > * > &surf_merge_lists)
CubitStatus unmerge_input (RefEdge *curve1, RefEdge *curve2, DLIList< DLIList< RefEdge * > * > &curve_merge_lists, DLIList< DLIList< RefFace * > * > &surf_merge_lists)
CubitStatus calculate_split_points_for_merge (RefEdge *c1, RefEdge *c2, DLIList< RefVertex * > &verts_to_merge, double *merge_tolerance, DLIList< CubitVector > &merge_end_points_on_curve1, DLIList< CubitVector > &merge_end_points_on_curve2, DLIList< CubitBoolean > &split_flags_for_curve1, DLIList< CubitBoolean > &split_flags_for_curve2, double divergence_angle)
CubitStatus find_overlap_region (RefEdge *c1, RefEdge *c2, RefVertex *v1, RefVertex *v2, bool forward_c1, bool forward_c2, bool &full_c1, bool &full_c2, double &c1_stop_param, double &c2_stop_param, double divergence_angle)
CubitStatus separate_body_after_webcut (DLIList< Body * > &input_list, DLIList< Body * > &output_list) const
void fixup_merged_entities (DLIList< int > &merged_surface_ids, DLIList< int > &merged_curve_ids) const
bool contains_intermediate_geom (DLIList< Body * > &list) const
bool contains_intermediate_geom (DLIList< TopologyBridge * > &list) const
void do_attribute_setup (void)
void do_attribute_cleanup (void)
void push_attributes_before_modify (DLIList< BodySM * > &old_sms)
CubitStatus restore_vg_after_modify (DLIList< BodySM * > &new_sms, DLIList< Body * > &old_bodies, GeometryModifyEngine *gme)
void remove_pushed_attributes (DLIList< BodySM * > &new_sms, DLIList< Body * > &old_bodies)
void push_imprint_attributes_before_modify (DLIList< BodySM * > &old_sms)
void push_named_attributes_to_curves_and_points (DLIList< TopologyBridge * > &tb_list, const char *name_in)
void remove_imprint_attributes_after_modify (DLIList< BodySM * > &body_sms, DLIList< BodySM * > &new_sms)
void propagate_from_small_edge (RefEdge *edge, DLIList< RefEdge * > &small_edges, DLIList< RefFace * > &narrow_faces, DLIList< RefFace * > &processed_faces, double small_edge_length)
void propagate_over_narrow_face (RefFace *narrow_face, RefEdge *edge, DLIList< RefFace * > &processed_faces, DLIList< RefEdge * > &small_edges, DLIList< RefFace * > &narrow_faces, double small_edge_length)
void propagate_merge_tolerance (DLIList< Body * > &body_list)
void push_tolerance_attribute (DLIList< Body * > &body_list)
CubitStatus prepare_bc_for_webcut ()
CubitStatus finish_bc_webcut ()
CubitStatus sweep_finish (const char *const sweep_function_name, DLIList< Body * > &input_body_list, DLIList< BodySM * > &new_body_list, DLIList< Body * > &output_body_list, CubitBoolean restore_newids)
CubitStatus finish_webcut (DLIList< Body * > &input_bodies, DLIList< BodySM * > &webcut_results, CubitBoolean merge, CubitStatus webcut_status, DLIList< Body * > &new_bodies, DLIList< int > *merged_surface_ids=NULL, DLIList< int > *merged_curve_ids=NULL, CubitBoolean print_info=CUBIT_TRUE) const
CubitStatus tweak_remove (DLIList< RefFace * > &ref_face_list, DLIList< Body * > &new_body_list, CubitBoolean extend_adjoining=CUBIT_TRUE, CubitBoolean keep_surface=CUBIT_FALSE, CubitBoolean keep_old_body=CUBIT_FALSE, CubitBoolean preview=CUBIT_FALSE)
void get_neighboring_bodies (DLIList< Body * > &input_bodies, DLIList< Body * > &neighboring_bodies)
CubitStatus unite_separately (GeometryModifyEngine *gme_ptr, DLIList< Body * > &body_list, DLIList< Body * > &new_body_list, bool keep_old)
CubitStatus unite_all (GeometryModifyEngine *gme_ptr, DLIList< Body * > &body_list, DLIList< Body * > &new_body_list, bool keep_old)
CubitStatus unite_private (GeometryModifyEngine *gme_ptr, DLIList< Body * > &body_list, DLIList< Body * > &new_body_list, bool keep_old)
GeometryModifyEnginepull_common_surfs (DLIList< RefFace * > &ref_face_list, DLIList< RefFace * > &common_face_list, DLIList< Surface * > &common_surf_list)
void remove_bodies_outside_bounding_box (DLIList< Body * > &body_list, CubitVector v1, CubitVector v2, CubitVector v3)
void remove_bodies_outside_bounding_box (DLIList< Body * > &body_list, CubitBox &tool_bounding_box)
CubitVector FindExtendedEndPt (double outer_rad, double inner_rad, CubitVector inner_AxisPt, CubitVector Axis, double Height)
CubitVector FindExtendedStartPt (CubitBox box, double outer_rad, double inner_rad, CubitVector inner_AxisPt, CubitVector Axis, double &Height, double dTanAngle, double &dExtendedadius)
void FindExtendedPoints (CubitVector AxisPt1, CubitVector AxisPt2, double outer_radius, double inner_radius, CubitVector axis, double Height, CubitBox bounding_box, double dTanAngle, CubitVector &start, CubitVector &end, double &dExtended_OuterRadius, double &dExtended_InnerRadius)
void preview_align (CubitVector translation_to_origin, CubitVector origin_to_target, double angle_of_rotation, CubitVector axis_of_rotation, DLIList< RefEntity * > &entities)

Static Private Member Functions

static void plane_preview (DLIList< Body * > &body_list, const CubitVector &pt1, const CubitVector &pt2, const CubitVector &pt3)
 draw a preview of a plane for webcut previews
static CubitStatus create_old_to_new_ref_ent_map (TopologyBridge *old_top_level_bridge, TopologyBridge *new_top_level_bridge, std::map< RefEntity *, RefEntity * > &old_to_new_map, std::map< TopologyBridge *, TopologyBridge * > &old_tb_to_new_tb)

Private Attributes

DLIList< GeometryModifyEngine * > gmeList
 The list of geometry modify engines.

Static Private Attributes

static GeometryModifyToolinstance_ = 0
 Static pointer to the unique instance of this class.
static CubitBoolean groupImprint = CUBIT_TRUE
 Use group imprinting, which is much faster. Default: true.
static CubitBoolean meshAutodelete = CUBIT_TRUE
 An object will be unmeshed if modified or deleted. Default: true.
static CubitBoolean meshAutodeleteRemesh = CUBIT_FALSE
 An object will be cached if the mesh is autodeleted and can be remeshed later. Default: false.
static CubitBoolean newIds = CUBIT_FALSE
 Causes code to reuse old ids, which are more persistent. Default: false.
static CubitBoolean oldNames = CUBIT_FALSE
 Attempt entity naming backwards compatible with v8/pre-bool-on-merged. Default: false.
static CubitBoolean sepAfterWebcut = CUBIT_TRUE
 Separate the result bodies of webcutting into single-body volumes. Default: true.
static CubitBoolean allEdgesImprint = CUBIT_TRUE
static CubitBoolean booleanRegularize = CUBIT_TRUE
 Regularized booleans are performed. Default: true.
static CubitBoolean uniteMixedModels = CUBIT_TRUE
 Unite operations can mix sheet bodies with solid bodies. Default: true.
static RefEntitycopyingEntity = NULL
 This pointer points to the entity that is being copied.

Friends

class MergeTool

Detailed Description

Interface class for modifying geometry.

Definition at line 66 of file GeometryModifyTool.hpp.


Constructor & Destructor Documentation

Destructor.

Definition at line 190 of file GeometryModifyTool.cpp.

{
   instance_ = NULL;
     //Kill the geometry modify engine(s)
   int i;
   for (i = gmeList.size(); i > 0; i--)
     delete gmeList.get_and_step();

   gmeList.clean_out();
}

Constructor for the (singleton) GeometryModifyTool object

Definition at line 5777 of file GeometryModifyTool.cpp.

{
  if (gme_ptr) gmeList.append(gme_ptr);
}

Member Function Documentation

void GeometryModifyTool::add_gme ( GeometryModifyEngine gme_ptr) [inline]

Add a geometry modify engine to the list.

add a geometry query engine to the list

Definition at line 2500 of file GeometryModifyTool.hpp.

CubitStatus GeometryModifyTool::align_entities ( RefFace my_face,
RefFace target_face,
DLIList< RefEntity * > &  entities_to_move,
bool  reverse,
CubitVector my_center,
CubitVector axis_of_rot,
CubitVector target_center,
double &  angle,
bool  preview 
)

Compute the transformation required to align my_face with target_face with respect to reference_body_ptr. Then perform the transformation on all entities in entities_to_move.

Aligns the body that contains my_face to match my_face with the target face..

Definition at line 3973 of file GeometryModifyTool.cpp.

{
  // Initialize angle to zero, so we are passing back a valid
  // value if we never need to rotate the body
  angle = 0.0;

  //Align the body, which contains my_face, with the target_face.

  //Essentially we want to align the body at my_face with the target_face.
  my_center = source_face->center_point();
  target_center = target_face->center_point();
  
  CubitVector my_vector = source_face->normal_at( my_center );
  CubitVector target_vector = target_face->normal_at( target_center );

  if( CubitUndo::get_undo_enabled() && !preview )
  {
    DLIList<RefEntity*> free_ents_to_save;
    DLIList<Body*> align_list(entities_to_move.size());
    for ( int k=0; k<entities_to_move.size(); k++ )
    {
      RefEntity *ref_ent = entities_to_move[k];      
      Body *tmp_body = dynamic_cast<Body*>(ref_ent);
      if( tmp_body )       
        align_list.append( tmp_body );              
      else
        free_ents_to_save.append( ref_ent );       
    }     
    CubitUndo::save_state_with_cubit_file( align_list, &free_ents_to_save );
  }

  axis_of_rot = my_vector * target_vector;

  if( axis_of_rot.length() < CUBIT_RESABS )  
  {
    CubitVector v1,v2;
    my_vector.orthogonal_vectors(v1, v2 );
    axis_of_rot = v1;    
  }

  if( axis_of_rot.length() > CUBIT_RESABS )
  {
    angle = axis_of_rot.vector_angle( my_vector, target_vector );

    //Now we have the angle and the axis to rotate about...
    angle = 180.0*angle/CUBIT_PI;
    
    if( angle > 90 )
      angle = angle - 180;

    if( reverse )
      angle += 180;
  }
  CubitVector origin(0.,0.,0.);

  if (preview)
  {    
    preview_align( -my_center, target_center, angle, axis_of_rot, entities_to_move );     
  }
  else 
  {   
    //Move the body so that the center of my_face
    //is at the origin.   
    DLIList<RefEntity*> entities_transformed;
    GeometryQueryTool::instance()->translate( entities_to_move,
      -my_center.x(),
      -my_center.y(),
      -my_center.z(),
      false,
      entities_transformed);

    //If the axis length is zero we dont want to do a rotation,
    //they are already parallel..  
    if (axis_of_rot.length() > CUBIT_RESABS )
    {    
      //Now rotate the body about the axis.
      GeometryQueryTool::instance()->rotate(entities_to_move, origin, 
        axis_of_rot, angle, false, entities_transformed,
        false);
    }
    //Now move the body to the location of the target_center.    
    GeometryQueryTool::instance()->translate( entities_to_move,
      target_center.x(),
      target_center.y(),
      target_center.z(),
      false,
      entities_transformed,
      preview);
  }

  //That should do it.
  return CUBIT_SUCCESS;
}
CubitStatus GeometryModifyTool::align_entities ( DLIList< RefEntity * > &  entities_to_move,
CubitVector position_to_align,
CubitVector position_to_align_to,
CubitVector axis_origin,
CubitVector axis_of_rot,
double &  angle_of_rotation,
bool  preview 
)

Aligns entities by rotating about them about axis from one point to another.

Returns:
CubitStatus
- success or failure
  • my_face - The surface to align
  • target_face - The surface to align to entities to move - Entities that will be aligned. Must containe body_ptr. (can include merged ones)
  • reverse - If true, normals will be pointing opposite one another.
  • my_center - Returned center of rotation
  • axis_of_rot - Axis of rotation
  • target_center - Returned center of target face
  • angle - Returned angle of rotation
  • preview -- If true, just draws the rotated edges This function will rotate 'entities_to_move' about the center point of my_face, such that the normal of my_face's center is aligned with the nomal at target_face's center and then translates everything by a vector from my_face's center point to target_face's center point.

Definition at line 4075 of file GeometryModifyTool.cpp.

{
  //project pos_to_align to axis
  axis_of_rot.normalize();
  CubitVector tmp_vec = pos_to_align - axis_origin;  
  double dot_prod = tmp_vec%axis_of_rot;
  CubitVector int_pt1 = axis_origin + (dot_prod*axis_of_rot);

  //project pos_to_align_to to axis
  tmp_vec = pos_to_align_to - axis_origin;  
  dot_prod = tmp_vec%axis_of_rot;
  CubitVector int_pt2 = axis_origin + (dot_prod*axis_of_rot);

  //determine angle of rotation
  tmp_vec = pos_to_align - int_pt1;
  CubitVector tmp_vec2 = pos_to_align_to - int_pt2;
  angle_of_rotation = axis_of_rot.vector_angle( tmp_vec, tmp_vec2 );
  angle_of_rotation *= 180.0/CUBIT_PI;
  
  if( angle_of_rotation < CUBIT_RESABS )
  {
    PRINT_WARNING("Points already aligned.\n");
    return CUBIT_SUCCESS;
  }

  if( CubitUndo::get_undo_enabled() && !preview )
  {
    DLIList<RefEntity*> free_ents_to_save;
    DLIList<Body*> align_list(entities_to_align.size());
    for ( int k=0; k<entities_to_align.size(); k++ )
    {
      RefEntity *ref_ent = entities_to_align[k];      
      Body *tmp_body = dynamic_cast<Body*>(ref_ent);
      if( tmp_body )       
        align_list.append( tmp_body );              
      else
        free_ents_to_save.append( ref_ent );       
    }     
    CubitUndo::save_state_with_cubit_file( align_list, &free_ents_to_save );
  }

  CubitVector translation_vector( int_pt1 );

  if( preview )
  {    
    preview_align( -translation_vector, translation_vector, 
      angle_of_rotation, axis_of_rot, entities_to_align );     
  }
  else
  {
    //translate to origin
    DLIList<RefEntity*> entities_transformed;
    GeometryQueryTool::instance()->translate( entities_to_align,
      -translation_vector.x(),
      -translation_vector.y(),
      -translation_vector.z(),
      false,
      entities_transformed);

    //rotate to align
    CubitVector origin(0,0,0);
    GeometryQueryTool::instance()->rotate( entities_to_align, origin, axis_of_rot, angle_of_rotation, false, 
      entities_transformed, false );

    //translate back
    GeometryQueryTool::instance()->translate( entities_to_align,
      translation_vector.x(),
      translation_vector.y(),
      translation_vector.z(),
      false,
      entities_transformed);      
  }

  //That should do it.
  return CUBIT_SUCCESS;  
}
CubitStatus GeometryModifyTool::align_entities ( DLIList< RefEntity * > &  reference_entities,
DLIList< RefEntity * > &  entities_to_move,
CubitVector  align_to_vec,
CubitVector my_center,
CubitVector axis_of_rot,
double &  angle,
bool  preview 
)

Aligns a the normal of a surface or a line to a plane.

Returns:
CubitStatus
- success or failure
  • entities - Entities to align
  • position_to_align - Where the angle of rotation starts
  • position_to_align_to - Where the angle of rotation ends
  • axis_origin - Origin of axis_or_rot
  • axis_of_rot - Axis of rotation
  • angle_of_rotation - Returned angle of rotation
  • preview -- If true, just draws the rotated edges This function will rotate 'entities_to_move' about an axis defined by axis_origin and axis_of_rot. The angle of rotation about the axis (right-hand-rule) is the angle between two vectors, v1 and v2, where v1 and v2 are vectors perpendicular to the axis, to position_to_align and position_to_align_to respectively.

Definition at line 4158 of file GeometryModifyTool.cpp.

{
   DLIList<RefFace*> ref_face_list;
   DLIList<RefVertex*> ref_vertex_list;

   CAST_LIST(reference_entities, ref_face_list, RefFace);
   CAST_LIST(reference_entities, ref_vertex_list, RefVertex);

   angle = 0.0;   

   CubitVector translation_vector;
   CubitVector axis_of_rotation;
   CubitVector vector_to_rotate;

   if( ref_face_list.size() == 1 &&
       ref_vertex_list.size() == 0 )
   {   
     //now form the axis of rotation
     RefFace *my_face = ref_face_list.get_and_step();
     translation_vector = my_face->center_point();     
     my_center = translation_vector;
     vector_to_rotate = my_face->normal_at( translation_vector );     
     axis_of_rot = align_to_vec * vector_to_rotate;
   }
   else if( ref_face_list.size() == 0 &&
            ref_vertex_list.size() == 2 )
   {
     RefVertex *vertex_1 = ref_vertex_list.get_and_step();
     RefVertex *vertex_2 = ref_vertex_list.get_and_step();     

     //now form the axis of rotation
     translation_vector = vertex_1->coordinates();
     my_center = vertex_1->coordinates();     
     vector_to_rotate = vertex_2->coordinates() - vertex_1->coordinates();     
     axis_of_rot = align_to_vec * vector_to_rotate;
   }   

   if( axis_of_rot.length() < CUBIT_RESABS )  
   {
    double dot_prod = align_to_vec%vector_to_rotate;
    //normals could be 180 degrees from one another
    if( dot_prod < 0 ) 
    {
      CubitVector v1,v2;
      align_to_vec.orthogonal_vectors(v1, v2 );
      axis_of_rot = v1;
    }
  }

   if( CubitUndo::get_undo_enabled() && !preview )
   {
     DLIList<RefEntity*> free_ents_to_save;
     DLIList<Body*> align_list(entities_to_move.size());
     for ( int k=0; k<entities_to_move.size(); k++ )
     {
       RefEntity *ref_ent = entities_to_move[k];      
       Body *tmp_body = dynamic_cast<Body*>(ref_ent);
       if( tmp_body )       
         align_list.append( tmp_body );              
       else
         free_ents_to_save.append( ref_ent );       
     }     
     CubitUndo::save_state_with_cubit_file( align_list, &free_ents_to_save );
   }

   //determine the angle of rotation   
   angle = axis_of_rot.vector_angle( vector_to_rotate, align_to_vec );
   angle = 180.0*angle/CUBIT_PI;

   if( preview )
   {
     preview_align( -translation_vector, translation_vector, 
                  angle, axis_of_rot, entities_to_move );     
   }
   else
   {
     //translate to origin
     DLIList<RefEntity*> entities_transformed;
     GeometryQueryTool::instance()->translate( entities_to_move,
       -translation_vector.x(),
       -translation_vector.y(),
       -translation_vector.z(),
       false,
       entities_transformed);

     //rotate to align
     CubitVector origin(0,0,0);
     GeometryQueryTool::instance()->rotate( entities_to_move, origin, axis_of_rot, angle, false, 
       entities_transformed, false );

     //translate back
     GeometryQueryTool::instance()->translate( entities_to_move,
       translation_vector.x(),
       translation_vector.y(),
       translation_vector.z(),
       false,
       entities_transformed);      
   }

   //That should do it.
   return CUBIT_SUCCESS;  
}
CubitStatus GeometryModifyTool::auto_mid_surface ( DLIList< Body * > &  body_list_in,
DLIList< Body * > &  body_list_out,
DLIList< Body * > &  old_bodies_midsurfaced,
DLIList< double > &  thickness_list,
double  lower_tol,
double  upper_tol,
CubitBoolean  delete_midsurfaced,
CubitBoolean  preview 
)

Create a midsurface from a volume.

Automatically create a midsurface from a volume. {body_list_in} - list of bodies to midsurface {body_list_out} - resulting midsurfaces {lower_tol} - lower tolerance for finding surface pairs {upper_tol} - upper tolerance for finding surface pairs {preview} - preview midsurfaces

Definition at line 10478 of file GeometryModifyTool.cpp.

{
    // Check for virtual geometry
    DLIList<RefEntity*> ref_ent_list;
    CAST_LIST_TO_PARENT(body_list_in, ref_ent_list);
    if ( GeometryQueryTool::instance()->contains_intermediate_geometry(ref_ent_list) )
    {
        PRINT_ERROR("Midsurfacing volumes containing virtual geometry is not\n"
            "       allowed. Delete virtual geometry on these surfaces\n"
            "       before operation.\n" );
        return CUBIT_FAILURE;
    }

    // Make sure all surfaces are from same geometry engine
    if ( !same_modify_engine(ref_ent_list, CUBIT_TRUE) )
    {
        PRINT_ERROR("Performing Midsurface with geometry from\n"
            "different modeling engines is not allowed.\n");
        return CUBIT_FAILURE;
    }

    AutoMidsurfaceTool mid_tool;
    DLIList<BodySM*> bodysm_list_out;

    if (CubitUndo::get_undo_enabled() && delete_midsurfaced && !preview)
        CubitUndo::save_state_with_cubit_file(body_list_in);

    CubitStatus result = mid_tool.midsurface(
        body_list_in,
        bodysm_list_out,
        old_bodies_midsurfaced,
        thickness_list,
        lower_tol,
        upper_tol,
        delete_midsurfaced,
        preview);


    if (result == CUBIT_SUCCESS &&
        bodysm_list_out.size() > 0 &&
        !preview)
    {
        if(CubitUndo::get_undo_enabled())
            CubitUndo::save_state();

        for( int i=0; i<bodysm_list_out.size(); i++ )
        {
            body_list_out.append(GeometryQueryTool::instance()->make_Body(bodysm_list_out[i]));
        }

        if( CubitUndo::get_undo_enabled() )
        {
            if( body_list_out.size() )
                CubitUndo::note_result_bodies( body_list_out );
            else
                CubitUndo::remove_last_undo();
        }
    }

    return result;
}
void GeometryModifyTool::boolean_regularize ( CubitBoolean  flag) [inline, static]

Gets boolean regularize flag.

Definition at line 2492 of file GeometryModifyTool.hpp.

Sets boolean regularize flag.

Definition at line 2490 of file GeometryModifyTool.hpp.

Body * GeometryModifyTool::brick ( double  wid,
double  dep,
double  hi 
)

Creates a brick (cube).

Creates an cuboid and assigns it to a Body $ {wid, dep, hi} input width, depth, height Returns the new Body or NULL

Definition at line 355 of file GeometryModifyTool.cpp.

{
   if (0 == gmeList.size())
   {
      PRINT_WARNING("No active geometry engine.\n");
      return NULL;
   }

     // First make sure that none of the input values are zero or less
   if ( width <= GEOMETRY_RESABS || depth <= GEOMETRY_RESABS || height <= GEOMETRY_RESABS )
   {
      PRINT_ERROR("In GeometryModifyTool::brick\n"
                  "    Cannot make a cuboid of size %f x %f x %f\n"
                  "       All dimensions must be > 0.0\n",
                  width, depth, height);
      return NULL;
   }

  if( CubitUndo::get_undo_enabled() )
    CubitUndo::save_state();

   Body *new_body = NULL;
   BodySM* bodyPtr = gmeList.get()->brick(width, depth, height);

   if (bodyPtr == NULL)
   {
      PRINT_ERROR("In GeometryModifyTool::brick\n"
                  "       Problem creating a brick.\n") ;
   }
   else
     new_body = GeometryQueryTool::instance()->make_Body(bodyPtr);

  if( CubitUndo::get_undo_enabled() )
  {
    if( new_body )
      CubitUndo::note_result_body( new_body );
    else
      CubitUndo::remove_last_undo();
  }

   return new_body;
}
Body * GeometryModifyTool::brick ( const CubitVector center,
const CubitVector  axes[3],
const CubitVector extension 
)

Creates a brick (cube).

Creates an cuboid and assigns it to a Body $ {center, axes, extension} input center, xyz axes, extension (extension vector is 1/2 width, height, depth) If one of dimensions is zero a planar sheet should be created. Returns the new Body or NULL

Definition at line 434 of file GeometryModifyTool.cpp.

{
   if (0 == gmeList.size())
   {
      PRINT_WARNING("No active geometry engine.\n");
      return NULL;
   }

   double width = 2.0*extension.x();
   double height = 2.0*extension.y();
   double depth = 2.0*extension.z();
     // First make sure that entity creation is possible.  Allow at most
     // only one of the dimensions to be zero - in which case a planar
     // sheet is created.
   if ( width < 0.0 || height < 0.0 || depth < 0.0 )
   {
      PRINT_ERROR( "Cannot make a brick of size %f x %f x %f\n"
                   "     Negative dimensions are not allowed.\n",
                   width, height, depth );
      return NULL ;
   }

   int wz = width < GEOMETRY_RESABS;
   int hz = height < GEOMETRY_RESABS;
   int dz = depth < GEOMETRY_RESABS;
   if( wz || hz || dz )
   {
      if( (wz + hz + dz) > 1 )
      {
         PRINT_ERROR( "Cannot make a sheet of size %f x %f x %f\n"
            "     At least two dimensions must be nonzero.\n",
            width, height, depth );
         return NULL ;
      }

      // Make a sheet body instead of a cuboid
      CubitVector sheet_axes[2];
      if( wz )
      {
         sheet_axes[0] = axes[1];
         sheet_axes[1] = axes[2];
         return planar_sheet( center, sheet_axes, height, depth );
      }
      else if( hz )
      {
         sheet_axes[0] = axes[2];
         sheet_axes[1] = axes[0];
         return planar_sheet( center, sheet_axes, depth, width );
      }
      else
      {
         sheet_axes[0] = axes[0];
         sheet_axes[1] = axes[1];
         return planar_sheet( center, sheet_axes, width, height );
      }
   }
   else
   {
      if( CubitUndo::get_undo_enabled() )
        CubitUndo::save_state();

      BodySM* bodyPtr = gmeList.get()->brick(center, axes, extension) ;
      Body *new_body = NULL;
      if (bodyPtr == NULL)
      {
         PRINT_ERROR("In GeometryTool::brick\n"
            "       Problem creating a brick.\n") ;
      }
      else
        new_body = GeometryQueryTool::instance()->make_Body(bodyPtr);

      if( CubitUndo::get_undo_enabled() )
      {
        if( new_body )
          CubitUndo::note_result_body( new_body );
        else
          CubitUndo::remove_last_undo();
      }

      return new_body;
   }
}
CubitStatus GeometryModifyTool::calculate_split_points_for_merge ( RefEdge c1,
RefEdge c2,
DLIList< RefVertex * > &  verts_to_merge,
double *  merge_tolerance,
DLIList< CubitVector > &  merge_end_points_on_curve1,
DLIList< CubitVector > &  merge_end_points_on_curve2,
DLIList< CubitBoolean > &  split_flags_for_curve1,
DLIList< CubitBoolean > &  split_flags_for_curve2,
double  divergence_angle 
) [private]

Definition at line 19547 of file GeometryModifyTool.cpp.

{

  CubitStatus status = CUBIT_SUCCESS;
  bool all_done = false;

  // Get the vertices of the two curves.
  RefVertex *c1_v1 = c1->start_vertex();
  RefVertex *c1_v2 = c1->end_vertex();
  RefVertex *c2_v1 = c2->start_vertex();
  RefVertex *c2_v2 = c2->end_vertex();

  // Check for closed curves.
  bool c1_closed = false;
  if(c1_v1 == c1_v2)
    c1_closed = true;
  bool merge_verts_at_both_ends = false;

  // If we are told that certain vertices need to merge
  // we will know that we do not need to split the curves there.
  bool full_c1=false, full_c2=false;
  int verts_to_merge_size = verts_to_merge.size();
  RefVertex *v1, *v2;
  if(verts_to_merge_size > 0)
  {
    // Verts to merge should always come in pairs.
    if(verts_to_merge_size % 2 != 0)
    {
      status = CUBIT_FAILURE;
    }
    else
    {
      if(verts_to_merge_size > 2 || c1_closed)
        merge_verts_at_both_ends = true;

      verts_to_merge.reset();
      // Process the first set of verts to merge.
      v1 = verts_to_merge.get_and_step();
      v2 = verts_to_merge.get_and_step();
      // Make sure v1 corresponds to c1 and v2 to c2.
      status = match_v1_to_c1(v1, v2, c1_v1, c1_v2, c2_v1, c2_v2);
    }
    if(status == CUBIT_SUCCESS)
    {
      // Determine whether the verts are at the
      // beginning or end of curves.
      bool forward_c1, forward_c2;
      if(v1 == c1_v1)
        forward_c1 = true;
      else
        forward_c1 = false;
      if(v2 == c2_v1)
        forward_c2 = true;
      else
        forward_c2 = false;

      double c1_stop_param, c2_stop_param;

      status = find_overlap_region(c1, c2, v1, v2, forward_c1, forward_c2, full_c1, full_c2,
        c1_stop_param, c2_stop_param, divergence_angle);

      if(status == CUBIT_SUCCESS)
      {
        merge_end_points_on_curve1.append(v1->coordinates());
        merge_end_points_on_curve2.append(v2->coordinates());
        split_flags_for_curve1.append(CUBIT_FALSE);
        split_flags_for_curve2.append(CUBIT_FALSE);

        // If we traversed the whole length of either curve and
        // we are told to merge the verts at both ends then
        // just add the verts at the other end and be done.
        if((full_c1 || full_c2) && merge_verts_at_both_ends)
        {
          split_flags_for_curve1.append(CUBIT_FALSE);
          split_flags_for_curve2.append(CUBIT_FALSE);
          if(c1_v1 == v1)
            merge_end_points_on_curve1.append(c1_v2->coordinates());
          else
            merge_end_points_on_curve1.append(c1_v1->coordinates());
          if(c2_v1 == v2)
            merge_end_points_on_curve2.append(c2_v2->coordinates());
          else
            merge_end_points_on_curve2.append(c2_v1->coordinates());
          all_done = true;
        }
        else
        {
          if(full_c2)
          {
            RefVertex *tmp_vert;
            if(c2_v1 == v2)
              tmp_vert = c2_v2;
            else
              tmp_vert = c2_v1;
            merge_end_points_on_curve2.append(tmp_vert->coordinates());
            split_flags_for_curve2.append(CUBIT_FALSE);
            if(!full_c1)
            {
              CubitVector pos1;
              c1->closest_point_trimmed(tmp_vert->coordinates(), pos1);
              merge_end_points_on_curve1.append(pos1);
              split_flags_for_curve1.append(CUBIT_TRUE);
            }
            else
            {
              if(c1_v1 == v1)
                merge_end_points_on_curve1.append(c1_v2->coordinates());
              else
                merge_end_points_on_curve1.append(c1_v1->coordinates());
              split_flags_for_curve1.append(CUBIT_FALSE);
            }
          }
          else
          {
            split_flags_for_curve2.append(CUBIT_TRUE);
            if(full_c1)
            {
              split_flags_for_curve1.append(CUBIT_FALSE);
              if(c1_v1 == v1)
              {
                merge_end_points_on_curve1.append(c1_v2->coordinates());
                // we need to imprint the end of c1 onto c2.
                CubitVector pos2;
                c2->closest_point_trimmed(c1_v2->coordinates(), pos2);
                merge_end_points_on_curve2.append(pos2);
              }
              else
              {
                merge_end_points_on_curve1.append(c1_v1->coordinates());
                // we need to imprint the end of c1 onto c2.
                CubitVector pos2;
                c2->closest_point_trimmed(c1_v1->coordinates(), pos2);
                merge_end_points_on_curve2.append(pos2);
              }
            }
            else
            {
              split_flags_for_curve1.append(CUBIT_TRUE);
              // we need to imprint the end of c2 onto c1.
              CubitVector pos1;
              c1->position_from_u(c1_stop_param, pos1);
              merge_end_points_on_curve1.append(pos1);
              // we need to imprint the end of c1 onto c2.
              CubitVector pos2;
              c2->closest_point_trimmed(pos1, pos2);
              merge_end_points_on_curve2.append(pos2);
            }
          }
        }
      }
    }
    if(status == CUBIT_SUCCESS && !all_done)
    {
      if(merge_verts_at_both_ends)
      {
        // Process the next set of verts to merge.
        v1 = verts_to_merge.get_and_step();
        v2 = verts_to_merge.get_and_step();
        // Make sure v1 corresponds to c1 and v2 to c2.
        status = match_v1_to_c1(v1, v2, c1_v1, c1_v2, c2_v1, c2_v2);
        if(status == CUBIT_SUCCESS)
        {
          // Determine whether the verts are at the
          // beginning or end of curves.
          bool forward_c1, forward_c2;
          if(v1 == c1_v1)
            forward_c1 = true;
          else
            forward_c1 = false;
          if(v2 == c2_v1)
            forward_c2 = true;
          else
            forward_c2 = false;

          double c1_stop_param, c2_stop_param;
          bool full_c1=false, full_c2=false;

          status = find_overlap_region(c1, c2, v1, v2, forward_c1, forward_c2, full_c1, full_c2,
            c1_stop_param, c2_stop_param, divergence_angle);
          if(status == CUBIT_SUCCESS)
          {
            merge_end_points_on_curve1.append(v1->coordinates());
            merge_end_points_on_curve2.append(v2->coordinates());
            split_flags_for_curve1.append(CUBIT_FALSE);
            split_flags_for_curve2.append(CUBIT_FALSE);
            split_flags_for_curve1.append(CUBIT_TRUE);
            split_flags_for_curve2.append(CUBIT_TRUE);
            // we need to imprint the end of c2 onto c1.
            CubitVector pos1;
            c1->position_from_u(c1_stop_param, pos1);
            merge_end_points_on_curve1.append(pos1);
            // we need to imprint the end of c1 onto c2.
            CubitVector pos2;
            c2->position_from_u(c2_stop_param, pos2);
            merge_end_points_on_curve2.append(pos2);
          }
        }
      }
    }
  }

  if(status == CUBIT_SUCCESS)
  {
  }

  return status;
}
CubitStatus GeometryModifyTool::chop ( DLIList< Body * > &  bodies,
DLIList< Body * > &  intersectBodies,
DLIList< Body * > &  outsideBodies,
Body *&  leftoversBody,
bool  keep_old = false,
bool  nonreg = false 
)

Intersects and subtracts the two bodies in the list.

Returns:
CubitStatus
- success or failure
  • ref_ent_list - The plane you want to align to, defined by either 2 vertices or a surface entities to move - Entities that will be aligned (can include merged ones).
  • align_to_vec - Vector defining the plane to align to
  • my_center_1 - Returned center of rotation
  • axis_of_rot - Returned axis of rotation
  • angle - Returned angle of rotation
  • preview -- If true, just draws the rotated edges If ref_ent_list contains a surface, A, this function will rotate entities_to_move about A's center point so that A's normal at the center point is aligned with vec_to_align_to. If ref_ent_list contains two vertices, this function will rotate entities_to_move about the first vertex so that a vector from vertex 1 to vertex 2 is aligned with vec_to_align_to.
This function accepts two bodies in the first list. The second body in the list is subtracted from and the first and the result is put into the outsideBodies list. intersectBodies list is the result of intersecting the original two bodies in the first list.

Definition at line 6685 of file GeometryModifyTool.cpp.

{
   leftoversBody = 0;
   if (bodies.size() <= 1)
   {
      PRINT_WARNING("There is only one body in the list. Nothing modified\n");
      return CUBIT_FAILURE;
   }
   if (!okay_to_modify( bodies, "CHOP" ))
     return CUBIT_FAILURE;

  int i;
  const int count = bodies.size();
  DLIList<Body*> original_body_list = bodies;
  DLIList<TopologyEntity*> entity_list(count);
  DLIList<TopologyBridge*> bridge_list(count);
  bodies.reset();
  for (i = bodies.size(); i--; )
    entity_list.append_unique(bodies.get_and_step());
  GeometryModifyEngine* gme = common_modify_engine( entity_list, bridge_list );

  if ( !gme )
  {
      PRINT_ERROR("Performing CHOP with volumes containing geometry\n"
                  " from different modeling engines is not allowed.\n"
                  "Delete uncommon geometry on these volumes before operation.\n\n");
      return CUBIT_FAILURE;
  }

   DLIList<BodySM*> body_sm_list;
   CAST_LIST( bridge_list, body_sm_list, BodySM );
   DLIList<BodySM*> intersect_bodies, outside_bodies;
   BodySM *leftovers_body = 0;

   if( CubitUndo::get_undo_enabled() )
   {
     if( keep_old )
       CubitUndo::save_state();
     else
     {
       //Get all the bodies associated with the vertex
       CubitUndo::save_state_with_cubit_file( bodies );
     }
   }

   DLIList<int> merged_surface_ids;
   DLIList<int> merged_curve_ids;
   DLIList<Body*> tmp_bodies(1);
   tmp_bodies.append( bodies.get() );
   if( keep_old == CUBIT_FALSE )
     get_merged_curve_and_surface_ids( tmp_bodies, merged_surface_ids, merged_curve_ids );

   do_attribute_setup();

   // Push attributes down onto the blank body (first one in list).
   DLIList<BodySM*> tmp_body_sm_list;
   body_sm_list.reset();
   tmp_body_sm_list.append(body_sm_list.get());
   push_attributes_before_modify(tmp_body_sm_list);

   CubitStatus result = gme->chop( body_sm_list, intersect_bodies,
                          outside_bodies, leftovers_body, keep_old, nonreg );

   if( result == CUBIT_FAILURE )
   {
     if( CubitUndo::get_undo_enabled() )
       CubitUndo::remove_last_undo();

     PRINT_ERROR("CHOP failed\n");
     remove_pushed_attributes(tmp_body_sm_list, tmp_bodies);
     do_attribute_cleanup();
     return CUBIT_FAILURE;
   }

   DLIList<BodySM*> all_sms = intersect_bodies;
   all_sms += outside_bodies;

   restore_vg_after_modify(all_sms, tmp_bodies, gme);
   remove_pushed_attributes(all_sms, tmp_bodies);

   DLIList<Body*> result_bodies;

   body_sm_list.clean_out();
   body_sm_list += intersect_bodies;

   CubitStatus stat = finish_sm_op(bodies, body_sm_list, result_bodies);

   if( CubitUndo::get_undo_enabled() )
   {
     if( stat == CUBIT_SUCCESS )
       CubitUndo::note_result_bodies( result_bodies );
     else
       CubitUndo::remove_last_undo();
   }

   if( stat == CUBIT_FAILURE )
   {
     if( CubitUndo::get_undo_enabled() )
       CubitUndo::remove_last_undo();

     PRINT_ERROR("CHOP failed\n");
     do_attribute_cleanup();
     return CUBIT_FAILURE;
   }
   intersectBodies += result_bodies;
   bodies.clean_out();

   body_sm_list.clean_out();
   body_sm_list += outside_bodies;
   result_bodies.clean_out();
   if (!finish_sm_op(bodies, body_sm_list, result_bodies))
   {
     if( CubitUndo::get_undo_enabled() )
       CubitUndo::remove_last_undo();

     PRINT_ERROR("CHOP failed\n");
     do_attribute_cleanup();
     return CUBIT_FAILURE;
   }
   outsideBodies += result_bodies;

   if( leftovers_body )
   {
     body_sm_list.clean_out();
     body_sm_list.append( leftovers_body );
     result_bodies.clean_out();
     if (!finish_sm_op(bodies, body_sm_list, result_bodies))
     {
       if( CubitUndo::get_undo_enabled() )
         CubitUndo::remove_last_undo();

       PRINT_ERROR("CHOP failed\n");
       do_attribute_cleanup();
       return CUBIT_FAILURE;
     }
     leftoversBody = result_bodies.get();

   }

   if( keep_old == CUBIT_FALSE )
     fixup_merged_entities( merged_surface_ids, merged_curve_ids);

  if( CubitUndo::get_undo_enabled() )
  {
    if( leftoversBody )
    {
      DLIList<Body*> tmp_list(1);
      tmp_list.append( leftoversBody );
      CubitUndo::note_result_bodies( tmp_list );
    }
    CubitUndo::note_result_bodies( intersectBodies );
    CubitUndo::note_result_bodies( outsideBodies );
  }

  do_attribute_cleanup();
  return CUBIT_SUCCESS;
}

Definition at line 1222 of file GeometryModifyTool.cpp.

{
  //Remove attributes on underlying entities of virtual geometry
  //entities which do not have corresponding RefEntities.
  DLIList<TopologyBridge*> bridge_list;
  bridge_list.append( old_bridge );
  GeometryQueryTool::instance()->ige_remove_attributes( bridge_list );

  //Remove attributes on original entity and children
  DLIList<RefEntity*> child_list;
  RefEntity *ref_ent = CAST_TO( old_bridge->topology_entity(), RefEntity );
  ref_ent->get_all_child_ref_entities( child_list );
  //child_list.append( ref_ent );
  CubitAttribUser::clear_all_simple_attrib( child_list );
  child_list.clean_out();
  child_list.append( ref_ent );
  CubitAttribUser::clear_all_simple_attrib( child_list );

  CGMApp::instance()->restore_previous_attribute_states();

return CUBIT_SUCCESS;
}
GeometryModifyEngine * GeometryModifyTool::common_modify_engine ( DLIList< RefFace * > &  faces,
DLIList< RefEdge * > &  edges,
DLIList< Surface * > &  surfaces,
DLIList< Curve * > &  curves,
CubitBoolean  allow_composites = CUBIT_FALSE 
) const

Determines if specified RefFaces and RefEdges are of the same geometry engine. Returns common engine, if any, and underlying surfaces and curves.

Definition at line 11717 of file GeometryModifyTool.cpp.

{
  int i;
  const int count = face_list.size() + edge_list.size();
  DLIList<TopologyEntity*> entity_list(count);
  DLIList<TopologyBridge*> bridge_list(count);

  face_list.reset();
  edge_list.reset();
  for (i = face_list.size(); i--; )
    entity_list.append(face_list.get_and_step());
  for (i = edge_list.size(); i--; )
    entity_list.append(edge_list.get_and_step());

  GeometryModifyEngine* engine = common_modify_engine(entity_list, bridge_list, allow_composites);
  if (!engine)
    return 0;

  entity_list.reset();
  CAST_LIST(bridge_list, surf_list, Surface);
  CAST_LIST(bridge_list, curv_list, Curve  );
  if(allow_composites)
  {
    if(surf_list.size() >= face_list.size() && curv_list.size() >= edge_list.size())
      return engine;
    else
      return 0;
  }
  else
  {
    if (surf_list.size() != face_list.size() || curv_list.size() != edge_list.size())
      return 0;
    else
      return engine;
  }
}
GeometryModifyEngine * GeometryModifyTool::common_modify_engine ( DLIList< Body * > &  bodies,
DLIList< BodySM * > &  bodysms 
) const [protected]

Definition at line 11676 of file GeometryModifyTool.cpp.

{
  input.reset();
  Body* body_ptr = input.get();
  BodySM* body_sm_ptr = body_ptr->get_body_sm_ptr();
  GeometryModifyEngine* engine = get_engine(body_sm_ptr);

  for (int i = input.size(); i--; )
  {
    body_ptr = input.get_and_step();
    body_sm_ptr = body_ptr->get_body_sm_ptr();
    output.append(body_sm_ptr);

    if (!body_sm_ptr)
    {
      PRINT_ERROR("Body %d is invalid -- no attached BodySM.\n", body_ptr->id());
      output.clean_out();
      return 0;
    }

    if (get_engine(body_sm_ptr) != engine)
    {
      output.clean_out();
      return 0;
    }
  }

  return engine;
}
GeometryModifyEngine * GeometryModifyTool::common_modify_engine ( DLIList< RefFace * > &  faces,
DLIList< Surface * > &  surfaces,
CubitBoolean  allow_composites = CUBIT_FALSE 
) const [protected]

Definition at line 11768 of file GeometryModifyTool.cpp.

{
  const int size = face_list.size();
  DLIList<TopologyEntity*> topo_list(size);
  DLIList<TopologyBridge*> geom_list(size);
  GeometryModifyEngine* result;

  CAST_LIST_TO_PARENT( face_list, topo_list );
  result = common_modify_engine( topo_list, geom_list, allow_composites );

  CAST_LIST( geom_list, surf_list, Surface );
  return result;
}
GeometryModifyEngine * GeometryModifyTool::common_modify_engine ( DLIList< RefEdge * > &  edges,
DLIList< Curve * > &  curves,
CubitBoolean  allow_composites = CUBIT_FALSE 
) const [protected]

Definition at line 11793 of file GeometryModifyTool.cpp.

{
  const int size = edge_list.size();
  DLIList<TopologyEntity*> topo_list(size);
  DLIList<TopologyBridge*> geom_list(size);
  GeometryModifyEngine* result;

  CAST_LIST_TO_PARENT( edge_list, topo_list );
  result = common_modify_engine( topo_list, geom_list, allow_composites );

  CAST_LIST( geom_list, curve_list, Curve );
  return result;
}
GeometryModifyEngine * GeometryModifyTool::common_modify_engine ( DLIList< RefVertex * > &  vertices,
DLIList< TBPoint * > &  points,
CubitBoolean  allow_composites = CUBIT_FALSE 
) const [protected]

Definition at line 11820 of file GeometryModifyTool.cpp.

{
  const int size = vertex_list.size();
  DLIList<TopologyEntity*> topo_list(size);
  DLIList<TopologyBridge*> geom_list(size);
  GeometryModifyEngine* result;

  CAST_LIST_TO_PARENT( vertex_list, topo_list );
  result = common_modify_engine( topo_list, geom_list, allow_composites );

  CAST_LIST( geom_list, point_list, TBPoint );
  return result;
}
GeometryModifyEngine * GeometryModifyTool::common_modify_engine ( DLIList< TopologyEntity * > &  topology_list,
DLIList< TopologyBridge * > &  engine_bridges,
CubitBoolean  allow_composites = CUBIT_FALSE 
) const [protected]
Returns:
GeometryModifyEngine* A GeometryModifyEngine common at least one TopologyBridge of each of the passed TopologyEntities, or NULL if no common geometry engine is found.
  • topology_list The input list of TopologyEntities
  • engine_bridges Pass back the list of TopolgyBridges associated with each of the passed TopologyEntities (topology_list) and owned by the returned geometry engine.
  • allow_virtual_engine Return VirtualGeometryEngine::instance() if no common geometry enginge can be found.
Look for a common geometry engine other than the VirtualGeometryEngine. If no common geometry engine other than VGE can be found and allow_virtual_engine is FALSE, NULL is returned. If allow_virtual_engine is TRUE, and no common geometry engine is found, VGE will be returned, and engine_bridges will be populated with any virtual geometry if possible, otherwise with the first topology bridge attached to each of the passed TopologyEntities.

Definition at line 11581 of file GeometryModifyTool.cpp.

{
  GeometryModifyEngine* gme_ptr = 0;
  if(allow_composites)
  {
    int i;
    engine_bridges.clean_out();
    for(i=topology_list.size(); i--;)
    {
      TopologyEntity* topo_ptr = topology_list.get_and_step();
      if (!topo_ptr)
        return (GeometryModifyEngine*)NULL;
      TopologyBridge *first_bridge = topo_ptr->bridge_manager()->topology_bridge();
      GeometryQueryEngine *gqe = first_bridge->get_geometry_query_engine();
      DLIList<TopologyBridge*> underlying_bridge_list;
      gqe->get_underlying_bridges(first_bridge, underlying_bridge_list);
      if(underlying_bridge_list.size() == 0)
        underlying_bridge_list.append(first_bridge);
      int k;
      for(k=underlying_bridge_list.size(); k--;)
      {
        TopologyBridge *bridge_ptr = underlying_bridge_list.get_and_step();
        engine_bridges.append( bridge_ptr );
        GeometryModifyEngine *cur_gme = get_engine(bridge_ptr);
        if(!gme_ptr)
          gme_ptr = cur_gme;
        else
        {
          if(gme_ptr != cur_gme)
          {
            gme_ptr = NULL;
            k=0;
            i=0;
          }
        }
      }
    }
  }
  else
  {
    topology_list.reset();

    TopologyEntity* topo_ptr = topology_list.get_and_step();
    if (!topo_ptr)
      return (GeometryModifyEngine*)NULL;
    DLIList<TopologyBridge*> first_bridge_list;
    topo_ptr->bridge_manager()->get_bridge_list( first_bridge_list );

    first_bridge_list.reset();
    for( int i = first_bridge_list.size(); i > 0; i-- )
    {
      TopologyBridge* bridge_ptr = first_bridge_list.get_and_step();
      engine_bridges.clean_out();
      engine_bridges.append( bridge_ptr );
      gme_ptr = get_engine(bridge_ptr);

      if( !gme_ptr )
      return (GeometryModifyEngine*)NULL;

      topology_list.reset();
      topology_list.step(); //skip first entry
      for( int j = topology_list.size(); j > 1; j-- )
      {
        topo_ptr = topology_list.get_and_step();
        bridge_ptr = topo_ptr->bridge_manager()->topology_bridge(gme_ptr->get_gqe());
        if( bridge_ptr ) engine_bridges.append( bridge_ptr );
        else break;
      }

      if( engine_bridges.size() == topology_list.size() )
        break;

      gme_ptr = 0;
    }
  }
  if( !gme_ptr )
  {
    engine_bridges.clean_out();
    PRINT_ERROR("Entities do not belong to the same geometry engine.\n");
  }
  return gme_ptr;
}

Definition at line 10932 of file GeometryModifyTool.cpp.

{
  DLIList<TopologyBridge*> child_list;
  while (bridge_list.size())
  {
    TopologyBridge* bridge = bridge_list.pop();
    TBOwner* bridge_owner = bridge->owner();
    if (bridge_owner && !dynamic_cast<BridgeManager*>(bridge_owner) &&
      GeometryQueryTool::instance()->ige_is_composite(bridge_owner))
      return true;

    child_list.clean_out();
    bridge->get_children_virt(child_list);
    bridge_list += child_list;
  }
  return false;
}

Definition at line 10923 of file GeometryModifyTool.cpp.

{
  DLIList<TopologyBridge*> bridges;
  list.reset();
  for (int i = list.size(); i--; )
    bridges.append(list.get_and_step()->get_body_sm_ptr());
  return contains_composites(bridges);
}
bool GeometryModifyTool::contains_intermediate_geom ( DLIList< Body * > &  list) const [private]

Definition at line 10878 of file GeometryModifyTool.cpp.

{
  DLIList<TopologyBridge*> bridges;
  list.reset();
  for (int i = list.size(); i--; )
    bridges.append(list.get_and_step()->get_body_sm_ptr());
  return contains_intermediate_geom(bridges);
}

Definition at line 10896 of file GeometryModifyTool.cpp.

{
  DLIList<TopologyBridge*> child_list;
  while (bridge_list.size())
  {
    TopologyBridge* bridge = bridge_list.pop();
    TBOwner* bridge_owner = bridge->owner();
    if (bridge_owner && !dynamic_cast<BridgeManager*>(bridge_owner))
      return true;

    child_list.clean_out();
    bridge->get_children_virt(child_list);
    bridge_list += child_list;
  }
  return false;
}

Definition at line 10951 of file GeometryModifyTool.cpp.

{
  DLIList<TopologyBridge*> child_list;
  while (bridge_list.size())
  {
    TopologyBridge* bridge = bridge_list.pop();
    TBOwner* bridge_owner = bridge->owner();
    if (bridge_owner && !dynamic_cast<BridgeManager*>(bridge_owner) &&
      GeometryQueryTool::instance()->ige_is_partition(bridge_owner))
      return true;

    child_list.clean_out();
    bridge->get_children_virt(child_list);
    bridge_list += child_list;
  }
  return false;
}

Definition at line 10914 of file GeometryModifyTool.cpp.

{
  DLIList<TopologyBridge*> bridges;
  list.reset();
  for (int i = list.size(); i--; )
    bridges.append(list.get_and_step()->get_body_sm_ptr());
  return contains_partitions(bridges);
}
Body * GeometryModifyTool::copy_body ( Body body_ptr,
std::map< RefEntity *, RefEntity * > *  old_to_new_map = NULL 
)

Copy a Body.

Returns:
Body*
- A pointer to a newly created body.
  • body_ptr A pointer to a Body which is to used to make copy.
This function makes a copy of the input Body and returns a pointer to the newly created copy. The input Body and the newly created Body are geometrically identical. If the copying operation fails for some reason, the function returns NULL. The old_to_new_map is an optional parameter that maps all the entities of the original to those of the copy.

Definition at line 2414 of file GeometryModifyTool.cpp.

{
   BodySM* body_sm = bodyPtr->get_body_sm_ptr();
   if (!body_sm)
   {
     PRINT_ERROR("Body %d is invalid -- no attached BodySM.\n", bodyPtr->id());
     return 0;
   }

   //this list will get all the TB's what we'll be copying
   DLIList<RefEntity*> tmp_list;
   tmp_list.append( bodyPtr );
   TopologyBridge *top_bridge;
   prepare_for_copy( bodyPtr, top_bridge );

   BodySM *tmp_body_sm = CAST_TO( top_bridge, BodySM );

   GeometryModifyEngine* GMEPtr = get_engine(tmp_body_sm);
   if ( GMEPtr == NULL )
   {
     clean_up_from_copy_failure( top_bridge );
     PRINT_ERROR("Cannot copy volume %d\n"
                 "     Copy is supported for bodies based on solid "
                 "models only\n", bodyPtr->ref_volume()->id() );
     return NULL ;
   }
   std::map<TopologyBridge*, TopologyBridge*> old_tb_to_new_tb;  

   BodySM *new_bodysm = GMEPtr->copy_body(tmp_body_sm, &old_tb_to_new_tb );

   if (!new_bodysm)
   {
     clean_up_from_copy_failure( top_bridge );
     PRINT_ERROR("Failed to copy volume %d\n", bodyPtr->ref_volume()->id());
     return 0;
   }

   TopologyBridge *top_bridge_new = new_bodysm;
   finish_copy( top_bridge_new, body_sm );

   new_bodysm = CAST_TO( top_bridge_new, BodySM );
   Body *body_new = GeometryQueryTool::instance()->make_Body(new_bodysm);

   if( old_to_new_map )
     create_old_to_new_ref_ent_map( body_sm, new_bodysm, *old_to_new_map, old_tb_to_new_tb );

   return body_new;
}

Copy a RefEntity.

Takes a RefEntity (RefVertex, RefEdge, or RefFace) and creates a copy of it using the make_RefXxxxx commands.

Definition at line 8791 of file GeometryModifyTool.cpp.

{
   RefEntity *new_entity = NULL;

   if( old_entity == NULL )
       return (RefEntity*) NULL;

   if( CAST_TO( old_entity, RefVolume ) )
       return (RefEntity*) NULL;

   RefFace *old_face = CAST_TO( old_entity, RefFace );
   if( old_face )
   {
      RefFace *new_face = instance()->make_RefFace( old_face );
      new_entity = CAST_TO( new_face, RefEntity );
   }

   RefEdge *old_edge = CAST_TO( old_entity, RefEdge );
   if( old_edge )
   {
      RefEdge *new_edge = instance()->make_RefEdge( old_edge );
      new_entity = CAST_TO( new_edge, RefEntity );
   }

   RefVertex *old_vert = CAST_TO( old_entity, RefVertex );
   if( old_vert )
   {
      RefVertex *new_vert = instance()->make_RefVertex( old_vert->coordinates() );
      new_entity = CAST_TO( new_vert, RefEntity );
   }

   return new_entity;
}
RefEdge * GeometryModifyTool::create_arc ( const CubitVector position,
double  radius,
double  start_angle,
double  end_angle,
CubitVector  plane,
CubitBoolean  preview = CUBIT_FALSE 
)

Definition at line 11122 of file GeometryModifyTool.cpp.

{
  if(0 == gmeList.size())
  {
    PRINT_WARNING("No active geometry engine.\n");
    return NULL;
  }

  if( radius <= GEOMETRY_RESABS )
  {
    PRINT_ERROR("Values must be positive\n");
    return NULL;
  }

  if(preview)
  {
    gmeList.get()->create_arc(position,radius,start_angle,end_angle, plane, preview);
    return NULL;
  }

  if( CubitUndo::get_undo_enabled() )
    CubitUndo::save_state();

  Curve* curve = gmeList.get()->create_arc(position,radius,start_angle,end_angle, plane,preview);
  if (!curve)
  {
    if( CubitUndo::get_undo_enabled() )
      CubitUndo::remove_last_undo();
    return 0;
  }

  RefEdge* result = GeometryQueryTool::instance()->make_free_RefEdge(curve);
  PRINT_INFO("Created curve %d\n", result->id());

  if( CubitUndo::get_undo_enabled() )
    CubitUndo::note_result_entity( result );
  return result;
}
RefEdge * GeometryModifyTool::create_arc_center_edge ( RefVertex ref_vertex1,
RefVertex ref_vertex2,
RefVertex ref_vertex3,
const CubitVector normal,
double  radius = CUBIT_DBL_MAX,
CubitBoolean  full = CUBIT_FALSE,
CubitBoolean  preview = CUBIT_FALSE 
)

Create an arc curve from two points and a center point. If full option is specified, a full circle is created.

Create an arc curve from two points and a center point.

Definition at line 11436 of file GeometryModifyTool.cpp.

{
  DLIList<TopologyEntity*> entity_list(3);
  DLIList<TopologyBridge*> bridge_list(3);
  entity_list.append(ref_vertex1);
  entity_list.append(ref_vertex2);
  entity_list.append(ref_vertex3);
  GeometryModifyEngine* gme = common_modify_engine(entity_list, bridge_list);
  if (!gme)
  {
    PRINT_ERROR("Vertices do not share a common modify engine.\n");
    return 0;
  }

  if(preview)
  {
    TBPoint* point0 = dynamic_cast<TBPoint*>(bridge_list.next(0));
    TBPoint* point1 = dynamic_cast<TBPoint*>(bridge_list.next(1));
    TBPoint* point2 = dynamic_cast<TBPoint*>(bridge_list.next(2));
    gme->create_arc_center_edge( point0, point1, point2,
      normal, radius, full,preview );
    return NULL;

  }

  //if we can reuse vertices, we decide here
  bool need_new_start_point=false, need_new_end_point=false;
  if( full )
  {
    need_new_start_point = ref_vertex2->get_parents() > 0;
    if (need_new_start_point)
    {
      bridge_list.reset();
      bridge_list.step(1);
      TBPoint *start_point = gme->make_Point( ref_vertex2->coordinates() );
      bridge_list.change_to( start_point );
    }
  }
  else
  {
    need_new_start_point = ref_vertex2->get_parents() > 0;
    need_new_end_point = ref_vertex3->get_parents() > 0;

    if (need_new_start_point)
    {
      bridge_list.reset();
      bridge_list.step();
      TBPoint *start_point = gme->make_Point( ref_vertex2->coordinates() );
      bridge_list.change_to( start_point );
    }
    if (need_new_end_point)
    {
      bridge_list.last();
      TBPoint *end_point = gme->make_Point( ref_vertex3->coordinates());
      bridge_list.change_to( end_point );
    }
  }

  if( CubitUndo::get_undo_enabled() )
  {
    DLIList<RefVertex*> vertices_to_save;
    if( !need_new_start_point )
      vertices_to_save.append( ref_vertex2 );
    if( !need_new_end_point )
      vertices_to_save.append( ref_vertex3 );

    if( vertices_to_save.size() )
      CubitUndo::save_state_with_cubit_file( vertices_to_save, true );
    else
      CubitUndo::save_state();
  }

  bridge_list.reset();
  TBPoint* point0 = dynamic_cast<TBPoint*>(bridge_list.next(0));
  TBPoint* point1 = dynamic_cast<TBPoint*>(bridge_list.next(1));
  TBPoint* point2 = dynamic_cast<TBPoint*>(bridge_list.next(2));
  Curve* curve = gme->create_arc_center_edge( point0, point1, point2,
    normal, radius, full );
  if (!curve)
  {
    if( CubitUndo::get_undo_enabled() )
      CubitUndo::remove_last_undo();
    return 0;
  }

  RefEdge* result = GeometryQueryTool::instance()->make_free_RefEdge(curve);
  PRINT_INFO("Created curve %d\n", result->id());

  if( CubitUndo::get_undo_enabled() )
    CubitUndo::note_result_entity( result );

  return result;

}
RefEdge * GeometryModifyTool::create_arc_radius ( RefVertex ref_vertex1,
RefVertex ref_vertex2,
const CubitVector normal,
double  radius,
CubitBoolean  other_arc = CUBIT_FALSE,
CubitBoolean  full = CUBIT_FALSE,
CubitBoolean  preview = CUBIT_FALSE 
)

Definition at line 11305 of file GeometryModifyTool.cpp.

{
  DLIList<TopologyEntity*> entity_list(2);
  DLIList<TopologyBridge*> bridge_list(2);
  entity_list.append(ref_vertex1);
  entity_list.append(ref_vertex2);
  GeometryModifyEngine* gme = common_modify_engine(entity_list, bridge_list);
  if (!gme)
  {
    PRINT_ERROR("Vertices do not share a common modify engine.\n");
    return 0;
  }



  CubitVector start = ref_vertex1->coordinates(); // Position on arc
  CubitVector end = ref_vertex2->coordinates(); // Position on arc

  CubitVector center_vec=end-start;

  CubitVector perp_vec=normal*center_vec;
  center_vec*=0.5;
  double b=radius*radius-center_vec.length_squared();
  if(b>=0)
  {
    b=sqrt(b);
  }
  else
  {
    PRINT_ERROR("Radius must be greater than half the distance between the end vertices.\n");
    return 0;
  }
  if(other_arc)
    b*=-1;


  perp_vec.normalize();
  perp_vec*=b;


  center_vec=center_vec+perp_vec;

  CubitVector center=start+center_vec;

  if(preview)
  {
    bridge_list.reset();
    TBPoint* point1 = dynamic_cast<TBPoint*>(bridge_list.next(0));
    TBPoint* point2 = dynamic_cast<TBPoint*>(bridge_list.next(1));
     gme->create_arc_radius(center,point1, point2,
      normal, radius, full,preview );
     return NULL;
  }
  else
  {

    //if we can reuse vertices, we decide here
    bool need_new_start_point=false, need_new_end_point=false;
    if( full )
    {
      need_new_start_point = ref_vertex1->get_parents() > 0;
      if (need_new_start_point)
      {
        bridge_list.reset();
        TBPoint *start_point = gme->make_Point( ref_vertex1->coordinates() );
        bridge_list.change_to( start_point );
      }
    }
    else
    {
      need_new_start_point = ref_vertex1->get_parents() > 0;
      need_new_end_point = ref_vertex2->get_parents() > 0;

      if (need_new_start_point)
      {
        bridge_list.reset();
        TBPoint *start_point = gme->make_Point( ref_vertex1->coordinates() );
        bridge_list.change_to( start_point );
      }
      if (need_new_end_point)
      {
        bridge_list.last();
        TBPoint *end_point = gme->make_Point( ref_vertex2->coordinates());
        bridge_list.change_to( end_point );
      }
    }

    if( CubitUndo::get_undo_enabled() )
    {
      DLIList<RefVertex*> vertices_to_save;
      if( !need_new_start_point )
        vertices_to_save.append( ref_vertex1 );
      if( !need_new_end_point )
        vertices_to_save.append( ref_vertex2 );

      if( vertices_to_save.size() )
        CubitUndo::save_state_with_cubit_file( vertices_to_save, true );
      else
        CubitUndo::save_state();
    }

    bridge_list.reset();
    TBPoint* point1 = dynamic_cast<TBPoint*>(bridge_list.next(0));
    TBPoint* point2 = dynamic_cast<TBPoint*>(bridge_list.next(1));
    Curve* curve = gme->create_arc_radius(center,point1, point2,
      normal, radius, full,preview );
    if (!curve)
    {
      if( CubitUndo::get_undo_enabled() )
        CubitUndo::remove_last_undo();
      return 0;
    }

    RefEdge* result = GeometryQueryTool::instance()->make_free_RefEdge(curve);
    PRINT_INFO("Created curve %d\n", result->id());

    if( CubitUndo::get_undo_enabled() )
      CubitUndo::note_result_entity( result );

    return result;
  }
  return 0;
}
RefEdge * GeometryModifyTool::create_arc_three ( RefVertex ref_vertex1,
RefVertex ref_vertex2,
RefVertex ref_vertex3,
CubitBoolean  full = CUBIT_FALSE,
CubitBoolean  preview = CUBIT_FALSE 
)

Create an arc curve from three points.

Definition at line 11170 of file GeometryModifyTool.cpp.

{
  DLIList<TopologyEntity*> entity_list(3);
  DLIList<TopologyBridge*> bridge_list(3);
  entity_list.append(ref_vertex1);
  entity_list.append(ref_vertex2);
  entity_list.append(ref_vertex3);
  GeometryModifyEngine* gme = common_modify_engine(entity_list, bridge_list);
  if (!gme)
  {
    PRINT_ERROR("Vertices do not share a common solid modeller.\n");
    return 0;
  }

  if(preview)
  {
    bridge_list.reset();
    TBPoint* point0 = dynamic_cast<TBPoint*>(bridge_list.next(0));
    TBPoint* point1 = dynamic_cast<TBPoint*>(bridge_list.next(1));
    TBPoint* point2 = dynamic_cast<TBPoint*>(bridge_list.next(2));
    gme->create_arc_three( point0, point1, point2, full,preview );
    return NULL;
  }

  //if we can reuse vertices, we decide here
  bool need_new_start_point = false;
  bool need_new_end_point = false;
  if( full )
  {
    need_new_start_point = ref_vertex1->get_parents() > 0;
    if (need_new_start_point)
    {
      bridge_list.reset();
      TBPoint *start_point = gme->make_Point( ref_vertex1->coordinates() );
      bridge_list.change_to( start_point );
    }
  }
  else
  {
    need_new_start_point = ref_vertex1->get_parents() > 0;
    need_new_end_point = ref_vertex3->get_parents() > 0;

    if (need_new_start_point)
    {
      bridge_list.reset();
      TBPoint *start_point = gme->make_Point( ref_vertex1->coordinates() );
      bridge_list.change_to( start_point );
    }
    if (need_new_end_point)
    {
      bridge_list.reset();
      bridge_list.last();
      TBPoint *end_point = gme->make_Point( ref_vertex3->coordinates());
      bridge_list.change_to( end_point );
    }
  }

  if( CubitUndo::get_undo_enabled() )
  {
    DLIList<RefVertex*> vertices_to_save;
    if( !need_new_start_point )
      vertices_to_save.append( ref_vertex1 );
    if( !need_new_end_point )
      vertices_to_save.append( ref_vertex3 );

    if( vertices_to_save.size() )
      CubitUndo::save_state_with_cubit_file( vertices_to_save, true );
    else
      CubitUndo::save_state();
  }

  bridge_list.reset();
  TBPoint* point0 = dynamic_cast<TBPoint*>(bridge_list.next(0));
  TBPoint* point1 = dynamic_cast<TBPoint*>(bridge_list.next(1));
  TBPoint* point2 = dynamic_cast<TBPoint*>(bridge_list.next(2));
  Curve* curve = gme->create_arc_three( point0, point1, point2, full,preview );
  if (!curve)
  {
    if( CubitUndo::get_undo_enabled() )
      CubitUndo::remove_last_undo();
    return 0;
  }

  RefEdge* result = GeometryQueryTool::instance()->make_free_RefEdge(curve);
  PRINT_INFO("Created curve %d\n", result->id());

  if( CubitUndo::get_undo_enabled() )
    CubitUndo::note_result_entity( result );
  return result;

}
RefEdge * GeometryModifyTool::create_arc_three ( RefEdge ref_edge1,
RefEdge ref_edge2,
RefEdge ref_edge3,
CubitBoolean  full = CUBIT_FALSE,
CubitBoolean  preview = CUBIT_FALSE 
)

Create an arc curve tangent to three curves.

Definition at line 11267 of file GeometryModifyTool.cpp.

{
  DLIList<TopologyEntity*> entity_list(3);
  DLIList<TopologyBridge*> bridge_list(3);
  entity_list.append(ref_edge1);
  entity_list.append(ref_edge2);
  entity_list.append(ref_edge3);
  GeometryModifyEngine* gme = common_modify_engine(entity_list, bridge_list);
  if (!gme)
  {
    PRINT_ERROR("The input curves must be associated with a common solid modeller.\n");
    return NULL;
  }

  bridge_list.reset();
  Curve* curve0 = dynamic_cast<Curve*>(bridge_list.next(0));
  Curve* curve1 = dynamic_cast<Curve*>(bridge_list.next(1));
  Curve* curve2 = dynamic_cast<Curve*>(bridge_list.next(2));
  Curve* curve = gme->create_arc_three( curve0, curve1, curve2, full,preview );
  if (!curve)
    return 0;

  if( CubitUndo::get_undo_enabled() )
    CubitUndo::save_state();

  RefEdge* result = GeometryQueryTool::instance()->make_free_RefEdge(curve);

  if( CubitUndo::get_undo_enabled() )
    CubitUndo::note_result_entity( result );

  PRINT_INFO("Created curve %d\n", result->id());
  return result;
}
Body * GeometryModifyTool::create_body ( VolumeFacets volume,
std::map< FacetShapes *, RefEntity * > &  entity_map,
const FacetPointSet points,
int  interp_order 
)

Creates a volume from facet data.

Creates a facet body based on facet information {volume} - topological and facet information of the volume and underlying entities {points} - a vector of doubles representing points used by the facets Returns the new Body or NULL

Definition at line 913 of file GeometryModifyTool.cpp.

{
  GeometryModifyEngine* engine = gmeList.get();
  if (!engine->supports_facets())
    return NULL;

  Body* new_body = NULL;

  if( CubitUndo::get_undo_enabled() )
     CubitUndo::save_state();

  std::map<FacetShapes*, GeometryEntity*> geom_entity_map;
  BodySM* body_sm = engine->create_body(volume, geom_entity_map, points, interp_order);
  if(body_sm)
  {
    new_body = GeometryQueryTool::instance()->make_Body(body_sm);
    // map information back to caller
    std::map<FacetShapes*, GeometryEntity*>::iterator geom_iter;
    for (geom_iter = geom_entity_map.begin(); geom_iter != geom_entity_map.end(); geom_iter++)
      entity_map[geom_iter->first] = dynamic_cast<RefEntity*>(geom_iter->second->topology_entity());
  }

  if( CubitUndo::get_undo_enabled() )
  {
    if( new_body )
      CubitUndo::note_result_body( new_body );
    else
      CubitUndo::remove_last_undo();
  }

  return new_body;
}

Definition at line 20939 of file GeometryModifyTool.cpp.

{
  if(0 == gmeList.size())
  {
    PRINT_WARNING("No active geometry engine.\n");
    return NULL;
  }

  if( radius <= GEOMETRY_RESABS )
  {
    PRINT_ERROR("Values must be positive\n");
    return NULL;
  }

  if( CubitUndo::get_undo_enabled() )
    CubitUndo::save_state();

  BodySM *sheet_body_sm = NULL;
  CubitStatus status = gmeList.get()->create_circle_surface(radius, plane, sheet_body_sm );

  if( status == CUBIT_FAILURE )
  {
    if(CubitUndo::get_undo_enabled())
      CubitUndo::remove_last_undo();
    return NULL;
  }

  Body *new_body = NULL;
  if( sheet_body_sm )
    new_body = GeometryQueryTool::instance()->make_Body(sheet_body_sm);

  if (new_body)
  {
    if(CubitUndo::get_undo_enabled())
      CubitUndo::note_result_body(new_body);    
  }
  else
  {
    if(CubitUndo::get_undo_enabled())
      CubitUndo::remove_last_undo();    
  }

  return new_body;
}

Definition at line 20984 of file GeometryModifyTool.cpp.

{
  if(0 == gmeList.size())
  {
    PRINT_WARNING("No active geometry engine.\n");
    return NULL;
  }

  GeometryModifyEngine *GMEPtr = get_engine( v1->get_point_ptr() );

  if( GMEPtr != get_engine( v3->get_point_ptr() ) )
  {
    PRINT_INFO("Vertices are not from same modeling engine.\n");
    return NULL;
  }

  TBPoint *pt1, *pt3;

  DLIList<RefVertex*> free_ref_vertices;
  if( v1->num_parent_ref_entities() == 0 )
  {
    free_ref_vertices.append( v1 );
    pt1 = v1->get_point_ptr();
  }
  else
    pt1 = GMEPtr->make_Point( v1->coordinates() );

  if( v3->num_parent_ref_entities() == 0 )
  {
    free_ref_vertices.append( v3 );
    pt3 = v3->get_point_ptr();
  }
  else
    pt3 = GMEPtr->make_Point( v3->coordinates() );


  if( CubitUndo::get_undo_enabled() )
  {
    if( free_ref_vertices.size() )
      CubitUndo::save_state_with_cubit_file( free_ref_vertices, true );
    else
      CubitUndo::save_state();
  }

  BodySM *sheet_body_sm = NULL;
  CubitStatus status = GMEPtr->create_circle_surface(pt1, v2->coordinates(), pt3, sheet_body_sm );

  if( status == CUBIT_FAILURE )
  {
    if(CubitUndo::get_undo_enabled())
      CubitUndo::remove_last_undo();
    return NULL;
  }

  Body *new_body = NULL;
  if( sheet_body_sm )
    new_body = GeometryQueryTool::instance()->make_Body(sheet_body_sm);

  if (new_body)
  {
    if(CubitUndo::get_undo_enabled())
      CubitUndo::note_result_body(new_body);    
  }
  else
  {
    if(CubitUndo::get_undo_enabled())
      CubitUndo::remove_last_undo();    
  }

  return new_body;
}

Definition at line 21058 of file GeometryModifyTool.cpp.

{
  if(0 == gmeList.size())
  {
    PRINT_WARNING("No active geometry engine.\n");
    return NULL;
  }

  GeometryModifyEngine *GMEPtr = get_engine( v1->get_point_ptr() );

  if( GMEPtr != get_engine( v2->get_point_ptr() ) )
  {
    PRINT_INFO("Vertices are not from same modeling engine.\n");
    return NULL;
  }

  TBPoint *pt1, *pt2;

  DLIList<RefVertex*> free_ref_vertices;
  if( v1->num_parent_ref_entities() == 0 )
  {
    free_ref_vertices.append( v1 );
    pt1 = v1->get_point_ptr();
  }
  else
    pt1 = GMEPtr->make_Point( v1->coordinates() );

  if( v2->num_parent_ref_entities() == 0 )
  {
    free_ref_vertices.append( v2 );
    pt2 = v2->get_point_ptr();
  }
  else
    pt2 = GMEPtr->make_Point( v2->coordinates() );


  if( CubitUndo::get_undo_enabled() )
  {
    if( free_ref_vertices.size() )
      CubitUndo::save_state_with_cubit_file( free_ref_vertices, true );
    else
      CubitUndo::save_state();
  }

  BodySM *sheet_body_sm = NULL;
  CubitStatus status = GMEPtr->create_circle_surface(pt1, pt2, center_point, sheet_body_sm );

  if( status == CUBIT_FAILURE )
  {
    if(CubitUndo::get_undo_enabled())
      CubitUndo::remove_last_undo();
    return NULL;
  }

  Body *new_body = NULL;
  if( sheet_body_sm )
    new_body = GeometryQueryTool::instance()->make_Body(sheet_body_sm);

  if (new_body)
  {
    if(CubitUndo::get_undo_enabled())
      CubitUndo::note_result_body(new_body);    
  }
  else
  {
    if(CubitUndo::get_undo_enabled())
      CubitUndo::remove_last_undo();    
  }

  return new_body;
}
CubitStatus GeometryModifyTool::create_curve_combine ( DLIList< RefEdge * > &  ref_edge_list,
RefEdge *&  new_ref_edge_ptr 
)

Create a curve that is a combination of the specified curves.

Definition at line 11538 of file GeometryModifyTool.cpp.

{
  DLIList<TopologyBridge*> bridge_list(ref_edge_list.size());
  CubitStatus result = CUBIT_FAILURE;

  int count = ref_edge_list.size();
  if (count == 0)
  {
    PRINT_ERROR("No edges to combine.\n");
    return result;
  }

  DLIList<TopologyEntity*> entity_list(count);
  CAST_LIST_TO_PARENT( ref_edge_list, entity_list );
  GeometryModifyEngine* gme = common_modify_engine(entity_list, bridge_list);
  if (!gme)
  {
    PRINT_ERROR("Edges do not share a common modify engine.\n");
    return result;
  }

  Curve* new_curve_ptr;
  DLIList<Curve*> curve_list(count);
  CAST_LIST( bridge_list, curve_list, Curve );
  result = gme->create_curve_combine(curve_list, new_curve_ptr);
  if (new_curve_ptr)
      new_ref_edge_ptr = CAST_TO(new_curve_ptr->topology_entity(), RefEdge);


  return result;
}
CubitStatus GeometryModifyTool::create_curve_helix ( CubitVector location,
CubitVector direction,
CubitVector start_point,
double &  thread_distance,
double &  angle,
bool  right_handed,
RefEdge *&  new_ref_edge_ptr 
)

Definition at line 21252 of file GeometryModifyTool.cpp.

{
  if (0 == gmeList.size())
  {
    PRINT_WARNING("No active geometry engine.\n");
    return CUBIT_FAILURE;
  }

  Curve *new_curve = gmeList.get()->create_curve_helix(location, direction,
                                                start_point, thread_distance,
                                                angle, right_handed );

  if (new_curve == NULL)
    return CUBIT_FAILURE;

  if( CubitUndo::get_undo_enabled() )
    CubitUndo::save_state();

  new_ref_edge_ptr = GeometryQueryTool::instance()->make_free_RefEdge(new_curve);

  if( CubitUndo::get_undo_enabled() )
    CubitUndo::note_result_entity( new_ref_edge_ptr );

  return CUBIT_SUCCESS;
}

Definition at line 21132 of file GeometryModifyTool.cpp.

{
  if(0 == gmeList.size())
  {
    PRINT_WARNING("No active geometry engine.\n");
    return NULL;
  }

  GeometryModifyEngine *GMEPtr = get_engine( v1->get_point_ptr() );

  if( GMEPtr != get_engine( v2->get_point_ptr() ) )
  {
    PRINT_INFO("Vertices are not from same modeling engine.\n");
    return NULL;
  }

  TBPoint *pt1, *pt2;

  DLIList<RefVertex*> free_ref_vertices;
  if( v1->num_parent_ref_entities() == 0 )
  {
    free_ref_vertices.append( v1 );
    pt1 = v1->get_point_ptr();
  }
  else
    pt1 = GMEPtr->make_Point( v1->coordinates() );

  if( v2->num_parent_ref_entities() == 0 )
  {
    free_ref_vertices.append( v2 );
    pt2 = v2->get_point_ptr();
  }
  else
    pt2 = GMEPtr->make_Point( v2->coordinates() );

  if( CubitUndo::get_undo_enabled() )
  {
    if( free_ref_vertices.size() )
      CubitUndo::save_state_with_cubit_file( free_ref_vertices, true );
    else
      CubitUndo::save_state();
  }

  BodySM *sheet_body_sm = NULL;
  CubitStatus status = GMEPtr->create_ellipse_surface(pt1, pt2, center_point, sheet_body_sm );

  if( status == CUBIT_FAILURE )
  {
    if(CubitUndo::get_undo_enabled())
      CubitUndo::remove_last_undo();
    return NULL;
  }

  Body *new_body = NULL;
  if( sheet_body_sm )
    new_body = GeometryQueryTool::instance()->make_Body(sheet_body_sm);

  if (new_body)
  {
    if(CubitUndo::get_undo_enabled())
      CubitUndo::note_result_body(new_body);    
  }
  else
  {
    if(CubitUndo::get_undo_enabled())
      CubitUndo::remove_last_undo();    
  }

  return new_body;
}
Body * GeometryModifyTool::create_ellipse_surface ( double  major_radius,
double  minor_radius,
CubitVector  plane 
)

Definition at line 21205 of file GeometryModifyTool.cpp.

{
  if(0 == gmeList.size())
  {
    PRINT_WARNING("No active geometry engine.\n");
    return NULL;
  }

  if( major_radius <= GEOMETRY_RESABS || minor_radius <= GEOMETRY_RESABS )
  {
    PRINT_ERROR("Values must be positive\n");
    return NULL;
  }

  if( CubitUndo::get_undo_enabled() )
    CubitUndo::save_state();

  BodySM *sheet_body_sm = NULL;
  CubitStatus status = gmeList.get()->create_ellipse_surface(major_radius, minor_radius, plane, sheet_body_sm );

  if( status == CUBIT_FAILURE )
  {
    if(CubitUndo::get_undo_enabled())
      CubitUndo::remove_last_undo();
    return NULL;
  }

  Body *new_body = NULL;
  if( sheet_body_sm )
    new_body = GeometryQueryTool::instance()->make_Body(sheet_body_sm);

  if (new_body)
  {
    if(CubitUndo::get_undo_enabled())
      CubitUndo::note_result_body(new_body);    
  }
  else
  {
    if(CubitUndo::get_undo_enabled())
      CubitUndo::remove_last_undo();    
  }

  return new_body;
}
CubitStatus GeometryModifyTool::create_net_surface ( DLIList< Surface * > &  ref_face_list,
BodySM *&  new_body,
DLIList< DLIList< CubitVector * > * > &  vec_lists_u,
DLIList< DLIList< CubitVector * > * > &  vec_lists_v,
double  net_tol = 1e-3,
CubitBoolean  heal = CUBIT_TRUE 
)

Create a surface using arrays of points in u and v directions.

CubitStatus GeometryModifyTool::create_net_surface ( DLIList< RefEdge * > &  u_curves,
DLIList< RefEdge * > &  v_curves,
double  net_tol = 1e-3,
CubitBoolean  heal = CUBIT_TRUE 
)

Create a surface using curves in u and v directions.

Definition at line 17428 of file GeometryModifyTool.cpp.

{
  DLIList<TopologyBridge*> bridge_list;
  DLIList<TopologyEntity*> entity_list;
  CAST_LIST_TO_PARENT( u_curves, entity_list );

  GeometryModifyEngine* GME_ptr =
    common_modify_engine( entity_list, bridge_list );
  if(! GME_ptr )
  {
     PRINT_ERROR("Cannot construct a Surface using entities that do "
                 "not share a common GeometryModifyEngine.\n");
     return CUBIT_FAILURE;
  }

  DLIList<Curve*> curves_in_u(bridge_list.size());
  CAST_LIST( bridge_list, curves_in_u, Curve );

  bridge_list.clean_out();
  entity_list.clean_out();
  CAST_LIST_TO_PARENT( v_curves, entity_list );

  GeometryModifyEngine* dummy_GME_ptr =
    common_modify_engine( entity_list, bridge_list );
  if(! dummy_GME_ptr || dummy_GME_ptr != GME_ptr )
  {
     PRINT_ERROR("Cannot construct a Surface using entities that do "
                 "not share a common GeometryModifyEngine.\n");
     return CUBIT_FAILURE;
  }

  DLIList<Curve*> curves_in_v(bridge_list.size());
  CAST_LIST( bridge_list, curves_in_v, Curve );

  BodySM *new_smbody = NULL;
  if( !GME_ptr->create_net_surface( curves_in_u, curves_in_v, new_smbody, net_tol, heal ) )
    return CUBIT_FAILURE;

  if (CubitUndo::get_undo_enabled())
    CubitUndo::save_state();

  Body* new_body = NULL;
  new_body = GeometryQueryTool::instance()->make_Body( new_smbody );
  if( new_body )
  {
    if (CubitUndo::get_undo_enabled())
      CubitUndo::note_result_body(new_body);

    return CUBIT_SUCCESS;
  }
  else
  {
    if (CubitUndo::get_undo_enabled())
      CubitUndo::remove_last_undo();

    return CUBIT_FAILURE;
  }
}
CubitStatus GeometryModifyTool::create_offset_body ( Body body_ptr,
Body *&  new_body,
double  offset_distance 
)

Create a body by offsetting all the surface of the body.

Definition at line 17736 of file GeometryModifyTool.cpp.

{
  GeometryModifyEngine* GMEPtr = get_engine(body_ptr);

  BodySM *body_sm = body_ptr->get_body_sm_ptr();
  if (!body_sm)
  {
    PRINT_ERROR("Body %d is invalid -- no attached BodySM.\n", body_ptr->id());
    return CUBIT_FAILURE;
  }

  BodySM *new_body_sm;
  if( !GMEPtr->create_offset_body( body_sm, new_body_sm, offset_distance ) )
    return CUBIT_FAILURE;

  if (CubitUndo::get_undo_enabled())
    CubitUndo::save_state();

  new_body = GeometryQueryTool::instance()->make_Body( new_body_sm );

  if( new_body )
  {
    if (CubitUndo::get_undo_enabled())
      CubitUndo::note_result_body(new_body);

    return CUBIT_SUCCESS;
  }
  else
  {
    if (CubitUndo::get_undo_enabled())
      CubitUndo::remove_last_undo();

    return CUBIT_FAILURE;
  }
}
CubitStatus GeometryModifyTool::create_offset_sheet ( DLIList< RefFace * > &  ref_face_list,
double  offset_distance,
DLIList< RefFace * > *  add_ref_face_list_ptr,
DLIList< double > *  add_offset_list_ptr,
DLIList< Body * > &  new_body_list,
CubitBoolean  preview = CUBIT_FALSE 
)

Create a body(s) by offsetting the given surfaces.

Create a sheet body (or bodies) by offsetting the given faces. The optional additional face list and double list (must be same length) allow different offset distances for different faces. Adjoining faces are extended or trimmed to remain joined in the new sheet body. Radial faces that cannot be so offset are removed and the resulting wound healed by the surrounding faces.

Definition at line 17537 of file GeometryModifyTool.cpp.

{
  if( !ref_face_list.size() )
  {
    return CUBIT_SUCCESS;
  }
  else
  {
    for (int i = 0; i < ref_face_list.size(); i++)
    {
      RefFace *temp = ref_face_list.get_and_step();
      if (temp->get_surface_ptr()->is_cylindrical() == 16)
      {
        DLIList<Curve*> curves;
        CubitVector loc;
        double rad;
        temp->get_surface_ptr()->curves(curves);
        curves.reset();
        int j = 0;
        while (curves.get()->geometry_type() != ELLIPSE_CURVE_TYPE && curves.get()->geometry_type() != ARC_CURVE_TYPE)
        {
          curves.step();
          if (j == curves.size())
          {
              break;
          }
          j++;
        }
        curves.get()->get_center_radius(loc, rad);
        if (offset_distance >= rad)
        {
          CubitVector norm, close, result;
          double angle;
          temp->get_surface_ptr()->closest_point(loc, &close, &norm);
          result.set(loc.x()-close.x(), loc.y()-close.y(), loc.z()-close.z());
          angle = result.interior_angle(norm);
          if (angle < GEOMETRY_RESABS && angle > -GEOMETRY_RESABS)
          {
            PRINT_ERROR("Offset is greater than the radius of curvature for surface %i.\n", temp->id());
            PRINT_WARNING("No body will be created for surface %i.\n", temp->id());
            if (ref_face_list.size() > 1)
            {
              ref_face_list.remove_all_with_value(temp);
            }
            else
            {
              return CUBIT_FAILURE;
            }
          }
        }
      }
    }
    for (int i = 0; i < add_ref_face_list_ptr->size(); i++)
    {
      RefFace *temp = ref_face_list.get_and_step();
      if (temp->get_surface_ptr()->is_cylindrical() == 16)
      {
        DLIList<Curve*> curves;
        CubitVector loc;
        double rad;
        temp->get_surface_ptr()->curves(curves);
        curves.reset();
        while (curves.get()->geometry_type() != ELLIPSE_CURVE_TYPE && curves.get()->geometry_type() != ARC_CURVE_TYPE)
        {
          curves.step();
        }
        curves.get()->get_center_radius(loc, rad);
        if (offset_distance >= rad)
        {
          CubitVector norm, close, result;
          double angle;
          temp->get_surface_ptr()->closest_point(loc, &close, &norm);
          result.set(loc.x()-close.x(), loc.y()-close.y(), loc.z()-close.z());
          angle = result.interior_angle(norm);
          if (angle < GEOMETRY_RESABS && angle > -GEOMETRY_RESABS)
          {
            PRINT_ERROR("Offset is greater than the radius of curvature for surface %i.\n", temp->id());
            PRINT_WARNING("No body will be created for surface %i.\n", temp->id());
            add_ref_face_list_ptr->remove_all_with_value(temp);
          }
        }
      }
    }
  }

  DLIList<RefFace*> all_ref_face_list(ref_face_list.size());
  all_ref_face_list = ref_face_list;
  if( add_ref_face_list_ptr->size() )
    all_ref_face_list += *add_ref_face_list_ptr;

  // Check for virtual geometry
  DLIList<RefEntity*> ref_ent_list;
  CAST_LIST_TO_PARENT(all_ref_face_list, ref_ent_list);
  if ( GeometryQueryTool::instance()->contains_intermediate_geometry(ref_ent_list) )
  {
    PRINT_ERROR("OFFSETTING surfaces containing virtual geometry is not\n"
      "       allowed. Delete virtual geometry on these surfaces\n"
      "       before operation.\n" );
    return CUBIT_FAILURE;
  }

  // Look for a common GeometryModifyEngine for all of the RefFaces
  int count = all_ref_face_list.size();
  DLIList<TopologyBridge*> bridge_list(count);
  DLIList<TopologyEntity*> entity_list(count);
  CAST_LIST_TO_PARENT( all_ref_face_list, entity_list );

  GeometryModifyEngine* GME_ptr =
    common_modify_engine( entity_list, bridge_list );
  if(! GME_ptr )
  {
     PRINT_ERROR("Cannot construct offset sheet(s) using surfaces that\n"
                 "       do not share a common geometry engine.\n");
     return CUBIT_FAILURE;
  }

  // Get Surfaces from the RefFaces
  DLIList<Surface*> surface_list(ref_face_list.size());
  int i;
  RefFace *ref_face_ptr;
  for( i=ref_face_list.size(); i--; )
  {
    ref_face_ptr = ref_face_list.get_and_step();
    surface_list.append( ref_face_ptr->get_surface_ptr() );
  }

  DLIList<Surface*> add_surf_list;
  if( add_ref_face_list_ptr->size() )
  {
    for( i=add_ref_face_list_ptr->size(); i--; )
    {
      ref_face_ptr = add_ref_face_list_ptr->get_and_step();
      add_surf_list.append( ref_face_ptr->get_surface_ptr() );
    }
  }
  
  if (CubitUndo::get_undo_enabled() && !preview )
    CubitUndo::save_state();

  CubitStatus status;
  DLIList<BodySM*> BodySM_list;
  if( add_surf_list.size() )
  {
    status = GME_ptr->create_offset_sheet( surface_list, offset_distance, &add_surf_list,
      add_offset_list_ptr, BodySM_list, preview );      
  }
  else
  {
    status = GME_ptr->create_offset_sheet( surface_list, offset_distance, NULL,
      NULL, BodySM_list, preview );      
  }

  if( status == CUBIT_FAILURE || !BodySM_list.size() )
  {
    if(CubitUndo::get_undo_enabled() && !preview )
      CubitUndo::remove_last_undo();
    return CUBIT_FAILURE;
  }

  BodySM *bodysm_ptr;
  Body* body_ptr;
  for( i=BodySM_list.size(); i--; )
  {
    DLIList<Surface*> surfs;
    bodysm_ptr = BodySM_list.get_and_step();
    bodysm_ptr->surfaces(surfs);
    if (!surfs.size())
    {
      PRINT_WARNING("Empty body created.  Body deleted.\n");
      PRINT_WARNING("Empty body likely due to an offset larger than the radius of curvature of a surface.\n");
      bodysm_ptr->get_geometry_query_engine()->delete_solid_model_entities(bodysm_ptr);
      break;
    }

    body_ptr = GeometryQueryTool::instance()->make_Body( bodysm_ptr );
    if( body_ptr )
      new_body_list.append( body_ptr );
  }

  if( new_body_list.size() )
  {
    if(CubitUndo::get_undo_enabled() && !preview )
      CubitUndo::note_result_bodies(new_body_list);
    return CUBIT_SUCCESS;
  }
  else
  {
    if(CubitUndo::get_undo_enabled() && !preview )
      CubitUndo::remove_last_undo();
    return CUBIT_FAILURE;
  }
}
CubitStatus GeometryModifyTool::create_offset_surface ( RefFace ref_face_ptr,
double  offset_distance 
)

Creates an offset surface some distance from a surface.

Definition at line 17488 of file GeometryModifyTool.cpp.

{
  TopologyBridge *bridge_ptr = NULL;
  GeometryModifyEngine* GMEPtr = get_engine(ref_face_ptr, &bridge_ptr );

  Surface *tmp_surf = NULL;
  tmp_surf = CAST_TO( bridge_ptr, Surface );

  BodySM *new_smbody;
  if( !GMEPtr->create_offset_surface( tmp_surf, new_smbody, offset_distance ) )
    return CUBIT_FAILURE;

  if (CubitUndo::get_undo_enabled())
    CubitUndo::save_state();

  Body* new_body = NULL;
  new_body = GeometryQueryTool::instance()->make_Body( new_smbody );
  if( new_body )
  {
    if (CubitUndo::get_undo_enabled())
      CubitUndo::note_result_body(new_body);

    return CUBIT_SUCCESS;
  }
  else
  {
    if (CubitUndo::get_undo_enabled())
      CubitUndo::remove_last_undo();

    return CUBIT_FAILURE;
  }
}
CubitStatus GeometryModifyTool::create_old_to_new_ref_ent_map ( TopologyBridge old_top_level_bridge,
TopologyBridge new_top_level_bridge,
std::map< RefEntity *, RefEntity * > &  old_to_new_map,
std::map< TopologyBridge *, TopologyBridge * > &  old_tb_to_new_tb 
) [static, private]

Definition at line 21675 of file GeometryModifyTool.cpp.

{
  std::vector< std::pair<TopologyBridge*, TopologyBridge*> > unmatched_pairs;
  bool debug = false;
  std::map< TopologyBridge*, TopologyBridge*>::iterator iter;  

  //This first loop tries to find a RefEntity on each TopologyBridge pair in the
  //map 'old_tb_to_new_tb'.  If there is no virtual geometry here, everything
  //should be found.  If it didn't find a RefEntity, put it in the 
  //unmatched_pairs vector.
  for( iter = old_tb_to_new_tb.begin(); iter!=old_tb_to_new_tb.end(); iter++ )
  {
    std::pair<TopologyBridge*, TopologyBridge*> tmp_pair = *iter;
    TopologyBridge *old_tb = tmp_pair.first;
    TopologyBridge *new_tb = tmp_pair.second;

    TopologyEntity *te_old = old_tb->topology_entity();
    TopologyEntity *te_new = new_tb->topology_entity();

    if( te_old && te_new )
    {
      RefEntity *old_ref_ent = dynamic_cast<RefEntity*>(te_old);
      RefEntity *new_ref_ent = dynamic_cast<RefEntity*>(te_new);

      if( old_ref_ent && new_ref_ent )
      {
        if( debug )
          PRINT_INFO("%s %d ---> %s %d\n", 
          old_ref_ent->class_name(), old_ref_ent->id(),
          new_ref_ent->class_name(), new_ref_ent->id() );

        old_to_new_map.insert( std::make_pair( old_ref_ent, new_ref_ent ) );
      }
      else
        unmatched_pairs.push_back( tmp_pair );
    }
    else
      unmatched_pairs.push_back( tmp_pair );
  }  

  //Virtual geometry will be in unmatched pairs.  Composite will have an n-to-1 
  //TB-to-RefEntity mapping.  So it might try to stuff duplicate pairs into the 
  //map, but that's alright.
  for( size_t k=0; k<unmatched_pairs.size(); k++ )
  {
    std::pair<TopologyBridge*, TopologyBridge*> tmp_pair = unmatched_pairs[k];

    TopologyBridge *old_tb = tmp_pair.first;
    TopologyBridge *new_tb = tmp_pair.second;

    //get the owner tbs associate with old_tb
    DLIList<TopologyBridge*> old_owner_tbs;
    GeometryQueryTool::instance()->get_tbs_with_bridge_manager_as_owner( old_tb, old_owner_tbs );

    DLIList<TopologyBridge*> new_owner_tbs;
    GeometryQueryTool::instance()->get_tbs_with_bridge_manager_as_owner( new_tb, new_owner_tbs );
    
    if( old_owner_tbs.size() && old_owner_tbs.size() == new_owner_tbs.size() )
    {
      if( old_owner_tbs.size() == 1 && new_owner_tbs.size() == 1 ) //composite case
      {
        TopologyEntity *te_old = old_owner_tbs.get()->topology_entity();
        TopologyEntity *te_new = new_owner_tbs.get()->topology_entity();

        if( te_old && te_new )
        {
          RefEntity *old_ref_ent = dynamic_cast<RefEntity*>(te_old);
          RefEntity *new_ref_ent = dynamic_cast<RefEntity*>(te_new);

          if( old_ref_ent && new_ref_ent )
          {
            if( debug )
              PRINT_INFO("Virtual: %s %d ---> %s %d\n", 
              old_ref_ent->class_name(), old_ref_ent->id(),
              new_ref_ent->class_name(), new_ref_ent->id() );

            old_to_new_map.insert( std::make_pair( old_ref_ent, new_ref_ent ) );

            old_tb_to_new_tb.insert( std::make_pair( old_owner_tbs.get(), new_owner_tbs.get() ) );
          }
        }        
      }      
    }
  }

  //Partitions can hide entities because of the the n-to-m mapping.
  //The solution is to get all the child TB lumps, surface, curves, and
  //points.  
  double tol_sq = old_top_level_bridge->get_geometry_query_engine()->get_sme_resabs_tolerance();
  tol_sq *= tol_sq;

  DLIList<Lump*> old_lumps, new_lumps;
  DLIList<Surface*> old_surfaces, new_surfaces;
  DLIList<Curve*> old_curves, new_curves;
  DLIList<TBPoint*> old_points, new_points;
  
  if( dynamic_cast<BodySM*>(old_top_level_bridge) )
  {
    old_top_level_bridge->lumps( old_lumps );
    old_top_level_bridge->surfaces( old_surfaces );
    new_top_level_bridge->lumps( new_lumps );
    new_top_level_bridge->surfaces( new_surfaces );
  }

  old_top_level_bridge->curves( old_curves );
  old_top_level_bridge->points( old_points ); 
  new_top_level_bridge->curves( new_curves );
  new_top_level_bridge->points( new_points );

  //If it is already in the map, it has been paired to something.
  //Remove it from the list and forget about it.
  for( int k=0; k<old_lumps.size(); k++ )
  {
    //if it is found, make it NULL in the list
    iter = old_tb_to_new_tb.find( old_lumps[k] );
    if( iter != old_tb_to_new_tb.end() )
    {
      old_lumps[k] = NULL;
      if( new_lumps.move_to( (Lump*)iter->second ) )
        new_lumps.change_to( NULL );
    }
  }
  for( int k=0; k<old_surfaces.size(); k++ )
  {
    //if it is found, make it NULL in the list
    iter = old_tb_to_new_tb.find( old_surfaces[k] );
    if( iter != old_tb_to_new_tb.end() )
    {
      old_surfaces[k] = NULL;
      if( new_surfaces.move_to( (Surface*)iter->second ) )
        new_surfaces.change_to( NULL );
    }
  }
  for( int k=0; k<old_curves.size(); k++ )
  {
    //if it is found, make it NULL in the list
    iter = old_tb_to_new_tb.find( old_curves[k] );
    if( iter != old_tb_to_new_tb.end() )
    {
      old_curves[k] = NULL;
      if( new_curves.move_to( (Curve*)iter->second ) )
        new_curves.change_to( NULL );
    }
  }
  for( int k=0; k<old_points.size(); k++ )
  {
    //if it is found, make it NULL in the list
    iter = old_tb_to_new_tb.find( old_points[k] );
    if( iter != old_tb_to_new_tb.end() )
    {
      old_points[k] = NULL;
      if( new_points.move_to( (TBPoint*)iter->second ) )
        new_points.change_to( NULL );
    }
  }

  //Remove all the NULL-ed out stuff
  old_lumps.remove_all_with_value(NULL);
  old_surfaces.remove_all_with_value(NULL);
  old_curves.remove_all_with_value(NULL);
  old_points.remove_all_with_value(NULL);

  new_lumps.remove_all_with_value(NULL);
  new_surfaces.remove_all_with_value(NULL);
  new_curves.remove_all_with_value(NULL);
  new_points.remove_all_with_value(NULL);

  //should have exact correspondence
  if( old_lumps.size() != new_lumps.size() )
    return CUBIT_FAILURE;
  if( old_surfaces.size() != new_surfaces.size() )
    return CUBIT_FAILURE;
  if( old_curves.size() != new_curves.size() )
    return CUBIT_FAILURE;
  if( old_points.size() != new_points.size() )
    return CUBIT_FAILURE;

  //If we are here, there are partitions we have to resolve.  The only way to do it 
  //is a brute force approach.  It's save to use a tolerance since we know the 
  //entities will be exactly on top of each other.  
  for( int k=0; k<old_surfaces.size(); k++ )
  {
    Surface *old_surf = old_surfaces[k];
    CubitBox old_bbox = old_surf->bounding_box();

    for( int j=0; j<new_surfaces.size(); j++ )
    {
      Surface *new_surf = new_surfaces[j];
      if( new_surf )
      {
        CubitBox new_bbox = new_surf->bounding_box();          
        if( old_bbox.center().distance_between_squared( new_bbox.center() ) < tol_sq )
        {
          if( fabs(old_bbox.diagonal().length_squared() - 
            new_bbox.diagonal().length_squared() ) < tol_sq )
          {
            TopologyEntity *te_old = old_surf->topology_entity();
            TopologyEntity *te_new = new_surf->topology_entity();

            if( te_old && te_new )
            {
              RefEntity *old_ref_ent = dynamic_cast<RefEntity*>(te_old);
              RefEntity *new_ref_ent = dynamic_cast<RefEntity*>(te_new);

              if( old_ref_ent && new_ref_ent )
              {
                if( debug )
                  PRINT_INFO("Partition: %s %d ---> %s %d\n", 
                  old_ref_ent->class_name(), old_ref_ent->id(),
                  new_ref_ent->class_name(), new_ref_ent->id() );

                old_to_new_map.insert( std::make_pair( old_ref_ent, new_ref_ent ) );
                new_surfaces[j] = NULL;
                break;
              }
            }
          }
        }
      }
    }
  }

  //Curves
  for( int k=0; k<old_curves.size(); k++ )
  {
    Curve *old_curve = old_curves[k];
    CubitBox old_bbox = old_curve->bounding_box();

    for( int j=0; j<new_curves.size(); j++ )
    {
      Curve *new_curve = new_curves[j];
      if( new_curve )
      {
        CubitBox new_bbox = new_curve->bounding_box();          
        if( old_bbox.center().distance_between_squared( new_bbox.center() ) < tol_sq )
        {
          if( fabs(old_bbox.diagonal().length_squared() - 
            new_bbox.diagonal().length_squared() ) < tol_sq )
          {
            TopologyEntity *te_old = old_curve->topology_entity();
            TopologyEntity *te_new = new_curve->topology_entity();

            if( te_old && te_new )
            {
              RefEntity *old_ref_ent = dynamic_cast<RefEntity*>(te_old);
              RefEntity *new_ref_ent = dynamic_cast<RefEntity*>(te_new);

              if( old_ref_ent && new_ref_ent )
              {
                if( debug )
                  PRINT_INFO("Partition: %s %d ---> %s %d\n", 
                  old_ref_ent->class_name(), old_ref_ent->id(),
                  new_ref_ent->class_name(), new_ref_ent->id() );

                old_to_new_map.insert( std::make_pair( old_ref_ent, new_ref_ent ) );
                new_curves[j] = NULL;
                break;
              }
            }
          }
        }
      }
    }
  }

  //Points
  for( int k=0; k<old_points.size(); k++ )
  {
    TBPoint *old_point = old_points[k];
    CubitBox old_bbox = old_point->bounding_box();

    for( int j=0; j<new_points.size(); j++ )
    {
      TBPoint *new_point = new_points[j];
      if( new_point )
      {
        CubitBox new_bbox = new_point->bounding_box();          
        if( old_bbox.center().distance_between_squared( new_bbox.center() ) < tol_sq )
        {
          if( fabs(old_bbox.diagonal().length_squared() - 
            new_bbox.diagonal().length_squared() ) < tol_sq )
          {
            TopologyEntity *te_old = old_point->topology_entity();
            TopologyEntity *te_new = new_point->topology_entity();

            if( te_old && te_new )
            {
              RefEntity *old_ref_ent = dynamic_cast<RefEntity*>(te_old);
              RefEntity *new_ref_ent = dynamic_cast<RefEntity*>(te_new);

              if( old_ref_ent && new_ref_ent )
              {
                if( debug )
                  PRINT_INFO("Partition: %s %d ---> %s %d\n", 
                  old_ref_ent->class_name(), old_ref_ent->id(),
                  new_ref_ent->class_name(), new_ref_ent->id() );

                old_to_new_map.insert( std::make_pair( old_ref_ent, new_ref_ent ) );
                new_points[j] = NULL;
                break;
              }
            }
          }
        }
      }
    }
  }

  return CUBIT_SUCCESS;

}

Definition at line 20853 of file GeometryModifyTool.cpp.

{
  if(0 == gmeList.size())
  {
    PRINT_WARNING("No active geometry engine.\n");
    return NULL;
  }

  GeometryModifyEngine *GMEPtr = get_engine( v1->get_point_ptr() );

  if( GMEPtr != get_engine( v2->get_point_ptr() ) )
  {
    PRINT_INFO("Vertices are not from same modeling engine.\n");
    return NULL;
  }
  if( GMEPtr != get_engine( v3->get_point_ptr() ) )
  {
    PRINT_INFO("Vertices are not from same modeling engine.\n");
    return NULL;
  }

  TBPoint *pt1, *pt2, *pt3;

  DLIList<RefVertex*> free_ref_vertices;
  if( v1->num_parent_ref_entities() == 0 )
  {
    free_ref_vertices.append( v1 );
    pt1 = v1->get_point_ptr();
  }
  else
    pt1 = GMEPtr->make_Point( v1->coordinates() );

  if( v2->num_parent_ref_entities() == 0 )
  {
    free_ref_vertices.append( v2 );
    pt2 = v2->get_point_ptr();
  }
  else
    pt2 = GMEPtr->make_Point( v2->coordinates() );

  if( v3->num_parent_ref_entities() == 0 )
  {
    free_ref_vertices.append( v3 );
    pt3 = v3->get_point_ptr();
  }
  else
    pt3 = GMEPtr->make_Point( v3->coordinates() );

  if( CubitUndo::get_undo_enabled() )
  {
    if( free_ref_vertices.size() )
      CubitUndo::save_state_with_cubit_file( free_ref_vertices, true );
    else
      CubitUndo::save_state();
  }

  BodySM *sheet_body_sm = NULL;
  CubitStatus status = GMEPtr->create_parallelogram_surface(pt1, pt2, pt3, sheet_body_sm );

  if( status == CUBIT_FAILURE )
  {
    if(CubitUndo::get_undo_enabled())
      CubitUndo::remove_last_undo();
    return NULL;
  }

  Body *new_body = NULL;
  if( sheet_body_sm )
    new_body = GeometryQueryTool::instance()->make_Body(sheet_body_sm);

  if (new_body)
  {
    if(CubitUndo::get_undo_enabled())
      CubitUndo::note_result_body(new_body);    
  }
  else
  {
    if(CubitUndo::get_undo_enabled())
      CubitUndo::remove_last_undo();    
  }

  return new_body;
}
Body * GeometryModifyTool::create_rectangle_surface ( double  width,
double  height,
CubitVector  plane 
)

Definition at line 20806 of file GeometryModifyTool.cpp.

{
  if(0 == gmeList.size())
  {
    PRINT_WARNING("No active geometry engine.\n");
    return NULL;
  }

  if( width <= GEOMETRY_RESABS || height <= GEOMETRY_RESABS )
  {
    PRINT_ERROR("Values must be positive\n");
    return NULL;
  }

  if( CubitUndo::get_undo_enabled() )
    CubitUndo::save_state();

  BodySM *sheet_body_sm = NULL;
  CubitStatus status = gmeList.get()->create_rectangle_surface(width, height, plane, sheet_body_sm );

  if( status == CUBIT_FAILURE )
  {
    if(CubitUndo::get_undo_enabled())
      CubitUndo::remove_last_undo();
    return NULL;
  }

  Body *new_body = NULL;
  if( sheet_body_sm )
    new_body = GeometryQueryTool::instance()->make_Body(sheet_body_sm);

  if (new_body)
  {
    if(CubitUndo::get_undo_enabled())
      CubitUndo::note_result_body(new_body);
    status = CUBIT_SUCCESS;
  }
  else
  {
    if(CubitUndo::get_undo_enabled())
      CubitUndo::remove_last_undo();
    status = CUBIT_FAILURE;
  }

  return new_body;
}
CubitStatus GeometryModifyTool::create_skin_surface ( DLIList< RefEdge * > &  ref_edges,
Body *&  new_body,
DLIList< RefEdge * > &  guides 
)

Create a sheet body skinning (lofting) a series of curves.

Definition at line 17773 of file GeometryModifyTool.cpp.

{
  DLIList<TopologyBridge*> bridge_list;
  DLIList<TopologyEntity*> entity_list;
  CAST_LIST_TO_PARENT( ref_edges, entity_list );

  DLIList<TopologyBridge*> guide_bridge_list;
  DLIList<TopologyEntity*> guide_entity_list;
  CAST_LIST_TO_PARENT(guides, guide_entity_list);

  if (ref_edges.size() < 2)
  {
     PRINT_ERROR("Must specify at least 2 curves to create a skinned surface.\n");
     return CUBIT_FAILURE;
  }

  GeometryModifyEngine* GME_ptr =
    common_modify_engine( entity_list, bridge_list );
  if(! GME_ptr )
  {
     PRINT_ERROR("Cannot construct a Surface using entities that do "
                 "not share a common GeometryModifyEngine.\n");
     return CUBIT_FAILURE;
  }

  if (guides.size() > 0)
  {
      GeometryModifyEngine* GME_ptr2 =
          common_modify_engine( guide_entity_list, guide_bridge_list );
      if (GME_ptr != GME_ptr2)
      {
          PRINT_ERROR("Performing create skin with geometry from\n"
            "different modeling engines is not allowed.\n");
          return CUBIT_FAILURE;
      }
  }

  DLIList<Curve*> curves_to_skin(bridge_list.size());
  CAST_LIST( bridge_list, curves_to_skin, Curve );

  DLIList<Curve*> guide_curves(guide_bridge_list.size());
  CAST_LIST(guide_bridge_list, guide_curves, Curve);

  BodySM *new_body_sm = NULL;
  if( !GME_ptr->create_skin_surface( curves_to_skin, new_body_sm, guide_curves ) )
    return CUBIT_FAILURE;

  if (CubitUndo::get_undo_enabled())
    CubitUndo::save_state();

  new_body = NULL;
  new_body = GeometryQueryTool::instance()->make_Body( new_body_sm );

  if( new_body )
  {
    if (CubitUndo::get_undo_enabled())
      CubitUndo::note_result_body(new_body);

    return CUBIT_SUCCESS;
  }
  else
  {
    if (CubitUndo::get_undo_enabled())
      CubitUndo::remove_last_undo();

    return CUBIT_FAILURE;
  }
}
CubitStatus GeometryModifyTool::create_solid_bodies_from_surfs ( DLIList< RefFace * > &  ref_face_list,
DLIList< Body * > &  new_bodies,
CubitBoolean  keep_old = CUBIT_FALSE,
CubitBoolean  heal = CUBIT_TRUE,
CubitBoolean  sheet = CUBIT_FALSE 
) const

Creates a body out of the specified surfaces.

Creates a body out of the surfaces in the ref_face_list. The surfaces can be either free surfaces or sheet bodies or both. The body should be healed. The bounding curves and vertices between the surfaces must be within tolerance.

Definition at line 10741 of file GeometryModifyTool.cpp.

{
    //First check to make sure the data is all here.
  for ( int ii = ref_face_list.size(); ii > 0; ii-- )
  {
    RefFace *ref_face = ref_face_list.get_and_step();
    DLIList<Body*> bodies;
    ref_face->bodies(bodies);
    if ( bodies.size() > 1 )
    {
      PRINT_ERROR("Can't create a volume with %s (surface %d) is attached to more\n"
                  "than one volume, or if the attached body is not a sheet body.\n",
                  ref_face->entity_name().c_str(),
                  ref_face->id());
      return CUBIT_FAILURE;
    }
    else if ( bodies.size() == 1 )
    {
      if (!bodies.get()->is_sheet_body())
      {
        PRINT_ERROR("Can't create a volume with %s (surface %d), it is\n"
                    "attached to a body that is not a sheet body.\n",
                    ref_face->entity_name().c_str(),
                    ref_face->id());
        return CUBIT_FAILURE;
      }
    }
  }

  DLIList<TopologyEntity*> entity_list(ref_face_list.size());
  DLIList<TopologyBridge*> bridge_list(ref_face_list.size());
  DLIList<Surface*>       surface_list(ref_face_list.size());
  GeometryModifyEngine* gme;

  CAST_LIST_TO_PARENT(ref_face_list, entity_list);
  gme = common_modify_engine(entity_list, bridge_list);
  CAST_LIST(bridge_list, surface_list, Surface);

  if (!gme) {
    PRINT_ERROR("Surfaces do not share a common modify engine.\n");
    return CUBIT_FAILURE;
  }

  DLIList<TopologyEntity*> query_output, query_input(ref_face_list.size());
  DLIList<Body*> body_list;

  CAST_LIST_TO_PARENT(ref_face_list, query_input);
  ModelQueryEngine::instance()->
    query_model( query_input, DagType::body_type(), query_output );
  CAST_LIST( query_output, body_list, Body );

  int i;
  DLIList<RefFace*> free_face_list;
  for ( i=ref_face_list.size(); i--; )
  {
    RefFace* ref_face = ref_face_list.get_and_step();
    query_output.clean_out();
    ModelQueryEngine::instance()->
      query_model( *ref_face, DagType::body_type(), query_output );
    if (!query_output.size())
      free_face_list.append(ref_face);
  }

  if (CubitUndo::get_undo_enabled())
    CubitUndo::save_state_with_cubit_file(ref_face_list);

  //get all the bodysm's
  DLIList<BodySM*> old_body_sm_list;
  for( i=body_list.size(); i--; )
  {
    Body *tmp_body = body_list.get_and_step();
    TopologyBridge *tb = tmp_body->bridge_manager()->topology_bridge();
    BodySM *tmp_body_sm = CAST_TO(tb, BodySM);
    if( tmp_body_sm )
      old_body_sm_list.append( tmp_body_sm );
  }

  // TODO: do I need a clear and a flush here? --KGM
  GeometryModifyTool::instance()->do_attribute_setup();
  GeometryModifyTool::instance()->push_attributes_before_modify(old_body_sm_list);

  DLIList<BodySM*> new_bodies_sm;
  CubitStatus stat = gme->create_solid_bodies_from_surfs( surface_list, new_bodies_sm, keep_old, heal, sheet );
  DLIList<BodySM*> body_sm_list;
  for ( i=new_bodies_sm.size(); i--; )
    body_sm_list.append( new_bodies_sm.get_and_step() );

  GeometryModifyTool::instance()->restore_vg_after_modify(new_bodies_sm, body_list, gme);
  GeometryModifyTool::instance()->remove_pushed_attributes(new_bodies_sm, body_list);

  if (!finish_sm_op( body_list, body_sm_list, new_bodies))
  {
    stat = CUBIT_FAILURE;
    if (CubitUndo::get_undo_enabled())
      CubitUndo::remove_last_undo();
  }
  else
  {
    if (CubitUndo::get_undo_enabled())
      CubitUndo::note_result_bodies(new_bodies);
  }

  GeometryModifyTool::instance()->do_attribute_cleanup();

  DLIList<int> id_list (free_face_list.size());
  while (free_face_list.size())
  {
    RefFace* ref_face = free_face_list.pop();
    if (!ref_face->get_surface_ptr())
    {
      id_list.append(ref_face->id());
      GeometryQueryTool::instance()->
        destroy_dead_entity( ref_face );
    }
  }

  GeometryQueryTool::instance()->cleanout_deactivated_geometry();
  if (id_list.size())
    CubitUtil::list_entity_ids( "Destroyed surface(s) ", id_list );

  //new_body = new_body_list.size() ? new_body_list.get() : 0;
  return stat;
}
CubitStatus GeometryModifyTool::create_surface ( DLIList< CubitVector * > &  vec_list,
Body *&  new_body,
RefFace ref_face_ptr,
CubitBoolean  project_points 
)

Fits an analytic spline surface through positions.

Fits an analytic spline surface through positions. If a surface is specified, positions are forced to lie on the surface and restrains the resultant surface geometry to match the surface's geometry. The project parameter will project the nodes or vertices to the specified surface.

Definition at line 18211 of file GeometryModifyTool.cpp.

{
   GeometryModifyEngine* GMEPtr = gmeList.get();
   if( ref_face_ptr )
   {
     if( GMEPtr != get_engine(ref_face_ptr) )
     {
       PRINT_ERROR("Geometry engine of Surface %d is not the active geometry engine.\n", ref_face_ptr->id() );
       PRINT_INFO("      Use command \"Set Geometry Engine ...\" to set to correct engine.\n");
       return CUBIT_FAILURE;
     }
   }
   BodySM* body_sm = NULL;
   Surface *project_to_surface = NULL;
   if( ref_face_ptr )
     project_to_surface = ref_face_ptr->get_surface_ptr();
   CubitStatus stat = GMEPtr->create_surface( vec_list, body_sm, project_to_surface, project_points );

   if( stat == CUBIT_FAILURE )
     return stat;

   if (CubitUndo::get_undo_enabled())
     CubitUndo::save_state();

   if( body_sm )
     new_body = GeometryQueryTool::instance()->make_Body(body_sm);

   if (new_body)
   {
     if (CubitUndo::get_undo_enabled())
       CubitUndo::note_result_body(new_body);

     stat = CUBIT_SUCCESS;
   }
   else
   {
     if (CubitUndo::get_undo_enabled())
       CubitUndo::remove_last_undo();

     stat = CUBIT_FAILURE;
   }
   return stat;
}
CubitStatus GeometryModifyTool::create_surface ( DLIList< RefVertex * > &  vert_list,
Body *&  new_body,
RefFace on_surface = NULL 
)

Definition at line 18113 of file GeometryModifyTool.cpp.

{
   //determine which vertices are free and which are not...
   //copy ones that are not
   vert_list.reset();
   DLIList<TBPoint*> points;
   GeometryModifyEngine *GMEPtr = get_engine( vert_list.get()->get_point_ptr() );

   DLIList<RefVertex*> free_ref_vertices;
   int i;
   for( i=vert_list.size(); i--; )
   {
     RefVertex *tmp_vert = vert_list.get_and_step();

     if( tmp_vert->num_parent_ref_entities() == 0 )
       free_ref_vertices.append( tmp_vert );

     TBPoint *tmp_point = tmp_vert->get_point_ptr();
     if( GMEPtr != get_engine( tmp_point ) )
     {
       PRINT_INFO("Vertices are not from same modeling engine.\n");
       return CUBIT_FAILURE;
     }

     if( tmp_vert->get_parents() == 0 )
     {
       points.append( tmp_point );
     }
     else
     {
       TBPoint *new_point = GMEPtr->make_Point( tmp_vert->coordinates() );
       points.append( new_point );
     }
   }

   if( on_surface )
   {
     if( GMEPtr != get_engine( on_surface->get_surface_ptr() ) )
     {
       PRINT_INFO("Surface and Vertices are not from same modeling engine.\n");
       return CUBIT_FAILURE;
     }
   }

   if(CubitUndo::get_undo_enabled())
   {
     if( free_ref_vertices.size() )
       CubitUndo::save_state_with_cubit_file( free_ref_vertices );
     else
       CubitUndo::save_state();
   }


   BodySM* body_sm = NULL;
   Surface *on_surf = NULL;

   if( on_surface )
     on_surf = on_surface->get_surface_ptr();

   CubitStatus stat = GMEPtr->create_surface( points, body_sm, on_surf );

   if( stat == CUBIT_FAILURE )
   {
     if (CubitUndo::get_undo_enabled())
       CubitUndo::remove_last_undo();
     return stat;
   }

   if( body_sm )
     new_body = GeometryQueryTool::instance()->make_Body(body_sm);

   if (new_body)
   {
     if (CubitUndo::get_undo_enabled())
       CubitUndo::note_result_body(new_body);

     stat = CUBIT_SUCCESS;
   }
   else
   {
     if (CubitUndo::get_undo_enabled())
       CubitUndo::remove_last_undo();

     stat = CUBIT_FAILURE;
   }

   for( i=free_ref_vertices.size(); i--; )
   {
     RefVertex *free_vertex = free_ref_vertices.get_and_step();
     AppUtil::instance()->send_event(GeometryEvent(GeometryEvent::TOP_LEVEL_ENTITY_DESTRUCTED, free_vertex));
     CGMHistory::Event evt(CGMHistory::TOP_LEVEL_ENTITY_DELETED, free_vertex );
     GeometryQueryTool::instance()->history().add_event(evt);
   }

   return stat;
}
CubitStatus GeometryModifyTool::create_surface_curve ( DLIList< RefEntity * >  curve_entity,
DLIList< RefEntity * >  target_entity,
CubitVector  sweep_direction = CubitVector(0, 0, 0),
CubitBoolean  distance_flag = CUBIT_FALSE 
)
CubitStatus GeometryModifyTool::create_surface_doubler ( DLIList< RefEntity * >  doubler_entity,
DLIList< RefEntity * >  target_entity,
DLIList< Body * > &  body_list_out,
CubitBoolean  internal_flg = CUBIT_FALSE,
CubitBoolean  extend_flg = CUBIT_TRUE,
CubitPlane limit_plane = NULL,
CubitVector  sweep_direction = CubitVector(0,0,0),
CubitBoolean  preview = CUBIT_FALSE 
)

Definition at line 13328 of file GeometryModifyTool.cpp.

{
    //need to switch the DLIList<RefEntity> to a DLIList<RefFace>
    DLIList<RefFace*> doubler_face;
    DLIList<RefFace*> target_face;
    CAST_LIST( doubler_entity, doubler_face, RefFace);
    CAST_LIST( target_entity, target_face, RefFace);

  bool enable_undo = CubitUndo::get_undo_enabled() && preview == CUBIT_FALSE;
  if(enable_undo)
  {
    CubitUndo::save_state_with_cubit_file(doubler_face);
  }

    DLIList <Surface*> doubler_surface;
    DLIList <Surface*> target_surface;
    DLIList <Body*> old_body_list;
    DLIList<RefFace*> tweak_face;
    DLIList<Surface*> tweak_surface;
    tweak_face+=doubler_face;
    tweak_face+=target_face;
    GeometryModifyEngine* gme_ptr;
    int ii=0, i=0;

    gme_ptr = tweak_setup(tweak_face,"doubler",old_body_list,tweak_surface);
    int z;
    for(z=0;z<doubler_face.size();z++)
    {
        doubler_surface.append(tweak_surface[z]);
    }
  for(z=doubler_face.size();z<tweak_face.size();z++)
    {
        target_surface.append(tweak_surface[z]);
    }

    DLIList<BodySM*> all_kept_bodies;
    DLIList<BodySM*> body_convert;
    DLIList<Surface*> copied_doubler_surface;
    DLIList <BodySM*> tweak_target_bodySM;

    for(z=0;z<doubler_surface.size();z++)
    {
        copied_doubler_surface.append(gme_ptr->make_Surface(doubler_surface[z]));
        body_convert.append(copied_doubler_surface[z]->bodysm());
    }

    //each workflow is dependent on whether or not a sweep_direction is specified
    if(sweep_direction == CubitVector(0,0,0))
    {
        DLIList<BodySM*> united_bodies;
        DLIList<BodySM*> separate_bodies;
        //this section takes all the doublers, unites them, and then splits them.  If only one body
        //then skip the aforementioned two steps.
        if(doubler_surface.size()==1)
        {
            separate_bodies=body_convert;
        }
        else
        {
            if(gme_ptr->unite(body_convert,united_bodies) == CUBIT_FAILURE || united_bodies.size()==0 )
            {
                PRINT_ERROR( "Command failed at unite command\n" );

        if(enable_undo)
          CubitUndo::remove_last_undo();

                return CUBIT_FAILURE;
            }

            if(gme_ptr->split_body(united_bodies[0],separate_bodies) == CUBIT_FAILURE || separate_bodies.size()==0)
            {
                PRINT_ERROR( "Command failed at separate command\n" );

        if(enable_undo)
          CubitUndo::remove_last_undo();

                return CUBIT_FAILURE;
            }
        }
        for(z=0; z<separate_bodies.size();z++)
        {
            DLIList<Surface*> body_surface;
            separate_bodies[z]->surfaces(body_surface);

            DLIList<CubitVector> doubler_surface_center_points;
            int d=0;
            for(d=0;d<body_surface.size();d++)
            {
                doubler_surface_center_points.append(body_surface[d]->bounding_box().center());
            }
            CubitVector doubler_normal,doubler_center_pt,doubler_to_target_vector,target_center_pt;
            double extrude_distance = 0.0;

            //make sure that the normal of the surface is pointing towards the target surface
            //the thicken command thickens in the direction of the surface normal, normals are checked using dot product check
            CubitVector center_pt = body_surface[0]->bounding_box().center();
            body_surface[0]->closest_point(center_pt,&doubler_center_pt,&doubler_normal);
            //adding this for loop because of l bracket doublers may have the first target surface perpendicular to an opposite side doubler surface
            //resulting in the code erroneously failing
            double dot=0.0;
            int mm;
            for(mm=0; mm<target_surface.size();mm++)
            {
                target_surface[mm]->closest_point_trimmed(doubler_center_pt, target_center_pt);
                doubler_to_target_vector = target_center_pt - doubler_center_pt;
                dot = doubler_to_target_vector.x()*doubler_normal.x()+doubler_to_target_vector.y()*doubler_normal.y()+doubler_to_target_vector.z()*doubler_normal.z();
                if(fabs(dot)>1E-6)
                {
                    mm=target_surface.size();
                }
            }
            if(fabs(dot)<1E-6)
            {
                PRINT_ERROR( "Doubler and target surface are touching or are perpendicular to each other\n" );
                for(ii =0;ii<separate_bodies.size();ii++)
                {
                    GeometryQueryEngine* gqe = separate_bodies[ii]->get_geometry_query_engine();
                    gqe->delete_solid_model_entities(separate_bodies[ii]);
                }

                if(enable_undo)
                  CubitUndo::remove_last_undo();

                return CUBIT_FAILURE;
            }
            else if(dot < 0)
            {
                if(gme_ptr->reverse_body(separate_bodies[z])==CUBIT_FAILURE)
                {
                    PRINT_ERROR( "Command failed at reverse body command.\n" );
                    for(ii =0;ii<separate_bodies.size();ii++)
                    {
                        GeometryQueryEngine* gqe = separate_bodies[ii]->get_geometry_query_engine();
                        gqe->delete_solid_model_entities(separate_bodies[ii]);
                    }

                    if(enable_undo)
                      CubitUndo::remove_last_undo();

                    return CUBIT_FAILURE;
                }
                extrude_distance = 0.0001;
            }
            else
            {
                extrude_distance = 0.0001;
            }

            DLIList<BodySM*> thickened_doubler_bodySM;
            DLIList<BodySM*> current_body;
            current_body.append(separate_bodies[z]);

            if(gme_ptr->thicken(current_body,thickened_doubler_bodySM,extrude_distance,CUBIT_FALSE) == CUBIT_FAILURE || thickened_doubler_bodySM.size()==0)
            {
                PRINT_ERROR( "Command failed at thicken command, this may be due to using a non-OCC geometry engine\n" );
                for(ii =0;ii<separate_bodies.size();ii++)
                {
                    GeometryQueryEngine* gqe = separate_bodies[ii]->get_geometry_query_engine();
                    gqe->delete_solid_model_entities(separate_bodies[ii]);
                }

                if(enable_undo)
                  CubitUndo::remove_last_undo();

                return CUBIT_FAILURE;
            }

            //need to grab the newly created surface opposite the user selected one from the thicken function to carry it through for the tweak target
            DLIList<Surface*> thicken_surfaces;
            thickened_doubler_bodySM[0]->surfaces(thicken_surfaces);
            DLIList <Surface*> post_thicken_doublers;

            int y=0;
            for(y=0;y<doubler_surface_center_points.size();y++)
            {
                doubler_center_pt = doubler_surface_center_points[y];
                int r=0;
                for(r=0;r<thicken_surfaces.size();r++)
                {
                    CubitVector test_center_pt = thicken_surfaces[r]->bounding_box().center();
                    if((test_center_pt-doubler_center_pt).length()<=.000001)
                    {
                        post_thicken_doublers.append(thicken_surfaces[r]);
                    }
                }
            }

            DLIList <LoopSM*> doubler_loopSM_list;
            DLIList <Curve*> doubler_external_curves;
            Curve* test_external_curves1 = NULL;
            Curve* test_external_curves2 = NULL;

            //need to do this in order to grab all curves, not just external IMPORTANT:THIS HAS TO BE DONE BEFORE THE tweak? COMMAND!
            for(y=0;y<post_thicken_doublers.size();y++)
            {
                post_thicken_doublers[y]->loopsms(doubler_loopSM_list);
            }
            for(i=0;i<doubler_loopSM_list.size();i++)
            {
                doubler_loopSM_list[i]->curves(doubler_external_curves);
            }

            doubler_loopSM_list.clean_out();
            tweak_target_bodySM.clean_out();
            DLIList <LoopSM*> test_loopSM_list;
            DLIList <Curve*> thicken_external_curves;
            DLIList <Surface*> tweak_target_surface = thicken_surfaces;

            //stepping through the surfaces from the thicken body
            for(i=0; i < thicken_surfaces.size(); i++)
            {
                thicken_surfaces[i]->loopsms(test_loopSM_list);
                //grabbing the external curves from the current thicken_surface
                test_loopSM_list[0]->curves(thicken_external_curves);
                test_loopSM_list.clean_out();
                int j=0;
                for(j=0;j<thicken_external_curves.size();j++)
                {
                    //step through the first curve
                    test_external_curves1 = thicken_external_curves[j];
                    int k=0;
                    for(k=0; k<doubler_external_curves.size();k++)
                    {
                        //while stepping through the doubler plate curves, compare them to the test_test_surface curves
                        test_external_curves2 = doubler_external_curves[k];

                        //if the two are equal, they are touching the doulber and therefore are either the side surfaces or the doubler
                        if(test_external_curves2 == test_external_curves1)
                        {
                            //remove the surface from the tweak_target_surface list
                            tweak_target_surface.remove_all_with_value(thicken_surfaces[i]);
                            break;
                        }
                    }
                    if(test_external_curves2 == test_external_curves1)
                    {
                        break;
                    }

                }
                thicken_external_curves.clean_out();
            }

            //pass the found opposite surface into the tweak_target routine
            if(gme_ptr->tweak_target(tweak_target_surface,target_surface,tweak_target_bodySM,extend_flg,limit_plane) == CUBIT_FAILURE || tweak_target_bodySM.size()==0)
            {
                PRINT_ERROR( "Command failed at Tweak_Target routine\n" );
                for(ii =0;ii<thickened_doubler_bodySM.size();ii++)
                {
                    GeometryQueryEngine* gqe = thickened_doubler_bodySM[ii]->get_geometry_query_engine();
                    gqe->delete_solid_model_entities(thickened_doubler_bodySM[ii]);
                }

                if(enable_undo)
                  CubitUndo::remove_last_undo();

                return CUBIT_FAILURE;
            }

            //fill out a tweak_body_surface list from tweak_target routine
            DLIList<Surface*> tweak_body_surfaces;
            tweak_target_bodySM[0]->surfaces(tweak_body_surfaces);
            DLIList <Curve*> tweak_external_curves;
            doubler_external_curves.clean_out();

            //refilling DLIList's as needed based on internal_flg
            //if we are not keeping internal surfaces we do not want it's curves in the doubler_external_curves list
            //otherwise if we are, we do want the curves in the list for the following sections for loop
            if(internal_flg==CUBIT_FALSE)
            {
                int j=0;
                for(i=0;i<post_thicken_doublers.size();i++)
                {
                    post_thicken_doublers[i]->loopsms(doubler_loopSM_list);
                    for(j=0;j<doubler_loopSM_list.size();j++)
                    {
                      LoopType loop_type = doubler_loopSM_list[j]->loop_type();
                      if(loop_type == LOOP_TYPE_EXTERNAL ||
                         loop_type == LOOP_TYPE_U_PERIODIC ||
                         loop_type == LOOP_TYPE_V_PERIODIC)
                      {
                          doubler_loopSM_list[j]->curves(doubler_external_curves);
                          break;
                      }
                    }
                    doubler_loopSM_list.clean_out();
                }
            }
            else
            {
                for(i=0;i<post_thicken_doublers.size();i++)
                {
                    post_thicken_doublers[i]->loopsms(doubler_loopSM_list);
                }
                for(i=0;i<doubler_loopSM_list.size();i++)
                {
                    doubler_loopSM_list[i]->curves(doubler_external_curves);
                }

            }

            DLIList <Surface*> surfaces_to_keep;
            for(i=0;i<tweak_body_surfaces.size();i++)
            {
                tweak_body_surfaces[i]->loopsms(test_loopSM_list);

                if(test_loopSM_list.size()==0)
                {
                    PRINT_ERROR( "Command failed to find any doubler drop down curves\n" );
                    for(ii =0;ii<thickened_doubler_bodySM.size();ii++)
                    {
                        GeometryQueryEngine* gqe = thickened_doubler_bodySM[ii]->get_geometry_query_engine();
                        gqe->delete_solid_model_entities(thickened_doubler_bodySM[ii]);
                    }

                    if(enable_undo)
                      CubitUndo::remove_last_undo();

                    return CUBIT_FAILURE;
                }

                test_loopSM_list[0]->curves(tweak_external_curves);
                test_loopSM_list.clean_out();

                int j=0;
                for(j=0;j<tweak_external_curves.size();j++)
                {
                    test_external_curves1 = tweak_external_curves[j];

                    int k=0;
                    for(k=0; k<doubler_external_curves.size();k++)
                    {
                        //while stepping through the doubler plate curves, compare them to the test_loop_list
                        test_external_curves2 = doubler_external_curves[k];

                        if(test_external_curves2 == test_external_curves1)
                        {
                            surfaces_to_keep.append(tweak_body_surfaces[i]);
                            break;
                        }
                    }
                    if(test_external_curves2 == test_external_curves1)
                    {
                        break;
                    }
                }
                tweak_external_curves.clean_out();
            }

            if(surfaces_to_keep.size()==0)
            {
                PRINT_ERROR( "Failed to find and keep surfaces\n" );
                for(ii =0;ii<tweak_target_bodySM.size();ii++)
                {
                    GeometryQueryEngine* gqe = tweak_target_bodySM[ii]->get_geometry_query_engine();
                    gqe->delete_solid_model_entities(tweak_target_bodySM[ii]);
                }

                if(enable_undo)
                  CubitUndo::remove_last_undo();

                return CUBIT_FAILURE;
            }

            //do this to remove the copied_doubler_surface since we no longer need the surface anymore
            int c=0;
            for(c=0;c<post_thicken_doublers.size();c++)
            {
                surfaces_to_keep.remove_all_with_value(post_thicken_doublers[c]);
            }

            DLIList <Surface*> surfaces_to_remove = tweak_body_surfaces;
            surfaces_to_remove -= surfaces_to_keep;
            DLIList<BodySM*> resulting_bodies;

            //remove all surfaces in the surfaces_to_remove list
            if(gme_ptr->tweak_remove(surfaces_to_remove,resulting_bodies,CUBIT_FALSE) == CUBIT_FAILURE || resulting_bodies.size()==0)
            {
                PRINT_ERROR( "Command failed at Tweak_Remove routine\n" );
                for(ii =0;ii<tweak_target_bodySM.size();ii++)
                {
                    GeometryQueryEngine* gqe = tweak_target_bodySM[ii]->get_geometry_query_engine();
                    gqe->delete_solid_model_entities(tweak_target_bodySM[ii]);
                }

                if(enable_undo)
                  CubitUndo::remove_last_undo();

                return CUBIT_FAILURE;
            }
            all_kept_bodies+=resulting_bodies;
        }
    }
    else
    {
        DLIList<BodySM*> swept_bodies;
        DLIList<BodySM*> swept_doubler_bodySM;

        //take the copied_doubler_surface and extrude it along the sweep_direction to create a body
        for(z=0;z<copied_doubler_surface.size();z++)
        {
            DLIList<GeometryEntity*> DLIList_copied_doubler_surface;
            DLIList_copied_doubler_surface.append(copied_doubler_surface[z]);
            if(gme_ptr->sweep_translational(DLIList_copied_doubler_surface,swept_doubler_bodySM,sweep_direction*0.0001,0.0,0,CUBIT_FALSE,CUBIT_FALSE) == CUBIT_FAILURE || swept_doubler_bodySM.size()==0)
            {
                PRINT_ERROR( "Command failed at sweep->extrude command\n" );
                for(ii =0;ii<body_convert.size();ii++)
                {
                    GeometryQueryEngine* gqe = body_convert[ii]->get_geometry_query_engine();
                    gqe->delete_solid_model_entities(body_convert[ii]);
                }

                if(enable_undo)
                  CubitUndo::remove_last_undo();

                return CUBIT_FAILURE;
            }
            swept_bodies+=swept_doubler_bodySM;
            swept_doubler_bodySM.clean_out();
        }

        DLIList<BodySM*> united_bodies;
        DLIList<BodySM*> separate_bodies;
        //if more than one body, unite and split the newly created bodies, if only one body skip this step
        //as the unite will fail
        if(swept_bodies.size()==1)
        {
            separate_bodies=swept_bodies;
        }
        else
        {
            if(gme_ptr->unite(swept_bodies,united_bodies) == CUBIT_FAILURE || united_bodies.size()==0 )
            {
                PRINT_ERROR( "Command failed at unite command\n" );

        if(enable_undo)
          CubitUndo::remove_last_undo();

                return CUBIT_FAILURE;
            }

            if(gme_ptr->split_body(united_bodies[0],separate_bodies) == CUBIT_FAILURE || separate_bodies.size()==0)
            {
                PRINT_ERROR( "Command failed at separate command\n" );

        if(enable_undo)
          CubitUndo::remove_last_undo();

                return CUBIT_FAILURE;
            }
        }

        //create another copy of copied_doubler_surface since copied_doubler_surface is going to be manipulated
        DLIList<Surface*> temp_copied_doubler_surface=copied_doubler_surface;
        for(z=0;z<separate_bodies.size();z++)
        {
            //need to grab the newly created surface opposite the user selected one from the thicken function to carry it through for the tweak target
            //this will need to be changed to a for loop to account for multiple thickened bodies if we impliment multiple doubler surfaces
            DLIList<Surface*> thicken_surfaces;
            separate_bodies[z]->surfaces(thicken_surfaces);

            //initializing a lot of variables to be used in the next few steps
            DLIList<Surface*> master_surface_remove_list;
            DLIList <Curve*> thicken_external_curves;
            DLIList<Surface*> tweak_target_surface;
            DLIList<Surface*> surfaces_to_remove;

            //using a centerpoint of the surfaces, I want to find out which surface from the recently swept bodies corresponds to the surface of the body closest the target
            //this has to be done because sweep_translational moves the source surface.  Thicken on the otherhand does and doesn't based on number of surfaces being thickened.
            int y=0;
            for(y=0;y<temp_copied_doubler_surface.size();y++)
            {
                CubitVector doubler_center_pt = temp_copied_doubler_surface[y]->bounding_box().center();
                int r=0;
                for(r=0;r<thicken_surfaces.size();r++)
                {
                    CubitVector test_center_pt = thicken_surfaces[r]->bounding_box().center();
                    if((test_center_pt-doubler_center_pt).length()<=.000001)
                    {
                        tweak_target_surface.append(thicken_surfaces[r]);
                        surfaces_to_remove.append(temp_copied_doubler_surface[y]);
                    }
                }
            }
            //remove the manipulated surfaces from the temp_copied_doubler_surface list
            temp_copied_doubler_surface-=surfaces_to_remove;
            surfaces_to_remove.clean_out();

            //grab all the curves of the doubler
            DLIList <Curve*> doubler_external_curves;
            DLIList <LoopSM*> doubler_loopSM_list;
            for(y=0;y<tweak_target_surface.size();y++)
            {
                tweak_target_surface[y]->loopsms(doubler_loopSM_list);
            }

            for(i=0;i<doubler_loopSM_list.size();i++)
            {
                doubler_loopSM_list[i]->curves(doubler_external_curves);
            }

            DLIList <Surface*> doubler_surface_for_this_body = thicken_surfaces;
            Curve* test_external_curves1 = NULL;
            Curve* test_external_curves2 = NULL;
            DLIList <LoopSM*> test_loopSM_list;

            for(i=0; i < thicken_surfaces.size(); i++)
            {
                //step through the thickened bodies surfaces
                thicken_surfaces[i]->loopsms(test_loopSM_list);
                //grabbing the external curve loop from the face and making it a DLIList <RefEdge*>
                test_loopSM_list[0]->curves(thicken_external_curves);

                int j=0;
                for(j=0;j<thicken_external_curves.size();j++)
                {
                    //step through the loop list
                    test_external_curves1 = thicken_external_curves[j];

                    int k=0;
                    for(k=0; k<doubler_external_curves.size();k++)
                    {
                        //while stepping through the doubler plate curves, compare them to the test_loop_list
                        test_external_curves2 = doubler_external_curves[k];

                        if(test_external_curves2 == test_external_curves1)
                        {
                            doubler_surface_for_this_body.remove_all_with_value(thicken_surfaces[i]);
                            break;
                        }
                    }
                    if(test_external_curves2 == test_external_curves1)
                    {
                        break;
                    }
                }

                thicken_external_curves.clean_out();
                thicken_external_curves.reset();
                test_loopSM_list.clean_out();
            }

            //DLIList <BodySM*> tweak_target_bodySM
            tweak_target_bodySM.clean_out();
            if(gme_ptr->tweak_target(tweak_target_surface,target_surface,tweak_target_bodySM,extend_flg,limit_plane) == CUBIT_FAILURE || tweak_target_bodySM.size()==0)
            {
                PRINT_ERROR( "Command failed at Tweak_Target routine\n" );
                for(ii =0;ii<body_convert.size();ii++)
                {
                    GeometryQueryEngine* gqe = body_convert[ii]->get_geometry_query_engine();
                    gqe->delete_solid_model_entities(body_convert[ii]);
                }

                if(enable_undo)
                  CubitUndo::remove_last_undo();

                return CUBIT_FAILURE;
            }

            //make note of the doubler_surface and add it to the delete list
            master_surface_remove_list+=doubler_surface_for_this_body;

            //clean out these DLIList's as they will be used later on
            doubler_loopSM_list.clean_out();
            doubler_external_curves.clean_out();

            //refilling DLIList's as needed based on internal_flg
            //basically if surfaces share a curve, that surface will be kept so if you don't want the internal surfaces
            //create the list without the internal curves and they'll be removed
            if(internal_flg==CUBIT_FALSE)
            {
                int j=0;
                for(i=0;i<doubler_surface_for_this_body.size();i++)
                {
                    doubler_surface_for_this_body[i]->loopsms(doubler_loopSM_list);
                    for(j=0;j<doubler_loopSM_list.size();j++)
                    {
                      LoopType loop_type = doubler_loopSM_list[j]->loop_type();
                      if(loop_type == LOOP_TYPE_EXTERNAL ||
                         loop_type == LOOP_TYPE_U_PERIODIC ||
                         loop_type == LOOP_TYPE_V_PERIODIC)
                      {
                          doubler_loopSM_list[j]->curves(doubler_external_curves);
                          break;
                      }

                    }
                    doubler_loopSM_list.clean_out();
                }
            }
            else
            {
                for(i=0;i<doubler_surface_for_this_body.size();i++)
                {
                    doubler_surface_for_this_body[i]->loopsms(doubler_loopSM_list);
                }
                for(i=0;i<doubler_loopSM_list.size();i++)
                {
                    doubler_loopSM_list[i]->curves(doubler_external_curves);
                }
            }

            //recreate the thicken_surfaces list based now on the bodies after the tweak_target command
            thicken_surfaces.clean_out();
            tweak_target_bodySM[0]->surfaces(thicken_surfaces);

            DLIList <Surface*> surfaces_to_keep;
            surfaces_to_remove = thicken_surfaces;
            DLIList <Curve*> tweak_external_curves;

            for(i=0;i<thicken_surfaces.size();i++)
            {
                thicken_surfaces[i]->loopsms(test_loopSM_list);
                //grabs the external curves from face
                test_loopSM_list[0]->curves(tweak_external_curves);

                int j=0;
                for(j=0;j<tweak_external_curves.size();j++)
                {
                    //step through the loop list
                    test_external_curves1 = tweak_external_curves[j];

                    int k=0;
                    for(k=0; k<doubler_external_curves.size();k++)
                    {
                        //while stepping through the doubler plate curves, compare them to the test_loop_list
                        test_external_curves2 = doubler_external_curves[k];

                        if(test_external_curves2 == test_external_curves1)
                        {
                            surfaces_to_keep.append(thicken_surfaces[i]);
                            break;
                        }
                    }
                    if(test_external_curves2 == test_external_curves1)
                    {
                        break;
                    }
                }
                test_loopSM_list.clean_out();
                tweak_external_curves.clean_out();
            }

            if(surfaces_to_keep.size()==0)
            {
                PRINT_ERROR( "Failed to find and keep tweak_target surfaces\n" );
                for(ii =0;ii<tweak_target_bodySM.size();ii++)
                {
                    GeometryQueryEngine* gqe = tweak_target_bodySM[ii]->get_geometry_query_engine();
                    gqe->delete_solid_model_entities(tweak_target_bodySM[ii]);
                }

        if(enable_undo)
          CubitUndo::remove_last_undo();

                return CUBIT_FAILURE;
            }

            //subtract surfaces
            surfaces_to_remove -= surfaces_to_keep;
            master_surface_remove_list+=surfaces_to_remove;

            DLIList<BodySM*> resulting_bodies;

            if(gme_ptr->tweak_remove(master_surface_remove_list,resulting_bodies,CUBIT_FALSE) == CUBIT_FAILURE || resulting_bodies.size()==0)
            {
                PRINT_ERROR( "Command failed at Tweak_Remove routine\n" );
                for(ii =0;ii<tweak_target_bodySM.size();ii++)
                {
                    GeometryQueryEngine* gqe = tweak_target_bodySM[ii]->get_geometry_query_engine();
                    gqe->delete_solid_model_entities(tweak_target_bodySM[ii]);
                }

        if(enable_undo)
          CubitUndo::remove_last_undo();

                return CUBIT_FAILURE;
            }

            //all_kept_bodies is a list of bodies that will eventually be passed into finish_sm_op at the end
            all_kept_bodies+=resulting_bodies;
        }
    }

    if(preview==CUBIT_FALSE)
    {
        DLIList<BodySM*> bodies_to_unite;
        //check to see if their is only one body.  If only one body skip over the unite and split because
        //the unite command will fail (there is a check at the beginning to return cubit_failure)
        //append the original doubler surfaces to the resulting body list

        for(i=0;i<doubler_surface.size();i++)
        {
            all_kept_bodies.insert_first(doubler_surface[i]->bodysm());
        }
        if(all_kept_bodies.size()!=1)
        {
            if(gme_ptr->unite(all_kept_bodies,bodies_to_unite) == CUBIT_FAILURE || bodies_to_unite.size()==0 )
            {
                PRINT_ERROR( "Command failed at unite command\n" );

                if(enable_undo)
                  CubitUndo::remove_last_undo();

                return CUBIT_FAILURE;
            }
            all_kept_bodies.clean_out();
            if(gme_ptr->split_body(bodies_to_unite[0],all_kept_bodies) == CUBIT_FAILURE || all_kept_bodies.size()==0)
            {
                PRINT_ERROR( "Command failed at separate command\n" );

                if(enable_undo)
                  CubitUndo::remove_last_undo();

                return CUBIT_FAILURE;
            }
        }
        else
        {
                PRINT_WARNING( "Command may have failed at finding doubler surface(s) and appending them to the drop-down surfaces\n" );

                if(enable_undo)
                  CubitUndo::remove_last_undo();

                return CUBIT_FAILURE;
        }

        //update DAG
        CubitStatus stat;
        stat = finish_sm_op( old_body_list, all_kept_bodies ,body_list_out );
    if (CUBIT_SUCCESS != stat) {
      PRINT_ERROR("GeometryModifyTool::finish_sm_op failed.\n");
      return stat;
    }
    if(enable_undo)
      CubitUndo::note_result_bodies(body_list_out);

        return CUBIT_SUCCESS;
    }
    else
    {
        DLIList<Curve*> kept_curves;
        for(i =0;i<all_kept_bodies.size();i++)
        {
            all_kept_bodies[i]->curves(kept_curves);
        }

        GfxPreview::clear();

        for(i=0; i<kept_curves.size();i++)
        {
            CubitStatus result;
            GMem g_mem;

            // get the graphics
            result = kept_curves[i]->get_geometry_query_engine()->
                get_graphics( kept_curves[i], &g_mem );

            if (result==CUBIT_FAILURE || g_mem.pointListCount == 0)
            {
                PRINT_WARNING("Unable to preview a curve\n" );;
                double len = kept_curves[i]->
                    length_from_u(kept_curves[i]->start_param(),kept_curves[i]->end_param());

                PRINT_WARNING("Curve len: %f\n",len);
            }

            // Draw the polyline
            GfxPreview::draw_polyline( g_mem.point_list(), g_mem.pointListCount, CUBIT_BLUE_INDEX );
        }
        GfxPreview::flush();
        for(ii =0;ii<tweak_target_bodySM.size();ii++)
        {
            GeometryQueryEngine* gqe = tweak_target_bodySM[ii]->get_geometry_query_engine();
            gqe->delete_solid_model_entities(tweak_target_bodySM[ii]);
        }

        if(enable_undo)
          CubitUndo::note_result_bodies(body_list_out);

        return CUBIT_SUCCESS;
    }
}
CubitStatus GeometryModifyTool::create_weld_surface ( CubitVector root,
RefFace ref_face1,
double  leg1,
RefFace ref_face2,
double  leg2,
Body *&  new_body 
)

Creates a simple triangular weld surface.

Definition at line 18258 of file GeometryModifyTool.cpp.

{
    GeometryModifyEngine* GMEPtr;
    DLIList<RefFace*> ref_faces;
    ref_faces.append(ref_face1);
    ref_faces.append(ref_face2);
    DLIList<Surface*> surfaces;

    GMEPtr = common_modify_engine(ref_faces, surfaces);
    if (!GMEPtr)
    {
        PRINT_ERROR("Loft surfaces on volumes containing surfaces from different\n"
            "       geometry engines is not allowed.\n");
        return CUBIT_FAILURE;
    }

    if (CubitUndo::get_undo_enabled())
      CubitUndo::save_state();

    surfaces.reset();
    BodySM* new_body_sm = 0;
    CubitStatus result = GMEPtr->create_weld_surface(
        root,
        surfaces.get_and_step(),
        leg1,
        surfaces.get_and_step(),
        leg2,
        new_body_sm );

    if(result && new_body_sm)
    {
        new_body = GeometryQueryTool::instance()->make_Body(new_body_sm);
        if (new_body)
        {
          if (CubitUndo::get_undo_enabled())
            CubitUndo::note_result_body(new_body);
        }
        else
        {
          if (CubitUndo::get_undo_enabled())
            CubitUndo::remove_last_undo();
        }
    }
    return result;
}
Body * GeometryModifyTool::cylinder ( double  hi,
double  r1,
double  r2,
double  r3 
)

Creates a clyinder.

Creates an frustum and assigns it to a Body $ {hi} input height $ {r1} input radius in x-direction at base $ {r2} input radius in y-direction at base $ {r3} input radius in x-direction at top Returns the new Body or NULL

Definition at line 653 of file GeometryModifyTool.cpp.

{
   if (0 == gmeList.size())
   {
      PRINT_WARNING("No active geometry engine.\n");
      return NULL;
   }

     // First make sure that the input values make sense
   if ( hi <= GEOMETRY_RESABS || r1 <= GEOMETRY_RESABS ||
        r2 <= GEOMETRY_RESABS || r3 < 0.0 )
   {
      PRINT_ERROR("In GeometryModifyTool::cylinder\n"
                  " Cannot make a frustum of a cone with height = %f,"
                  " lower x-direction radius = %f,"
                  " lower y-direction radius = %f, and "
                  "top radius = %f\n"
                  "       All dimensions must be > 0.0\n",
                  hi, r1, r2, r3);
      return NULL;
   }

   if( CubitUndo::get_undo_enabled() )
     CubitUndo::save_state();

     // Create a Body that represents the prism
   BodySM* bodyPtr = gmeList.get()->cylinder( hi, r1, r2, r3);
   Body *new_body = NULL;

   if (bodyPtr == NULL)
   {
      PRINT_ERROR("In GeometryModifyTool::cylinder\n"
                  "       Problems building a volume from the conical frustum.\n");
   }
   else
     new_body = GeometryQueryTool::instance()->make_Body(bodyPtr);

  if( CubitUndo::get_undo_enabled() )
  {
    if( new_body )
      CubitUndo::note_result_body( new_body );
    else
      CubitUndo::remove_last_undo();
  }

   return new_body;
}

Definition at line 210 of file GeometryModifyTool.cpp.

{
  if( NULL != instance_ )
  {
    delete instance_;
    instance_ = NULL;
  }
}
CubitStatus GeometryModifyTool::discover_topology ( RefFace ref_face_ptr,
CubitVector pos,
double &  step_size,
int  num_subdivisions 
)

Beta function.

Definition at line 20629 of file GeometryModifyTool.cpp.

{
  CubitStatus ret = CUBIT_SUCCESS;

  CubitVector point_on_surf;
  surf->get_surface_ptr()->closest_point_trimmed(pos, point_on_surf);
  RefVolume *v = surf->ref_volume();
  CubitVector norm = surf->normal_at(point_on_surf, v);
  CubitVector march_dir = norm * CubitVector(1,0,0);
  if(march_dir.length() < .001)
  {
    march_dir = norm * CubitVector(0,1,0);
    if(march_dir.length() < .001)
    {
      march_dir = norm * CubitVector(0,0,1);
      if(march_dir.length() < .001)
      {
        PRINT_ERROR("Couldn't find a good march direction.\n");
        ret = CUBIT_FAILURE;
      }
    }
  }

  if(ret == CUBIT_SUCCESS)
  {
    int new_approach = 0;
    if(new_approach)
    {
      // Get initial 4 directions.
      march_dir.normalize();
      DLIList<CubitVector> march_directions;
      CubitVector v1 = march_dir;
      CubitVector v3 = -march_dir;
      CubitVector v2 = norm*march_dir;
      march_directions.append(v1);
      march_directions.append(v2);
      march_directions.append(v3);

      // Now subdivide directions further if requested.
      for(int i=0; i<num_subdivisions; ++i)
      {
        DLIList<CubitVector> tmp_list;
        int list_size = march_directions.size();
        for(int j=0; j<list_size-1; j++)
        {
          CubitVector dir1 = march_directions[j];
          CubitVector dir2 = march_directions[(j+1)%list_size];
          CubitVector mid = dir1 + dir2;
          mid.normalize();
          tmp_list.append(dir1);
          tmp_list.append(mid);
        }
        tmp_list.append(march_directions[list_size-1]);
        march_directions = tmp_list;
      }
      DLIList<DLIList<CubitVector> > horizontal_points, vertical_points;
      DLIList<RefFace*> horiz_ending_faces, vert_ending_faces;
      for(int i=0; i<march_directions.size()-1; i++)
      {
        DLIList<CubitVector> new_list;
        horizontal_points.append(new_list);
        vertical_points.append(new_list);
        march_using_planes(point_on_surf, surf, march_directions[i], step_size, horizontal_points[i], vertical_points[i]);
      }
    }
    else
    {
      // Get initial 4 directions.
      march_dir.normalize();
      DLIList<CubitVector> march_directions;
      CubitVector v1 = march_dir;
      CubitVector v3 = -march_dir;
      CubitVector v2 = norm*march_dir;
      CubitVector v4 = -v2;
      march_directions.append(v1);
      march_directions.append(v2);
      march_directions.append(v3);
      march_directions.append(v4);
      
      // Now subdivide directions further if requested.
      for(int i=0; i<num_subdivisions; ++i)
      {
        DLIList<CubitVector> tmp_list;
        int list_size = march_directions.size();
        for(int j=0; j<list_size; j++)
        {
          CubitVector dir1 = march_directions[j];
          CubitVector dir2 = march_directions[(j+1)%list_size];
          CubitVector mid = dir1 + dir2;
          mid.normalize();
          tmp_list.append(dir1);
          tmp_list.append(mid);
        }
        march_directions = tmp_list;
      }
      DLIList<DLIList<CubitVector> > horizontal_points, vertical_points;
      DLIList<RefFace*> horiz_ending_faces, vert_ending_faces;
      for(int i=0; i<march_directions.size(); i++)
      {
        DLIList<CubitVector> new_list;
        new_list.append(point_on_surf);
        horizontal_points.append(new_list);
        march_path_to_discover_horizontal(point_on_surf, norm, surf, march_directions[i], step_size, horizontal_points[i], horiz_ending_faces);
      }
      CubitVector new_dir = -norm;
      for(int i=0; i<march_directions.size(); i++)
      {
        CubitVector start_pos = horizontal_points[i].last_item();
        DLIList<CubitVector> new_list;
        new_list.append(start_pos);
        vertical_points.append(new_list);
        march_path_to_discover_vertical(start_pos, norm, horiz_ending_faces[i], new_dir, step_size, vertical_points[i], vert_ending_faces);
//        GfxDebug::draw_point(vertical_points[i].last_item(), CUBIT_GREEN_INDEX);
//        GfxDebug::flush();
      }
      
      // Draw lines traced out by marching directions
      for(int i=0; i<horizontal_points.size(); i++)
      {
        int size1 = horizontal_points[i].size();
        for(int j=0; j<size1-1; j++)
        {
          GfxDebug::draw_line(horizontal_points[i][j],
                              horizontal_points[i][j+1],
                              CUBIT_WHITE_INDEX);
        }
      }
      for(int i=0; i<vertical_points.size(); i++)
      {
        int size1 = vertical_points[i].size();
        for(int j=0; j<size1-1; j++)
        {
          GfxDebug::draw_line(vertical_points[i][j],
                              vertical_points[i][j+1],
                              CUBIT_YELLOW_INDEX);
        }
      }
      // Draw new topology
      int size1 = horizontal_points.size();
      for(int i=0; i<size1; i++)
      {
        GfxDebug::draw_line(horizontal_points[i].last_item(),
                            horizontal_points[(i+1)%size1].last_item(),
                            CUBIT_RED_INDEX);
      }
      size1 = vertical_points.size();
      for(int i=0; i<size1; i++)
      {
        GfxDebug::draw_line(vertical_points[i].last_item(),
                            vertical_points[(i+1)%size1].last_item(),
                            CUBIT_RED_INDEX);
      }
      GfxDebug::flush();
    }
  }

  return ret;
}
void GeometryModifyTool::do_attribute_cleanup ( void  ) [private]

Definition at line 3412 of file GeometryModifyTool.cpp.

{

  CGMApp::instance()->restore_previous_attribute_states();
}
void GeometryModifyTool::do_attribute_setup ( void  ) [private]

Definition at line 3365 of file GeometryModifyTool.cpp.

{
  //save attribute settings
  CGMApp::instance()->save_current_attribute_states();

  //Turn off all attributes
  CubitAttribManager *attrib_manager = CGMApp::instance()->attrib_manager();
  attrib_manager->set_all_auto_update_flags( CUBIT_FALSE );
  attrib_manager->set_all_auto_actuate_flags( CUBIT_FALSE );
  attrib_manager->set_all_auto_write_flags( CUBIT_FALSE );
  attrib_manager->set_all_auto_read_flags( CUBIT_FALSE );

  CGMApp::instance()->attrib_manager()->set_auto_update_flag(CA_ENTITY_NAME, CUBIT_TRUE);
  CGMApp::instance()->attrib_manager()->set_auto_actuate_flag(CA_ENTITY_NAME, CUBIT_TRUE);
  CGMApp::instance()->attrib_manager()->set_auto_write_flag(CA_ENTITY_NAME, CUBIT_TRUE);
  CGMApp::instance()->attrib_manager()->set_auto_read_flag(CA_ENTITY_NAME, CUBIT_TRUE);

  CGMApp::instance()->attrib_manager()->set_auto_update_flag(CA_MESH_OUTPUT_GROUP, CUBIT_TRUE);
  CGMApp::instance()->attrib_manager()->set_auto_actuate_flag(CA_MESH_OUTPUT_GROUP, CUBIT_TRUE);
  CGMApp::instance()->attrib_manager()->set_auto_write_flag(CA_MESH_OUTPUT_GROUP, CUBIT_TRUE);
  CGMApp::instance()->attrib_manager()->set_auto_read_flag(CA_MESH_OUTPUT_GROUP, CUBIT_TRUE);


  // enable update, actuate, write, read for composite attributes
  CGMApp::instance()->attrib_manager()->set_auto_update_flag(CA_COMPOSITE_VG, CUBIT_TRUE);
  CGMApp::instance()->attrib_manager()->set_auto_actuate_flag(CA_COMPOSITE_VG, CUBIT_TRUE);
  CGMApp::instance()->attrib_manager()->set_auto_write_flag(CA_COMPOSITE_VG, CUBIT_TRUE);
  CGMApp::instance()->attrib_manager()->set_auto_read_flag(CA_COMPOSITE_VG, CUBIT_TRUE);
  // enable update, actuate, write, read for partition attributes
  CGMApp::instance()->attrib_manager()->set_auto_update_flag(CA_PARTITION_VG, CUBIT_TRUE);
  CGMApp::instance()->attrib_manager()->set_auto_actuate_flag(CA_PARTITION_VG, CUBIT_TRUE);
  CGMApp::instance()->attrib_manager()->set_auto_write_flag(CA_PARTITION_VG, CUBIT_TRUE);
  CGMApp::instance()->attrib_manager()->set_auto_read_flag(CA_PARTITION_VG, CUBIT_TRUE);
  // enable update, actuate, write, read for entity ids
  // We will use these ID atts to make sure the ref entities associated with unmodified
  // virtual bridges will maintain the same ids after real operations.
  CGMApp::instance()->attrib_manager()->set_auto_update_flag(CA_ENTITY_ID, CUBIT_TRUE);
  CGMApp::instance()->attrib_manager()->set_auto_actuate_flag(CA_ENTITY_ID, CUBIT_TRUE);
  CGMApp::instance()->attrib_manager()->set_auto_write_flag(CA_ENTITY_ID, CUBIT_TRUE);
  CGMApp::instance()->attrib_manager()->set_auto_read_flag(CA_ENTITY_ID, CUBIT_TRUE);
  // enable metadata attributes
  CGMApp::instance()->attrib_manager()->set_auto_update_flag(CA_ASSEMBLY_DATA, CUBIT_TRUE);
  CGMApp::instance()->attrib_manager()->set_auto_actuate_flag(CA_ASSEMBLY_DATA, CUBIT_TRUE);
  CGMApp::instance()->attrib_manager()->set_auto_write_flag(CA_ASSEMBLY_DATA, CUBIT_TRUE);
  CGMApp::instance()->attrib_manager()->set_auto_read_flag(CA_ASSEMBLY_DATA, CUBIT_TRUE);
}
CubitStatus GeometryModifyTool::find_best_curves_to_merge ( DLIList< RefEdge * > *&  curves_from_curve1,
DLIList< RefEdge * > *&  curves_from_curve2,
RefEdge *&  curve1,
RefEdge *&  curve2 
) [private]

Definition at line 19119 of file GeometryModifyTool.cpp.

{
  /*
  for(int i=curves_from_curve1.size(); i>0; i--)
  {
     if found better curve than curve1 set curve1 to be this curve
  }
  for(int i=curves_from_curve2.size(); i>0; i--)
  {
     if found better curve than curve2 set curve2 to be this curve
  }
  */
  return CUBIT_SUCCESS;
}
CubitStatus GeometryModifyTool::find_overlap_region ( RefEdge c1,
RefEdge c2,
RefVertex v1,
RefVertex v2,
bool  forward_c1,
bool  forward_c2,
bool &  full_c1,
bool &  full_c2,
double &  c1_stop_param,
double &  c2_stop_param,
double  divergence_angle 
) [private]

Definition at line 19374 of file GeometryModifyTool.cpp.

{
  CubitStatus status = CUBIT_SUCCESS;
  double start_t, end_t, dt, cur_t;
  int num_segments = 20;
  double reverse_multiplier;
  double divergence_tol = cos(divergence_angle*CUBIT_PI/180.0);
  int i;

  if(forward_c1 != forward_c2)
    reverse_multiplier = -1.0;
  else
    reverse_multiplier = 1.0;

  // Start from the projection of v2 onto c1.
  CubitVector tmp_pos;
  c1->closest_point_trimmed(v2->coordinates(), tmp_pos);
  start_t = c1->u_from_position(tmp_pos);
  if(forward_c1)
  {
    end_t = c1->end_param();
    dt = (end_t-start_t)/(double)num_segments;
    cur_t = start_t + dt;
  }
  else
  {
    end_t = c1->start_param();
    dt = (end_t-start_t)/(double)num_segments;
    cur_t = start_t + dt;
  }
  // Check all of the interior points to see if the tangents
  // of the two curves are within tolerance.
  bool went_past_end_of_c2 = false;
  bool went_out_of_angle_tolerance = false;
  for(i=num_segments; i>0; i--)
//  for(i=num_segments-1; i>0; i--)
  {
    if(i==1)
    {
      cur_t = end_t;
    }
    // Evaluate curve 1.
    CubitVector vec1, vec2, tangent1, tangent2;
    c1->position_from_u(cur_t, vec1);
    c1->tangent(vec1, tangent1);
    tangent1.normalize();
    // Project the point to curve 2 and get the tangent.
    c2->closest_point_trimmed(vec1, vec2);
    c2->tangent(vec2, tangent2);
    tangent2.normalize();
    if(((tangent1 % tangent2) * reverse_multiplier) > divergence_tol)
    {
      CubitVector check_vec = vec2-vec1;
      double dot_val = 0.0;
      if(check_vec.length() > 1e-6)
      {
        check_vec.normalize();
        dot_val = check_vec % tangent2;
      }
      if(dot_val > .001 || dot_val < -.001)
      {
        went_past_end_of_c2 = true;
      }
      else
      {
        // If we made it to the end of curve 1 check to see
        // if the end of curve 2 is within some tolerance of
        // the endpoint of curve 1 and if so set the
        // full_c2 flag to true.
        if(i==1)
        {
          RefVertex *c1_end, *c2_end;
          if(forward_c1)
            c1_end = c1->end_vertex();
          else
            c1_end = c1->start_vertex();
          if(forward_c2)
            c2_end = c2->end_vertex();
          else
            c2_end = c2->start_vertex();
          if(c1_end == c2_end) // verts are already merged
            full_c2 = true;
          else
          {
            CubitVector c2_end_pos;
            if(forward_c2)
              c2_end_pos = c2->end_coordinates();
            else
              c2_end_pos = c2->start_coordinates();
            double dist_sq_1 = (vec1-vec2).length_squared();
            double dist_sq_2 = (vec1-c2_end_pos).length_squared();
            if(dist_sq_2 < 2.25*dist_sq_1)
              full_c2 = true;
          }
        }
      }
    }
    else
    {
      went_out_of_angle_tolerance = true;
    }
    if(went_past_end_of_c2)
    {
      i=0;
      full_c2 = true;
      c1_stop_param = cur_t;
      // calculate split point on curve 1
    }
    else if(went_out_of_angle_tolerance)
    {
      if(i==num_segments)
        status = CUBIT_FAILURE;
      i=0;
      c1_stop_param = cur_t;
      c2_stop_param = c2->u_from_position(vec2);
    }

    cur_t += dt;
  }

  if(i==0)
  {
    full_c1 = true;
  }

  return status;
}
CubitVector GeometryModifyTool::FindExtendedEndPt ( double  outer_rad,
double  inner_rad,
CubitVector  inner_AxisPt,
CubitVector  Axis,
double  Height 
) [private]

Definition at line 21505 of file GeometryModifyTool.cpp.

{
    CubitVector Extended_End_Pt;

    double Diff     = (outer_rad - inner_rad);
           Diff    /= Height;
    double dAngle   = atan ( Diff ) ;
    Axis.normalize();

    double dTan        = tan( dAngle );
    double dExtendvalue = inner_rad / dTan;

    CubitVector ExtendedPt;
    ExtendedPt.x( ( Axis.x() * dExtendvalue )  + inner_AxisPt.x() );
    ExtendedPt.y( ( Axis.y() * dExtendvalue )  + inner_AxisPt.y() );
    ExtendedPt.z( ( Axis.z() * dExtendvalue )  + inner_AxisPt.z() );

    return ExtendedPt;
}
void GeometryModifyTool::FindExtendedPoints ( CubitVector  AxisPt1,
CubitVector  AxisPt2,
double  outer_radius,
double  inner_radius,
CubitVector  axis,
double  Height,
CubitBox  bounding_box,
double  dTanAngle,
CubitVector start,
CubitVector end,
double &  dExtended_OuterRadius,
double &  dExtended_InnerRadius 
) [private]

Definition at line 21567 of file GeometryModifyTool.cpp.

{

    CubitVector endpt ;
    if( outer_radius > inner_radius )
    {
        endpt  = FindExtendedEndPt( outer_radius , inner_radius , AxisPt2 , axis,  Height );
        Height = sqrt( (endpt.x() - AxisPt1.x()) * (endpt.x() - AxisPt1.x())+
            (endpt.y() - AxisPt1.y()) * (endpt.y() - AxisPt1.y())+
            (endpt.z() - AxisPt1.z()) * (endpt.z() - AxisPt1.z()) );

        AxisPt2.x( endpt.x() );
        AxisPt2.y( endpt.y() );
        AxisPt2.z( endpt.z() );

        end.x( endpt.x() );
        end.y( endpt.y() );
        end.z( endpt.z() );

        dExtended_InnerRadius = 0;
    }
    else
    {
        // reverse the axis.

        axis.x( -axis.x());
        axis.y( -axis.y());
        axis.z( -axis.z());

        endpt  = FindExtendedEndPt( inner_radius , outer_radius , AxisPt1 , axis,  Height );
        Height = sqrt( (endpt.x() - AxisPt2.x()) * (endpt.x() - AxisPt2.x())+
            (endpt.y() - AxisPt2.y()) * (endpt.y() - AxisPt2.y())+
            (endpt.z() - AxisPt2.z()) * (endpt.z() - AxisPt2.z()) );

        AxisPt1.x( endpt.x() );
        AxisPt1.y( endpt.y() );
        AxisPt1.z( endpt.z() );

        start.x( endpt.x() );
        start.y( endpt.y() );
        start.z( endpt.z() );

        // reset the axis.
        axis.x( -axis.x());
        axis.y( -axis.y());
        axis.z( -axis.z());


        dExtended_OuterRadius = 0;

     }



    //*****************************************//
    // Now find the extension of the bigger end.
    //*****************************************//

    if( outer_radius > inner_radius )
    {
        // reverse the axis.
        axis.x( -axis.x());
        axis.y( -axis.y());
        axis.z( -axis.z());


        endpt  = FindExtendedStartPt( bounding_box , outer_radius , inner_radius , AxisPt1 , axis,  Height , dTanAngle , dExtended_OuterRadius );
        Height = sqrt( (endpt.x() - AxisPt2.x()) * (endpt.x() - AxisPt2.x())+
            (endpt.y() - AxisPt2.y()) * (endpt.y() - AxisPt2.y())+
            (endpt.z() - AxisPt2.z()) * (endpt.z() - AxisPt2.z()) );

        AxisPt1.x( endpt.x() );
        AxisPt1.y( endpt.y() );
        AxisPt1.z( endpt.z() );

        start.x( endpt.x() );
        start.y( endpt.y() );
        start.z( endpt.z() );

        // reverse the axis.
        axis.x( -axis.x());
        axis.y( -axis.y());
        axis.z( -axis.z());

    }
    else
    {
        endpt  = FindExtendedStartPt( bounding_box ,  inner_radius , outer_radius , AxisPt2 , axis,  Height , dTanAngle , dExtended_InnerRadius );
        Height = sqrt( (endpt.x() - AxisPt1.x()) * (endpt.x() - AxisPt1.x())+
            (endpt.y() - AxisPt1.y()) * (endpt.y() - AxisPt1.y())+
            (endpt.z() - AxisPt1.z()) * (endpt.z() - AxisPt1.z()) );

        AxisPt2.x( endpt.x() );
        AxisPt2.y( endpt.y() );
        AxisPt2.z( endpt.z() );

        end.x( endpt.x() );
        end.y( endpt.y() );
        end.z( endpt.z() );
    }
}
CubitVector GeometryModifyTool::FindExtendedStartPt ( CubitBox  box,
double  outer_rad,
double  inner_rad,
CubitVector  inner_AxisPt,
CubitVector  Axis,
double &  Height,
double  dTanAngle,
double &  dExtendedadius 
) [private]

2

Definition at line 21526 of file GeometryModifyTool.cpp.

{
    CubitVector Extended_Start_Pt;

    // Find the Difference between the Max and thre min values in all 3 directions.
    // Incase the point is within the box limits, then add the difference values
    // in all 3 directions , witht he " Axis " as the direction vector and extend the point.

    // After that find the Radius of this bigger end.

    CubitVector DiffVec;

    Axis.normalize();

    DiffVec.x( fabs( Box.max_x() - Box.min_x() ));
    DiffVec.y( fabs( Box.max_y() - Box.min_y() ));
    DiffVec.z( fabs( Box.max_z() - Box.min_z() ));

    // Extend the start Pt

    Extended_Start_Pt.x( AxisPt.x() + ( Axis.x() * DiffVec.x() ) );
    Extended_Start_Pt.y( AxisPt.y() + ( Axis.y() * DiffVec.y() ) );
    Extended_Start_Pt.z( AxisPt.z() + ( Axis.z() * DiffVec.z() ) );


    // Find the length

    dLength = sqrt( (( AxisPt.x() - Extended_Start_Pt.x()) *  (AxisPt.x() - Extended_Start_Pt.x()) ) +
                           (( AxisPt.y() - Extended_Start_Pt.y()) *  (AxisPt.y() - Extended_Start_Pt.y()) ) +
                           (( AxisPt.z() - Extended_Start_Pt.z()) *  (AxisPt.z() - Extended_Start_Pt.z()) ) );



    // Find the Extended Radius

    dExtendedadius = outer_rad + ( tan( dTanAngle ) * dLength ) ;

    return Extended_Start_Pt;
}
CubitStatus GeometryModifyTool::finish_copy ( TopologyBridge *&  new_bridge,
TopologyBridge old_bridge 
) [static]

Definition at line 1245 of file GeometryModifyTool.cpp.

{
  //Remove attributes on underlying entities of virtual geometry
  //entities which do not have corresponding RefEntities.
  DLIList<TopologyBridge*> bridge_list;
  bridge_list.append( old_bridge );
  GeometryQueryTool::instance()->ige_remove_attributes( bridge_list );

  //Remove attributes on original entity and children
  DLIList<RefEntity*> child_list;
  RefEntity *ref_ent = CAST_TO( old_bridge->topology_entity(), RefEntity );
  ref_ent->get_all_child_ref_entities( child_list );
  //child_list.append( ref_ent );
  CubitAttribUser::clear_all_simple_attrib( child_list );
  child_list.clean_out();
  child_list.append( ref_ent );
  CubitAttribUser::clear_all_simple_attrib( child_list );


  //Restore virtual
  //Could create virtual geometry here so the Topology Bridge can change
  bridge_list.clean_out();
  bridge_list.append( new_bridge );
  TopologyBridge *tmp_bridge_before = new_bridge;
  GeometryQueryTool::instance()->ige_import_geom( bridge_list );
  assert( bridge_list.size() == 1 );
  if( tmp_bridge_before != bridge_list.get() )
    new_bridge = bridge_list.get();

  //make the RefEntities
  Curve *curve = NULL;
  Surface *surface = NULL;
  Lump *lump = NULL;
  BodySM *body = NULL;

  RefEntity *new_ref_ent = NULL;
  if( (curve = CAST_TO( new_bridge, Curve ) ) != NULL )
    new_ref_ent = GeometryQueryTool::instance()->make_RefEdge( curve );
  else if( (surface = CAST_TO( new_bridge, Surface) ) != NULL )
    new_ref_ent = GeometryQueryTool::instance()->make_RefFace( surface );
  else if( (lump = CAST_TO( new_bridge, Lump) ) != NULL )
    new_ref_ent = GeometryQueryTool::instance()->make_Body( lump->bodysm() );
  else if( (body = CAST_TO( new_bridge, BodySM) ) != NULL )
    new_ref_ent = GeometryQueryTool::instance()->make_Body( body );

  //actuate the attributes on everything
  child_list.clean_out();
  new_ref_ent->get_all_child_ref_entities( child_list );
  child_list.append( new_ref_ent );
  GeometryQueryTool::import_actuate( child_list );

  //Remove attributes on new entity and children
  child_list.clean_out();
  new_ref_ent->get_all_child_ref_entities( child_list );
  CubitAttribUser::clear_all_simple_attrib( child_list );
  child_list.clean_out();
  child_list.append( new_ref_ent );
  CubitAttribUser::clear_all_simple_attrib( child_list );

  CGMApp::instance()->restore_previous_attribute_states();
  return CUBIT_SUCCESS;
}
CubitStatus GeometryModifyTool::finish_sm_op ( DLIList< Body * > &  input_bodies,
DLIList< BodySM * > &  new_bodies,
DLIList< Body * > &  result_bodies,
bool  print_info = true 
) const

Internal use only.

Definition at line 2577 of file GeometryModifyTool.cpp.

{
  int i;
  GeometryQueryTool* gqt = GeometryQueryTool::instance();

  DLIList<int> updated_ids, created_ids, destroyed_ids;
  DLIList<int> updated_vol_ids, created_vol_ids, destroyed_vol_ids;

  // traverse the body object and remove any meshes from modified objects
  int b;
  for (b = 0; b < input_bodies.size(); b++) {
      Body* body = input_bodies.get_and_step();
    AppUtil::instance()->send_event(GeometryEvent(GeometryEvent::TOPOLOGY_ENTITY_MODIFIED, body));
  }

    // Remove dead bodies
  input_bodies.reset();
  for (i = input_bodies.size(); i--;)
  {
    Body* body = input_bodies.step_and_get();

    BodySM* bodysm = body->get_body_sm_ptr();
    if (!bodysm)
    {
        // If the body was destroyed, update the list
      destroyed_ids.append( body->id() );

      DLIList<RefVolume*> temp_vols;
      body->ref_volumes( temp_vols );
      for( int nv = temp_vols.size(); nv > 0; nv-- )
      {
        if( !temp_vols.get()->get_lump_ptr() )
          destroyed_vol_ids.append( temp_vols.get_and_step()->id() );
      }

      input_bodies.change_to(0);
      gqt->destroy_dead_entity(body);
    }
    else
    {
      remove_dead_entity_names( body );
    }
  }
  gqt->cleanout_deactivated_geometry();

    // Create new bodies
  new_bodies.last();
  for (i = new_bodies.size(); i--; )
  {
    BodySM* bodysm = new_bodies.step_and_get();
    bool newbody = bodysm->owner() == 0;
    Body* body = gqt->make_Body(bodysm);
    result_bodies.append(body);

    if (newbody)
    {
      created_ids.append(body->id());

      DLIList<RefVolume*> temp_vols;
      body->ref_volumes( temp_vols );
      for( int nv = temp_vols.size(); nv > 0; nv-- )
      {
        created_vol_ids.append( temp_vols.get_and_step()->id() );
      }
    }
    else
    {
      updated_ids.append(body->id());

      DLIList<RefVolume*> temp_vols;
      body->ref_volumes( temp_vols );
      for( int nv = temp_vols.size(); nv > 0; nv-- )
      {
        updated_vol_ids.append( temp_vols.get_and_step()->id() );
      }
    }
  }
  gqt->cleanout_deactivated_geometry();

  if (print_info)
  {
    if( DEBUG_FLAG( 153 ) )
    {
      if (created_ids.size())
         CubitUtil::list_entity_ids( "Created body(s): ", created_ids );
      if (updated_ids.size())
         CubitUtil::list_entity_ids( "Updated body(s): ", updated_ids );
      if (destroyed_ids.size())
         CubitUtil::list_entity_ids( "Destroyed body(s): ", destroyed_ids );
    }

    if (created_vol_ids.size())
       CubitUtil::list_entity_ids( "Created volume(s): ", created_vol_ids );
    if (updated_vol_ids.size())
       CubitUtil::list_entity_ids( "Updated volume(s): ", updated_vol_ids );
    if (destroyed_vol_ids.size())
       CubitUtil::list_entity_ids( "Destroyed volume(s): ", destroyed_vol_ids );
  }

  return CUBIT_SUCCESS;
}
CubitStatus GeometryModifyTool::finish_webcut ( DLIList< Body * > &  input_bodies,
DLIList< BodySM * > &  webcut_results,
CubitBoolean  merge,
CubitStatus  webcut_status,
DLIList< Body * > &  new_bodies,
DLIList< int > *  merged_surface_ids = NULL,
DLIList< int > *  merged_curve_ids = NULL,
CubitBoolean  print_info = CUBIT_TRUE 
) const [private]

Definition at line 2537 of file GeometryModifyTool.cpp.

{
   if (!finish_sm_op(webcut_body_list, result_body_sms, result_list,(bool)print_info))
     status = CUBIT_FAILURE;

   DLIList<Body*> temp_result_list;
   if (status)
   {
     status = separate_body_after_webcut( result_list, temp_result_list);
     result_list = temp_result_list;
   }

   if( merged_surface_ids && merged_curve_ids )
     fixup_merged_entities( *merged_surface_ids, *merged_curve_ids );

   if (merge && status)
   {
     DLIList<Body*> temp_results(result_list);
     status = MergeTool::instance()->merge_bodies( temp_results );
   }
   return status;
}
void GeometryModifyTool::fixup_merged_entities ( DLIList< int > &  merged_surface_ids,
DLIList< int > &  merged_curve_ids 
) const [private]

Definition at line 20000 of file GeometryModifyTool.cpp.

{
  //use ids to find surviving merged entities
  DLIList<RefFace*> ref_face_list;
  DLIList<RefEdge*> ref_edge_list;

  int i;
  //see what merged survived operation
  for( i=merged_surface_ids.size(); i--; )
  {
    int face_id = merged_surface_ids.get_and_step();
    RefFace *surviving_merged_face = RefEntityFactory::instance()->get_ref_face( face_id );
    if( surviving_merged_face )
      ref_face_list.append( surviving_merged_face );
  }

  //see what merged survived operation
  for( i=merged_curve_ids.size(); i--; )
  {
    int edge_id = merged_curve_ids.get_and_step();
    RefEdge *surviving_merged_edge = RefEntityFactory::instance()->get_ref_edge( edge_id );
    if( surviving_merged_edge )
      ref_edge_list.append( surviving_merged_edge );
  }

  //fix up merged faces -- some might need to be reversed
  for(i=ref_face_list.size(); i--; )
  {
    RefFace *merged_face = ref_face_list.get_and_step();
    BasicTopologyEntity *bte = static_cast<BasicTopologyEntity*>(merged_face);

    //get the first bridge of the entity
    DLIList<TopologyBridge*> face_bridge_list;
    bte->bridge_manager()->get_bridge_list( face_bridge_list );

    //if there are 2 bridges in the list, it's still merged...do nothing
    if( face_bridge_list.size() > 1 )
      continue;

    //get the center of the RefFace
    CubitVector center = merged_face->center_point();

    //get the normal according to the RefFace
    CubitVector ref_face_normal = merged_face->normal_at( center );

    //get the normal at the center from the underlying Surface
    Surface *surface_ptr = CAST_TO( face_bridge_list.get(), Surface );
    CubitVector surface_normal;
    surface_ptr->closest_point( center, NULL, &surface_normal );

    //if normals are opposite, flip sense of surface_ptr
    if( fabs(ref_face_normal.interior_angle( surface_normal ) - 180 ) < 0.1  )
      merged_face->reverse_normal();

    //One more thing.....if surface is a composite, update the graphics
    //on the hidden curve...could have been deleted.
    if ( GeometryQueryTool::instance()->ige_is_composite( surface_ptr ) )
      AppUtil::instance()->send_event(GeometryEvent(GeometryEvent::TOPOLOGY_MODIFIED, merged_face));
  }

  //fix up merged edges -- some might need to be reversed
  for(i=ref_edge_list.size(); i--; )
  {
    RefEdge *merged_edge = ref_edge_list.get_and_step();
    BasicTopologyEntity *bte = static_cast<BasicTopologyEntity*>(merged_edge);

    //get the first bridge of the entity
    DLIList<TopologyBridge*> edge_bridge_list;
    bte->bridge_manager()->get_bridge_list( edge_bridge_list );

    //get start/end points of the edge
    CubitVector edge_start_point = merged_edge->start_vertex()->coordinates();
    CubitVector edge_end_point = merged_edge->end_vertex()->coordinates();

    //get start/end point of the curve
    edge_bridge_list.reset();
    Curve *curve_ptr = CAST_TO( edge_bridge_list.get(), Curve);
    DLIList<TBPoint*> tmp_points;
    curve_ptr->points( tmp_points );
    CubitVector curve_start_point = tmp_points.get_and_step()->coordinates();
    CubitVector curve_end_point = tmp_points.get_and_step()->coordinates();

    //check to see if curve sense needs to be reversed
    if( edge_start_point.distance_between( curve_start_point ) < GEOMETRY_RESABS &&
          edge_end_point.distance_between( curve_end_point ) < GEOMETRY_RESABS )
    {
      //do nothing...everything is fine
      continue;
    }
    else
    {
      if( edge_start_point.distance_between( curve_end_point ) < GEOMETRY_RESABS &&
            edge_end_point.distance_between( curve_start_point ) < GEOMETRY_RESABS )
      {
        //switch sense of ref entity
        merged_edge->reverse_tangent();
      }
    }
  }
}

Gets all edges imprint flag.

Definition at line 2487 of file GeometryModifyTool.hpp.

{return allEdgesImprint;}
static RefEntity* GeometryModifyTool::get_copy_entity ( ) [inline, static]

Gets the entity being copied, if any.

Definition at line 1154 of file GeometryModifyTool.hpp.

{ return copyingEntity; }
double GeometryModifyTool::get_dihedral_angle_score ( RefFace f1,
RefFace f2,
RefEdge common_edge 
)
double GeometryModifyTool::get_edge_type_score ( RefEdge common_edge,
double  small_curve_size 
)

Gets the GeometryModifyEngine of this entity.

Definition at line 11933 of file GeometryModifyTool.cpp.

{
  int i;
  GeometryModifyEngine *gme;
  for (i = 0; i < gmeList.size(); i++) {
    gme = gmeList.next(i);
    if (gme->is_modify_engine(tb_ptr)) return gme;
  }
  return NULL;
}

Gets the GeometryModifyEngine of this entity.

Definition at line 11944 of file GeometryModifyTool.cpp.

{
  int i;
  GeometryModifyEngine *gme = 0;
  TopologyBridge* tb_ptr = NULL;
  BridgeManager* bm = te_ptr->bridge_manager();
  DLIList<TopologyBridge*> bridges(bm->number_of_bridges());
  bm->get_bridge_list(bridges);
  bridges.reset();
  for (i = bridges.size(); !gme && i--; )
  {
    tb_ptr = bridges.get_and_step();
    gme = get_engine(tb_ptr);
  }

  if (bridge && gme)
    *bridge = tb_ptr;

  return gme;
}

Gets the current active GeometryModifyEngine.

Definition at line 2515 of file GeometryModifyTool.hpp.

{
  GeometryModifyEngine *gme = NULL;
  if (gmeList.size()) {
    const_cast<GeometryModifyTool*>(this)->gmeList.reset();
    gme = gmeList.get();
  }
  return gme;
}

Returns a list of GeometryModifyEngines.

return the list of gme's

Definition at line 2508 of file GeometryModifyTool.hpp.

Gets group imprint flag.

Definition at line 1115 of file GeometryModifyTool.hpp.

{return groupImprint;}
void GeometryModifyTool::get_merged_curve_and_surface_ids ( DLIList< Body * > &  bodies,
DLIList< int > &  merged_surface_ids,
DLIList< int > &  merged_curve_ids 
) const [private]

Definition at line 20102 of file GeometryModifyTool.cpp.

{
  int i;
  for( i=bodies.size(); i--; )
  {
    DLIList<RefEntity*> merged_children;

    MergeTool::instance()->contains_merged_children( bodies.get_and_step(),
                                                     merged_children );

    int j;
    for( j=merged_children.size(); j--; )
    {
      RefEntity *ref_ent = merged_children.get_and_step();

      RefFace *ref_face = CAST_TO( ref_ent, RefFace );

      if( ref_face )
        merged_surface_ids.append( ref_face->id() );
      else
      {
        RefEdge *ref_edge = CAST_TO( ref_ent, RefEdge );

        if( ref_edge )
          merged_curve_ids.append( ref_edge->id() );
      }
    }
  }
}
CubitStatus GeometryModifyTool::get_mid_plane ( RefFace ref_face_1,
RefFace ref_face_2,
Body body_to_trim_to,
DLIList< RefFace * > &  mid_plane_surfs 
) const

From two surface, create a midplane, then trim it with a body.

Definition at line 12119 of file GeometryModifyTool.cpp.

{
  if( ref_face1 == ref_face2 )
  {
    PRINT_ERROR("Cannot create midplane between the same surface.\n"
                "       Surface %d was entered twice\n",  ref_face1->id() );
    return CUBIT_FAILURE;
  }

  BodySM* body_sm_to_trim_to = body_to_trim_to->get_body_sm_ptr();
  GeometryModifyEngine *gme1_ptr = get_engine(body_sm_to_trim_to);
  if ( !gme1_ptr )
  {
    PRINT_ERROR("Geometry can't be modified, no associated modify engine.\n");
    return CUBIT_FAILURE;
  }

  CubitVector normal_1, normal_2, point_1, point_2, point_3;
  CubitPlane plane_1, plane_2;
  CubitVector p_mid, n_mid;

  point_1 = ref_face1->center_point();
  point_2 = ref_face2->center_point();

  normal_1 = ref_face1->normal_at(point_1);
  normal_2 = ref_face2->normal_at(point_2);

  plane_1 = CubitPlane(normal_1,point_1);
  plane_2 = CubitPlane(normal_2,point_2);

  if(point_1 == point_2)
  {
    PRINT_ERROR("Since both surfaces share the same point, the midplane is not well-defined\n");
    return CUBIT_FAILURE;
  }
  else
  {
    CubitVector temp1 = point_2;
    temp1 = plane_1.project(temp1);
    temp1 -= point_2;
    if ( temp1.length_squared() < GEOMETRY_RESABS*GEOMETRY_RESABS )
    {
      PRINT_ERROR("Since both planes are the same, the mid-plane is not well-defined.\n");
      return CUBIT_FAILURE;
    }
  }

  if(plane_1.normal()==plane_2.normal() || plane_1.normal()==-plane_2.normal())
  {
    p_mid = (point_1+point_2)/2;
    n_mid = plane_1.normal();
  }
  else
  {

    CubitVector direction_of_line;
    plane_1.intersect(plane_2,p_mid,direction_of_line);
    direction_of_line.normalize();

    // Find if point_1 and point_2 are on the line of intersection
    // If they are, then the mid-plane is not well-defined
    CubitVector p1 = point_1-p_mid;
    CubitVector p2 = point_2-p_mid;
    p1.normalize();
    p2.normalize();

    if(p1==direction_of_line || p1==-direction_of_line)
    {
      PRINT_ERROR("P1 is on the line of intersection.\n");
      return CUBIT_FAILURE;
    }

    if(p2==direction_of_line || p2==-direction_of_line)
    {
      PRINT_ERROR("P2 is on the line of intersection.\n");
      return CUBIT_FAILURE;
    }

    CubitVector v1 = p1 - (p1%direction_of_line)*direction_of_line;
    v1.normalize();

    CubitVector v2 = p2 - (p2%direction_of_line)*direction_of_line;
    v2.normalize();

    n_mid = v1 - v2;
    n_mid.normalize();
  }

  CubitPlane mid_plane(n_mid, p_mid);
  point_1 = p_mid;
    //find three points that will define the infinite plane from the
    //mid plane.
  CubitVector test1(1,0,0), test1n(-1,0,0),test2(0,1,0);
  CubitVector direction1;
    //through the point in any direction just not along the
    //normal direction.
  if(n_mid != test1 && n_mid != test1n )
    direction1 = test1 + n_mid;
  else
    direction1 = test2 + n_mid;

  point_2 = p_mid + direction1;
  point_2 = mid_plane.project(point_2);

  direction1 = point_2-point_1;
  CubitVector direction2 = direction1*n_mid;
  point_3 = point_1 + direction2;

  BodySM* midplane_body_sm = NULL;
  CubitStatus ret = gme1_ptr->get_mid_plane(point_1, point_2, point_3,
                                            body_sm_to_trim_to, midplane_body_sm );

  if (midplane_body_sm)
  {
    Body *midplane_body;

    midplane_body = GeometryQueryTool::instance()->make_Body(midplane_body_sm);

    DLIList<RefFace*> ref_faces;
    midplane_body->ref_faces( ref_faces );

    //make each surface of the body into its own body
    int i;
    for( i=0; i<ref_faces.size(); i++ )
    {
      RefEntity *new_entity_ptr;
      new_entity_ptr = GeometryModifyTool::instance()->copy_refentity(ref_faces.get_and_step());
      RefFace *ref_face_ptr = CAST_TO(new_entity_ptr, RefFace);
      mid_plane_surfs.append( ref_face_ptr );
    }
    GeometryQueryTool::instance()->delete_Body( midplane_body );
  }
  else
    return CUBIT_FAILURE;

  return ret;
}
CubitStatus GeometryModifyTool::get_mid_surface ( RefFace ref_face_1,
RefFace ref_face_2,
Body body_to_trim_to,
DLIList< RefFace * > &  mid_plane_surfs 
) const

Given 2 surfaces, this returns trimmed surfaces of the midsurface (this is an ALPHA feature).

Definition at line 12381 of file GeometryModifyTool.cpp.

{
  if( ref_face1 == ref_face2 )
  {
    PRINT_ERROR("Cannot create midplane between the same surface.\n"
                "       Surface %d was entered twice\n",  ref_face1->id() );
    return CUBIT_FAILURE;
  }

  BodySM *body_sm_to_trim_to = body_to_trim_to->get_body_sm_ptr();
  GeometryModifyEngine *gme1_ptr = get_engine(body_sm_to_trim_to);
  if ( !gme1_ptr )
  {
    PRINT_ERROR("In GeometryModifyTool::get_mid_surface\n"
        "       Geometry can't be modified, no associated modify engine.\n");
    return CUBIT_FAILURE;
  }

  bool found_case = false;
  CubitStatus ret = CUBIT_SUCCESS;
  BodySM* midsurface_body_sm = NULL;

  // Plane to plane case
  if ( ( ref_face1->geometry_type() == PLANE_SURFACE_TYPE ) && ( ref_face2->geometry_type() == PLANE_SURFACE_TYPE ) )
  {
    found_case = true;
    ret = get_planar_mid_surface( ref_face1, ref_face2, body_sm_to_trim_to, midsurface_body_sm, gme1_ptr );
  }

  // Quadric to quadric cases
  if ( ( ( ref_face1->geometry_type() == SPHERE_SURFACE_TYPE ) && ( ref_face2->geometry_type() == SPHERE_SURFACE_TYPE ) )
       ||
       ( ( ref_face1->geometry_type() == CONE_SURFACE_TYPE ) && ( ref_face2->geometry_type() == CONE_SURFACE_TYPE ) )
       ||
       ( ( ref_face1->geometry_type() == TORUS_SURFACE_TYPE ) && ( ref_face2->geometry_type() == TORUS_SURFACE_TYPE ) ) )
  {
    found_case = true;
    DLIList<TopologyEntity*> entity_list(2);
    DLIList<TopologyBridge*> bridge_list(2);

    entity_list.append(ref_face1);
    entity_list.append(ref_face2);
    GeometryModifyEngine* gme2_ptr = common_modify_engine(entity_list,bridge_list);

    if( gme2_ptr == 0 )
    {
      PRINT_ERROR( "In GeometryModifyTool::get_mid_surface\n"
           "       Surfaces %d and %d do not have the same underlying geometry modeling engine.\n"
           "       For midsurface calculations, they must be the same\n",
           ref_face1->id(), ref_face2->id() );
      return CUBIT_FAILURE;
    }

    if( gme1_ptr != gme2_ptr )
    {
      PRINT_ERROR( "In GeometryModifyTool::get_mid_surface\n"
           "       Body and surfaces do not have the same underlying geometry modeling engine.\n"
           "       For midsurface calculations, they must be the same\n");
      return CUBIT_FAILURE;
    }

    bridge_list.reset();
    Surface* surface1_ptr = dynamic_cast<Surface*>(bridge_list.next(0));
    Surface* surface2_ptr = dynamic_cast<Surface*>(bridge_list.next(1));

    // Sphere to sphere case
    if ( ( ref_face1->geometry_type() == SPHERE_SURFACE_TYPE ) && ( ref_face2->geometry_type() == SPHERE_SURFACE_TYPE ) )
    {
      ret = gme2_ptr->get_spheric_mid_surface( surface1_ptr, surface2_ptr, body_sm_to_trim_to, midsurface_body_sm );
    }

    // Cone to cone case
    if ( ( ref_face1->geometry_type() == CONE_SURFACE_TYPE ) && ( ref_face2->geometry_type() == CONE_SURFACE_TYPE ) )
    {
      ret = gme2_ptr->get_conic_mid_surface( surface1_ptr, surface2_ptr, body_sm_to_trim_to, midsurface_body_sm );
    }

    // Torus to torus case
    if ( ( ref_face1->geometry_type() == TORUS_SURFACE_TYPE ) && ( ref_face2->geometry_type() == TORUS_SURFACE_TYPE ) )
    {
      ret = gme2_ptr->get_toric_mid_surface( surface1_ptr, surface2_ptr, body_sm_to_trim_to, midsurface_body_sm );
    }
  }

  // Unsupported pair of surfaces
  if ( ! found_case )
  {
    PRINT_ERROR("In GeometryModifyTool::get_mid_surface\n"
        "       Midsurface calculation not yet supported for such a pair of surfaces.\n");
    return CUBIT_FAILURE;
  }

  if ( midsurface_body_sm )
  {
    if(CubitUndo::get_undo_enabled())
      CubitUndo::save_state();

    DLIList<Surface*> mid_surfaces;
    DLIList<Body*> new_bodies;
    midsurface_body_sm->surfaces( mid_surfaces);
    //make each surface of the body into its own body
    int i;
    for( i=0; i<mid_surfaces.size(); i++ )
    {
      Surface *tmp_surface = mid_surfaces.get_and_step();
      Surface* new_surface_ptr = gme1_ptr->make_Surface( tmp_surface );

      Body *new_Body = make_Body(new_surface_ptr);
      new_bodies.append( new_Body );
      DLIList<RefFace*> ref_faces;
      new_Body->ref_faces(ref_faces);
      RefFace *ref_face_ptr = ref_faces.get();
      mid_surface_surfs.append( ref_face_ptr );
    }
    gme1_ptr->get_gqe()->delete_solid_model_entities( midsurface_body_sm );

    if( CubitUndo::get_undo_enabled() )
    {
      if( new_bodies.size() )
        CubitUndo::note_result_bodies( new_bodies );
      else
        CubitUndo::remove_last_undo();
    }

    return ret;
  }
  else
    return CUBIT_FAILURE;
}
double GeometryModifyTool::get_neighbor_type_score ( RefEdge common_edge,
RefFace other_face,
double  small_curve_size,
int &  neighbor_is_narrow_or_small 
)
void GeometryModifyTool::get_neighboring_bodies ( DLIList< Body * > &  input_bodies,
DLIList< Body * > &  neighboring_bodies 
) [private]
static CubitBoolean GeometryModifyTool::get_new_ids ( ) [inline, static]

Gets new ids flag.

Definition at line 1133 of file GeometryModifyTool.hpp.

{return newIds;}
CubitStatus GeometryModifyTool::get_offset_intersections ( RefEdge ref_edge1,
RefEdge ref_edge2,
DLIList< CubitVector > &  intersection_list,
double  offset,
CubitBoolean  ext_first = CUBIT_TRUE 
)

Finds the intersections of a certain distance (offset) between two curves.

Finds the intersections of a certain distance (offset) between two curves. The two curves must lie in a plane. The first curve is offset the offset distance in both directions, and the bounded intersections with the second curve are found. The first curve can optionally be extended to infinity for the intersection calculation. The intent of the function is so that the user can create a point on a curve a certain distance from another curve, as in specifying a reference location for a gage diameter on an arc in an engineering drawing. The function allocates the CubitVectors in the returned list, so be sure to free them.

Definition at line 11966 of file GeometryModifyTool.cpp.

{
  DLIList<TopologyEntity*> entity_list(2);
  DLIList<TopologyBridge*> bridge_list(2);
  entity_list.append(ref_edge1);
  entity_list.append(ref_edge2);
  GeometryModifyEngine* gme_ptr1 = common_modify_engine(entity_list,bridge_list);

  if( gme_ptr1 == 0 )
  {
      PRINT_ERROR( "Curves %d and %d do not have the same underlying geometry modeling engine\n"
                   "      For intersection calculations, they must be the same\n",
         ref_edge1->id(), ref_edge2->id() );
      return CUBIT_FAILURE;
   }

   bridge_list.reset();
   Curve* curve0 = dynamic_cast<Curve*>(bridge_list.next(0));
   Curve* curve1 = dynamic_cast<Curve*>(bridge_list.next(1));

   return gme_ptr1->get_offset_intersections( curve0, curve1, intersection_list,
                                              offset, ext_first );
}
CubitStatus GeometryModifyTool::get_offset_intersections ( RefEdge ref_edge_ptr,
RefFace ref_face_ptr,
DLIList< CubitVector > &  intersection_list,
double  offset = 0.0,
CubitBoolean  ext_surf = CUBIT_TRUE 
)

Finds intersections (points) of the curve and surface.

Finds intersections (points) of the curve and surface. The surface can be offset - it is offset to each side and intersections are found. By default the surface is extended to infinity (if possible) and the intersections are found. The function allocates the CubitVectors in the returned list, so be sure to free them.

Definition at line 11992 of file GeometryModifyTool.cpp.

{
  // If curve is straight and surface is planar, compute their intersection;
  // otherwise use the geometry engine to do it.

  Curve* curve_ptr = ref_edge_ptr->get_curve_ptr();
  Surface* surface_ptr = ref_face_ptr->get_surface_ptr();

  if( curve_ptr == NULL )
  {
      PRINT_ERROR("Unable to retrieve underlying geometric entity of Curve %d\n"
      "       This is a bug - please report it\n", ref_edge_ptr->id() );
    return CUBIT_FAILURE;
  }

  if( surface_ptr == NULL )
  {
      PRINT_ERROR("Unable to retrieve underlying geometric entity of Surface %d\n"
      "       This is a bug - please report it\n", ref_face_ptr->id() );
    return CUBIT_FAILURE;
  }

  // If straight line and plane, find location right here analytically.
  CubitVector pln_origin, pln_normal;
  CubitVector crv_origin, crv_direction;
  if( ref_face_ptr->get_point_normal( pln_origin, pln_normal ) &&
     ref_edge_ptr->get_point_direction( crv_origin, crv_direction ) )
  {
     double pln_orig[3], pln_norm[3];
     pln_orig[0]=pln_origin.x(); pln_orig[1]=pln_origin.y(); pln_orig[2]=pln_origin.z();
     pln_norm[0]=pln_normal.x(); pln_norm[1]=pln_normal.y(); pln_norm[2]=pln_normal.z();

     double crv_orig[3], crv_dir[3];
     crv_orig[0]=crv_origin.x(); crv_orig[1]=crv_origin.y(); crv_orig[2]=crv_origin.z();
     crv_dir[0]=crv_direction.x(); crv_dir[1]=crv_direction.y(); crv_dir[2]=crv_direction.z();

     AnalyticGeometryTool *agt = AnalyticGeometryTool::instance();

     if( agt->is_vec_perp( pln_norm, crv_dir ) )
     {
        PRINT_ERROR( "Line is parallel to the plane - intersection not possible\n" );
        return CUBIT_FAILURE;
     }

     double ang = agt->angle_vec_vec( pln_norm, crv_dir );
     if( ang > AGT_PI_DIV_2 )
        ang = AGT_PI - ang;

     double int_pnt[3];
     agt->int_ln_pln( crv_orig, crv_dir, pln_orig, pln_norm, int_pnt );

     // ang2 is angle between line and plane
     double ang2 = AGT_PI_DIV_2 - ang;

     double hypotenuse = offset/sin(ang2);

     double final_pnt[3];

     agt->next_pnt( int_pnt, crv_dir, hypotenuse, final_pnt );

     double end1[3], end2[3];
     CubitVector start, end;
     start = ref_edge_ptr->start_coordinates();
     end = ref_edge_ptr->end_coordinates();
     end1[0]=start.x(); end1[1]=start.y(); end1[2]=start.z();
     end2[0]=end.x(); end2[1]=end.y(); end2[2]=end.z();

     CubitVector curve_position;
     if( agt->is_pnt_on_ln_seg( final_pnt, end1, end2 ) )
     {
        curve_position.x( final_pnt[0] );
        curve_position.y( final_pnt[1] );
        curve_position.z( final_pnt[2] );
     }
     else
     {
        agt->reverse_vec( crv_dir, crv_dir );

        agt->next_pnt( int_pnt, crv_dir, hypotenuse, final_pnt );

        if( agt->is_pnt_on_ln_seg( final_pnt, end1, end2 ) )
        {
           curve_position.x( final_pnt[0] );
           curve_position.y( final_pnt[1] );
           curve_position.z( final_pnt[2] );
        }
        else
        {
           PRINT_ERROR( "Resultant point does not lie on bounded curve\n" );
           return CUBIT_FAILURE;
        }
     }
     intersection_list.append( curve_position );
  }
  else
  {
     DLIList<TopologyEntity*> entity_list(2);
     DLIList<TopologyBridge*> bridge_list(2);
     entity_list.append(ref_edge_ptr);
     entity_list.append(ref_face_ptr);
     GeometryModifyEngine* gme_ptr1 = common_modify_engine(entity_list,bridge_list);

     if( gme_ptr1 == 0 )
     {
        PRINT_ERROR( "Curve %d and Surface %d do not have the same underlying geometry modeling engine\n"
           "       For intersection calculations, they must be the same\n",
           ref_edge_ptr->id(), ref_face_ptr->id() );
        return CUBIT_FAILURE;
     }

     bridge_list.reset();
     curve_ptr = dynamic_cast<Curve*>(bridge_list.next(0));
     surface_ptr = dynamic_cast<Surface*>(bridge_list.next(1));

     // Use geometry engine to find intersections
     return gme_ptr1->get_offset_intersections( curve_ptr, surface_ptr,
                                                intersection_list, offset, ext_surf );

  }

  return CUBIT_FAILURE;
}
static CubitBoolean GeometryModifyTool::get_old_names ( ) [inline, static]

Gets old names flag.

Definition at line 1138 of file GeometryModifyTool.hpp.

{ return oldNames; }
double GeometryModifyTool::get_resultant_angle_score ( RefFace narrow_face,
RefFace other_face,
RefEdge common_edge 
)

Gets sepAfterWebcut variable.

Definition at line 1957 of file GeometryModifyTool.hpp.

{return sepAfterWebcut;}
GeometryModifyEngine * GeometryModifyTool::group_bodies_by_engine ( DLIList< Body * > &  remaining_bodies,
DLIList< Body * > &  engine_bodies,
DLIList< BodySM * > &  engine_body_sms 
) const

Groups Bodies with the same underlying geometry engine into a list.

Get a subset of bodies from 'remaining_bodies' that share a common GeometryModifyEngine. Remove them from 'remaining_bodies', put the Bodies and corresponding BodySMs in 'engine_bodies' and 'engine_body_sms', and return the engine. Returns NULL if all bodies remaining in the list have no modify engine.

Definition at line 6368 of file GeometryModifyTool.cpp.

{
  int i = remaining_bodies.size();
  remaining_bodies.reset();
  GeometryModifyEngine* engine = 0;

  if (i == 0)
    return 0;

    // Skip over any bodies that don't have a modify engine.
  while (i--)
  {
    Body* body = remaining_bodies.get();
    TopologyBridge* bridge = 0;
    engine = get_engine(body, &bridge);
    if (engine)
    {
      remaining_bodies.change_to(0);
      engine_bodies.append(body);
      engine_body_sms.append(dynamic_cast<BodySM*>(bridge));
      remaining_bodies.step();
      break;
    }
    remaining_bodies.step();
  }

  // catch case where no engine was found
  if (0 == engine)
  {
    PRINT_WARNING("No geometry modify engine found for this operation.");
    return engine;
  }


    // Get remaining bodies with same modify engine.
  while (i--)
  {
    Body* body = remaining_bodies.get();
    TopologyBridge* bridge = 0;
    if (get_engine(body, &bridge) == engine)
    {
      remaining_bodies.change_to(0);
      engine_bodies.append(body);
      engine_body_sms.append(dynamic_cast<BodySM*>(bridge));
    }
    remaining_bodies.step();
  }

  remaining_bodies.remove_all_with_value(0);
  return engine;
}
CubitStatus GeometryModifyTool::hollow ( DLIList< Body * > &  bodies,
DLIList< RefFace * >  faces_to_remove,
DLIList< Body * > &  new_bodies,
double  depth 
)

Definition at line 6848 of file GeometryModifyTool.cpp.

{
  if (bodies.size() <= 0 || faces_to_remove.size() <= 0)
  {
     PRINT_WARNING("Needs at least one body and one face. Nothing modified\n");
     return CUBIT_FAILURE;
  }

  if (!okay_to_modify( bodies, "HOLLOW" ))
    return CUBIT_FAILURE;

  // Get the GeometryEngine for each Body of the list to check
  // if they are the same and if they are GeometryModifyEngine

  const int count = bodies.size();
  DLIList<TopologyEntity*> entity_list(count);
  DLIList<TopologyBridge*> bridge_list(count);
  CAST_LIST_TO_PARENT(bodies, entity_list);
  GeometryModifyEngine* gme = common_modify_engine( entity_list, bridge_list );

  if (!gme)
  {
     PRINT_ERROR("Performing THICKEN with volumes containing geometry\n"
                 " from different modeling engines is not allowed.\n"
                 "Delete uncommon geometry on these volumes before operation.\n\n");
     return CUBIT_FAILURE;
  }

  DLIList<BodySM*> new_sms(count);
  DLIList<BodySM*> body_sms(count);
  CAST_LIST(bridge_list, body_sms, BodySM);

  if( CubitUndo::get_undo_enabled() )
  {
    CubitUndo::save_state_with_cubit_file( bodies );
  }

  DLIList <Surface*> surfs_to_remove;
  for(int i = 0 ; i < faces_to_remove.size(); i++)
  {
    Surface* surf = faces_to_remove.get_and_step()->get_surface_ptr();
    if(surf)
      surfs_to_remove.append(surf);
  }


  DLIList<int> merged_surface_ids;
  DLIList<int> merged_curve_ids;
  get_merged_curve_and_surface_ids( bodies, merged_surface_ids, merged_curve_ids );
  do_attribute_setup();

  // Push attributes down onto the bodies to be hollowed
  push_attributes_before_modify( body_sms );

  CubitStatus result = gme->hollow( body_sms, surfs_to_remove, new_sms, depth);

   if( result == CUBIT_FAILURE )
   {
     if( CubitUndo::get_undo_enabled() )
       CubitUndo::remove_last_undo();

     PRINT_ERROR("Hollow failed\n");
     remove_pushed_attributes(body_sms, bodies);
     do_attribute_cleanup();
     return CUBIT_FAILURE;
   }

  // check for resued entities, they have been moved and we need to notify observers
  DLIList<RefEntity*> entities_to_update;
  int i;
  for(i=0; i<new_sms.size(); i++)
  {
    BodySM* bodysm = new_sms.get_and_step();
    DLIList<TopologyBridge*> to_check;
    DLIList<TopologyBridge*> tmp;
    DLIList<Surface*> surfs;
    bodysm->surfaces(surfs);
    DLIList<Curve*> curves;
    bodysm->curves(curves);
    DLIList<TBPoint*> points;
    bodysm->points(points);
    to_check.append(bodysm);
    to_check.append(bodysm->lump());
    CAST_LIST_TO_PARENT(surfs, tmp);
    to_check += tmp;
    CAST_LIST_TO_PARENT(curves, tmp);
    to_check += tmp;
    CAST_LIST_TO_PARENT(points, tmp);
    to_check += tmp;

    int k;
    for(k=0; k<to_check.size(); k++)
      if(BridgeManager* m = to_check.get_and_step()->bridge_manager())
        if(TopologyEntity* t = m->topology_entity())
          entities_to_update.append(CAST_TO(t, RefEntity));

  }

  restore_vg_after_modify( new_sms, bodies, gme );
  remove_pushed_attributes( new_sms, bodies );

  result = finish_sm_op(bodies, new_sms, new_bodies);
  fixup_merged_entities( merged_surface_ids, merged_curve_ids);

  if (CUBIT_FAILURE == result) {
    if( CubitUndo::get_undo_enabled() )
      CubitUndo::remove_last_undo();

    PRINT_ERROR("Hollow failed\n");
    do_attribute_cleanup();
    return CUBIT_FAILURE;
  }
  else if( CubitUndo::get_undo_enabled() ) {
    CubitUndo::note_result_bodies( new_bodies );
  }

  do_attribute_cleanup();
  return CUBIT_SUCCESS;
}
CubitStatus GeometryModifyTool::idealize_fillet_geometry ( DLIList< RefEntity * >  idealize_entity,
DLIList< RefEntity * >  exclude_entity,
double  fillet_rad,
CubitBoolean  internal_flg,
CubitBoolean  external_flg,
CubitBoolean  preview = CUBIT_FALSE 
)

Definition at line 12758 of file GeometryModifyTool.cpp.

{
    //cast the DLIList<RefEntity> to a DLIList<RefFace>
    DLIList<RefFace*> face_to_idealize;
    CAST_LIST(idealize_entity, face_to_idealize, RefFace);

    //grabbing geometry tolerance
    double geo_tol = GeometryQueryTool::instance()->get_sme_resabs_tolerance(),temp_fillet_radius;

    //grabbing all the curve loops ONLY from surfaces which are a sheet body
    int y, i, j, z;
    DLIList<RefFace*> sheet_body_idealize_face;

    for(i=0; i<face_to_idealize.size(); i++)
    {
        RefFace* target_face = face_to_idealize.get_and_step();
        DLIList<Shell*> shell_list;
        target_face->shells(shell_list);
        for(j=0; j<shell_list.size(); j++)
        {
            Shell* target_shell = shell_list.get_and_step();
            if(target_face->is_nonmanifold( (GroupingEntity*)target_shell ) )
            {
                sheet_body_idealize_face.append(face_to_idealize[i]);
            }
        }
    }

    face_to_idealize.clean_out();

    //this section is going to remove all excluded curves loopsm from the 'master' loopsm list
    DLIList<Curve*> exclude_cuves;
    DLIList <Body*> old_body_list;
    if(exclude_entity.size()>0)
    {
        //cast the exclude DLIList<RefEntity> to DLIList<RefEdge>
        DLIList<RefEdge*> exclude_edge;
        CAST_LIST(exclude_entity, exclude_edge, RefEdge);

        //switching the DLIList<RefEdge> to DLIList<Curve>
        GeometryModifyEngine* gme_ptr1;
        gme_ptr1 = tweak_setup(exclude_edge,"idealize",old_body_list,exclude_cuves);
        if (NULL == gme_ptr1) {
          PRINT_ERROR("Unexpected NULL GeometryModifyEngine pointer.\n");
          return CUBIT_FAILURE;
        }
        exclude_edge.clean_out();
    }

    //switching the DLIList<RefFace> to DLIList<Surface>
    GeometryModifyEngine* gme_ptr;
    DLIList<Surface*> sheet_body_idealize_surface;
    gme_ptr = tweak_setup(sheet_body_idealize_face,"idealize",old_body_list,sheet_body_idealize_surface);
    sheet_body_idealize_face.clean_out();

    //grab all the loops from each sheet body surface
    DLIList <LoopSM*> idealize_loopSM_list;
    for(y=0;y<sheet_body_idealize_surface.size();y++)
    {
        sheet_body_idealize_surface[y]->loopsms(idealize_loopSM_list);
    }
    sheet_body_idealize_surface.clean_out();

    //search through possible fillet curves filtering only for curves of type arc
    //if it is an arc, does it have a straight line on both sides of it, if so'
    //check the radius of the arc and if it passes test add it to the list of curves to be tweaked removed
    DLIList <Curve*> master_curve_remove_list,possible_fillet_arcs,potential_fillet,internal_fillet, external_fillet, attached_curves;
    CubitVector fillet_center_point, intersection_pt,arc_mid,test_point;
    DLIList <TBPoint*> arc_vertices;
    for(y=0;y<idealize_loopSM_list.size();y++)
    {
        idealize_loopSM_list[y]->curves(possible_fillet_arcs);
        //doing this as a performance boost, it'll keep the code out of the next couple of for loops for situations
        //where there is no fillet possible, for instance, a hole with 2 curves will never be a fillet
        if(possible_fillet_arcs.size()>3)
        {
            for(i=0;i<possible_fillet_arcs.size();i++)
            {
                if(possible_fillet_arcs[i]->geometry_type() == ARC_CURVE_TYPE &&
                    exclude_cuves.is_in_list(possible_fillet_arcs[i])==CUBIT_FALSE)
                {
                    possible_fillet_arcs[i]->points(arc_vertices);
                    //don't need to check for one point as in a hole because I have a check that there needs to be
                    //at least 3 curves in the loop

                    //this is to check that there is only one curve attached to the arc
                    for(z=0;z<arc_vertices.size();z++)
                    {
                        arc_vertices[z]->curves(attached_curves);
                        if(attached_curves.size()!=2)
                        {
                            //I dont' think this break point is going to kick me far enough out of the for loop
                            break;
                        }
                    }

                    possible_fillet_arcs[i]->mid_point(arc_mid);
                    possible_fillet_arcs[i]->get_center_radius(fillet_center_point,temp_fillet_radius);
                    test_point = arc_mid + geo_tol * (fillet_center_point-arc_mid);
                    DLIList<Surface*> test_surf;
                    idealize_loopSM_list[y]->surfaces(test_surf);

                    //this may be dangerous but I'm assuming that a loop is on only one surface
                    CubitPointContainment cpc = test_surf[0]->point_containment(test_point);
                    if(temp_fillet_radius <= fillet_rad && cpc==CUBIT_PNT_INSIDE)
                    {
                        external_fillet.append(possible_fillet_arcs[i]);
                    }
                    else if(temp_fillet_radius <= fillet_rad && cpc==CUBIT_PNT_OUTSIDE)
                    {
                        internal_fillet.append(possible_fillet_arcs[i]);
                    }
                }
            }
        }
        possible_fillet_arcs.clean_out();
    }

    if(internal_flg==CUBIT_TRUE)
    {
        master_curve_remove_list+=internal_fillet;
    }
    if(external_flg==CUBIT_TRUE)
    {
        master_curve_remove_list+=external_fillet;
    }

    //if no arcs are found to be removed, warn the user.
    if(master_curve_remove_list.size()==0)
    {
        PRINT_INFO( "Failed to find any fillets which met users requirements\n\n" );
        //I'm returning success here even though no curves were found
        return CUBIT_SUCCESS;
    }
    else if(preview == CUBIT_TRUE)
    {
        DLIList<BodySM*> new_bodysm_list;
        bool old_error_flag = GET_ERROR_FLAG();
        SET_ERROR_FLAG(false); // don't throw any tweak_remove errors

        CubitStatus stat = gme_ptr->tweak_remove(master_curve_remove_list, new_bodysm_list,CUBIT_FALSE, CUBIT_TRUE );

        SET_ERROR_FLAG(old_error_flag); // turn errors back on
        if(stat==CUBIT_FAILURE)
        {
            PRINT_WARNING("At least one of the fillets which met your requirements \n"
                "           can't be preview due to the curve's geometry\n");
        }

        //output the number of holes or slots which were found
        PRINT_INFO("Found %d fillets which met idealization parameters\n\n", master_curve_remove_list.size());
        return CUBIT_SUCCESS;
    }
    else
    {
        DLIList<BodySM*> new_bodysm_list;
        bool old_error_flag = GET_ERROR_FLAG();
        SET_ERROR_FLAG(false); // don't throw any tweak_remove errors

        //pass master_curve_remove_list to the tweak_remove command
        CubitStatus stat = gme_ptr->tweak_remove(master_curve_remove_list, new_bodysm_list,CUBIT_FALSE, CUBIT_FALSE );
        if(stat==CUBIT_FAILURE)
        {
            PRINT_WARNING("At least one of the fillets which met your requirements \n"
                "           can't be tweaked due to the curve's geometry\n");
        }
        SET_ERROR_FLAG(old_error_flag); // turn errors back on

        //update DAG
        DLIList<Body*> new_body_list;
        stat = finish_sm_op( old_body_list, new_bodysm_list ,new_body_list );
        //output the number of holes or slots which were found
        PRINT_INFO("Found %d fillets which met idealization parameters\n\n", master_curve_remove_list.size());
        return CUBIT_SUCCESS;
    }
}
CubitStatus GeometryModifyTool::idealize_hole_slot_geometry ( DLIList< RefEntity * >  idealize_entity,
DLIList< RefEntity * >  exclude_entity,
double  arc_radius,
double  slot_arc_radius,
double  slot_length,
CubitBoolean  preview = CUBIT_FALSE 
)

Definition at line 12948 of file GeometryModifyTool.cpp.

{
    //cast the DLIList<RefEntity> to a DLIList<RefFace>
    DLIList<RefFace*> face_to_idealize;
    CAST_LIST(idealize_entity, face_to_idealize, RefFace);

    //grabbing geometry tolerance
    double geo_tol = GeometryQueryTool::instance()->get_sme_resabs_tolerance();

    //grabbing all the curve loops ONLY from surfaces which are a sheet body
    int y=0, i=0, j=0;
    DLIList<RefFace*> sheet_body_idealize_face;

    for(i=0; i<face_to_idealize.size(); i++)
    {
        RefFace* target_face = face_to_idealize.get_and_step();
        DLIList<Shell*> shell_list;
        target_face->shells(shell_list);
        for(j=0; j<shell_list.size(); j++)
        {
            Shell* target_shell = shell_list.get_and_step();
            if(target_face->is_nonmanifold( (GroupingEntity*)target_shell ) )
            {
                sheet_body_idealize_face.append(face_to_idealize[i]);
            }
        }
    }

    //if no faces to idealize that pass requirements, error out a warning message
    if(sheet_body_idealize_face.size()==0)
    {
        //I'm returning success here even though no surfaces found that meet shell requirements set above
        {
            PRINT_INFO( "Failed to find any feature(s) which met user requirements\n\n" );
        }
        return CUBIT_SUCCESS;
    }

    //temp_body_ptr = face_to_idealize[y]->body();
    //if(temp_body_ptr->is_sheet_body())
    //{
    //    sheet_body_idealize_face.append(face_to_idealize[y]);
    //}

    face_to_idealize.clean_out();

    //switching the DLIList<RefFace> to DLIList<Surface>
    GeometryModifyEngine* gme_ptr;
    DLIList <Body*> old_body_list;
    DLIList<Surface*> sheet_body_idealize_surface;
    gme_ptr = tweak_setup(sheet_body_idealize_face,"idealize",old_body_list,sheet_body_idealize_surface);
    sheet_body_idealize_face.clean_out();

    //grab all the loops from each sheet body surface
    DLIList <LoopSM*> idealize_loopSM_list;
    for(y=0;y<sheet_body_idealize_surface.size();y++)
    {
            sheet_body_idealize_surface[y]->loopsms(idealize_loopSM_list);
    }
    sheet_body_idealize_surface.clean_out();

    //this section is going to remove all excluded curves loopsm from the 'master' loopsm list
    if(exclude_entity.size()>0)
    {
        //cast the exclude DLIList<RefEntity> to DLIList<RefEdge>
        DLIList<RefEdge*> exclude_edge;
        CAST_LIST(exclude_entity, exclude_edge, RefEdge);

        //switching the DLIList<RefEdge> to DLIList<Curve>
        DLIList<Curve*> exclude_cuves;
        GeometryModifyEngine* gme_ptr1;
        gme_ptr1 = tweak_setup(exclude_edge,"idealize",old_body_list,exclude_cuves);
        if (NULL == gme_ptr1) {
          PRINT_ERROR("Unexpected NULL GeometryModifyEngine pointer.\n");
          return CUBIT_FAILURE;
        }
        exclude_edge.clean_out();

        //grabbing all the curve loops from the given excluded curves
        DLIList <LoopSM*> exclude_loops;
        for(y=0;y<exclude_cuves.size();y++)
        {
            exclude_cuves[y]->loopsms(exclude_loops);
        }
        exclude_cuves.clean_out();

        //remove the excluded loops from the list of sheet body loopsms
        idealize_loopSM_list -= exclude_loops;
    }

    //removing all the external loops from the list as they will not be tweak removed
    DLIList <LoopSM*> possible_internal_LoopSM_list;
    for(y=0;y<idealize_loopSM_list.size();y++)
    {
        if(idealize_loopSM_list[y]->loop_type() == LOOP_TYPE_HOLE)
        {
            possible_internal_LoopSM_list.append(idealize_loopSM_list[y]);
        }
    }
    idealize_loopSM_list.clean_out();
    DLIList <Curve*> hole_curves_to_remove;          //hole_curves_to_remove is the curves selected for removal out of the 'hole' search algorithm
    DLIList <Curve*> master_curve_remove_list;
    DLIList <LoopSM*> arc_LoopSM_list;
    DLIList <Surface*> temp_list;

    //this begins the hole search algorithm
    //if no arc radius given, skip hole search algorithm
    if(arc_radius!=CUBIT_DBL_MAX)
    {
        DLIList <LoopSM*> not_hole_loop;        //loops which don't meet the all curves are arc type filter
        DLIList <Curve*> possible_internal_arcs;

        //search through possible internal curves filtering only for curves of type arc
        //if one of the curves in a loop is not an arc, add that loop to the not_hole_loop list
        for(y=0;y<possible_internal_LoopSM_list.size();y++)
        {
            possible_internal_arcs.clean_out();
            possible_internal_LoopSM_list[y]->curves(possible_internal_arcs);
            for(i=0;i<possible_internal_arcs.size();i++)
            {
                temp_list.clean_out();
                possible_internal_arcs[i]->surfaces(temp_list);
                //check whether or not curve is of arc type and whether it is attached to more than one surface
                if( possible_internal_arcs[i]->geometry_type() != ARC_CURVE_TYPE || temp_list.size() != 1)
                {
                    not_hole_loop.append(possible_internal_LoopSM_list[y]);
                    break;
                }
            }
        }

        //change name of possible_internal_LoopSM_list to arc_LoopSM_list
        arc_LoopSM_list = possible_internal_LoopSM_list;
        //subtract from the possible loops the loops which don't have curves which are all arcs or are attached to more than two surfaces
        arc_LoopSM_list-=not_hole_loop;
        not_hole_loop.clean_out();

        //this next filter checks to make sure that all arcs of the same loop share the same
        //radius center within the geometry tolerance
        CubitVector arc_center_point, arc_center_point1;
        DLIList <LoopSM*> not_center_arc_loop;
        double rad_distance, temp_arc_radius , temp_arc_radius1;

        //this for loop is going to check that each loops arc curves have the same center radius point
        //if not you can remove that loop as a possibility for being added to the tweak_remove command
        for(y=0;y<arc_LoopSM_list.size();y++)
        {
            //clean out curve list before grabbing a new loop
            hole_curves_to_remove.clean_out();
            arc_LoopSM_list[y]->curves(hole_curves_to_remove);
            //iterate across the hole_curves_to_remove size
            for (i=0;i<hole_curves_to_remove.size();i++)
            {
                //if you are on the first index, we need to set a baseline radius point
                if(i==0)
                {
                    hole_curves_to_remove[i]->get_center_radius(arc_center_point,temp_arc_radius);
                    //if this is the only arc in the loop go ahead and check if it meets specified arc parameter
                    //if it doesn't meet the users parameter add the loop to the not_center_arc_loop list
                    if(temp_arc_radius >= arc_radius && hole_curves_to_remove.size()==1)
                    {
                        not_center_arc_loop.append(arc_LoopSM_list[y]);
                        break;
                    }
                }
                //now compare the other arc center points to the baseline, if it ever fails the users parameter
                //add the loop to the not_center_arc_loop list
                else
                {
                    hole_curves_to_remove[i]->get_center_radius(arc_center_point1,temp_arc_radius1);
                    rad_distance = arc_center_point.distance_between_squared(arc_center_point1);
                    if(rad_distance > geo_tol || temp_arc_radius >= arc_radius)
                    {
                        not_center_arc_loop.append(arc_LoopSM_list[y]);
                        break;
                    }
                }
            }
        }

        //remove loops which didn't have perfect circular holes from the arc_loopsm_list
        arc_LoopSM_list -= not_center_arc_loop;
        for(y=0;y<arc_LoopSM_list.size();y++)
        {
            arc_LoopSM_list[y]->curves(hole_curves_to_remove);
        }
        master_curve_remove_list+=hole_curves_to_remove;
    }

    //this begins the slot search algorithm
    DLIList<LoopSM*> removable_slot_loop;
    if(slot_arc_radius!=CUBIT_DBL_MAX || slot_length!=CUBIT_DBL_MAX)
    {
        DLIList<LoopSM*> four_curve_possible_slot;
        DLIList<LoopSM*> possible_slot;
        DLIList<Curve*> internal_curves_in_loop;

        //checks to make sure the loop has only four curves - may want to expand this in the future
        for(y=0;y<possible_internal_LoopSM_list.size();y++)
        {
            possible_internal_LoopSM_list[y]->curves(internal_curves_in_loop);
            if(internal_curves_in_loop.size()==4)
            {
                four_curve_possible_slot.append(possible_internal_LoopSM_list[y]);
            }
            internal_curves_in_loop.clean_out();
        }


        //check to make sure it alternates straight line, arc, etc...
        for(y=0;y<four_curve_possible_slot.size();y++)
        {
            four_curve_possible_slot[y]->curves(internal_curves_in_loop);

            if(internal_curves_in_loop[0]->geometry_type() == ARC_CURVE_TYPE &&
                internal_curves_in_loop[1]->geometry_type() == STRAIGHT_CURVE_TYPE &&
                internal_curves_in_loop[2]->geometry_type() == ARC_CURVE_TYPE &&
                internal_curves_in_loop[3]->geometry_type() == STRAIGHT_CURVE_TYPE)
            {
                int num_of_surfs=0;
                for(i=0;i<internal_curves_in_loop.size();i++)
                {
                    temp_list.clean_out();
                    internal_curves_in_loop[i]->surfaces(temp_list);
                    num_of_surfs=num_of_surfs + temp_list.size();
                }
                if(num_of_surfs==4)
                {
                    possible_slot.append(four_curve_possible_slot[y]);
                }
            }
            else if(internal_curves_in_loop[0]->geometry_type() == STRAIGHT_CURVE_TYPE &&
                internal_curves_in_loop[1]->geometry_type() == ARC_CURVE_TYPE &&
                internal_curves_in_loop[2]->geometry_type() == STRAIGHT_CURVE_TYPE &&
                internal_curves_in_loop[3]->geometry_type() == ARC_CURVE_TYPE)
            {
                int num_of_surfs=0;
                for(i=0;i<internal_curves_in_loop.size();i++)
                {
                    temp_list.clean_out();
                    internal_curves_in_loop[i]->surfaces(temp_list);
                    num_of_surfs=num_of_surfs + temp_list.size();
                }
                if(num_of_surfs==4)
                {
                    possible_slot.append(four_curve_possible_slot[y]);
                }
            }
            internal_curves_in_loop.clean_out();
        }

        CubitVector arc_center_point;
        double temp_arc_radius = CUBIT_DBL_MAX, curve_length = CUBIT_DBL_MAX;

        //check to make sure that the rad and/or length meet users parameters
        for(y=0;y<possible_slot.size();y++)
        {
            possible_slot[y]->curves(internal_curves_in_loop);
            //if user specified rad, then passed rad_counter should = 2 after for loop completes
            //if length specified, length_counter should =2 after for loop completes
            int rad_counter = 0, length_counter = 0;
            for(i=0;i<internal_curves_in_loop.size();i++)
            {
                //if curve is an arc and user specified a radius enter if statement
                if( internal_curves_in_loop[i]->geometry_type() == ARC_CURVE_TYPE && slot_arc_radius!=CUBIT_DBL_MAX )
                {
                    //check the radius against the user inputed value
                    internal_curves_in_loop[i]->get_center_radius(arc_center_point,temp_arc_radius);
                    if(temp_arc_radius <= slot_arc_radius)
                    {
                        //if it passes rad test, add to rad_counter
                        rad_counter++;
                    }
                }
                else if(internal_curves_in_loop[i]->geometry_type() == STRAIGHT_CURVE_TYPE && slot_length!=CUBIT_DBL_MAX )
                {
                    //check the length against the user inputed value
                    curve_length = internal_curves_in_loop[i]->get_arc_length();
                    if(curve_length <= slot_length)
                    {
                        //if it passes rad test, add to length_counter
                        length_counter++;
                    }
                }
            }

            //checks that if user specified length and radius constraint that its parameter passes for all four curves
            if(slot_length!=CUBIT_DBL_MAX && slot_arc_radius!=CUBIT_DBL_MAX  && rad_counter==2 && length_counter==2)
            {
                removable_slot_loop.append(possible_slot[y]);
            }

            //if user only specified one length or arc parameter, it only needs to meet 2 criteria
            else if((slot_length!=CUBIT_DBL_MAX  && length_counter==2) || (slot_arc_radius!=CUBIT_DBL_MAX  && rad_counter==2))
            {
                removable_slot_loop.append(possible_slot[y]);
            }
            internal_curves_in_loop.clean_out();
        }
        //add removable loops curves to the master_curve_remove_list list
        for(y=0;y<removable_slot_loop.size();y++)
        {
            removable_slot_loop[y]->curves(master_curve_remove_list);
        }
    }

    //if no arcs are found to be removed, warn the user.
    if(master_curve_remove_list.size()==0)
    {
        //I'm returning success here even though no curves were found
        {
            PRINT_INFO( "Failed to find any feature(s) which met user requirements\n\n" );
        }
        return CUBIT_SUCCESS;
    }
    else if(preview == CUBIT_TRUE)
    {
        GfxPreview::clear();

        for(i=0; i<master_curve_remove_list.size();i++)
        {
            CubitStatus result;
            GMem g_mem;

            // get the graphics
            result = master_curve_remove_list[i]->get_geometry_query_engine()->
                get_graphics( master_curve_remove_list[i], &g_mem );

            if (result==CUBIT_FAILURE || g_mem.pointListCount == 0)
            {
                PRINT_WARNING("Unable to preview a curve\n" );
                double len = master_curve_remove_list[i]->
                    length_from_u(master_curve_remove_list[i]->start_param(),master_curve_remove_list[i]->end_param());

                PRINT_WARNING("Curve len: %f\n",len);
            }

            // Draw the polyline
            GfxPreview::draw_polyline( g_mem.point_list(), g_mem.pointListCount, CUBIT_BLUE_INDEX );

        }

        //output the number of holes or slots which were found
        PRINT_INFO("Found %d holes and %d slots which met idealization parameters\n\n", arc_LoopSM_list.size(),removable_slot_loop.size());
        GfxPreview::flush();
        return CUBIT_SUCCESS;
    }
    else
    {
        DLIList<BodySM*> new_bodysm_list;
        //pass master_curve_remove_list to the tweak_remove command
        CubitStatus stat = gme_ptr->tweak_remove(master_curve_remove_list, new_bodysm_list,CUBIT_FALSE, CUBIT_FALSE );
        if (CUBIT_SUCCESS != stat) {
          PRINT_ERROR("GeometryModifyEngine::tweak_remove failed.\n");
          return stat;
        }

        //update DAG
        DLIList<Body*> new_body_list;
        stat = finish_sm_op( old_body_list, new_bodysm_list ,new_body_list );
        //output the number of holes or slots which were found
        PRINT_INFO("Found %d holes, and %d slots which met idealization parameters\n\n", arc_LoopSM_list.size(), removable_slot_loop.size());
        return CUBIT_SUCCESS;
    }
}
CubitStatus GeometryModifyTool::imprint ( DLIList< Body * > &  from_body_list,
DLIList< Body * > &  new_body_list,
CubitBoolean  keep_old = CUBIT_FALSE 
)

Imprints a group of bodies with one another.

Definition at line 7515 of file GeometryModifyTool.cpp.

{
  if( from_body_list.size() == 1 )
  {
    PRINT_WARNING("Need more than 1 body or volume to imprint.\n");
    return CUBIT_FAILURE;
  }

   if (get_group_imprint() == CUBIT_FALSE)
   {
     CubitStatus result = imprint_singly( from_body_list, new_body_list, keep_old );
     return result;
   }

     // Check the GeometryEngine for each of the Body's; check to
     // make sure they're all the same
   from_body_list.reset();
   if (!okay_to_modify( from_body_list, "IMPRINT" ))
     return CUBIT_FAILURE;

     //Check for repeats in each individual list and for overlap
     //between the two lists.
   from_body_list.uniquify_ordered();

   DLIList<BodySM*> from_sms(from_body_list.size()), new_sms;
   GeometryModifyEngine* gePtr1 = common_modify_engine(from_body_list, from_sms);
   if ( !gePtr1 )
   {
      PRINT_ERROR("Performing IMPRINT with volumes containing geometry\n"
                  "from different modeling engines is not allowed.\n"
                  "Delete uncommon geometry on these volumes before operation.\n\n");
      return CUBIT_FAILURE;
   }

   if( CubitUndo::get_undo_enabled() )
   {
     if( keep_old )
       CubitUndo::save_state();
     else
       CubitUndo::save_state_with_cubit_file( from_body_list );
   }

   int process_composites = 0;
   if(contains_composites(from_body_list))
     process_composites = 1;

   if(process_composites)
   {
      // Push virtual attributes down to solid model topology before
      // doing the imprint.
      do_attribute_setup();
      push_attributes_before_modify(from_sms);
      // This must be done after pushing the vg atts because it uses them.
      DLIList<TopologyBridge*> tb_list;
      CAST_LIST(from_sms, tb_list, TopologyBridge);
      push_named_attributes_to_curves_and_points(tb_list, "IMPRINTER");
      push_named_attributes_to_curves_and_points(tb_list, "ORIGINAL");
   }

   CubitStatus result =  gePtr1->imprint(from_sms, new_sms, keep_old);

   int i, j;
   if(process_composites)
   {
     if(result == CUBIT_SUCCESS)
     {
        // Analyze the results and adjust virtual attributes as necessary.
       DLIList<TopologyBridge*> tb_list;
       CAST_LIST(new_sms, tb_list, TopologyBridge);
        GeometryQueryTool::instance()->ige_attribute_after_imprinting(tb_list, from_body_list);

        // Clean up attributes.
        remove_imprint_attributes_after_modify(from_sms, new_sms);

        // Restore the virtual geometry.
        restore_vg_after_modify(new_sms, from_body_list, gePtr1);
     }
     remove_pushed_attributes(new_sms, from_body_list);
   }

   if (get_old_names() == CUBIT_FALSE)
   {
     if (!finish_sm_op(from_body_list, new_sms, new_body_list))
       result = CUBIT_FAILURE;

     if( CubitUndo::get_undo_enabled() )
     {
       if( result == CUBIT_SUCCESS )
         CubitUndo::note_result_bodies( new_body_list );
       else
         CubitUndo::remove_last_undo();
     }

     if(process_composites)
       do_attribute_cleanup();

     return result;
   }

   if(process_composites)
     do_attribute_cleanup();

   // If old_names is true, need to make sure things are deleted in
   // the correct order so that entities get the same @A type extension
   // on their names.

   // Update existing bodies.
   from_body_list.reset();
   for (i = from_body_list.size(); i--; )
   {
     Body* body = from_body_list.get();
     BodySM* body_sm = body->get_body_sm_ptr();
     if (!body_sm)
     {
       GeometryQueryTool::instance()->destroy_dead_entity(body);
       from_body_list.change_to(0);
     }
     else
     {
       remove_dead_entity_names(body);
       GeometryQueryTool::instance()->make_Body(body_sm);
     }
     from_body_list.step();
   }

      // Construct new bodies
   new_sms.reset();
   for (j = new_sms.size(); j--; )
   {
     BodySM* body_sm = new_sms.get_and_step();
     Body* body = GeometryQueryTool::instance()->make_Body(body_sm);
     new_body_list.append(body);
   }
   GeometryQueryTool::instance()->cleanout_deactivated_geometry();

   if( CubitUndo::get_undo_enabled() )
   {
     if( result == CUBIT_SUCCESS )
       CubitUndo::note_result_bodies( new_body_list );
     else
       CubitUndo::remove_last_undo();
   }

   return result;
}
CubitStatus GeometryModifyTool::imprint ( DLIList< Body * > &  body_list,
DLIList< RefEdge * > &  ref_edge_list,
DLIList< Body * > &  new_body_list,
CubitBoolean  keep_old_body = CUBIT_FALSE,
CubitBoolean  show_messages = CUBIT_TRUE 
)

Imprints a list of Bodies with a list of RefEdges. Useful for.

Imprints a list of Bodies with a list of RefEdges. Useful for splitting surfaces. If edge pierces a surface a hardpoint will result at the pierce location. Interface is free of but currently only works if all entities are entities.

Definition at line 7972 of file GeometryModifyTool.cpp.

{
  // Check the GeometryEngine for each of the bodies; check to
  // make sure they're all the same
  body_list.reset();
  int i;

  if (!okay_to_modify( body_list, "IMPRINT" ))
    return CUBIT_FAILURE;

  const int count = body_list.size() + ref_edge_list.size();
  DLIList<TopologyEntity*> entity_list(count);
  DLIList<TopologyBridge*> bridge_list(count);
  CAST_LIST_TO_PARENT(body_list, entity_list);
  ref_edge_list.reset();
  for (i = ref_edge_list.size(); i--;)
    entity_list.append(ref_edge_list.get_and_step());

  GeometryModifyEngine* gePtr1 = common_modify_engine(entity_list, bridge_list);

  DLIList<BodySM*> body_sm_list(body_list.size());
  DLIList<Curve*> curve_list(ref_edge_list.size());
  CAST_LIST(bridge_list, body_sm_list, BodySM);
  CAST_LIST(bridge_list, curve_list, Curve);

  if ( !gePtr1 ||
      body_sm_list.size() != body_list.size() ||
      curve_list.size() != ref_edge_list.size() )
  {
    PRINT_ERROR("Performing IMPRINT with volumes containing geometry from\n"
                "different modeling engines is not allowed.\n"
                "Delete uncommon geometry on these volumes before operation.\n\n");
    return CUBIT_FAILURE;
  }

  if( CubitUndo::get_undo_enabled() )
  {
    if( keep_old_body )
      CubitUndo::save_state();
    else
      CubitUndo::save_state_with_cubit_file( body_list );
  }

  int process_composites = 0;
  if(contains_composites(body_list))
    process_composites = 1;

  if(process_composites)
  {
    // Turn certain attributes on.
    do_attribute_setup();
    // Push virtual attributes down to solid model topology before
    // doing the imprint.
    push_attributes_before_modify(body_sm_list);
    // Put "ORIGINAL" attributes on the bodies being imprinted and
    // the curves as these originally existed.
    DLIList<TopologyBridge*> tb_list;
    CAST_LIST(body_sm_list, tb_list, TopologyBridge);
    push_named_attributes_to_curves_and_points(tb_list, "ORIGINAL");
    tb_list.clean_out();
    CAST_LIST(curve_list, tb_list, TopologyBridge);
    push_named_attributes_to_curves_and_points(tb_list, "ORIGINAL");
  }

  DLIList<BodySM*> new_sm_list;
  // The bridges doing the imprinting often get split during the process but
  // because of the way we are making copies, the IMPRINTER attribute doesn't
  // get propagated to them.  temporary_bridges will be filled in with any
  // additional IMPRINTER bridges we need to consider below when deciding whether to
  // keep composite attributes.
  DLIList<TopologyBridge*> temporary_bridges;
  CubitStatus status = gePtr1->imprint( body_sm_list, curve_list,
            new_sm_list, temporary_bridges, keep_old_body, show_messages);

  temporary_bridges.uniquify_ordered();

  if(status == CUBIT_FAILURE)
  {
    if(process_composites)
    {
      remove_pushed_attributes(new_sm_list, body_list);
      do_attribute_cleanup();
    }

    while(temporary_bridges.size())
    {
      TopologyBridge* bridge = temporary_bridges.pop();
      bridge->get_geometry_query_engine()->delete_topology_bridge(bridge);
    }

    return status;
  }
  else
  {
    if(process_composites)
    {
      DLIList<TopologyBridge*> tb_list;
      // Analyze the results and adjust virtual attributes as necessary.
      CAST_LIST(new_sm_list, tb_list, TopologyBridge);
      // The bridges coming back in temporary_bridges may not have IMPRINTER
      // attributes on them becuase of the way they were generated below.  Make
      // sure they get IMPRINTER attributes.
      push_named_attributes_to_curves_and_points(temporary_bridges, "IMPRINTER");
      tb_list += temporary_bridges;
      GeometryQueryTool::instance()->ige_attribute_after_imprinting(tb_list, body_list);

      // Clean up attributes.
      remove_imprint_attributes_after_modify(body_sm_list, new_sm_list);

      // Restore the virtual geometry.
      restore_vg_after_modify(new_sm_list, body_list, gePtr1);
      remove_pushed_attributes(new_sm_list, body_list);
    }
  }

  while(temporary_bridges.size())
  {
    TopologyBridge* bridge = temporary_bridges.pop();
    bridge->get_geometry_query_engine()->delete_topology_bridge(bridge);
  }

  status = finish_sm_op(body_list, new_sm_list, new_body_list);

  if(process_composites)
    do_attribute_cleanup();

   if( CubitUndo::get_undo_enabled() )
   {
     if( status == CUBIT_SUCCESS )
       CubitUndo::note_result_bodies( new_body_list );
     else
       CubitUndo::remove_last_undo();
   }

   return status;
}
CubitStatus GeometryModifyTool::imprint ( DLIList< RefFace * > &  ref_face_list,
DLIList< RefEdge * > &  ref_edge_list,
DLIList< Body * > &  new_body_list,
CubitBoolean  keep_old_body = CUBIT_FALSE 
)

Imprints a list of RefFaces with a list of RefEdges. This is.

Imprints a list of RefFaces with a list of RefEdges. This is useful if the user has a curve which spans several surfaces on a body and only wants to imprint to selected surfaces. Algorithm does not support imprinting to free surfaces. This method is not as reliable as the function to imprint a curve to a body. Interface is free of but currently only works if all entities are entities. Imprints a list of Surfaces with list of Curves, sorted per Surface (ie., curve_lists_list is same length as surface_list). This version is more efficient than the general-purpose one above, as we know which curves to imprint with which surfaces. Also, the Curves need not be RefEntities. All input surfaces must be from the same body however.

Definition at line 8113 of file GeometryModifyTool.cpp.

{
  for(int j=0;j<ref_edge_list.size();j++)
  {
    RefEdge* edge=ref_edge_list[j];
    if(edge->get_arc_length()<=edge->get_geometry_query_engine()->get_sme_resabs_tolerance())
    {

      PRINT_ERROR( "Curve %d has zero length.\n To imprint curve as a hard point use the vertex of the curve.\n",edge->id() );
      return CUBIT_FAILURE;

    }
  }

  //get the owning bodies of the faces and edges
  DLIList<Body*> body_list;
  int j;
  for(j=ref_face_list.size(); j--;)
    ref_face_list.get_and_step()->bodies( body_list );
  for(j=ref_edge_list.size(); j--;)
    ref_edge_list.get_and_step()->bodies( body_list );
  body_list.uniquify_ordered();
  if (!okay_to_modify( body_list, "IMPRINT" ))
    return CUBIT_FAILURE;

  DLIList<TopologyEntity*> temp_list, temp_list_2, body_me_list;
  CAST_LIST_TO_PARENT(ref_face_list, temp_list);
  CAST_LIST_TO_PARENT(ref_edge_list, temp_list_2);
  temp_list += temp_list_2;
  ModelQueryEngine::instance()->query_model(temp_list, DagType::body_type(), body_me_list );

  DLIList<Surface*> surf_list(ref_face_list.size());
  DLIList<Curve*> curve_list(ref_edge_list.size());
  GeometryModifyEngine* gePtr1 = common_modify_engine( ref_face_list,ref_edge_list,surf_list,
                             curve_list,true);
  if ( !gePtr1 )
  {
    PRINT_ERROR("Performing IMPRINT with volumes containing geometry from\n"
            "different modeling engines is not allowed.\n"
            "Delete uncommon geometry on these volumes before operation.\n\n");
    return CUBIT_FAILURE;
  }

  if( CubitUndo::get_undo_enabled() )
  {
    if( keep_old_body )
      CubitUndo::save_state();
    else
      CubitUndo::save_state_with_cubit_file( ref_face_list );
  }

  int process_composites = 0;
  if(contains_composites(body_list))
    process_composites = 1;

  int i;
  DLIList<BodySM*> body_sm_list;
  if(process_composites)
  {
    // Turn certain attributes on.
    do_attribute_setup();
    for(i=body_list.size(); i--;)
      body_sm_list.append_unique(body_list.get_and_step()->get_body_sm_ptr());
    // Push virtual attributes down to solid model topology before
    // doing the imprint.
    push_attributes_before_modify(body_sm_list);
    // Put "ORIGINAL" attributes on the bodies being imprinted and
    // the curves as these originally existed.
    DLIList<TopologyBridge*> tmp_tb_list;
    CAST_LIST(surf_list, tmp_tb_list, TopologyBridge);
    push_named_attributes_to_curves_and_points(tmp_tb_list, "ORIGINAL");
  }

  DLIList<BodySM*> new_sm_list;
  // The bridges doing the imprinting often get split during the process but
  // because of the way we are making copies, the IMPRINTER attribute doesn't
  // get propagated to them.  temporary_bridges will be filled in with any
  // additional IMPRINTER bridges we need to consider below when deciding whether to
  // keep composite attributes.
  DLIList<TopologyBridge*> temporary_bridges;
  CubitStatus status = gePtr1->imprint( surf_list, curve_list, temporary_bridges,
                                         new_sm_list, keep_old_body );
  temporary_bridges.uniquify_ordered();

  if(process_composites)
  {
    // Analyze the results and adjust virtual attributes as necessary.
    DLIList<TopologyBridge*> tb_list;
    CAST_LIST(new_sm_list, tb_list, TopologyBridge);
    // The bridges coming back in temporary_bridges may not have IMPRINTER
    // attributes on them becuase of the way they were generated below.  Make
    // sure they get IMPRINTER attributes.
    push_named_attributes_to_curves_and_points(temporary_bridges, "IMPRINTER");
    tb_list += temporary_bridges;
    GeometryQueryTool::instance()->ige_attribute_after_imprinting(tb_list, body_list);

    // Clean up attributes.
    remove_imprint_attributes_after_modify(body_sm_list, new_sm_list);

    restore_vg_after_modify(body_sm_list, body_list, gePtr1);
    remove_pushed_attributes(body_sm_list, body_list);
  }

  while(temporary_bridges.size())
  {
    TopologyBridge* bridge = temporary_bridges.pop();
    bridge->get_geometry_query_engine()->delete_topology_bridge(bridge);
  }

  CubitStatus status2 = finish_sm_op(body_list, new_sm_list, new_body_list);

  if(process_composites)
    do_attribute_cleanup();

  if( CubitUndo::get_undo_enabled() )
   {
     if( status == CUBIT_SUCCESS )
       CubitUndo::note_result_bodies( new_body_list );
     else
       CubitUndo::remove_last_undo();
   }

   if( status == CUBIT_SUCCESS && status2 == CUBIT_SUCCESS)
     return status;

   else
     return CUBIT_FAILURE;
}
CubitStatus GeometryModifyTool::imprint ( DLIList< Surface * > &  surface_list,
DLIList< DLIList< Curve * > * > &  curve_lists_list,
Body *&  new_body,
CubitBoolean  keep_old_body = CUBIT_FALSE,
CubitBoolean  expand = CUBIT_TRUE 
)

Imprints a list of Surfaces with list of Curves, sorted per.

Definition at line 8245 of file GeometryModifyTool.cpp.

{
  int i;
  DLIList<Curve*> *curve_list_ptr;

  // Check to see if any curves exist - if none, just exit
  int have_curves = 0;
  for( i=curve_lists_list.size(); i--; )
  {
    curve_list_ptr = curve_lists_list.get_and_step();
    for(int j=0;j<curve_list_ptr->size();j++)
    {
      Curve* curve=(*curve_list_ptr)[j];
      if(curve->get_arc_length()<=curve->get_geometry_query_engine()->get_sme_resabs_tolerance())
      {
        RefEdge* edge = dynamic_cast<RefEdge*>(curve->topology_entity());
        if(edge)
        {
          PRINT_ERROR( "Curve %d has zero length.\n To imprint as a hard point use the vertex of the curve.\n",edge->id() );
          return CUBIT_FAILURE;
        }
        else
        {
          return CUBIT_FAILURE;
        }
      }
      else
      {
        have_curves++;
        break;
      }
    }
  }
  if( !have_curves )
    return CUBIT_SUCCESS;

  // Get parent bodies
  DLIList<Body*> old_body_list;
  surface_list.reset();
  for( i=surface_list.size(); i--; )
  {
    Surface *surf_ptr = surface_list.get_and_step();
    RefEntity* ref_ent = dynamic_cast<RefEntity*>(surf_ptr->topology_entity());
    RefFace *ref_face_ptr = CAST_TO( ref_ent, RefFace );

    if( ref_face_ptr )
    {
      DLIList<Body*> body_list;
      ref_face_ptr->bodies( body_list );
      old_body_list.merge_unique( body_list );
    }
  }

  if( old_body_list.size() > 1 )
  {
    PRINT_ERROR( "This operation requires all surfaces to be from the same volume\n" );
    // Note: this restriction could be pretty easily lifted by sorting the
    //       input lists and calling the GeometryModifyEngine for each body
    //       separately, or having engines handle this.
    return CUBIT_FAILURE;
  }


  // In order to support imprinting on composite surfaces we will
  // get any surfaces underlying the surfaces passed in.  For now
  // we will only do this if a single surface is coming in but
  // it could be extended for multiple surfaces as well.
  DLIList<Surface*> new_surface_list;
  if(surface_list.size() == 1)
  {
    GeometryQueryEngine *gqe = surface_list.get()->get_geometry_query_engine();
    DLIList<TopologyBridge*> tbs;
    gqe->get_underlying_surfaces(surface_list.get(), tbs);
    if(tbs.size() > 0)
    {
      for(int k=tbs.size(); k--;)
        new_surface_list.append(dynamic_cast<Surface*>(tbs.get_and_step()));
    }
    else
      new_surface_list.append(surface_list.get());
  }
  else
    new_surface_list = surface_list;

  // Check engines - must all be the same
  GeometryModifyEngine* gme;
  new_surface_list.reset();
  gme = get_engine( new_surface_list.get() );
  for( i=new_surface_list.size(); i--; )
  {
    Surface *surf_ptr = new_surface_list.get_and_step();
    GeometryModifyEngine* gme2 = get_engine( surf_ptr );
    if( gme != gme2 )
    {
      PRINT_ERROR( "All surfaces being imprinted must be from the same geometry engine\n" );
      return CUBIT_FAILURE;
    }
  }

  int j;
  for( i=curve_lists_list.size(); i--; )
  {
    curve_list_ptr = curve_lists_list.get_and_step();
    for( j=curve_list_ptr->size(); j--; )
    {
      Curve *curve_ptr = curve_list_ptr->get_and_step();
      GeometryModifyEngine* gme2 = get_engine( curve_ptr );
      if( gme != gme2 )
      {
        PRINT_ERROR( "Curves used to imprint must be from same geometry engine as Surface\n" );
        return CUBIT_FAILURE;
      }
    }
  }

   if( CubitUndo::get_undo_enabled() )
   {
     if( keep_old_body )
       CubitUndo::save_state();
     else
       CubitUndo::save_state_with_cubit_file( old_body_list );
   }

  int process_composites = 0;
  if(contains_composites(old_body_list))
    process_composites = 1;

  BodySM* new_body_sm = 0;
  DLIList<BodySM*> body_sm_list;

  DLIList<TopologyBridge*> tb_list;
  if(process_composites)
  {
    do_attribute_setup();
    for(i=old_body_list.size(); i--;)
      body_sm_list.append_unique(old_body_list.get_and_step()->get_body_sm_ptr());
    push_attributes_before_modify(body_sm_list);
 //   push_imprint_attributes_before_modify(body_sm_list);
    DLIList<TopologyBridge*> tmp_tb_list;
    CAST_LIST(new_surface_list, tmp_tb_list, TopologyBridge);
    push_named_attributes_to_curves_and_points(tmp_tb_list, "ORIGINAL");

    for(i=curve_lists_list.size(); i>0; i--)
    {
      DLIList<Curve*> *cur_list = curve_lists_list.get_and_step();
      for(j=cur_list->size(); j>0; j--)
      {
        Curve *cur_curve = cur_list->get_and_step();
        tb_list.append(cur_curve);
      }
    }
    push_named_attributes_to_curves_and_points(tb_list, "IMPRINTER");
  }

  CubitStatus status = gme->imprint( new_surface_list, curve_lists_list,
    new_body_sm, keep_old_body, expand);

  DLIList<Body*> new_body_list;
  DLIList<BodySM*> new_sm_list;
  new_sm_list.append( new_body_sm );

  if(process_composites)
  {
    // Analyze the results and adjust virtual attributes as necessary.
       DLIList<TopologyBridge*> tmp_tb_list;
       CAST_LIST(new_sm_list, tmp_tb_list, TopologyBridge);
       tb_list += tmp_tb_list;
    GeometryQueryTool::instance()->ige_attribute_after_imprinting(tb_list, old_body_list);

    // Clean up attributes.
    remove_imprint_attributes_after_modify(body_sm_list, new_sm_list);

    restore_vg_after_modify(body_sm_list, old_body_list, gme);
    remove_pushed_attributes(body_sm_list, old_body_list);
  }

  CubitStatus status2 = finish_sm_op(old_body_list, new_sm_list, new_body_list);

  if(process_composites)
    do_attribute_cleanup();

  if( CubitUndo::get_undo_enabled() )
  {
    if( status == CUBIT_SUCCESS )
      CubitUndo::note_result_bodies( new_body_list );
    else
      CubitUndo::remove_last_undo();
  }

  if( status == CUBIT_SUCCESS && status2 == CUBIT_SUCCESS)
     return status;

   else
     return CUBIT_FAILURE;
}
CubitStatus GeometryModifyTool::imprint ( DLIList< Body * > &  body_list,
DLIList< CubitVector > &  vector_list,
DLIList< Body * > &  new_body_list,
CubitBoolean  keep_old_body = CUBIT_FALSE,
CubitBoolean  merge = CUBIT_FALSE 
)

Imprints a list of bodies to a list of locations.

Imprints a list of bodies to a list of locations. Useful for splitting curves and creating hardpoints on surfaces. Interface is free of but currently only works if bodies are bodies.

Definition at line 8445 of file GeometryModifyTool.cpp.

{
  // Check the GeometryEngine for each of the RefEdges; check to
  // make sure they're all the same
  body_list.reset();

  if (!okay_to_modify( body_list, "IMPRINT" ))
    return CUBIT_FAILURE;

  DLIList<BodySM*> body_sm_list(body_list.size()), new_sm_list;
  GeometryModifyEngine* gePtr1 = common_modify_engine(body_list, body_sm_list);
  if ( !gePtr1 )
  {
    PRINT_ERROR("Performing IMPRINT with volumes containing geometry from\n"
                "different modeling engines is not allowed.\n"
                "Delete uncommon geometry on these volumes before operation.\n\n");
    return CUBIT_FAILURE;
  }

  if( CubitUndo::get_undo_enabled() )
  {
    if( keep_old_body )
      CubitUndo::save_state();
    else
      CubitUndo::save_state_with_cubit_file( body_list );
  }

  int process_composites = 0;
  if(contains_composites(body_list))
    process_composites = 1;

  int i;
  DLIList<TopologyBridge*> temporary_bridges;
  if(process_composites)
  {
    // Turn certain attributes on.
    do_attribute_setup();
    // Push virtual attributes down to solid model topology before
    // doing the imprint.
    push_attributes_before_modify(body_sm_list);
    // Create temporary bridges for the vector positions.  We do
    // this so that we can put an IMPRINTER attribute on them
    // and use them later for deciding whether to keep composite
    // attributes or not.
    for(i=vector_list.size(); i>0; i--)
    {
      CubitVector vec = vector_list.get_and_step();
      TBPoint *pt = gePtr1->make_Point(vec);
      temporary_bridges.append(pt);
    }
    push_named_attributes_to_curves_and_points(temporary_bridges, "IMPRINTER");
    DLIList<TopologyBridge*> tmp_tb_list;
    CAST_LIST(body_sm_list, tmp_tb_list, TopologyBridge);
    // Put "ORIGINAL" attributes on the bridges that originally existed.
    push_named_attributes_to_curves_and_points(tmp_tb_list, "ORIGINAL");
  }

  CubitStatus status = gePtr1->imprint( body_sm_list, vector_list,new_sm_list,
    keep_old_body);

  temporary_bridges.uniquify_ordered();

  if(process_composites)
  {
    // Analyze the results and adjust virtual attributes as necessary.
    DLIList<TopologyBridge*> tb_list;
    CAST_LIST(new_sm_list, tb_list, TopologyBridge);
    tb_list += temporary_bridges;
    GeometryQueryTool::instance()->ige_attribute_after_imprinting(tb_list, body_list);

    while(temporary_bridges.size())
    {
      TopologyBridge* bridge = temporary_bridges.pop();
      bridge->get_geometry_query_engine()->delete_topology_bridge(bridge);
    }

    // Clean up attributes.
    remove_imprint_attributes_after_modify(body_sm_list, new_sm_list);

    // Restore the virtual geometry.
    restore_vg_after_modify(new_sm_list, body_list, gePtr1);
    remove_pushed_attributes(new_sm_list, body_list);
  }

  CubitStatus status2 = finish_sm_op(body_list, new_sm_list, new_body_list);

  if(process_composites)
    do_attribute_cleanup();

   if( merge )
   {
     DLIList<Body*> bodies_to_merge;
     int i;
     for( i=new_body_list.size(); i--; )
     {
       Body *tmp_body = new_body_list.get_and_step();
       DLIList<RefEdge*> ref_edge_list;
       tmp_body->ref_edges( ref_edge_list );

       int j;
       for( j=ref_edge_list.size(); j--; )
       {
         RefEdge *tmp_edge = ref_edge_list.get_and_step();
         DLIList<Body*> body_list;
         tmp_edge->bodies( body_list );
         bodies_to_merge.merge_unique( body_list );
       }
     }
     MergeTool::instance()->merge_bodies( bodies_to_merge );
   }

   if( CubitUndo::get_undo_enabled() )
   {
     if( status == CUBIT_SUCCESS )
       CubitUndo::note_result_bodies( new_body_list );
     else
       CubitUndo::remove_last_undo();
   }

   if( status == CUBIT_SUCCESS && status2 == CUBIT_SUCCESS)
     return status;

   else
     return CUBIT_FAILURE;
}
CubitStatus GeometryModifyTool::imprint_and_merge_curves ( RefEdge curve1,
RefEdge curve2,
DLIList< RefVertex * > &  vert_list,
double  divergence_angle,
DLIList< DLIList< RefEdge * > * > &  curves_to_merge1,
DLIList< DLIList< RefEdge * > * > &  curves_to_merge2,
DLIList< DLIList< RefEdge * > * > &  prev_curve_merge_lists,
DLIList< DLIList< RefFace * > * > &  prev_surf_merge_lists 
)

Definition at line 19137 of file GeometryModifyTool.cpp.

{
  CubitStatus status;
  status = this->unmerge_input(input_curve1, input_curve2, prev_curve_merge_lists, prev_surf_merge_lists);
  if(status == CUBIT_FAILURE)
    return status;
  RefEdge *curve1, *curve2;
  DLIList<RefEdge*> *curves_from_curve1 = new DLIList<RefEdge*>();
  DLIList<RefEdge*> *curves_from_curve2 = new DLIList<RefEdge*>();
  for(int i=prev_curve_merge_lists.size(); i>0; i--)
  {
    DLIList<RefEdge*> *cur_list = prev_curve_merge_lists.get_and_step();
//    DLIList<RefEdge*> cur_list = prev_curve_merge_lists.get();
    if(cur_list->move_to(input_curve1))
    {
      *curves_from_curve1 = *cur_list;
     // prev_curve_merge_lists.remove();
    }
    else if(cur_list->move_to(input_curve2))
    {
      *curves_from_curve2 = *cur_list;
     // prev_curve_merge_lists.remove();
    }
//    else
 //     prev_curve_merge_lists.step();
  }
  // Make sure at least the input curves are in the lists.
  if(curves_from_curve1->size() == 0)
    curves_from_curve1->append(input_curve1);
  if(curves_from_curve2->size() == 0)
    curves_from_curve2->append(input_curve2);

  curve1 = input_curve1;
  curve2 = input_curve2;
  status = this->find_best_curves_to_merge(curves_from_curve1, curves_from_curve2, curve1, curve2);
  if(CUBIT_FAILURE == status)
    return status;

  DLIList<CubitVector> merge_end_points_on_curve1, merge_end_points_on_curve2;
  DLIList<CubitBoolean> split_flags1, split_flags2;
  this->calculate_split_points_for_merge(curve1, curve2, vert_list, NULL,
    merge_end_points_on_curve1, merge_end_points_on_curve2, split_flags1, split_flags2, divergence_angle);

  merge_end_points_on_curve1.reset();
  split_flags1.reset();
  for(int k=merge_end_points_on_curve1.size(); k>0; k=k-2)
  {
    CubitVector end_point1 = merge_end_points_on_curve1.get_and_step();
    CubitVector end_point2 = merge_end_points_on_curve1.get_and_step();
    bool split_flag_end = split_flags1.get_and_step();
    if(split_flag_end)
    {
      DLIList<RefEdge*> *cur_merge_list = new DLIList<RefEdge*>();
      for(int n=curves_from_curve1->size(); n>0; n--)
      {
        RefEdge *curve_to_split = curves_from_curve1->get();
        CubitVector mid = (end_point1 + end_point2)/2.0;
        CubitVector pos_for_identifying;
        curve_to_split->closest_point_trimmed(mid, pos_for_identifying);

        DLIList<CubitVector> loc_list;
        loc_list.append(end_point2);
        CubitStatus loc_status;

        int expected_edge_id_1 = RefEntityFactory::instance()->current_edge_id() + 1;
        int expected_edge_id_2 = expected_edge_id_1 + 1;

        if(curve_to_split->body())
        {
          DLIList<Body*> edge_bodies, new_bodies;
          edge_bodies.append(curve_to_split->body());  // for now just handle single body case

          loc_status = this->imprint( edge_bodies, loc_list, new_bodies );
        }
        else
        {
          DLIList<RefEdge*> new_ref_edges;
          loc_status = this->split_free_curve( curve_to_split, loc_list, new_ref_edges );
        }

        if(loc_status == CUBIT_FAILURE)
        {
          return CUBIT_FAILURE;
        }

        RefEdge *new_edge_1 = RefEntityFactory::instance()->get_ref_edge(expected_edge_id_1);
        RefEdge *new_edge_2 = RefEntityFactory::instance()->get_ref_edge(expected_edge_id_2);

        if(!new_edge_1 || !new_edge_2)
        {
          return CUBIT_FAILURE;
        }

        CubitVector closest;
        new_edge_1->closest_point_trimmed(pos_for_identifying, closest);
        if(closest.about_equal(pos_for_identifying))
        {
          cur_merge_list->append(new_edge_1);
          RefEdge *edge_that_was_split = curves_from_curve1->get();
          curves_from_curve1->change_to(new_edge_2);
          for(int w=prev_curve_merge_lists.size(); w>0; w--)
          {
            DLIList<RefEdge*> *cur_list = prev_curve_merge_lists.get_and_step();
            if(cur_list->move_to(edge_that_was_split))
            {
              cur_list->change_to(new_edge_2);
              w=0;
            }
          }
        }
        else
        {
          cur_merge_list->append(new_edge_2);
          RefEdge *edge_that_was_split = curves_from_curve1->get();
          curves_from_curve1->change_to(new_edge_1);
          for(int w=prev_curve_merge_lists.size(); w>0; w--)
          {
            DLIList<RefEdge*> *cur_list = prev_curve_merge_lists.get_and_step();
            if(cur_list->move_to(edge_that_was_split))
            {
              cur_list->change_to(new_edge_1);
              w=0;
            }
          }
        }
        curves_from_curve1->step();
      }
      curves_to_merge1.append(cur_merge_list);
    }
    else
    {
      curves_to_merge1.append(curves_from_curve1);
    }
  }

  merge_end_points_on_curve2.reset();
  split_flags2.reset();
  for(int k=merge_end_points_on_curve2.size(); k>0; k=k-2)
  {
    CubitVector end_point1 = merge_end_points_on_curve2.get_and_step();
    CubitVector end_point2 = merge_end_points_on_curve2.get_and_step();
    bool split_flag_end = split_flags2.get_and_step();
    if(split_flag_end)
    {
      DLIList<RefEdge*> *cur_merge_list = new DLIList<RefEdge*>();
      for(int n=curves_from_curve2->size(); n>0; n--)
      {
        RefEdge *curve_to_split = curves_from_curve2->get();
        CubitVector mid = (end_point1 + end_point2)/2.0;
        CubitVector pos_for_identifying;
        curve_to_split->closest_point_trimmed(mid, pos_for_identifying);

        DLIList<CubitVector> loc_list;
        loc_list.append(end_point2);
        CubitStatus loc_status;

        int expected_edge_id_1 = RefEntityFactory::instance()->current_edge_id() + 1;
        int expected_edge_id_2 = expected_edge_id_1 + 1;

        if(curve_to_split->body())
        {
          DLIList<Body*> edge_bodies, new_bodies;
          edge_bodies.append(curve_to_split->body());  // for now just handle single body case

          loc_status = this->imprint( edge_bodies, loc_list, new_bodies );
        }
        else
        {
          DLIList<RefEdge*> new_ref_edges;
          loc_status = this->split_free_curve( curve_to_split, loc_list, new_ref_edges );
        }

        if(loc_status == CUBIT_FAILURE)
        {
          return CUBIT_FAILURE;
        }

        RefEdge *new_edge_1 = RefEntityFactory::instance()->get_ref_edge(expected_edge_id_1);
        RefEdge *new_edge_2 = RefEntityFactory::instance()->get_ref_edge(expected_edge_id_2);

        if(!new_edge_1 || !new_edge_2)
        {
          return CUBIT_FAILURE;
        }

        CubitVector closest;
        new_edge_1->closest_point_trimmed(pos_for_identifying, closest);
        if(closest.about_equal(pos_for_identifying))
        {
          cur_merge_list->append(new_edge_1);
          RefEdge *edge_that_was_split = curves_from_curve2->get();
          curves_from_curve2->change_to(new_edge_2);
          for(int w=prev_curve_merge_lists.size(); w>0; w--)
          {
            DLIList<RefEdge*> *cur_list = prev_curve_merge_lists.get_and_step();
            if(cur_list->move_to(edge_that_was_split))
            {
              cur_list->change_to(new_edge_2);
              w=0;
            }
          }
        }
        else
        {
          cur_merge_list->append(new_edge_2);
          RefEdge *edge_that_was_split = curves_from_curve2->get();
          curves_from_curve2->change_to(new_edge_1);
          for(int w=prev_curve_merge_lists.size(); w>0; w--)
          {
            DLIList<RefEdge*> *cur_list = prev_curve_merge_lists.get_and_step();
            if(cur_list->move_to(edge_that_was_split))
            {
              cur_list->change_to(new_edge_1);
              w=0;
            }
          }
        }
        curves_from_curve2->step();
      }
      curves_to_merge2.append(cur_merge_list);
    }
    else
    {
      curves_to_merge2.append(curves_from_curve2);
    }
  }
  return status;
}
CubitStatus GeometryModifyTool::imprint_projected_edges ( DLIList< RefFace * > &  ref_face_list,
DLIList< RefEdge * > &  ref_edge_list,
DLIList< Body * > &  new_body_list,
CubitBoolean  keep_old_body,
CubitBoolean  keep_free_edges 
)

Imprints a list of RefFaces with a list of projected RefEdges.

Definition at line 8669 of file GeometryModifyTool.cpp.

{

   DLIList<Surface*> surface_list(ref_face_list.size());
   DLIList<Curve*> curve_list(ref_edge_list_in.size());
   GeometryModifyEngine* gme = common_modify_engine( ref_face_list,
                                                     ref_edge_list_in,
                                                     surface_list,
                                                     curve_list );
   if ( !gme )
   {
      PRINT_ERROR("Performing IMPRINT with volumes containing geometry from\n"
                  "different modeling engines is not allowed.\n"
                  "Delete uncommon geometry on these volumes before operation.\n\n");
      return CUBIT_FAILURE;
   }

   DLIList<TopologyEntity*> query_output, query_input(ref_face_list.size());
   CAST_LIST_TO_PARENT(ref_face_list, query_input);
   ModelQueryEngine::instance()->query_model(query_input, DagType::body_type(), query_output);
   DLIList<Body*> body_list(query_output.size());
   CAST_LIST(query_output, body_list, Body);
   DLIList<BodySM*> new_sm_list;
   DLIList<Curve*> kept_free_edges;

   if( CubitUndo::get_undo_enabled() )
   {
     if( keep_old_body )
       CubitUndo::save_state();
     else
       CubitUndo::save_state_with_cubit_file( ref_face_list );
   }

   CubitStatus status = gme->imprint_projected_edges( surface_list, curve_list,
                                                      new_sm_list, kept_free_edges,
                                                      keep_old_body, keep_free_edges);

   if (!finish_sm_op(body_list, new_sm_list, new_body_list))
     status = CUBIT_FAILURE;

   DLIList<RefEdge*> kept_ref_edges;
   if( keep_free_edges )
   {
     for( int i=kept_free_edges.size(); i--; )
     {
       RefEdge *tmp_edge = GeometryQueryTool::instance()->make_free_RefEdge( kept_free_edges.get_and_step());
       if( tmp_edge )
         kept_ref_edges.append(tmp_edge );
     }
   }

   if( CubitUndo::get_undo_enabled() )
   {
     if( status == CUBIT_FAILURE )
       CubitUndo::remove_last_undo();
     else
     {
       CubitUndo::note_result_bodies( new_body_list );
       if( keep_free_edges )
       {
         DLIList<RefEntity*> ref_ents;
         for( int i=kept_ref_edges.size(); i--; )
           ref_ents.append( kept_ref_edges.get_and_step() );
         CubitUndo::note_result_entities( ref_ents );
       }
     }
   }

   return status;
}
CubitStatus GeometryModifyTool::imprint_projected_edges ( DLIList< RefFace * > &  ref_face_list,
DLIList< Body * > &  body_list,
DLIList< RefEdge * > &  ref_edge_list,
DLIList< Body * > &  new_body_list,
CubitBoolean  keep_old_body,
CubitBoolean  keep_free_edges 
)

Imprints a list of Bodies with a list of RefEdges which are projected to a list of RefFaces.

Definition at line 8745 of file GeometryModifyTool.cpp.

{

   DLIList<Surface*> surface_list(ref_face_list.size());
   DLIList<Curve*>     curve_list(ref_edge_list_in.size());
   DLIList<BodySM*>  body_sm_list(body_list.size()), new_sm_list;
   GeometryModifyEngine* gme = common_modify_engine(ref_face_list,
                                                    ref_edge_list_in,
                                                    surface_list,
                                                    curve_list);
   if (!gme || gme != common_modify_engine(body_list, body_sm_list))
   {
      PRINT_ERROR("Performing IMPRINT with volumes containing geometry from\n"
                  "different modeling engines is not allowed.\n"
                  "Delete uncommon geometry on these volumes before operation.\n\n");
      return CUBIT_FAILURE;
   }

     // Get RefFace bodies
   DLIList<TopologyEntity*> query_output, query_input(ref_face_list.size());
   CAST_LIST_TO_PARENT(ref_face_list, query_input);
   ModelQueryEngine::instance()->
     query_model( query_input, DagType::body_type(), query_output );
   DLIList<Body*> face_body_list;
   CAST_LIST(query_output, face_body_list, Body);

   CubitStatus status = gme->imprint_projected_edges( surface_list,
                                                      body_sm_list,
                                                      curve_list,
                                                      new_sm_list,
                                                      keep_old_body,
                                                      keep_free_edges);
   face_body_list += body_list;
   if (!finish_sm_op(face_body_list, new_sm_list, new_body_list))
     status = CUBIT_FAILURE;

   return status;

}
CubitStatus GeometryModifyTool::imprint_singly ( DLIList< Body * > &  body_list,
DLIList< Body * > &  new_bodies,
CubitBoolean  keep_old 
) [protected]

Definition at line 7788 of file GeometryModifyTool.cpp.

{

     // Check the GeometryEngine for each of the Body's; check to
     // make sure they're all the same
   from_body_list.reset();
   if (!okay_to_modify( from_body_list, "IMPRINT" ))
     return CUBIT_FAILURE;

     //Check for repeats in each individual list and for overlap
     //between the two lists.
   from_body_list.uniquify_ordered();

   DLIList<BodySM*> from_sms(from_body_list.size());
   GeometryModifyEngine* gePtr1 = common_modify_engine(from_body_list, from_sms);
   if ( !gePtr1 )
   {
      PRINT_ERROR("Performing IMPRINT with volumes containing geometry\n"
                  "from different modeling engines is not allowed.\n"
                  "Delete uncommon geometry on these volumes before operation.\n\n");
      return CUBIT_FAILURE;
   }

   CubitBoolean reset_new_ids = CUBIT_FALSE;
   if (get_new_ids() == CUBIT_FALSE) {
     PRINT_WARNING("New ids must be TRUE when group imprint FALSE; "
                   "setting new ids TRUE for this operation only.\n");
     set_new_ids(CUBIT_TRUE);
     reset_new_ids = CUBIT_TRUE;
   }

     // do the imprinting; bounding box should be checked in
     // SMEEngine function
   new_body_list = from_body_list;
   GeometryQueryTool* gqt = GeometryQueryTool::instance();

   if( CubitUndo::get_undo_enabled() )
   {
     if( keep_old )
       CubitUndo::save_state();
     else
       CubitUndo::save_state_with_cubit_file( from_body_list );
   }

   int i;
   for (i = 0; i < new_body_list.size(); i++) {
     for (int j = 1; j < new_body_list.size()-i; j++) {
       new_body_list.reset();
       new_body_list.step(i);
       Body *body_1 = new_body_list.get();
       Body *body_2 = new_body_list.next(j);
       Body *newBodyPtr1 = NULL;
       Body *newBodyPtr2 = NULL;

       if (body_1 == body_2) {
         PRINT_WARNING("Can't imprint a volume with itself.\n");

         if (reset_new_ids == CUBIT_TRUE) set_new_ids(CUBIT_FALSE);

         return CUBIT_FAILURE;
       }

       BodySM *new_sm_1, *new_sm_2;
       CubitStatus status = gePtr1->imprint(body_1->get_body_sm_ptr(),
                                            body_2->get_body_sm_ptr(),
                                            new_sm_1, new_sm_2,
                                            keep_old);

       if ( status != CUBIT_FAILURE &&
            (new_sm_1 != NULL ||
             new_sm_2 != NULL) )
       {
         from_body_list.reset();
         from_body_list.step(i);

           //put the new ones in the new list and
           //remove the olds ones.
         if ( new_sm_1 != NULL )
         {
           if (!body_1->get_body_sm_ptr())
             gqt->destroy_dead_entity(body_1);
           newBodyPtr1 = gqt->make_Body(new_sm_1);
           new_body_list.change_to(newBodyPtr1);
           from_body_list.change_to(0);
         }
         else
           gqt->make_Body(body_1->get_body_sm_ptr());

         new_body_list.step(j);
         from_body_list.step(j);
         if ( new_sm_2 != NULL )
         {
           if (!body_2->get_body_sm_ptr())
             gqt->destroy_dead_entity(body_2);
           newBodyPtr2 = gqt->make_Body(new_sm_2);
           new_body_list.change_to(newBodyPtr2);
           from_body_list.change_to(NULL);
         }
         else
           gqt->make_Body(body_2->get_body_sm_ptr());
       }
       gqt->cleanout_deactivated_geometry();
     }
   }

   from_body_list.remove_all_with_value(NULL);
   Body *temp_body;
   for (i = from_body_list.size(); i > 0; i--)
   {
     temp_body = from_body_list.get_and_step();
     while (new_body_list.move_to(temp_body)) new_body_list.remove();
   }

   if( CubitUndo::get_undo_enabled() )
   {
     if( new_body_list.size() )
       CubitUndo::note_result_bodies( new_body_list );
     else
       CubitUndo::remove_last_undo();
   }

   PRINT_INFO("\n");
   if( DEBUG_FLAG( 153 ) )
   {
     PRINT_INFO( "  New Body(ies) created:");
     new_body_list.reset();
     for (i = 0; i < new_body_list.size(); i++)
     {
       if (i != 0) PRINT_INFO( ",");
       PRINT_INFO( " %d", new_body_list.get_and_step()->id());
     }
     PRINT_INFO("\n");
     PRINT_INFO( "  Original Body(ies) retained:");
     from_body_list.reset();
     for (i = 0; i < from_body_list.size(); i++)
     {
       if (i != 0) PRINT_INFO( ",");
       PRINT_INFO( " %d", from_body_list.get_and_step()->id());
     }
     PRINT_INFO("\n");
   }

   PRINT_INFO( "  New Volume(s) created:");
   new_body_list.reset();
   DLIList<RefVolume*> new_vol_list;
   for (i = 0; i < new_body_list.size(); i++)
   {
     DLIList<RefVolume*> t2;
     new_body_list.get_and_step()->ref_volumes( t2 );
     new_vol_list += t2;
   }

   for( i = 0; i < new_vol_list.size(); i++ )
   {
     if (i != 0) PRINT_INFO( ",");
     PRINT_INFO( " %d", new_vol_list.get_and_step()->id());
   }
   PRINT_INFO("\n");

   PRINT_INFO( "  Original Volume(s) retained:");
   from_body_list.reset();
   DLIList<RefVolume*> from_vol_list;
   for (i = 0; i < from_body_list.size(); i++)
   {
     DLIList<RefVolume*> t2;
     from_body_list.get_and_step()->ref_volumes( t2 );
     from_vol_list += t2;
   }

   for( i = 0; i < from_vol_list.size(); i++ )
   {
     if (i != 0) PRINT_INFO( ",");
     PRINT_INFO( " %d", from_vol_list.get_and_step()->id());
   }
   PRINT_INFO("\n");

   if (reset_new_ids) set_new_ids(CUBIT_FALSE);

   return CUBIT_SUCCESS;
}
Returns:
GeometryModifyTool* - Pointer to the singleton GeometryModifyTool object
  • SMEPtr Pointer to a SolidModelingEngine object. The default value is set to NULL.
Return a pointer to the only instance of the class with the default solid modeling engine (SME) set to the argument, if it is not NULL. If the argument is NULL, return the pointer to the existing instance without modifying the default SME. A valid SMEPtr *must* be supplied at the time of the first call to this function. Hence, this instance function should specifically be called at startup with a valid non-NULL input SMEPtr.

Definition at line 149 of file GeometryModifyTool.cpp.

{
     // Check to see if we have created an instance of the class
     // If not, proceed to create one.

   if (instance_ == 0)
   {
        // When creating the instance, we should always have a valid
        // SMEPtr. If not, complain.

     instance_ = new GeometryModifyTool (GMEPtr) ;

        // check to make sure there's a ref entity factory extant
     //RefEntityFactory *factory =
     RefEntityFactory::instance();
   }

     // If there is an existing instance of the class, check if there
     // was a request to set default solid modeling engine. If so, be nice
     // to the calling routine :) :) and kindly set the default solid
     // modeling engine.

   else if ( GMEPtr != NULL && instance_->gmeList.move_to(GMEPtr)) {
     delete instance_->gmeList.remove();
     instance_->gmeList.insert(GMEPtr);
   }

     // Return the a pointer to the instance of the class.

   return instance_ ;
}
CubitStatus GeometryModifyTool::intersect ( Body tool_body_ptr,
DLIList< Body * > &  from_bodies,
DLIList< Body * > &  new_bodies,
bool  keep_old = false,
bool  preview = false 
)

Boolean intersect.

Definition at line 7427 of file GeometryModifyTool.cpp.

{
  if(tool_body_ptr == NULL )
    return CUBIT_FAILURE;
  if(from_bodies.size() == 0 || from_bodies.get() == NULL )
    return CUBIT_FAILURE;

  GfxPreview::clear();

  DLIList<Body*> tem_bodies = from_bodies;
  tem_bodies.append( tool_body_ptr );
  if (!okay_to_modify( tem_bodies, "INTERSECT" ))
    return CUBIT_FAILURE;

  DLIList<BodySM*> from_sm_list(tem_bodies.size());
  GeometryModifyEngine* engine = common_modify_engine(tem_bodies, from_sm_list);
  if ( NULL == engine )
  {
    PRINT_ERROR("Performing INTERSECTION with volumes containing geometry\n"
                "from different modeling engines is not allowed.\n"
                "Delete uncommon geometry on these volumes before operation.\n\n");
    return CUBIT_FAILURE;
  }

  BodySM* tool_sm = from_sm_list.pop();


  //cannot intersect tool with itself
  from_sm_list.remove_all_with_value( tool_sm );
  if( from_sm_list.size() == 0 )
  {
    PRINT_ERROR("Cannot intersect volume %d from itself\n",
                 tool_body_ptr->ref_volume()->id() );
    return CUBIT_FAILURE;
  }

  if( !preview && CubitUndo::get_undo_enabled() )
  {
    if( keep_old )
      CubitUndo::save_state();
    else
    {
      DLIList<Body*> bodies;
      bodies.append( tool_body_ptr );
      bodies += from_bodies;
      CubitUndo::save_state_with_cubit_file( bodies );
    }
  }

  DLIList<int> merged_surface_ids;
  DLIList<int> merged_curve_ids;
  if( !preview && (keep_old == CUBIT_FALSE) )
    get_merged_curve_and_surface_ids( from_bodies, merged_surface_ids, merged_curve_ids );

     // Do the intersect operation
  DLIList<BodySM*> new_sms;
  CubitStatus result =
      engine->intersect(tool_sm, from_sm_list, new_sms, keep_old, preview );

  if (!preview)
  {
    result = finish_sm_op(tem_bodies, new_sms, new_bodies);

    if( CubitUndo::get_undo_enabled() )
    {
      if( result == CUBIT_SUCCESS )
        CubitUndo::note_result_bodies( new_bodies );
      else
        CubitUndo::remove_last_undo();
    }

    if ( result == CUBIT_FAILURE )
    {
      PRINT_ERROR("Intersect FAILED\n" );
      return CUBIT_FAILURE;
    }

    if( keep_old == CUBIT_FALSE )
      fixup_merged_entities( merged_surface_ids, merged_curve_ids);
  }

  return CUBIT_SUCCESS;
}
CubitStatus GeometryModifyTool::intersect ( DLIList< Body * > &  from_bodies,
DLIList< Body * > &  new_bodies,
bool  keep_old = false,
bool  preview = false 
)

Boolean intersect.

Definition at line 7313 of file GeometryModifyTool.cpp.

{
  DLIList<Body*> tem_bodies = from_bodies;
  if (!okay_to_modify( tem_bodies, "INTERSECT" ))
    return CUBIT_FAILURE;

  GfxPreview::clear();

  DLIList<BodySM*> from_sm_list(tem_bodies.size());
  GeometryModifyEngine* engine = common_modify_engine(tem_bodies, from_sm_list);
  if ( NULL == engine )
  {
    PRINT_ERROR("Performing INTERSECTION with volumes containing geometry\n"
                "from different modeling engines is not allowed.\n"
                "Delete uncommon geometry on these volumes before operation.\n\n");
    return CUBIT_FAILURE;
  }

  if( !preview && CubitUndo::get_undo_enabled() )
  {
    if( keep_old )
      CubitUndo::save_state();
    else
      CubitUndo::save_state_with_cubit_file( from_bodies );
  }

  DLIList<int> merged_surface_ids;
  DLIList<int> merged_curve_ids;
  if( !preview && (keep_old == CUBIT_FALSE) )
    get_merged_curve_and_surface_ids( from_bodies, merged_surface_ids, merged_curve_ids );

  GeometryModifyEngine* gme_ptr = get_engine(from_sm_list.get());
  GeometryQueryEngine* gqe_ptr = gme_ptr->get_gqe();

  DLIList<BodySM*> all_new_bodysms;
  int i,j;
  for( i=0; i<from_sm_list.size(); i++ )
  {
    from_sm_list.reset();
    from_sm_list.step(i);
    BodySM *body1 = from_sm_list.get_and_step();

    for(j=i+1; j<from_sm_list.size(); j++ )
    {
      BodySM *body2 = from_sm_list.get_and_step();

      if( body1 == body2 )
        continue;

      //copy the bodies
      BodySM *body1_copy = gme_ptr->copy_body( body1 );
      BodySM *body2_copy = gme_ptr->copy_body( body2 );

      DLIList<BodySM*> tmp_sm_list(1);
      tmp_sm_list.append( body2_copy );
      DLIList<BodySM*> new_sms;

      CubitStatus result =
          engine->intersect(body1_copy, tmp_sm_list, new_sms, true, preview );

      //delete the copies
      gqe_ptr->delete_solid_model_entities( body1_copy );
      gqe_ptr->delete_solid_model_entities( body2_copy );

      if (!preview)
      {
        if ( result == CUBIT_FAILURE || new_sms.size() == 0 )
        {
          RefEntity* ref_ent1 = dynamic_cast<RefEntity*>(body1->topology_entity());
          RefEntity* ref_ent2 = dynamic_cast<RefEntity*>(body2->topology_entity());

          PRINT_WARNING("INTERSECTION of %s with %s failed\n",
            ref_ent1->entity_name().c_str(),
            ref_ent2->entity_name().c_str() );
          continue;

        }

        all_new_bodysms += new_sms;
      }
    }
  }

  if (!preview)
  {
    //now make all the RefEntities
    all_new_bodysms.reset();
    for( i=all_new_bodysms.size(); i--; )
    {
      Body *new_body = GeometryQueryTool::instance()->make_Body(all_new_bodysms.get_and_step());
      if( new_body )
        new_bodies.append( new_body );
    }

    if( CubitUndo::get_undo_enabled() )
    {
      if( all_new_bodysms.size() )
        CubitUndo::note_result_bodies( new_bodies );
      else
        CubitUndo::remove_last_undo();
    }

    if( keep_old == CUBIT_FALSE )
      fixup_merged_entities( merged_surface_ids, merged_curve_ids);
  }

  return CUBIT_SUCCESS;
}
CubitStatus GeometryModifyTool::loft_surfaces_to_body ( DLIList< RefFace * > &  surfaces,
DLIList< double > &  takeoff_factor_list,
DLIList< RefFace * > &  takeoff_vector_surface_list,
DLIList< CubitVector > &  surface_takeoff_vector_list,
DLIList< RefEdge * > &  takeoff_vector_curve_list,
DLIList< CubitVector > &  curve_takeoff_vector_list,
DLIList< RefEdge * > &  guides,
DLIList< RefVertex * > &  match_vertices_list,
Body *&  new_body,
CubitBoolean  global_guides,
CubitBoolean  closed,
CubitBoolean  show_matching_curves,
CubitBoolean  preview 
)

Definition at line 17842 of file GeometryModifyTool.cpp.

{
    DLIList<Surface*> loft_surfaces;

    // Get engine and correspoding geom entities
    GeometryModifyEngine* result_ptr;
    result_ptr = common_modify_engine( surfaces, loft_surfaces );
    if (!result_ptr)
    {
        PRINT_ERROR("Loft surfaces on volumes containing surfaces from different\n"
            "       geometry engines is not allowed.\n");
        return CUBIT_FAILURE;
    }


    DLIList<Curve*> loft_guide_curves;
    // Get engine and correspoding geom entities
    if(guides.size())
    {
      result_ptr = common_modify_engine( guides, loft_guide_curves );
      if (!result_ptr)
      {
        PRINT_ERROR("Loft guide curves containing curves from different\n"
          "       geometry engines is not allowed.\n");
        return CUBIT_FAILURE;
      }
    }



    DLIList<TBPoint*> loft_matched_points;
    // Get engine and correspoding geom entities
    if(match_vertices_list.size())
    {
      result_ptr = common_modify_engine( match_vertices_list, loft_matched_points );
      if (!result_ptr)
      {
        PRINT_ERROR("Loft matched vertices containing points from different\n"
          "       geometry engines is not allowed.\n");
        return CUBIT_FAILURE;
      }
    }

    DLIList<Surface*> loft_takeoff_surfaces;

    if(takeoff_vector_surface_list.size())
    {
      // Get engine and correspoding geom entities
      GeometryModifyEngine* result_ptr;
      result_ptr = common_modify_engine( takeoff_vector_surface_list, loft_takeoff_surfaces );
      if (!result_ptr)
      {
        PRINT_ERROR("Loft takeoff surfaces on volumes containing surfaces from different\n"
          "       geometry engines is not allowed.\n");
        return CUBIT_FAILURE;
      }
    }

    DLIList<Curve*> loft_takeoff_curves;

    if(takeoff_vector_curve_list.size())
    {
      // Get engine and correspoding geom entities
      GeometryModifyEngine* result_ptr;
      result_ptr = common_modify_engine( takeoff_vector_curve_list, loft_takeoff_curves );
      if (!result_ptr)
      {
        PRINT_ERROR("Loft takeoff surfaces on volumes containing surfaces from different\n"
          "       geometry engines is not allowed.\n");
        return CUBIT_FAILURE;
      }
    }


    BodySM* new_body_sm = 0;

    if( CubitUndo::get_undo_enabled() )
      CubitUndo::save_state();

    CubitStatus result = result_ptr->loft_surfaces_to_body(
        loft_surfaces,
        takeoff_factor_list,
        loft_takeoff_surfaces,
        surface_takeoff_vector_list,
        loft_takeoff_curves,
        curve_takeoff_vector_list,
        loft_guide_curves,
        loft_matched_points,
        new_body_sm,
        global_guides,
        closed,
        show_matching_curves,
        preview);

    if(result && new_body_sm)
    {
        new_body = GeometryQueryTool::instance()->make_Body(new_body_sm);

        if( CubitUndo::get_undo_enabled() )
          CubitUndo::note_result_body(new_body);
    }
    else
    {
      if( CubitUndo::get_undo_enabled() )
        CubitUndo::remove_last_undo();
    }
   return result;
}
Body * GeometryModifyTool::make_Body ( Surface surface) const

Creates a sheet body from a surface.

Definition at line 1061 of file GeometryModifyTool.cpp.

{
  // make a Body from a Surface
  BodySM *body_sm = surface->bodysm();

  GeometryModifyEngine* gme = get_engine(surface);

  if (gme && !body_sm)
    body_sm = gme->make_BodySM(surface);

  assert(body_sm != 0);

  return GeometryQueryTool::instance()->make_Body(body_sm);
}
Body * GeometryModifyTool::make_Body ( DLIList< RefVolume * > &  ref_volume_list) const

Creates a body from a list of volumes.

Returns:
Body*
- A pointer to a newly created Body
  • ref_volume_list The RefVolumes to use to create the Body
This function takes a list of RefVolumes to create a Body. The underlying representation of the Body is determined by the GeometryQueryEngine of the RefVolumes. All the RefVolumes in the list must be associated with the same GeometryQueryEngine. The return value can be a NULL pointer, if the RefFace cannot be succesfully made for some reason.

Definition at line 2267 of file GeometryModifyTool.cpp.

{
  DLIList<TopologyEntity*> topo_list;
  DLIList<Lump*> lump_list;
  DLIList<TopologyBridge*> bridge_list;
  CAST_LIST_TO_PARENT( ref_volume_list, topo_list );
  GeometryModifyEngine* GME_ptr =
    common_modify_engine( topo_list, bridge_list, CUBIT_FALSE );
  if( ! GME_ptr )
  {
    PRINT_ERROR("The specified volumes do not belong to the same "
      "geometry engine, and therefore cannot be used to form a "
      "single body.");
    return 0;
  }
  CAST_LIST( bridge_list, lump_list, Lump );
  assert( ref_volume_list.size() == lump_list.size() );


     // Use the Lumps to create a BodySM
   BodySM* bodySM_ptr = GME_ptr->make_BodySM(lump_list) ;

     // If we get a NULL pointer, give a warning message and return
     // a NULL pointer.
   if ( bodySM_ptr == NULL )
   {
      PRINT_WARNING("In GeometryModifyTool::make_Body\n"
                    "         Got a NULL pointer to a BodySM.\n"
                    "         Cannot make a Body.\n") ;
      return (Body *)NULL;
   }

   return GeometryQueryTool::instance()->make_Body(bodySM_ptr);
}
Body * GeometryModifyTool::make_Body ( RefFace from_ref_face,
std::map< RefEntity *, RefEntity * > *  old_to_new_map = NULL 
) const

Creates a body from a surface.

Creates a body from a ref_face. This will always be a sheet body, with no volume, consisting of a single face. The old_to_new_map is an optional parameter that maps all the entities of the original to those of the copy.

Definition at line 2313 of file GeometryModifyTool.cpp.

{
     // Given the arguments, make a RefFace.
   RefFace* new_ref_face = this->make_RefFace(from_ref_face,
                                              old_to_new_map );
   if (!new_ref_face)
   {
      return (Body *)NULL;
   }

   DLIList<Body*> bodies;
   new_ref_face->bodies(bodies);

   if (!bodies.size()) {
     GeometryEntity *ge_ptr = new_ref_face->get_geometry_entity_ptr();
     Surface *surf_ptr = CAST_TO(ge_ptr, Surface);
     assert(surf_ptr != 0);

     BodySM *body_sm = gmeList.get()->make_BodySM(surf_ptr);
     return GeometryQueryTool::instance()->make_Body(body_sm);
   }

   else return bodies.get();
}
Body * GeometryModifyTool::make_Body ( GeometryType  ref_face_type,
DLIList< RefEdge * > &  ref_edge_list,
RefFace ref_face_ptr = NULL 
) const

Creates a body from a surface created from a list of curves.

Returns:
Body*
- A pointer to a newly created Body that has just one RefFace
  • ref_face_type The type of the RefFace
  • ref_edge_list The RefEdges to use to create the RefFace. The RefFace will have just one loop. The first RefEdge in the list will be first RefEdge of the loop and so on.
This function takes a type information and a list of RefEdges to create a Body that has just one RefFace. The underlying representation of the Body is determined by the GeometryQueryEngine of the RefEdges. All the RefEdges in the list must be associated with the same GeometryQueryEngine. The return value can be a NULL pointer, if the Body cannot be succesfully made for some reason.

Each RefEdge in ref_edge_list MUST be a free edge, i.e., not attached to a RefFace, for this function to succeed!

Definition at line 2355 of file GeometryModifyTool.cpp.

{
   if( CubitUndo::get_undo_enabled() )
     CubitUndo::save_state_with_cubit_file( ref_edge_list );

   bool is_free_face = false;

     // Given the arguments, make a RefFace.
   RefFace* new_ref_face = this->make_RefFace(ref_face_type,
                                              ref_edge_list,
                                              is_free_face,
                                              ref_face_ptr);

   if( new_ref_face == NULL )
      return NULL;

      // If new_ref_face doesn't have a body, create one.
   DLIList<Body*> bodies;
   new_ref_face->bodies(bodies);

   if (!bodies.size()) {
     Surface *surf_ptr = new_ref_face->get_surface_ptr();
     assert(surf_ptr != 0);
     GeometryModifyEngine* engine = get_engine(surf_ptr);
     assert(engine != 0);

     BodySM *body_sm = engine->make_BodySM(surf_ptr);
     Body* body = GeometryQueryTool::instance()->make_Body(body_sm);
     bodies.append( body );
   }

   if( CubitUndo::get_undo_enabled() )
   {
     if( bodies.size() )
       CubitUndo::note_result_entity( bodies.get() );
     else
      CubitUndo::remove_last_undo();
   }

     // Return the body containing the new RefFace.
   return bodies.get();
}
RefEdge * GeometryModifyTool::make_elliptical_RefEdge ( RefVertex vert1,
RefVertex vert2,
CubitVector  center_point,
double  start_angle,
double  end_angle,
CubitSense  sense 
) const

Definition at line 1729 of file GeometryModifyTool.cpp.

{
  GeometryModifyEngine* GMEPtr = 0;

  // Extract the Points to be used to make the RefEdge
  TBPoint* point_ptr1 = NULL;
  TBPoint* point_ptr2 = NULL;

  // Look for a common geometric modeling engine to use
  GMEPtr = make_RefEdge_common( vert1, vert2,
                                point_ptr1, point_ptr2 );
  if (!GMEPtr)
    return 0;

  // Make sure that we get back valid Points
  assert ( point_ptr1 != NULL && point_ptr2 != NULL ) ;

  if( CubitUndo::get_undo_enabled() )
  {
    //if endpoints are free vertices, need to save them out
    DLIList<RefVertex*> verts_to_save;
    verts_to_save.append( vert1 );
    verts_to_save.append( vert2 );
    bool save_only_if_free = true;
    CubitUndo::save_state_with_cubit_file( verts_to_save, save_only_if_free );
  }

  // Request the GME to create a Curve using the Points
  Curve* curve_ptr = GMEPtr->make_elliptical_Curve(point_ptr1,
                                                   point_ptr2,
                                                   center_point,
                                                   start_angle,
                                                   end_angle,
                                                   sense);

  // If we get a NULL pointer, give a warning message and return
  // a NULL pointer.
  if ( curve_ptr == NULL )
  {
    PRINT_WARNING("In GeometryModifyTool::make_elliptical_RefEdge\n"
                  "         Got a NULL pointer to a Curve.\n"
                  "         Problems making RefEdge from RefVertex %d and %d\n",
                  vert1->id(), vert2->id());
    return (RefEdge *)NULL ;
  }

  // Complete the task of linking this new Curve into the rest of the
  // geometry datastructures and return the new RefEdge.
  RefEdge *new_edge = GeometryQueryTool::instance()->make_free_RefEdge( curve_ptr );
  if( CubitUndo::get_undo_enabled() )
  {
    if( new_edge )
      CubitUndo::note_result_entity( new_edge );
  }

  return new_edge;
}
Body * GeometryModifyTool::make_extended_sheet ( DLIList< RefFace * > &  ref_face_list,
CubitBox clip_box_ptr = NULL,
bool  preview = false 
) const

This function creates a sheet body by extending the input surfaces.

Returns:
Body*
- Pointer to a newly created Body object.
  • ref_face_list The RefFace list from which we want to create an extended sheet.
  • clip_box An optional bounding box to clip the resultant sheet body by.
  • preview If true just draw the extended sheet instead of creating it
This function creates a sheet body by extending the input surfaces. The result can be optionally clipped to fit inside of the given bounding box.

Definition at line 2050 of file GeometryModifyTool.cpp.

{
  if( !ref_face_list.size() )
    return 0;

  GfxPreview::clear();

  // Check for virtual geometry
  DLIList<RefEntity*> ref_ent_list;
  CAST_LIST_TO_PARENT(ref_face_list, ref_ent_list);
  if ( GeometryQueryTool::instance()->contains_intermediate_geometry(ref_ent_list) )
  {
    PRINT_ERROR("EXTENDING surfaces containing virtual geometry is not\n"
      "       allowed. Delete virtual geometry on these surfaces\n"
      "       before operation.\n" );
    return 0;
  }

  // Look for a common GeometryModifyEngine for all of the RefFaces
  int count = ref_face_list.size();
  DLIList<TopologyBridge*> bridge_list(count);
  DLIList<TopologyEntity*> entity_list(count);
  CAST_LIST_TO_PARENT( ref_face_list, entity_list );

  GeometryModifyEngine* GME_ptr =
    common_modify_engine( entity_list, bridge_list );
  if(! GME_ptr )
  {
     PRINT_ERROR("Cannot construct an extended sheet using surfaces that\n"
                 "       do not share a common geometry engine.\n");
     return 0;
  }

  DLIList<Surface*> surface_list(count);
  CAST_LIST( bridge_list, surface_list, Surface );
  
  if( CubitUndo::get_undo_enabled() )
    CubitUndo::save_state();

  BodySM *bodySM_ptr = GME_ptr->make_extended_sheet( surface_list,
    clip_box_ptr, preview );

  if( !bodySM_ptr )
    CubitUndo::remove_last_undo();

  if( bodySM_ptr )
  {
    Body *tmp_body = GeometryQueryTool::instance()->make_Body(bodySM_ptr);

    if( CubitUndo::get_undo_enabled() )
    {
      if( tmp_body )
        CubitUndo::note_result_entity( tmp_body );
      else 
        CubitUndo::remove_last_undo();
    }

    return tmp_body;
  }
  else
    return 0;
}
RefEdge * GeometryModifyTool::make_RefEdge ( GeometryType  ref_edge_type,
RefVertex ref_vertex_1,
RefVertex ref_vertex_2,
DLIList< CubitVector * > &  vector_list,
RefFace reffaca_ptr = NULL 
) const

Creates a curve from two or more points.

Returns:
RefEdge*
- A pointer to a newly created RefEdge
  • ref_edge_type The type of the RefEdge
  • ref_vertex_1 The starting point of the to be created RefEdge.
  • ref_vertex_2 The end point of the to be created RefEdge.
  • vector_list List of CubitVectors.
  • refface_ptr Input pointer to a RefFace -- defaults to NULL.
This function creates a RefEdge connected to the input RefVertices as end points. This RefEdge interpolates between the locations represented by the input set of CubitVectors. A spline curve is created. If the input refface_ptr is not NULL, the points are first moved to the surface before interpolation.

Definition at line 1815 of file GeometryModifyTool.cpp.

{
   GeometryModifyEngine* GMEPtr = 0;

     // Extract the end Points to be used to make the RefEdge
   TBPoint* point_ptr1 = NULL;
   TBPoint* point_ptr2 = NULL;
   Surface* surface_ptr = NULL;

   // Look for a common GeometryModifyEngine
  GMEPtr = make_RefEdge_common( ref_vertex_1, ref_vertex_2,
                                point_ptr1, point_ptr2,
                                refface_ptr, &surface_ptr );
  if (!GMEPtr)
    return 0;

     // Make sure that we get back valid Points
   assert ( point_ptr1 != NULL && point_ptr2 != NULL );

   if( CubitUndo::get_undo_enabled() )
   {
     //if endpoints are free vertices, need to save them out
     DLIList<RefVertex*> verts_to_save;
     verts_to_save.append( ref_vertex_1 );
     verts_to_save.append( ref_vertex_2 );
     bool save_only_if_free = true;
     CubitUndo::save_state_with_cubit_file( verts_to_save, save_only_if_free );
   }

     // Request the GME to create a Curve using the Points
   Curve* curve_ptr = GMEPtr->make_Curve(ref_edge_type,
                                         point_ptr1,
                                         point_ptr2,
                                         vector_list,
                                         refface_ptr ? refface_ptr->get_surface_ptr() : 0);

     // If we get a NULL pointer, give a warning message and return
     // a NULL pointer.
   if ( curve_ptr == NULL )
   {
      PRINT_WARNING("In GeometryModifyTool::make_RefEdge\n"
                    "         Got a NULL pointer to a Curve.\n"
                    "         Problems making a spline RefEdge from RefVertex %d and %d\n"
                    "         and the input list of positions.\n",
                    ref_vertex_1->id(), ref_vertex_2->id());
      return (RefEdge *)NULL ;
   }

     // Complete the task of linking this new Curve into the rest of the
     // geometry datastructures and return the new RefEdge.
   RefEdge *new_edge = GeometryQueryTool::instance()->make_free_RefEdge(curve_ptr);
   if( CubitUndo::get_undo_enabled() )
   {
     if( new_edge )
       CubitUndo::note_result_entity( new_edge );
   }
   return new_edge;
}
RefEdge * GeometryModifyTool::make_RefEdge ( RefVertex ref_vertex_1,
RefVertex ref_vertex_2,
RefFace ref_face_ptr,
RefVertex const *  ref_vertex_3 = NULL 
) const

Creates a curve from two or more points, on a surface.

Returns:
RefEdge*
- A pointer to a newly created RefEdge
  • ref_edge_type The type of the RefEdge
  • ref_vertex_1 The starting point of the to be created RefEdge.
  • ref_vertex_2
  • refface_ptr
This function creates a RefEdge connected to the input RefVertices as end points. This is along the ref_face. It is basically a straight line along the surface. In periodic surfaces, a third point may be used to create the give the correct direction.

Definition at line 1614 of file GeometryModifyTool.cpp.

{
      //make sure that the vertices are on the ref-face.
   CubitVector vert_1 = ref_vertex_1->coordinates();
   CubitVector vert_2 = ref_vertex_2->coordinates();

   ref_face_ptr->move_to_surface(vert_1);
   ref_face_ptr->move_to_surface(vert_2);

   GeometryQueryEngine *gqe = ref_face_ptr->get_geometry_query_engine();

   if (!ref_vertex_1->coordinates().within_tolerance(vert_1, gqe->get_sme_resabs_tolerance()))
   {
      PRINT_ERROR("vertices must lie within tolerance to the given"
                  " surface.\n"
                  "%s (Vertex %d) does not lie on %s (Surface %d).\n",
                  ref_vertex_1->entity_name().c_str(),
                  ref_vertex_1->id(),
                  ref_face_ptr->entity_name().c_str(),
                  ref_face_ptr->id() );
      return (RefEdge*)NULL;
   }
   else if (!ref_vertex_2->coordinates().within_tolerance(vert_2, gqe->get_sme_resabs_tolerance() ))
   {
      PRINT_ERROR("vertices must lie within tolerance to the given"
                  " surface.\n"
                  "%s (Vertex %d) does not lie on %s (Surface %d).\n",
                  ref_vertex_2->entity_name().c_str(),
                  ref_vertex_2->id(),
                  ref_face_ptr->entity_name().c_str(),
                  ref_face_ptr->id() );
      return (RefEdge*)NULL;
   }
     //Now let us find the points on the surface.  We want to
     //create them as we go for accuracy.

      // Get the GME of the first RefVertex.
   GeometryModifyEngine* GMEPtr = 0;

     // Extract the end Points to be used to make the RefEdge
   TBPoint* point_ptr1 = NULL;
   TBPoint* point_ptr2 = NULL;
   Surface* surface_ptr = NULL;

   // Look for a common GeometryModifyEngine
  GMEPtr = make_RefEdge_common( ref_vertex_1, ref_vertex_2,
                                point_ptr1, point_ptr2,
                                ref_face_ptr, &surface_ptr );

  //If we did not find a common GeometryModifyEngine, fail
  if( ! GMEPtr )
  {
    PRINT_ERROR("Surface %d, vertex %d and vertex %d do not "
      "belong to the same geometric modeling engine.\n", ref_face_ptr->id(),
      ref_vertex_1->id(), ref_vertex_2->id() );

    return 0;
  }

   CubitVector *third_vector_ptr = NULL;
   CubitVector third_vector;
   if ( ref_vertex_3 != NULL )
   {
      third_vector = ref_vertex_3->coordinates();
      third_vector_ptr = &third_vector;
      ref_face_ptr->move_to_surface( third_vector );
   }

     // Make sure that we get back valid Points
   assert ( point_ptr1 != NULL && point_ptr2 != NULL );
   
   if( CubitUndo::get_undo_enabled() )
   {
     //if endpoints are free vertices, need to save them out
     DLIList<RefVertex*> verts_to_save;
     verts_to_save.append( ref_vertex_1 );
     verts_to_save.append( ref_vertex_2 );
     bool save_only_if_free = true;
     CubitUndo::save_state_with_cubit_file( verts_to_save, save_only_if_free );
   }

     // Request the GME to create a Curve using the Points
   Curve *curve_ptr;
   curve_ptr = GMEPtr->make_Curve( point_ptr1,
                          point_ptr2,
                          surface_ptr,
                          third_vector_ptr);


     // If we get a NULL pointer, give a warning message and return
     // a NULL pointer.
   if ( curve_ptr == NULL )
   {
      PRINT_WARNING("In GeometryModifyTool::make_RefEdge\n"
                    "\tProblems making a spline curve from Vertex %d and %d\n"
                    "\tand the input list of positions.\n",
                    ref_vertex_1->id(), ref_vertex_2->id());
      return (RefEdge *)NULL ;
   }
  

     // Complete the task of linking this new Curve into the rest of the
     // geometry datastructures and return the new RefEdge.
   RefEdge *new_edge = GeometryQueryTool::instance()->make_free_RefEdge(curve_ptr);
   if( CubitUndo::get_undo_enabled() )
   {
     if( new_edge )
       CubitUndo::note_result_entity( new_edge );
   }
   return new_edge;
}
RefEdge * GeometryModifyTool::make_RefEdge ( RefEdge ref_edge,
bool  copy_attribs = true,
std::map< RefEntity *, RefEntity * > *  old_to_new_map = NULL 
) const

Create a curve from an existing curve.

Give a certain ref edge, create a new one. This is useful when you are creating surfaces from curves already in the model. If you use curves existing in the model (attached to other surfaces) then will mess up. So we basically need a copy. This will also create new vertices... The old_to_new_map is an optional parameter that maps all the entities of the original to those of the copy.

Definition at line 1083 of file GeometryModifyTool.cpp.

{
  if ( ref_edge_ptr == NULL )
  {
    PRINT_ERROR("curve is NULL\n");
    return (RefEdge*)NULL;
  }

  TopologyBridge* bridge = 0;
  GeometryModifyEngine* engine = get_engine(ref_edge_ptr, &bridge);
  Curve *old_curve = dynamic_cast<Curve*>(bridge);
  if (engine == NULL)
  {
     PRINT_ERROR( "%s (curve %d) does not have a modify engine.\n",
                  ref_edge_ptr->entity_name().c_str(),
                  ref_edge_ptr->id() );
     return 0;
  }

  Curve *tmp_curve;
  if( copy_attribs )
  {
    DLIList<RefEntity*> tmp_list;
    tmp_list.append( ref_edge_ptr );
    TopologyBridge *curve_bridge;
    prepare_for_copy( ref_edge_ptr, curve_bridge );
    tmp_curve = CAST_TO( curve_bridge, Curve);
  }
  else
    tmp_curve = old_curve;

  std::map<TopologyBridge*, TopologyBridge*> old_tb_to_new_tb;
  Curve *new_curve = NULL;
  if( old_to_new_map )
    new_curve = engine->make_Curve( tmp_curve, &old_tb_to_new_tb );
  else 
    new_curve = engine->make_Curve( tmp_curve );

  if (!new_curve)
  {
    if( copy_attribs )
      clean_up_from_copy_failure( old_curve );
    return (RefEdge *)NULL;
  }

  TopologyBridge *new_curve_bridge;
  if( copy_attribs )
  {
    new_curve_bridge = new_curve;
    finish_copy( new_curve_bridge, old_curve );
    new_curve = CAST_TO( new_curve_bridge, Curve);
  }

  if( CubitUndo::get_undo_enabled() )
    CubitUndo::save_state();

  // Complete the task of linking this new Curve into the rest of the
  // geometry datastructures and return the new RefEdge.
  RefEdge *new_ref_edge = GeometryQueryTool::instance()->make_free_RefEdge(new_curve);

  if( old_to_new_map )
     create_old_to_new_ref_ent_map( old_curve, new_curve, *old_to_new_map, old_tb_to_new_tb );

  if( CubitUndo::get_undo_enabled() )
    CubitUndo::note_result_entity( new_ref_edge );

  return new_ref_edge;
}
RefEdge * GeometryModifyTool::make_RefEdge ( GeometryType  ref_edge_type,
RefVertex ref_vertex_1,
RefVertex ref_vertex_2,
CubitVector const *  intermediate_point = NULL 
) const

Create a curve, i.e. ellipse, parabola, straight, or arc curves.

Returns:
RefEdge*
- A pointer to a newly created RefEdge
  • ref_edge_type The type of the RefEdge
  • ref_vertex_1 The starting point of the to be created RefEdge.
  • ref_vertex_2 The end point of the to be created RefEdge. indermediate_point The intermediate point to be used to form the RefEdge. For a parabola, the intermediate point is the tip of the parabola. For an ellipse, the intermediate point is the center of the ellipse. If the intermediate point is does not lie at the center of a circle, an logarithmic spiral curve is generated. For straight curves this argument is ignored.
  • sense
The "sense" makes sense (no pun intended) only for ellipses in the XY plane. For ellipses in the XY plane, the curve can defined from point-1 to point-2 in two ways. The direction of the curve can be such that the vector going from the center to the first point can be rotated in a counter clockwise manner to reach the vector going from the center to the second point. Such an ellipse is considered to have positive or FORWARD sense. When the curve is defined in the other direction it is considered to have a negative or REVERSED sense. This argument is ignored for straight and parabolic curves. This function takes a type information, two RefVertices, an intermediate position, and a sense information to create a RefEdge. The RefVertices must be associated with the same GeometryQueryEngine. The return value can be a NULL pointer, if the RefEdge cannot be succesfully made for some reason.

Elliptical: The portion of the ellipse (circle) that is generated goes from the first point to the second point.

Parabolic: Construct a parabolic arc from 3 points. The intermediate point is the peak of the parabola - in this case, the point which is equidistant from the start and end points of the parabola. The 3 points must form an isosceles triangle. This definition limits the user to generation of the tip of parabolic shapes only.

Definition at line 1892 of file GeometryModifyTool.cpp.

{
   GeometryModifyEngine* GMEPtr = 0;

     // Extract the Points to be used to make the RefEdge
   TBPoint* point_ptr1 = NULL;
   TBPoint* point_ptr2 = NULL;

    // Look for a common geometric modeling engine to use
  GMEPtr = make_RefEdge_common( ref_vertex_1, ref_vertex_2,
                                point_ptr1, point_ptr2 );
  if (!GMEPtr)
    return 0;

     // Make sure that we get back valid Points
   assert ( point_ptr1 != NULL && point_ptr2 != NULL ) ;

   if( CubitUndo::get_undo_enabled() )
   {
     //if endpoints are free vertices, need to save them out
     DLIList<RefVertex*> verts_to_save;
     verts_to_save.append( ref_vertex_1 );
     verts_to_save.append( ref_vertex_2 );
     bool save_only_if_free = true;
     CubitUndo::save_state_with_cubit_file( verts_to_save, save_only_if_free );
   }

     // Request the GME to create a Curve using the Points
   Curve* curve_ptr = GMEPtr->make_Curve(ref_edge_type,
                                         point_ptr1,
                                         point_ptr2,
                                         intermediate_point );

     // If we get a NULL pointer, give a warning message and return
     // a NULL pointer.
   if ( curve_ptr == NULL )
   {
      PRINT_WARNING("In GeometryModifyTool::make_RefEdge\n"
                    "         Got a NULL pointer to a Curve.\n"
                    "         Problems making RefEdge from RefVertex %d and %d\n",
                    ref_vertex_1->id(), ref_vertex_2->id());
      return (RefEdge *)NULL ;
   }

     // Complete the task of linking this new Curve into the rest of the
     // geometry datastructures and return the new RefEdge.
   RefEdge *new_edge = GeometryQueryTool::instance()->make_free_RefEdge( curve_ptr );
   if( CubitUndo::get_undo_enabled() )
   {
     if( new_edge )
       CubitUndo::note_result_entity( new_edge );
   }
   return new_edge;
}
GeometryModifyEngine * GeometryModifyTool::make_RefEdge_common ( RefVertex start_vertex,
RefVertex end_vertex,
TBPoint *&  start_point,
TBPoint *&  end_point,
RefFace ref_face = 0,
Surface **  surface = 0 
) const [protected]

Definition at line 1523 of file GeometryModifyTool.cpp.

{
  DLIList<TopologyEntity*> entity_list(3);
  DLIList<TopologyBridge*> bridge_list(3);
  TopologyBridge* bridge = 0;
  GeometryModifyEngine* gme = 0;
  start_point = end_point = 0;

  bool new_start_point = start_vertex->get_parents() > 0;
  bool new_end_point = end_vertex->get_parents() > 0;

  if (ref_face)
    entity_list.append( ref_face );
  if (!new_start_point)
    entity_list.append( start_vertex );
  if (!new_end_point)
    entity_list.append( end_vertex );

  if (entity_list.size())
    gme = common_modify_engine( entity_list, bridge_list );

  if (gme)
  {
    bridge_list.reset();
    if (ref_face)
      *surface = dynamic_cast<Surface*>(bridge_list.get_and_step());
    if (!new_start_point)
      start_point = dynamic_cast<TBPoint*>(bridge_list.get_and_step());
    if (!new_end_point)
      end_point = dynamic_cast<TBPoint*>(bridge_list.get_and_step());
  }
  else if (ref_face)
  {
    gme = get_engine( ref_face, &bridge );
    if (!gme)
    {
      PRINT_ERROR("No modify engine for surface %d\n", ref_face->id()) ;
      return 0;
    }
    *surface = dynamic_cast<Surface*>(bridge);
    GeometryQueryEngine* gqe = bridge->get_geometry_query_engine();
    if (!new_start_point)
      start_point = dynamic_cast<TBPoint*>( start_vertex->
                                  bridge_manager()->topology_bridge( gqe ) );
    if (!new_end_point)
      end_point = dynamic_cast<TBPoint*>( end_vertex->
                                  bridge_manager()->topology_bridge( gqe ) );
  }
  else if (!new_start_point && (gme = get_engine( start_vertex, &bridge )))
  {
    start_point = dynamic_cast<TBPoint*>(bridge);
    if (!new_end_point)
      end_point = dynamic_cast<TBPoint*>( end_vertex->bridge_manager()->
                    topology_bridge( bridge->get_geometry_query_engine() ) );
  }
  else if (!new_end_point && (gme = get_engine( end_vertex, &bridge )))
  {
    end_point = dynamic_cast<TBPoint*>(bridge);
  }
  else
  {
    gme = get_gme();
  }


  if (!start_point)
    start_point = gme->make_Point( start_vertex->coordinates() );
  if (!end_point)
    end_point = gme->make_Point( end_vertex->coordinates());

  return gme;
}
RefFace * GeometryModifyTool::make_RefFace ( RefFace from_ref_face,
std::map< RefEntity *, RefEntity * > *  old_to_new_map = NULL 
) const

Create a surface from an existing one.

Definition at line 1962 of file GeometryModifyTool.cpp.

{
   GeometryModifyEngine* GME_ptr = get_engine(from_ref_face);

   if (!GME_ptr)
   {
      PRINT_ERROR("Cannot create surface from another virtual surface.\n");
      return NULL;
   }
     //From the surface create a new surface.
   TopologyBridge* bridge = 0;
   GeometryModifyEngine* engine = get_engine(from_ref_face, &bridge);
   Surface* old_surface_ptr = dynamic_cast<Surface*>(bridge);
   if ( engine == NULL )
   {
      PRINT_ERROR("%s (surface %d) does not have a modify engine.\n",
                  from_ref_face->entity_name().c_str(),
                  from_ref_face->id() );
      return (RefFace*)NULL;
   }

  if( CubitUndo::get_undo_enabled() )
    CubitUndo::save_state();

  //this list will get all the TB's what we'll be copying
  TopologyBridge *top_bridge = old_surface_ptr;

  
  //if( !extended_from )
  {
    prepare_for_copy( from_ref_face, top_bridge );
  }

  Surface *tmp_surface = CAST_TO( top_bridge, Surface );
  std::map< TopologyBridge*, TopologyBridge* > old_tb_to_new_tb;
  Surface* new_surface_ptr = engine->make_Surface( tmp_surface, &old_tb_to_new_tb );

  if (!new_surface_ptr)
  {
    PRINT_ERROR("Surface copy failed.\n");
    //if( !extended_from )
      clean_up_from_copy_failure( old_surface_ptr );

   if( CubitUndo::get_undo_enabled() )
        CubitUndo::remove_last_undo();

    return 0;
  }
  
  //if( !extended_from  )
  {
    TopologyBridge *top_bridge_new = new_surface_ptr;
    finish_copy( top_bridge_new, old_surface_ptr );
    new_surface_ptr = CAST_TO( top_bridge_new, Surface );
  }

  Body *new_Body = make_Body(new_surface_ptr);
  DLIList<RefFace*> ref_faces;
  new_Body->ref_faces(ref_faces);
  assert(ref_faces.size() > 0);
  
  if( old_to_new_map )
    create_old_to_new_ref_ent_map( tmp_surface, new_surface_ptr, *old_to_new_map, old_tb_to_new_tb );

  if( CubitUndo::get_undo_enabled() )
  {
    if( new_Body )
      CubitUndo::note_result_body( new_Body );
    else
      CubitUndo::remove_last_undo();
  }

  return ref_faces.get();
}
RefFace * GeometryModifyTool::make_RefFace ( GeometryType  ref_face_type,
DLIList< RefEdge * > &  ref_edge_list,
bool  is_free_face,
RefFace ref_face_ptr = NULL,
bool  check_edges = true 
) const

Creates a surface from bounding curves.

Returns:
RefFace*
- A pointer to a newly created RefFace
  • ref_face_type The type of the RefFace
  • ref_edge_list The RefEdges to use to create the RefFace. The RefFace will have just one loop. The first RefEdge in the list will be first RefEdge of the loop and so on.
  • ref_face_ptr The surface that the curves will "cut" a piece out of. The curves must lie on this surface. (specific to OCC) Creates duplicate edges if these edges are already in use or if their vertices are merged. For more info see: AME::make_Surface
This function takes a type information and a list of RefEdges to create a RefFace. The underlying representation of the RefFace is determined by the GeometryQueryEngine of the RefEdges. All the RefEdges in the list must be associated with the same GeometryQueryEngine. The return value can be a NULL pointer, if the RefFace cannot be succesfully made for some reason.

Definition at line 2132 of file GeometryModifyTool.cpp.

{
    //Look for a common GeometryModifyEngine for all of
    //the RefEdges.

  const int count = ref_edge_list.size() + (ref_face_ptr ? 1 : 0);
  DLIList<TopologyBridge*> bridge_list(count);
  DLIList<TopologyEntity*> entity_list(count);
  CAST_LIST_TO_PARENT( ref_edge_list, entity_list );
  if( ref_face_ptr ) entity_list.append( ref_face_ptr );

  GeometryModifyEngine* GME_ptr =
    common_modify_engine( entity_list, bridge_list );
  if(! GME_ptr )
  {
     PRINT_ERROR("Cannot construct a Surface using entities that do "
                 "not share a common geometry engine.\n");
     return 0;
  }

   Surface* old_surface_ptr = 0;
   if (ref_face_ptr)
    old_surface_ptr = dynamic_cast<Surface*>(bridge_list.pop());

   //Collect all the names on vertices to propagate after you create
   //the surface
   DLIList<CubitVector> vertex_coordinates;
   DLIList<CubitString> vertex_names;
   DLIList<RefEdge*> free_ref_edges;
   int kk;
   for( kk=ref_edge_list.size(); kk--; )
   {
     DLIList<CubitString> tmp_names;
     RefEdge *tmp_edge = ref_edge_list.get_and_step();

     if( tmp_edge->num_parent_ref_entities() == 0 )
       free_ref_edges.append( tmp_edge );

     RefVertex *s_vertex = tmp_edge->start_vertex();
     RefVertex *e_vertex = tmp_edge->end_vertex();
     int jj;

     s_vertex->entity_names( tmp_names );
     for( jj=tmp_names.size(); jj--; )
     {
       CubitVector tmp_vec = tmp_edge->start_vertex()->coordinates();
       CubitString name = tmp_names.get_and_step();
       vertex_coordinates.append( tmp_vec );
       vertex_names.append( name );
     }

     tmp_names.clean_out();
     e_vertex->entity_names( tmp_names );
     for( jj=tmp_names.size(); jj--; )
     {
       CubitVector tmp_vec = tmp_edge->end_vertex()->coordinates();
       CubitString name = tmp_names.get_and_step();
       vertex_coordinates.append( tmp_vec );
       vertex_names.append( name );
     }
   }

   DLIList<Curve*> curve_list(ref_edge_list.size());
   CAST_LIST( bridge_list, curve_list, Curve );

     // Use the Curves to create a Surface
   Surface* surface_ptr = GME_ptr->make_Surface(ref_face_type, curve_list,
                                                old_surface_ptr, check_edges) ;

   if (surface_ptr == NULL) {
     PRINT_ERROR("Couldn't make new RefFace.\n");
     return NULL;
   }

   GeometryQueryTool* const gqt = GeometryQueryTool::instance();

   RefFace* result_face = gqt->make_free_RefFace(surface_ptr, is_free_face);
   gqt->cleanout_deactivated_geometry();

   //send out events for free curves saying that their 'free' status has
   //be changed

  for( kk=0; kk<free_ref_edges.size(); kk++ )
  {
    RefEdge *free_edge = free_ref_edges.get_and_step();
    AppUtil::instance()->send_event(GeometryEvent(GeometryEvent::TOP_LEVEL_ENTITY_DESTRUCTED, free_edge));
    CGMHistory::Event evt(CGMHistory::TOP_LEVEL_ENTITY_DELETED, free_edge );
    GeometryQueryTool::instance()->history().add_event(evt);
  }


   //look for a vertex at the same location of the original
   //vertex(s).  Add the name to this new vertex.
   DLIList<RefVertex*> tmp_verts;
   result_face->ref_vertices( tmp_verts);
   for( kk=vertex_coordinates.size(); kk--; )
   {
     CubitVector tmp_coord = vertex_coordinates.get_and_step();
     CubitString tmp_name = vertex_names.get_and_step();

     int jj;
     for( jj=tmp_verts.size(); jj--; )
     {
       RefVertex *tmp_vert = tmp_verts.get_and_step();
       if( tmp_coord.distance_between( tmp_vert->coordinates() ) < GEOMETRY_RESABS )
       {
         //add the name if it doesn't already exist
         RefEntityName::instance()->add_refentity_name( tmp_vert, tmp_name );
       }
     }
   }

   return result_face;
}

Creates a point from an x,y,z location.

Returns:
RefVertex*
- A pointer to a newly created RefVertex
  • ref_vertex_type The type of the RefVertex
  • point The spatial location to use to create the RefVertex This function takes a type information and a location to create a RefVertex. The underlying representation of the RefVertex is determined by the default GeometryQueryEngine.
  • color Allows the color to define during creation defaults to CUBIT_DEFAULT_COLOR_INDEX

Definition at line 1016 of file GeometryModifyTool.cpp.

{
   if (0 == gmeList.size())
   {
      PRINT_WARNING("No active geometry engine.\n");
      return NULL;
   }

     // Call the default GeometryModifyEngine to create a new TBPoint
   TBPoint* point_ptr = gmeList.get()->make_Point(point);

     // If we get a NULL pointer, give a warning message and return
     // a NULL pointer.
   if ( point_ptr == NULL )
   {
      PRINT_WARNING("In GeometryModifyTool::make_RefVertex\n"
                    "         Got a NULL pointer to a TBPoint.\n"
                    "         Cannot make a RefVertex.\n") ;
      return (RefVertex *)NULL ;
   }

   if( CubitUndo::get_undo_enabled() )
     CubitUndo::save_state();

     // Use the TBPoint to create a RefVertex
   RefVertex* ref_vertex_ptr = RefEntityFactory::instance()->construct_RefVertex(point_ptr) ;

  if( CubitUndo::get_undo_enabled() )
  {
    if( ref_vertex_ptr )
      CubitUndo::note_result_entity( ref_vertex_ptr );
    else
      CubitUndo::remove_last_undo();
  }

   ref_vertex_ptr->color(color);

     // Send a message to the model indicating the vertex was created
   AppUtil::instance()->send_event(GeometryEvent(GeometryEvent::FREE_REF_ENTITY_GENERATED, ref_vertex_ptr));

     // Return the newly created RefVertex
   return ref_vertex_ptr ;
}

Definition at line 947 of file GeometryModifyTool.cpp.

{
  if ( vertex == NULL )
  {
    PRINT_ERROR("Vertex is NULL\n");
    return NULL;
  }

  TopologyBridge* bridge = 0;
  GeometryModifyEngine* engine = get_engine(vertex, &bridge);
  if (engine == NULL)
  {
     PRINT_ERROR( "%s (vertex %d) does not have a modify engine.\n",
                  vertex->entity_name().c_str(),
                  vertex->id() );
     return 0;
  }

  CubitVector point = vertex->coordinates();

  // Call the default GeometryModifyEngine to create a new TBPoint
  TBPoint* point_ptr = engine->make_Point(point);

  if( CubitUndo::get_undo_enabled() )
    CubitUndo::save_state();

  // Use the TBPoint to create a RefVertex
  RefVertex* ref_vertex_ptr = RefEntityFactory::instance()->construct_RefVertex(point_ptr) ;

  if( CubitUndo::get_undo_enabled() )
  {
    if( ref_vertex_ptr )
      CubitUndo::note_result_entity( ref_vertex_ptr );
    else
      CubitUndo::remove_last_undo();
  }

  //transfer the names
  DLIList<CubitString> names;
  vertex->entity_names( names );

  int i;
  for( i=names.size(); i--; )
  {
    CubitString tmp_name = names.get_and_step();
    ref_vertex_ptr->entity_name( tmp_name );
  }

  // Send a message to the model indicating the vertex was created
  AppUtil::instance()->send_event(GeometryEvent(GeometryEvent::FREE_REF_ENTITY_GENERATED, ref_vertex_ptr));

  // Return the newly created RefVertex
  return ref_vertex_ptr ;
}
void GeometryModifyTool::march_path_to_discover_horizontal ( CubitVector start_pos,
CubitVector sweep_dir,
RefFace start_face,
CubitVector march_dir,
double &  step_size,
DLIList< CubitVector > &  final_points,
DLIList< RefFace * > &  ending_faces 
)

Beta function.

Definition at line 20270 of file GeometryModifyTool.cpp.

{
  double cos_45 = 0.70710678118654752440084436210485;
  double geo_tol = GeometryQueryTool::instance()->get_sme_resabs_tolerance();
  CubitVector point_on_surf = start_pos;
  RefVolume *v = start_face->ref_volume();
  RefFace *cur_face = start_face;

  RefEdge *snap_edge = NULL;
  bool snapped_to_edge_last_time = false;
  bool turned = false;
  CubitVector old_pos = point_on_surf;
  while(!turned)
  {
    CubitVector new_pos;
    if(snapped_to_edge_last_time)
    {
      // Just set the new position to the position on the
      // edge.  This will force us to jump out without doing
      // anything and then on the next loop we will start
      // onto the new face.
      new_pos = old_pos;
      snapped_to_edge_last_time = false;
      continue;
    }
    else
    {
      // Calculate a new step along the vector.
      new_pos = old_pos + step_size * march_dir;
    }

    cur_face->get_surface_ptr()->closest_point_trimmed(new_pos, point_on_surf);

    CubitVector norm = cur_face->normal_at(point_on_surf, v);
    if(sweep_dir % norm < cos_45)
    {
      turned = true;
    }
    else
    {
      bool snapping_to_edge = true;
      CubitVector proj_dir = point_on_surf - new_pos;
      double proj_dist = proj_dir.length();
      if(proj_dist < geo_tol)
        snapping_to_edge = false;
      else
      {
        proj_dir /= proj_dist;
        double dot = proj_dir % norm;
        if(dot > .99 || dot < -.99)
          snapping_to_edge = false;
      }
      if(!snapping_to_edge)
      {
        snap_edge = NULL;
        // didn't snap to boundary
        old_pos = point_on_surf;
        final_points.append(point_on_surf);
      }
      else
      {
        // probably snapped to the boundary of this face
        DLIList<RefEdge*> face_edges;
        RefEdge *best_edge = NULL;
        cur_face->ref_edges(face_edges);
        int i;
        DLIList<RefEdge*> possible_edges;
        CubitVector closest;
        for(i=face_edges.size(); i>0; i--)
        {
          RefEdge *e = face_edges.get_and_step();
          e->closest_point_trimmed(point_on_surf, closest);
          double cur_dist = (closest - point_on_surf).length();
          if(cur_dist < geo_tol)
          {
            possible_edges.append(e);
          }
        }
        if(possible_edges.size() == 1)
          best_edge = possible_edges.get();
        else if(possible_edges.size() > 1)
        {
          int h;
          double smallest_dist = CUBIT_DBL_MAX;
          for(h=possible_edges.size(); h>0; h--)
          {
            RefEdge *ce = possible_edges.get_and_step();
            ce->closest_point_trimmed(old_pos, closest);
            double cur_dist = (old_pos-closest).length();
            if(cur_dist < smallest_dist)
            {
              smallest_dist = cur_dist;
              best_edge = ce;
            }
          }
        }
        if(best_edge)
        {
          if(snap_edge && snap_edge == best_edge)
          {
            final_points.append(point_on_surf);
            old_pos = point_on_surf;
            snapped_to_edge_last_time = true;
          }
          else
          {
            snap_edge = best_edge;
            cur_face = best_edge->other_face(cur_face, v);
            CubitVector old_pos_save = old_pos;
            old_pos = closest;
            i = 0;
            snapped_to_edge_last_time = true;

            GeometryModifyEngine *gme = get_engine((TopologyBridge*)best_edge->get_curve_ptr());
            if(gme)
            {
              TBPoint *pt1 = gme->make_Point(old_pos_save);
              TBPoint *pt2 = gme->make_Point(new_pos);
              CubitVector const* pt3 = NULL;
              Curve *crv = gme->make_Curve(STRAIGHT_CURVE_TYPE, pt1, pt2, pt3 );
              if(crv)
              {
                CubitVector pos1, pos2;
                double dist;
                GeometryQueryTool::instance()->entity_entity_distance(crv, best_edge->get_curve_ptr(), pos1,
                  pos2, dist);
                old_pos = pos2;
                delete crv;
                delete pt1;
                delete pt2;
                final_points.append(old_pos);
              }
            }
          }
        }
      }
    }
  }
  ending_faces.append(cur_face);
}
void GeometryModifyTool::march_path_to_discover_vertical ( CubitVector start_pos,
CubitVector sweep_dir,
RefFace start_face,
CubitVector march_dir,
double &  step_size,
DLIList< CubitVector > &  final_points,
DLIList< RefFace * > &  ending_faces 
)

Definition at line 20417 of file GeometryModifyTool.cpp.

{
  double cos_45 = 0.70710678118654752440084436210485;
  double geo_tol = GeometryQueryTool::instance()->get_sme_resabs_tolerance();
  CubitVector point_on_surf = start_pos;
  RefVolume *v = start_face->ref_volume();
  RefFace *cur_face = start_face;
  
  RefEdge *snap_edge = NULL;
  bool snapped_to_edge_last_time = false;
  bool turned = false;
  CubitVector old_pos = point_on_surf;
  while(!turned)
  {
    CubitVector new_pos;
    if(snapped_to_edge_last_time)
    {
      // Just set the new position to the position on the
      // edge.  This will force us to jump out without doing
      // anything and then on the next loop we will start
      // onto the new face.
      new_pos = old_pos;
      snapped_to_edge_last_time = false;
      //snap_edge = NULL;
      continue;
    }
    else
    {
      // Calculate a new step along the vector.
      new_pos = old_pos + step_size * march_dir;
    }
    
    cur_face->get_surface_ptr()->closest_point_trimmed(new_pos, point_on_surf);

    int d = 0;
    if(d)
    {
      GfxDebug::draw_point(new_pos, CUBIT_BLUE_INDEX);
      GfxDebug::draw_point(point_on_surf, CUBIT_RED_INDEX);
      GfxDebug::flush();
      GfxDebug::mouse_xforms();
    }
    
    CubitVector norm = cur_face->normal_at(point_on_surf, v);
    double tmp_dot = sweep_dir % norm;
    if(tmp_dot > cos_45 || tmp_dot < -cos_45)
    {
      turned = true;
    }
    else
    {
      bool snapping_to_edge = true;
      CubitVector proj_dir = point_on_surf - new_pos;
      double proj_dist = proj_dir.length();
      if(proj_dist < geo_tol)
        snapping_to_edge = false;
      else
      {
        proj_dir /= proj_dist;
        double dot = proj_dir % norm;
        if(dot > .99 || dot < -.99)
          snapping_to_edge = false;
      }
      if(!snapping_to_edge)
      {
        snap_edge = NULL;
        // didn't snap to boundary
        old_pos = point_on_surf;
        final_points.append(point_on_surf);
      }
      else
      {
        // probably snapped to the boundary of this face
        DLIList<RefEdge*> face_edges;
        RefEdge *best_edge = NULL;
        CubitVector best_pos;
        cur_face->ref_edges(face_edges);
        DLIList<RefEdge*> possible_edges;
        CubitVector closest;
        for(int i=face_edges.size(); i>0; i--)
        {
          RefEdge *e = face_edges.get_and_step();
          e->closest_point_trimmed(point_on_surf, closest);
          double cur_dist = (closest - point_on_surf).length();
          if(cur_dist < geo_tol)
          {
            // If there are more than one edge that are coincident with the point
            // choose the one whose tangent is most normal to the direction we are
            // marching.  Switching onto the corresponding face should be best.
            if(best_edge)
            {
              CubitVector best_edge_tan, cur_edge_tan;
              best_edge->tangent(point_on_surf, best_edge_tan);
              e->tangent(point_on_surf, cur_edge_tan);
              if(fabs(best_edge_tan % march_dir) > fabs(cur_edge_tan % march_dir))
                best_edge = e;
            }
            else
              best_edge = e;
          }
        }
        if(best_edge)
        {
          if(snap_edge && snap_edge == best_edge)
          {
            final_points.append(point_on_surf);
            old_pos = point_on_surf;
            snapped_to_edge_last_time = true;
          }
          else
          {
            snap_edge = best_edge;
            cur_face = best_edge->other_face(cur_face, v);
            CubitVector old_pos_save = old_pos;
            old_pos = best_pos;
            snapped_to_edge_last_time = true;
            
            GeometryModifyEngine *gme = get_engine((TopologyBridge*)best_edge->get_curve_ptr());
            if(gme)
            {
              TBPoint *pt1 = gme->make_Point(old_pos_save);
              TBPoint *pt2 = gme->make_Point(new_pos);
              CubitVector const* pt3 = NULL;
              Curve *crv = gme->make_Curve(STRAIGHT_CURVE_TYPE, pt1, pt2, pt3 );
              if(crv)
              {
                CubitVector pos1, pos2;
                double dist;
                GeometryQueryTool::instance()->entity_entity_distance(crv, best_edge->get_curve_ptr(), pos1,
                                                                      pos2, dist);
                old_pos = pos2;
                delete crv;
                delete pt1;
                delete pt2;
                final_points.append(old_pos);
              }
            }
          }
        }
      }
    }
  }
  ending_faces.append(cur_face);
}
void GeometryModifyTool::march_using_planes ( CubitVector point_on_surf,
RefFace surf,
CubitVector march_dir,
double  step_size,
DLIList< CubitVector > &  horizontal_points,
DLIList< CubitVector > &  vertical_points 
)

Definition at line 20186 of file GeometryModifyTool.cpp.

{
  CubitVector surf_norm = surf->normal_at(point_on_surf);
  CubitVector plane_norm = march_dir * surf_norm;
  GeometryModifyEngine *gme = get_engine((TopologyBridge*)surf->get_surface_ptr());
  if(gme)
  {
    CubitPlane plane(plane_norm, point_on_surf);
    CubitBox bbox = surf->ref_volume()->bounding_box();
    CubitVector p1, p2, p3, p4;
    AnalyticGeometryTool::instance()->min_pln_box_int_corners( plane, bbox, 1,
                                    10.0, p1, p2, p3, p4, CUBIT_TRUE );
    Body *plane_body = GeometryModifyTool::instance()->planar_sheet( p1, p2, p3, p4 );
    Body *model_body_copy = GeometryModifyTool::instance()->copy_body(surf->body());
    DLIList<Body*> from_body_list, new_body_list;
    from_body_list.append(plane_body);
    from_body_list.append(model_body_copy);
    GeometryModifyTool::imprint(from_body_list, new_body_list, CUBIT_FALSE);
    for(int i=0; i<new_body_list.size(); i++)
    {
      if(new_body_list[i] == plane_body)
      {
        trace_out_curves(plane_body, point_on_surf, march_dir,
                         step_size, horizontal_points, vertical_points);
        /*
        GfxDebug::clear();
        DLIList<RefEdge*> plane_curves;
        plane_body->ref_edges(plane_curves);
        for(int j=0; j<plane_curves.size(); j++)
        {
          GfxDebug::draw_ref_edge(plane_curves[j], CUBIT_RED_INDEX);
        }
        GfxDebug::flush();
        GfxDebug::mouse_xforms();
         */
      }
      else
        GeometryQueryTool::instance()->delete_single_Body(new_body_list[i]);
    }
  }
}
CubitStatus GeometryModifyTool::match_v1_to_c1 ( RefVertex *&  v1,
RefVertex *&  v2,
RefVertex c1_v1,
RefVertex c1_v2,
RefVertex c2_v1,
RefVertex c2_v2 
) [private]

Definition at line 19512 of file GeometryModifyTool.cpp.

{
  CubitStatus status = CUBIT_SUCCESS;

  if(v1 == c1_v1 || v1 == c1_v2)
  {
    if(v2 == c2_v1 || v2 == c2_v2)
    {
      // everything is fine
    }
    else
      status = CUBIT_FAILURE;
  }
  else if(v1 == c2_v1 || v1 == c2_v2)
  {
    if(v2 == c1_v1 || v2 == c1_v2)
    {
      RefVertex *tmp = v1;
      v1 = v2;
      v2 = tmp;
    }
    else
      status = CUBIT_FAILURE;
  }
  else
    status = CUBIT_FAILURE;

  return status;
}
CubitStatus GeometryModifyTool::offset_curves ( DLIList< RefEdge * > &  ref_edge_list,
DLIList< RefEdge * > &  output_edge_list,
double  offset_distance,
const CubitVector offset_direction,
int  gap_type = 1 
)

Creates curves offset from a chain of curves. The offset direction is.

Creates curves offset from a chain of curves. The offset direction is only used if there is one linear curve. Otherwise, the offset direction is calculated by (the cross product of the wires tangent and the planar normal). The gap type is 0 - rounded, 1 - extended, 2 - natural.

Definition at line 3920 of file GeometryModifyTool.cpp.

{
  // Make sure all curves are from same geometry engine
  DLIList<TopologyEntity*> entity_list(ref_edge_list.size());
  DLIList<TopologyBridge*> bridge_list(ref_edge_list.size());
  CAST_LIST_TO_PARENT(ref_edge_list, entity_list);
  GeometryModifyEngine* gme_ptr = common_modify_engine(entity_list, bridge_list);
  if ( !gme_ptr )
  {
    PRINT_ERROR("Can't create offset curves that don't all originate from same\n"
      "       modeling engine.\n");
    return CUBIT_FAILURE;
  }

  if( CubitUndo::get_undo_enabled() )
    CubitUndo::save_state();

  DLIList<Curve*> curve_list(bridge_list.size()), result_list;
  CAST_LIST(bridge_list, curve_list, Curve);
  assert(curve_list.size() == ref_edge_list.size());

  CubitStatus rval = gme_ptr->offset_curves( curve_list, result_list,
                        offset_distance, offset_direction, gap_type );
  assert( rval || !result_list.size() );
  result_list.reset();

  DLIList<RefEntity*> created_edges;
  output_edge_list.clean_out();
  for (int i = result_list.size(); i--; )
  {
    RefEdge *new_edge = GeometryQueryTool::instance()->make_free_RefEdge(result_list.get_and_step());
    created_edges.append( new_edge );
    output_edge_list.append( new_edge );
  }

  if( CubitUndo::get_undo_enabled() )
  {
    if( created_edges.size() )
      CubitUndo::note_result_entities( created_edges );
    else
      CubitUndo::remove_last_undo();
  }

  return rval;
}
CubitStatus GeometryModifyTool::okay_to_modify ( DLIList< Body * > &  bodies,
const char *  op 
) const [protected]

Definition at line 2473 of file GeometryModifyTool.cpp.

{
  CubitStatus ret = CUBIT_SUCCESS;

  Body *b = webcut_body_list.get();
  if(b)
  {
    GeometryModifyEngine *gme = get_engine(b);
    if(gme)
    {
      if(!gme->supports_interoperability() &&
          contains_intermediate_geom(webcut_body_list))
      {
        PRINT_ERROR("Intermixing real and virtual geometry operations using the current solid modeling kernel is not allowed.\n");
        ret = CUBIT_FAILURE;
      }
    }
  }

  if(ret == CUBIT_SUCCESS)
  {
    // If the operation is not one of the ones below...
    if(strcmp(op, "WEBCUT") &&
      strcmp(op, "CHOP") &&
      strcmp(op, "UNITE") &&
      strcmp(op, "TWEAK") &&
      strcmp(op, "IMPRINT") &&
      strcmp(op, "REGULARIZE") &&
      strcmp(op, "SPLIT_SURFACE") &&
      strcmp(op, "REMOVE_TOPOLOGY") &&
      strcmp(op, "SPLIT") &&
      strcmp(op, "NON_UNIFORM_SCALE"))
    {
      if (contains_intermediate_geom(webcut_body_list))
      {
        PRINT_ERROR("Performing %s on volumes containing virtual geometry is not allowed.\n", op);
        ret = CUBIT_FAILURE;
      }
    }
    else
    {
      if(contains_partitions(webcut_body_list))
      {
        PRINT_ERROR("Performing %s on volumes containing virtual partitions is not allowed.\n", op);
        ret = CUBIT_FAILURE;
      }
    }
  }

  return ret;
}
Body * GeometryModifyTool::planar_sheet ( const CubitVector p1,
const CubitVector p2,
const CubitVector p3,
const CubitVector p4 
)

Creates a planar surface from using four vertices.

Creates a Body consisting of a planar sheet (no volume) p1 - 1st corner of the sheet p2 - 2nd corner of the sheet p3 - 3rd corner of the sheet p4 - 4th corner of the sheet

Definition at line 765 of file GeometryModifyTool.cpp.

{
   if (0 == gmeList.size())
   {
      PRINT_WARNING("No active geometry engine.\n");
      return NULL;
   }

   if( CubitUndo::get_undo_enabled() )
     CubitUndo::save_state();

  // Create a Body that represents the sheet
  BodySM* body_ptr = gmeList.get()->planar_sheet(p1, p2, p3, p4) ;
  Body *new_body = NULL;
  if( body_ptr == NULL )
  {
    PRINT_ERROR("In GeometryTool::planar_sheet\n"
      "       Problems building a volume from the sheet.\n") ;
  }
  else
    new_body = GeometryQueryTool::instance()->make_Body(body_ptr);

  if( CubitUndo::get_undo_enabled() )
  {
    if( new_body )
      CubitUndo::note_result_body( new_body );
    else
      CubitUndo::remove_last_undo();
  }

  return new_body;
}
Body * GeometryModifyTool::planar_sheet ( const CubitVector center,
const CubitVector  axes[2],
double  width,
double  height 
)

Creates a surface from using four vertices.

Creates an body consisting of a planar sheet (no volume) {center, axes, width, height} - input location, orientation and size of sheet Returns the new Body or NULL

Definition at line 811 of file GeometryModifyTool.cpp.

{
   if (0 == gmeList.size())
   {
      PRINT_WARNING("No active geometry engine.\n");
      return NULL;
   }

   CubitVector p1, p2, p3, p4;

   // Get the corners of the sheet
   center.next_point( axes[0], width/2.0, p1 );
   p1.next_point( axes[1], -height/2.0, p1 );
   p1.next_point( axes[1], height, p2 );
   p2.next_point( axes[0], -width, p3 );
   p3.next_point( axes[1], -height, p4 );

   if( CubitUndo::get_undo_enabled() )
     CubitUndo::save_state();

   // Create a Body that represents the sheet
   BodySM* body_ptr = gmeList.get()->planar_sheet(p1, p2, p3, p4) ;
   Body *new_body = NULL;

   if( body_ptr == NULL )
   {
      PRINT_ERROR("In GeometryTool::planar_sheet\n"
         "       Problems building a volume from the sheet.\n") ;
   }
   else
     new_body = GeometryQueryTool::instance()->make_Body(body_ptr);

  if( CubitUndo::get_undo_enabled() )
  {
    if( new_body )
      CubitUndo::note_result_body( new_body );
    else
      CubitUndo::remove_last_undo();
  }

  return new_body;
}
Body * GeometryModifyTool::planar_sheet ( const CubitPlane plane,
const CubitBox bounding_box,
int  extension_type = 0,
double  extension = 0.0 
)

Creates a surface from a plane and bounding box.

Creates an body consisting of a planar sheet (no volume) {plane} - plane it will lie in {bounding_box} - 3D bounding box it must expand. Plane will have minimal area required to just cut the box. {extension_type} - 0: no extension, 1: percentage, 2: absolute {extension} - distance sheet is to extend outside of bounding box Returns the new Body or NULL

Definition at line 868 of file GeometryModifyTool.cpp.

{
   if (0 == gmeList.size())
   {
      PRINT_WARNING("No active geometry engine.\n");
      return NULL;
   }

   CubitVector p1, p2, p3, p4;

   // Get the corners of the sheet
   if( AnalyticGeometryTool::instance()->
      min_pln_box_int_corners( plane, bounding_box, extension_type,
                               extension, p1, p2, p3, p4 ) == CUBIT_FAILURE )
      return NULL;

   if( CubitUndo::get_undo_enabled() )
     CubitUndo::save_state();

   // Create a Body that represents the sheet
   BodySM* body_ptr = gmeList.get()->planar_sheet(p1, p2, p3, p4) ;
   Body *new_body = NULL;

   if( body_ptr == NULL )
   {
      PRINT_ERROR("In GeometryModifyTool::planar_sheet\n"
         "       Problems building a volume from the sheet.\n") ;
   }
   else
     new_body = GeometryQueryTool::instance()->make_Body(body_ptr);

   if( CubitUndo::get_undo_enabled() )
   {
     if( new_body )
       CubitUndo::note_result_body( new_body );
     else
       CubitUndo::remove_last_undo();
   }

   return new_body;
}
void GeometryModifyTool::plane_preview ( DLIList< Body * > &  body_list,
const CubitVector pt1,
const CubitVector pt2,
const CubitVector pt3 
) [static, private]

draw a preview of a plane for webcut previews

Definition at line 20135 of file GeometryModifyTool.cpp.

{
  CubitPlane plane;
  if( plane.mk_plane_with_points( pt1, pt2, pt3) == CUBIT_FAILURE)
  {
       PRINT_INFO( "Unable to create plane from given information.\n" );
       return ;
  }

  CubitBox bounding_box;
  Body* body_ptr = body_list.get_and_step();
  bounding_box = body_ptr->bounding_box();

  int i;
  for( i=1; i<body_list.size(); i++ )
  {
     body_ptr = body_list.get_and_step();
     bounding_box |= body_ptr->bounding_box();
  }

  int extension_type = 1;
  double extension = 10; //10%
  CubitVector p1, p2, p3, p4;

  if( AnalyticGeometryTool::instance()->
         min_pln_box_int_corners( plane, bounding_box, extension_type,
         extension, p1, p2, p3, p4 ) == CUBIT_FAILURE )
  {
     PRINT_INFO( "Unable to create plane from given information.\n" );
     return ;
  }

  GPoint gp[4];
  gp[0].x=p1.x(); gp[0].y=p1.y(); gp[0].z=p1.z();
  gp[1].x=p2.x(); gp[1].y=p2.y(); gp[1].z=p2.z();
  gp[2].x=p3.x(); gp[2].y=p3.y(); gp[2].z=p3.z();
  gp[3].x=p4.x(); gp[3].y=p4.y(); gp[3].z=p4.z();

  // clear previous previews
  GfxPreview::clear();

  // Get the color to draw in
  int color = CUBIT_BLUE_INDEX;
  GfxPreview::draw_quad(gp, color);
  GfxPreview::flush();
  return;
}
CubitStatus GeometryModifyTool::prepare_for_copy ( RefEntity ref_ents,
TopologyBridge *&  top_bridge 
) [static]

Definition at line 1154 of file GeometryModifyTool.cpp.

{
  //save attribute settings
  CGMApp::instance()->save_current_attribute_states();

  CGMApp::instance()->attrib_manager()->auto_flag(1);
  // Groups are saved directly in the Cubit file, not with attributes
  CGMApp::instance()->attrib_manager()->set_auto_update_flag(CA_GROUP, CUBIT_FALSE);
  CGMApp::instance()->attrib_manager()->set_auto_actuate_flag(CA_GROUP, CUBIT_FALSE);
  CGMApp::instance()->attrib_manager()->set_auto_write_flag(CA_GROUP, CUBIT_FALSE);
  CGMApp::instance()->attrib_manager()->set_auto_read_flag(CA_GROUP, CUBIT_FALSE);

  // The mesh container is only used for the Exodus save/resore method
  CGMApp::instance()->attrib_manager()->set_auto_update_flag(CA_MESH_CONTAINER, CUBIT_FALSE);
  CGMApp::instance()->attrib_manager()->set_auto_actuate_flag(CA_MESH_CONTAINER, CUBIT_FALSE);
  CGMApp::instance()->attrib_manager()->set_auto_write_flag(CA_MESH_CONTAINER, CUBIT_FALSE);
  CGMApp::instance()->attrib_manager()->set_auto_read_flag(CA_MESH_CONTAINER, CUBIT_FALSE);

  // Genesis Entities are saved directly in the Cubit file, not with attributes
  CGMApp::instance()->attrib_manager()->set_auto_update_flag(CA_GENESIS_ENTITY, CUBIT_FALSE);
  CGMApp::instance()->attrib_manager()->set_auto_actuate_flag(CA_GENESIS_ENTITY, CUBIT_FALSE);
  CGMApp::instance()->attrib_manager()->set_auto_write_flag(CA_GENESIS_ENTITY, CUBIT_FALSE);
  CGMApp::instance()->attrib_manager()->set_auto_read_flag(CA_GENESIS_ENTITY, CUBIT_FALSE);

  //Don't save out entity ids
  CGMApp::instance()->attrib_manager()->set_auto_update_flag(CA_ENTITY_ID, CUBIT_FALSE);
  CGMApp::instance()->attrib_manager()->set_auto_actuate_flag(CA_ENTITY_ID, CUBIT_FALSE);
  CGMApp::instance()->attrib_manager()->set_auto_write_flag(CA_ENTITY_ID, CUBIT_FALSE);
  CGMApp::instance()->attrib_manager()->set_auto_read_flag(CA_ENTITY_ID, CUBIT_FALSE);

  //Don't save out graphics
  CGMApp::instance()->attrib_manager()->set_auto_update_flag(CA_GRAPHICS_OPTS, CUBIT_FALSE);
  CGMApp::instance()->attrib_manager()->set_auto_actuate_flag(CA_GRAPHICS_OPTS, CUBIT_FALSE);
  CGMApp::instance()->attrib_manager()->set_auto_write_flag(CA_GRAPHICS_OPTS, CUBIT_FALSE);
  CGMApp::instance()->attrib_manager()->set_auto_read_flag(CA_GRAPHICS_OPTS, CUBIT_FALSE);

  //Flag to say "we're copying" attributes
  copyingEntity = ref_ent;

  //Get all children
  DLIList<RefEntity*> child_list;
  ref_ent->get_all_child_ref_entities( child_list );

  //Puts attributes on all the entities
  child_list.append( ref_ent );
  CubitAttribUser::auto_update_cubit_attrib( child_list );

  //Prepare virtual
  TopologyEntity *topo_ptr = dynamic_cast<TopologyEntity*>( ref_ent );
  top_bridge = topo_ptr->bridge_manager()->topology_bridge();
  DLIList<TopologyBridge*> bridge_list;
  bridge_list.append( top_bridge );
  GeometryQueryTool::instance()->ige_export_geom( bridge_list );

  //Should only have 1 bridge in the list
  assert( bridge_list.size() == 1 );
  TopologyBridge *tmp_bridge_after = bridge_list.get();
  if( top_bridge != tmp_bridge_after)
    top_bridge = tmp_bridge_after;

  //Done copying attributes
  copyingEntity = NULL;

  return CUBIT_SUCCESS;

}
void GeometryModifyTool::preview_align ( CubitVector  translation_to_origin,
CubitVector  origin_to_target,
double  angle_of_rotation,
CubitVector  axis_of_rotation,
DLIList< RefEntity * > &  entities 
) [private]

Definition at line 4267 of file GeometryModifyTool.cpp.

{
  CubitTransformMatrix prev_xform;
  prev_xform.translate(translation_to_origin);

  CubitTransformMatrix rot_mat;
  rot_mat.rotate( angle_of_rotation, axis_of_rotation );

  CubitTransformMatrix mov_mat;
  mov_mat.translate( origin_to_target );

  for( int k=0; k<entities.size(); k++ )
  {
    RefEntity *tmp_ent = entities[k];           
    TopologyEntity *te = dynamic_cast<TopologyEntity*>(tmp_ent);
    if( NULL == te )
      continue;

    DLIList<RefEdge*> edges;
    te->ref_edges(edges);      
    for (int i = 0; i < edges.size(); i++)
    {
      GMem poly;
      if( CUBIT_SUCCESS == edges[i]->get_graphics(poly) )
      {
        poly.transform(prev_xform);
        poly.transform(rot_mat);
        poly.transform(mov_mat);
        GfxPreview::draw_polyline(poly.point_list(), poly.point_list_size(), CUBIT_BLUE_INDEX);
      }
      else if( edges[i]->start_vertex() == edges[i]->end_vertex() )
      {
        CubitVector tmp_pt = edges[i]->start_vertex()->coordinates();
        tmp_pt = prev_xform*tmp_pt;
        tmp_pt = rot_mat*tmp_pt;
        tmp_pt = mov_mat*tmp_pt;       
        GfxPreview::draw_point( tmp_pt, CUBIT_BLUE_INDEX);
      }
    }
  }
}
Body * GeometryModifyTool::prism ( double  height,
int  sides,
double  major,
double  minor 
)

Creates a brick (cube).

Creates an prism and assigns it to a Body $ {height, major, minor} input height, major and minor radii. $ {sides} input number of sides. Must be >= 3. Returns the new Body or NULL

Definition at line 530 of file GeometryModifyTool.cpp.

{
   if (0 == gmeList.size())
   {
      PRINT_WARNING("No active geometry engine.\n");
      return NULL;
   }

     // First make sure that the input values make sense
   if ( major < minor ||
        major <= GEOMETRY_RESABS || minor <= GEOMETRY_RESABS ||
        height <= GEOMETRY_RESABS || sides < 3 )
   {
      PRINT_ERROR("In GeometryModifyTool::prism\n"
                  "   Cannot make a prism of major-radius = %f,"
                  " minor-radius = %f, height = %f, and"
                  " number of sides = %d\n"
                  "   All dimensions must be > 0.0, the major-radius\n"
                  " should be greater than or equal to the minor-"
                  "radius,\n and the number of sides should be greater"
                  " than 2.\n", major, minor, height, sides);

      return NULL;
   }

   if( CubitUndo::get_undo_enabled() )
     CubitUndo::save_state();

     // Create a Body that represents the prism
   BodySM* bodyPtr = gmeList.get()->prism(height,  sides, major, minor) ;
   Body *new_body = NULL;
   if (bodyPtr == NULL)
   {
      PRINT_ERROR("In GeometryModifyTool::prism\n"
                  "       Problems building a volume from the prism.\n") ;
   }
   else
     new_body = GeometryQueryTool::instance()->make_Body(bodyPtr);

  if( CubitUndo::get_undo_enabled() )
  {
    if( new_body )
      CubitUndo::note_result_body( new_body );
    else
      CubitUndo::remove_last_undo();
  }

   return new_body;
}
CubitStatus GeometryModifyTool::project_edges ( DLIList< RefFace * > &  ref_face_list,
DLIList< RefEdge * > &  ref_edge_list_in,
DLIList< RefEdge * > &  ref_edge_list_new,
CubitBoolean  trim_projected = CUBIT_FALSE 
)

Projects list RefEdges onto a list of RefFaces.

Definition at line 8574 of file GeometryModifyTool.cpp.

{
  int i, j;

   // Check the GeometryEngine for each of the RefEdges; check to
   // make sure they're all the same
  DLIList<Surface*> surface_list(ref_face_list.size());
  DLIList<Curve*> curve_list_in(ref_edge_list_in.size()), curve_list_new;
  GeometryModifyEngine* gme = common_modify_engine( ref_face_list,
                                                    ref_edge_list_in,
                                                    surface_list,
                                                    curve_list_in );

  if ( !gme ) {
    PRINT_ERROR("In GeometryTool::create_blend\n"
                "       Curves have different modify engines.\n");
    return CUBIT_FAILURE;
  }

   CubitStatus status = gme->
     project_edges( surface_list, curve_list_in, curve_list_new);

  if( CubitUndo::get_undo_enabled() && status == CUBIT_SUCCESS )
    CubitUndo::save_state();


   curve_list_new.reset();

   if(trim_projected){
     DLIList<Curve*> tmp_curves, all_new_curves;
     Curve* tmp_curve;
     Surface* tmp_surface;

     for(i = 0; i< surface_list.size(); i++){
       tmp_curves.clean_out();
       tmp_surface = surface_list.get_and_step();
       for(j=0; j<curve_list_new.size(); j++){
         tmp_curve = curve_list_new.get_and_step();
         status = gme->curve_surface_intersection( tmp_surface, tmp_curve, tmp_curves);
       }
       all_new_curves += tmp_curves;

     }

     if(!all_new_curves.size()){
       if(!curve_list_new.size()){
         PRINT_ERROR("Projection resulted in no curves.\n");
         return CUBIT_FAILURE;
       }
       else{
         PRINT_WARNING("No curve remained after trimming operation.  \n \tCurve projection may lie completely outside of trimmed surface.\n");
       }
     }

       //fix this...
       //can we just cleanout this list or do we need to delete the entities in it.
     for( i = 0; i< curve_list_new.size(); i++ )
     {
       Curve *tmp_curve = curve_list_new.get_and_step();
       gme->get_gqe()->delete_solid_model_entities( tmp_curve );
     }

     curve_list_new.clean_out();
     curve_list_new = all_new_curves;

     if( CubitUndo::get_undo_enabled() && status == CUBIT_SUCCESS )
       CubitUndo::save_state();
   }



   curve_list_new.reset();
   for (i = curve_list_new.size(); i--; )
   {
     Curve* curve = curve_list_new.get_and_step();
     RefEdge* new_edge = GeometryQueryTool::instance()->make_free_RefEdge(curve);
     PRINT_INFO("Created Curve %d\n", new_edge->id());
     ref_edge_list_new.append(new_edge);
     if( CubitUndo::get_undo_enabled() && new_edge )
       CubitUndo::note_result_entity( new_edge );
   }

   if( CubitUndo::get_undo_enabled() )
   {
     if( ref_edge_list_new.size() == 0 )
       CubitUndo::remove_last_undo();
   }

   return status;
}
void GeometryModifyTool::propagate_from_small_edge ( RefEdge edge,
DLIList< RefEdge * > &  small_edges,
DLIList< RefFace * > &  narrow_faces,
DLIList< RefFace * > &  processed_faces,
double  small_edge_length 
) [private]

Definition at line 14343 of file GeometryModifyTool.cpp.

{
  int i, j;
  // First find any small edges connected to this edge.
  DLIList<RefVertex*> edge_verts;
  edge->ref_vertices(edge_verts);
  for(i=edge_verts.size(); i--;)
  {
    RefVertex *vert = edge_verts.get_and_step();
    DLIList<RefEdge*> vert_edges;
    vert->ref_edges(vert_edges);
    for(j=vert_edges.size(); j--;)
    {
      RefEdge *cur_edge = vert_edges.get_and_step();
      if(cur_edge != edge && !cur_edge->marked())
      {
        // Mark of > 0 means it has been processed.
        cur_edge->marked(1);
        if(cur_edge->get_arc_length() < small_edge_length)
        {
          small_edges.append(cur_edge);
          // Mark of 2 means it is a small edge.
          cur_edge->marked(2);
          propagate_from_small_edge(cur_edge, small_edges, narrow_faces,
            processed_faces, small_edge_length);
        }
      }
    }
  }
  // Now look at adjacent narrow faces and recursively process them.
  DLIList<RefFace*> edge_faces;
  edge->ref_faces(edge_faces);
  for(i=edge_faces.size(); i--;)
  {
    RefFace *cur_face = edge_faces.get_and_step();
    if(!cur_face->marked())
    {
      cur_face->marked(1);
      if(GeomMeasureTool::narrow_region_exists(cur_face, small_edge_length))
      {
        DLIList<CubitVector> split_pos1_list;
        DLIList<CubitVector> split_pos2_list;
        GeomMeasureTool::find_split_points_for_narrow_regions(cur_face,
          small_edge_length, split_pos1_list, split_pos2_list);
        if(split_pos1_list.size() == 0)
        {
          narrow_faces.append_unique(cur_face);
          propagate_over_narrow_face(cur_face, edge, processed_faces,
            small_edges, narrow_faces, small_edge_length);
        }
      }
    }
  }
}
void GeometryModifyTool::propagate_merge_tolerance ( DLIList< Body * > &  body_list) [private]

Definition at line 14481 of file GeometryModifyTool.cpp.

{
  // For each body
  //  get a list of all children that have a local tolerance
  //  iterate over that list
  //    for each entity, get a list of all of its children
  //    if the parent's tolerance is > child tolerance && the child isn't in the owner_set list
  //     then set the child's tolerance to the parent's tolerance

  DLIList<RefEntity*> owner_set_tolerance_list;
  DLIList<RefEntity*> entity_list;

  double parent_tolerance = 0.0;

  for (int i=body_list.size(); i--;)
  {
    Body* local_body = body_list.get_and_step();

    // First, get all the children for this body. Save those that already have
    // a local tolerance set
    local_body->get_all_child_ref_entities(entity_list);
    for (int i = entity_list.size(); i--;)
    {
      RefEntity* local_entity = entity_list.get_and_step();
      if (local_entity->local_tolerance() > 0.0)
        owner_set_tolerance_list.append(local_entity);
    }

    // for each entity in the owner_set list, get all of its children
    for (int i = owner_set_tolerance_list.size(); i--;)
    {
      RefEntity* local_entity = owner_set_tolerance_list.get_and_step();
      parent_tolerance = local_entity->local_tolerance();

      entity_list.clean_out();
      local_entity->get_all_child_ref_entities(entity_list);
      for (int j = entity_list.size(); j--;)
      {
        RefEntity* child_entity = entity_list.get_and_step();
        if (!owner_set_tolerance_list.is_in_list(child_entity))
        {
          if (child_entity->local_tolerance() < parent_tolerance)
            child_entity->local_tolerance(parent_tolerance);
        }
      }
    }
  }
}
void GeometryModifyTool::propagate_over_narrow_face ( RefFace narrow_face,
RefEdge edge,
DLIList< RefFace * > &  processed_faces,
DLIList< RefEdge * > &  small_edges,
DLIList< RefFace * > &  narrow_faces,
double  small_edge_length 
) [private]

Definition at line 14402 of file GeometryModifyTool.cpp.

{
  int i, j;
  processed_faces.append(narrow_face);
  DLIList<RefEdge*> face_edges;
  narrow_face->ref_edges(face_edges);
  for(i=face_edges.size(); i--;)
  {
    RefEdge *cur_edge = face_edges.get_and_step();
    if(cur_edge != edge && !cur_edge->marked())
    {
      cur_edge->marked(1);
      if(cur_edge->get_arc_length() < small_edge_length)
      {
        cur_edge->marked(2);
        small_edges.append(cur_edge);
        propagate_from_small_edge(cur_edge, small_edges,
                narrow_faces, processed_faces, small_edge_length);
      }
      else
      {
        DLIList<RefFace*> edge_faces;
        cur_edge->ref_faces(edge_faces);
        for(j=edge_faces.size(); j--;)
        {
          RefFace *cur_face = edge_faces.get_and_step();
          if(cur_face != narrow_face)
          {
            if(!cur_face->marked())
            {
              cur_face->marked(1);
              if(GeomMeasureTool::narrow_region_exists(cur_face, small_edge_length))
              {
                DLIList<CubitVector> split_pos1_list;
                DLIList<CubitVector> split_pos2_list;
                GeomMeasureTool::find_split_points_for_narrow_regions(cur_face,
                  small_edge_length, split_pos1_list, split_pos2_list);
                if(split_pos1_list.size() == 0)
                {
                  narrow_faces.append_unique(cur_face);
                  propagate_over_narrow_face(cur_face, edge, processed_faces,
                    small_edges, narrow_faces, small_edge_length);
                }
              }
            }
          }
        }
      }
    }
  }
}
GeometryModifyEngine * GeometryModifyTool::pull_common_surfs ( DLIList< RefFace * > &  ref_face_list,
DLIList< RefFace * > &  common_face_list,
DLIList< Surface * > &  common_surf_list 
) [private]

Pull RefFaces with a common GeometryModifyEngine out of the input ref_face_list. Place their surfaces in the output RefFace and Surface lists, and return the common modify engine. Note the function returns a NULL pointer if a RefFace without a modify engine is found in the input list.

Definition at line 11849 of file GeometryModifyTool.cpp.

{
  int i;
  RefFace *ref_face_ptr;
  Surface *surf_ptr;

  GeometryModifyEngine *gme1 = 0, *gme2 = 0;

  ref_face_list.reset();
  for( i=0; i<ref_face_list.size(); i++ )
  {
    ref_face_ptr = ref_face_list.get();
    surf_ptr = ref_face_ptr->get_surface_ptr();

    if( i==0 )
    {
      common_face_list.append( ref_face_ptr );
      common_surf_list.append( surf_ptr );
      gme1 = get_engine( surf_ptr );
      if (!gme1)
      {
        PRINT_ERROR("Surface %d does not have a modify engine.\n", ref_face_ptr->id());
        return 0;
      }
      ref_face_list.change_to( NULL );
      ref_face_list.step();
      continue;
    }

    gme2 = get_engine( surf_ptr );
    if (!gme2)
    {
      PRINT_ERROR("Surface %d does not have a modify engine.\n", ref_face_ptr->id());
      return 0;
    }

    if( gme2 == gme1 )
    {
      common_face_list.append( ref_face_ptr );
      common_surf_list.append( surf_ptr );
      ref_face_list.change_to( NULL );
    }

    ref_face_list.step();
  }

  ref_face_list.remove_all_with_value( NULL );

  return gme1;
}

Definition at line 3420 of file GeometryModifyTool.cpp.

{
  // Get all of the ref entities involved and push CA_ENTITY_ID attributes
  // on to them.  This will help us maintain ids on virtual that doesn't
  // get modified by the real operation.
  int i;
  DLIList<RefVolume*> volume_list;

  for(i=old_sms.size(); i--;)
  {
    BodySM *bsm = old_sms.get_and_step();
    Body *body = dynamic_cast<Body*>(bsm->topology_entity());
    if(body)
    {
      // Append to the total list of volumes.
      body->ref_volumes(volume_list);
    }
  }
  // get all child entities (only get entities below volumes)
  DLIList<RefEntity*> child_list, ref_ent_list;
  CAST_LIST_TO_PARENT(volume_list, ref_ent_list);
  RefEntity::get_all_child_ref_entities( ref_ent_list, child_list );

  //by including the volumes we can propagate the bcs on them
  //across webcuts
  child_list+=ref_ent_list;


  // Only push the id attributes if we are doing persistent ids.
  if(!get_new_ids())
    CubitAttribUser::auto_update_cubit_attrib(child_list);

  DLIList<TopologyBridge*> top_bridges;
  CAST_LIST_TO_PARENT(old_sms, top_bridges);
  GeometryQueryTool::instance()->ige_export_geom(top_bridges);
}

Definition at line 3459 of file GeometryModifyTool.cpp.

{
  GeometryQueryTool::instance()->ige_push_imprint_attributes_before_modify(body_sms);
}
void GeometryModifyTool::push_named_attributes_to_curves_and_points ( DLIList< TopologyBridge * > &  tb_list,
const char *  name_in 
) [private]

Definition at line 3464 of file GeometryModifyTool.cpp.

{
  GeometryQueryTool::instance()->ige_push_named_attributes_to_curves_and_points(tb_list, name_in);
}
void GeometryModifyTool::push_tolerance_attribute ( DLIList< Body * > &  body_list) [private]

Definition at line 14459 of file GeometryModifyTool.cpp.

{
  Body* local_body;
  DLIList<RefEntity*> child_list;

  //save attribute settings
  CGMApp::instance()->save_current_attribute_states();

  CGMApp::instance()->attrib_manager()->auto_flag(0);
  CGMApp::instance()->attrib_manager()->set_auto_update_flag(CA_ENTITY_TOL, CUBIT_TRUE);

  for (int i = body_list.size(); i--;)
  {
    child_list.clean_out();

    local_body = body_list.get_and_step();
    local_body->get_all_child_ref_entities( child_list);
    child_list.append(local_body);
    CubitAttribUser::auto_update_cubit_attrib( child_list );
  }
}
Body * GeometryModifyTool::pyramid ( double  height,
int  sides,
double  major,
double  minor,
double  top = 0.0 
)

Creates a pyramid.

Creates an pyramid and assigns it to a Body $ {height, major, minor} input height, major and minor radii. $ {sides} input number of sides. Must be >= 3. {top} radius at top of pyramid. Returns the new Body or NULL

Definition at line 590 of file GeometryModifyTool.cpp.

{
   if (0 == gmeList.size())
   {
      PRINT_WARNING("No active geometry engine.\n");
      return NULL;
   }

     // First make sure that the input values make sense
   if ( major < minor ||
        major <= GEOMETRY_RESABS || minor <= GEOMETRY_RESABS ||
        height <= GEOMETRY_RESABS || top < 0.0 || sides < 3  )
   {
      PRINT_ERROR("In GeometryModifyTool::pyramid\n"
                  "    Cannot make a pyramid of major-radius = %f,"
                  " minor-radius = %f, height = %f,"
                  " top %f, and number of sides = %d\n"
                  "     All dimensions must be > 0.0, the major-radius"
                  " should be greater than the minor-radius, the "
                  "number of sides should be greater than 2.\n",
                  major, minor, height, top, sides);
      return NULL;
   }

   if( CubitUndo::get_undo_enabled() )
     CubitUndo::save_state();

     // Create a Body that represents the prism
   BodySM* bodyPtr = gmeList.get()->pyramid ( height, sides, major, minor, top);
   Body *new_body = NULL;
   if (bodyPtr == NULL)
   {
      PRINT_ERROR("In GeometryModifyTool::pyramid\n"
                  "      Problems building a volume from the pyramid.\n");
   }
   else
     new_body = GeometryQueryTool::instance()->make_Body(bodyPtr);

  if( CubitUndo::get_undo_enabled() )
  {
    if( new_body )
      CubitUndo::note_result_body( new_body );
    else
      CubitUndo::remove_last_undo();
  }

   return new_body;
}
CubitStatus GeometryModifyTool::regularize_body ( Body body_ptr,
Body *&  new_body 
)

Removes all unnessesary faces, curves, vertices from a body.

Definition at line 10695 of file GeometryModifyTool.cpp.

{
   DLIList<Body*> b_list;
   b_list.append(body_ptr);
   if (!okay_to_modify( b_list, "REGULARIZE" ))
     return CUBIT_FAILURE;   

   BodySM* body_sm = body_ptr->get_body_sm_ptr(), *new_sm = 0;
   GeometryModifyEngine* gme = get_engine(body_sm);
   if (!gme) {
     PRINT_ERROR("Volume does not have a modify engine.\n" );
     return CUBIT_FAILURE;
  }

   do_attribute_setup();
   DLIList<BodySM*> body_sm_list, new_bodysm_list;
   body_sm_list.append(body_sm);
   push_attributes_before_modify(body_sm_list);

   CubitStatus stat = gme->regularize_body( body_sm, new_sm );
   if ( new_sm == NULL )
   {
      PRINT_ERROR("REGULARIZATION failure.\n");
      return CUBIT_FAILURE;
   }

   // remove mesh from modified body
   AppUtil::instance()->send_event(GeometryEvent(GeometryEvent::TOPOLOGY_ENTITY_MODIFIED, body_ptr));

   new_bodysm_list.append(new_sm);
   restore_vg_after_modify(new_bodysm_list, b_list, gme);
   remove_pushed_attributes(new_bodysm_list, b_list);

   body_sm = body_ptr->get_body_sm_ptr();
   update_body(body_ptr);

   new_body = GeometryQueryTool::instance()->make_Body(new_sm);
   GeometryQueryTool::instance()->cleanout_deactivated_geometry();

   do_attribute_cleanup();

   return stat;
}
CubitStatus GeometryModifyTool::regularize_refentity ( RefEntity old_entity_ptr,
Body *&  new_body_ptr 
)

Removes all unnessesary faces, curves, vertices and associated data from a refentity.

Definition at line 10559 of file GeometryModifyTool.cpp.

{
  BasicTopologyEntity* bte_ptr = dynamic_cast<BasicTopologyEntity*>(old_entity_ptr);
  if (!bte_ptr)
  {
    PRINT_ERROR("Invalid entity passed to regularize_refentity(..)\n");
    return CUBIT_FAILURE;
  }

  DLIList<Body*> body_list;
  bte_ptr->bodies(body_list);

  //ignore free entities
  if( body_list.size() == 0 )
  {
    PRINT_ERROR("%s %d is a free entity.  Cannot regularize it.\n", old_entity_ptr->class_name(),
                                                                    old_entity_ptr->id() );
    new_body_ptr = NULL;
    return CUBIT_FAILURE;
  }

  if (!okay_to_modify( body_list, "REGULARIZE" ))
    return CUBIT_FAILURE;

  DLIList<TopologyBridge*> bridge_list;
  // For curves we can try to handle composite curves.
  if(dynamic_cast<RefEdge*>(old_entity_ptr))
  {
    TopologyBridge *first_bridge = bte_ptr->bridge_manager()->topology_bridge();
    GeometryQueryEngine *gqe = first_bridge->get_geometry_query_engine();
    gqe->get_underlying_bridges(first_bridge, bridge_list);
    if(bridge_list.size() == 0)
      bridge_list.append(first_bridge);
  }
  else
  {
    bte_ptr->bridge_manager()->get_bridge_list(bridge_list);
  }

  //bte_ptr->bridge_manager()->get_bridge_list(bridge_list);
  bridge_list.reset();

  DLIList<BodySM*> new_sm_list;
  DLIList<Body*> new_body_list;
  CubitStatus stat = CUBIT_SUCCESS;

  do_attribute_setup();

  GeometryModifyEngine *save_gme = NULL;
  for (int i = bridge_list.size(); i--; )
  {
    TopologyBridge* bridge = bridge_list.get_and_step();
    GeometryEntity* geom_ptr = dynamic_cast<GeometryEntity*>(bridge);
    GeometryModifyEngine* gme = get_engine(geom_ptr);
    if(!save_gme)
      save_gme = gme;
    if (!gme) continue;

    DLIList<BodySM*> body_sm_list;
    geom_ptr->bodysms(body_sm_list);
    push_attributes_before_modify(body_sm_list);

    BodySM *new_body_sm = NULL;
    if (!gme->regularize_entity( geom_ptr, new_body_sm ))
      stat = CUBIT_FAILURE;

    if (new_body_sm)
      new_sm_list.append(new_body_sm);
  }

  new_sm_list.uniquify_ordered();

  // This is bad in that it assumes all of the gmes will be the
  // same but I don't know that we truly support the other case
  // anyway.
  if(new_sm_list.size())
  {
    restore_vg_after_modify(new_sm_list, body_list, save_gme);
    remove_pushed_attributes(new_sm_list, body_list);
  }

  if (!finish_sm_op(body_list, new_sm_list, new_body_list))
    stat = CUBIT_FAILURE;

  do_attribute_cleanup();

  new_body_ptr = new_body_list.size() ? new_body_list.get() : 0;
  return stat;
}

Definition at line 21302 of file GeometryModifyTool.cpp.

{
    //create a bounding box from the body list and the passed in points
    CubitBox bbox1;
    for( int k=body_list.size(); k--; )
        bbox1 |= body_list.get_and_step()->bounding_box();

  //add in the pts
  bbox1 |= v1;
  bbox1 |= v2;
  bbox1 |= v3;

    //get the diagonal of the bounding box
  double diagonal_length = bbox1.diagonal().length();

    //offset each point by the diagonal
  CubitVector new_pt;
  CubitVector direction;
  direction = v2-v1;
  direction.normalize();
  new_pt = v1 + direction*diagonal_length;

  CubitBox bbox2( new_pt );

  direction = v3-v1;
  direction.normalize();
  new_pt = v1 + direction*diagonal_length;
  bbox2 |= new_pt;

  direction = v1-v2;
  direction.normalize();
  new_pt = v2 + direction*diagonal_length;
  bbox2 |= new_pt;
  direction = v3-v2;
  direction.normalize();
  new_pt = v2 + direction*diagonal_length;
  bbox2 |= new_pt;

  direction = v1-v3;
  direction.normalize();
  new_pt = v3 + direction*diagonal_length;
  bbox2 |= new_pt;
  direction = v2-v3;
  direction.normalize();
  new_pt = v3 + direction*diagonal_length;
  bbox2 |= new_pt;

  //remove bodies that don't overlap
  for( int k=body_list.size(); k--; )
  {
    Body *tmp_body = body_list.get();
    if( !bbox2.overlap( 0.001, tmp_body->bounding_box() ) )
      body_list.change_to( NULL );
    body_list.step();
  }

  body_list.remove_all_with_value(NULL);
}
void GeometryModifyTool::remove_bodies_outside_bounding_box ( DLIList< Body * > &  body_list,
CubitBox tool_bounding_box 
) [private]

Definition at line 21284 of file GeometryModifyTool.cpp.

{
  //remove bodies that don't overlap
  for( int k=body_list.size(); k--; )
  {
    Body *tmp_body = body_list.get();
    if( !tool_bounding_box.overlap( 0.001, tmp_body->bounding_box() ) )
      body_list.change_to( NULL );
    body_list.step();
  }

  body_list.remove_all_with_value(NULL);
}
CubitStatus GeometryModifyTool::remove_curve_slivers ( DLIList< Body * > &  bodies,
double  lengthlimit 
)

Converts edges smaller than 'lengthlimit' into tolerant (or fat) vertices. only.

Definition at line 19915 of file GeometryModifyTool.cpp.

{
  DLIList<BodySM*> body_sm_list;
  GeometryModifyEngine* gme = common_modify_engine(bodies, body_sm_list);
  if ( !gme )
  {
    PRINT_ERROR("Curve sliver removal only supported on  geometry\n");
    return CUBIT_FAILURE;
  }

  if( CubitUndo::get_undo_enabled() )
    CubitUndo::save_state_with_cubit_file( bodies );

  CubitStatus status = CUBIT_FAILURE;
  DLIList<BodySM*> modified_bodies;
  int i;
  for( i=body_sm_list.size(); i--; )
  {
    BodySM *tmp_body_sm = body_sm_list.get_and_step();
    if( gme->remove_curve_slivers( tmp_body_sm, lengthlimit ) == CUBIT_SUCCESS )
    {
      modified_bodies.append( tmp_body_sm );
      status = CUBIT_SUCCESS;
    }
  }

  if( status == CUBIT_FAILURE )
  {
    PRINT_WARNING("Did not remove any sliver curves\n");
    if( CubitUndo::get_undo_enabled() )
      CubitUndo::remove_last_undo();
    return CUBIT_FAILURE;
  }

  DLIList<Body*> dummy_list;
  status = finish_sm_op( bodies, modified_bodies, dummy_list );
  if( status == CUBIT_FAILURE )
  {
    PRINT_WARNING("Did not remove any sliver curves\n");
    if( CubitUndo::get_undo_enabled() )
      CubitUndo::remove_last_undo();
    return CUBIT_SUCCESS;
  }

  return status;
}
void GeometryModifyTool::remove_dead_entity_names ( RefEntity entity) const [protected]

Definition at line 18319 of file GeometryModifyTool.cpp.

{
  TopologyEntity* topo_ent = dynamic_cast<TopologyEntity*>(entity);
  if (topo_ent->bridge_manager()->topology_bridge() == NULL)
    RefEntityName::instance()->remove_refentity_name( entity, CUBIT_TRUE );

  DLIList<RefEntity*> children;
  entity->get_child_ref_entities(children);
  children.last();
  for (int i = children.size(); i--; )
  {
    //PRINT_INFO("Removing dead entity on %s %d\n", children.get()->class_name(), children.get()->id() );
    remove_dead_entity_names( children.step_and_get() );
  }
}

< remove a geometry modify engine from the list; returns CUBIT_FAILURE if it wasn't in the list.

void GeometryModifyTool::remove_imprint_attributes_after_modify ( DLIList< BodySM * > &  body_sms,
DLIList< BodySM * > &  new_sms 
) [private]

Definition at line 3472 of file GeometryModifyTool.cpp.

{
  GeometryQueryTool::instance()->ige_remove_imprint_attributes_after_modify(old_sms, new_sms);
}
void GeometryModifyTool::remove_pushed_attributes ( DLIList< BodySM * > &  new_sms,
DLIList< Body * > &  old_bodies 
) [private]

Definition at line 6227 of file GeometryModifyTool.cpp.

{
  DLIList<TopologyBridge*> old_bridges(old_bodies.size());
  DLIList<TopologyBridge*> new_bridges(new_sms.size());
  CAST_LIST(new_sms, new_bridges, TopologyBridge);

  // Get bridges for all of the old Bodies.
  int k;
  for(k = old_bodies.size(); k>0; k--)
  {
    Body *body = old_bodies.get_and_step();
    TopologyBridge *tb = body->bridge_manager()->topology_bridge();
    if(tb)
    {
      old_bridges.append(tb);
      DLIList<TopologyBridge*> bridge_list;
      bridge_list.append(tb);
      // Add any bodies with composites to the new_sms list so that
      // make_Body gets called on them.  This will make sure that the
      // virtual gets ref entities properly built.
      if(this->contains_composites(bridge_list))
      {
        BodySM *bsm = dynamic_cast<BodySM*>(tb);
        if(bsm)
          new_sms.append_unique(bsm);
      }
    }
  }

  // Make a list including all of the bridges passed in.
  DLIList<TopologyBridge*> all_bridges;
  all_bridges = new_bridges;
  for(k=old_bridges.size(); k--;)
    all_bridges.append_unique(old_bridges.get_and_step());   
  
  
  //Remove ENTITY_ID attributes off non-virtual entities
  DLIList<CubitSimpleAttrib> list;
  for( k=all_bridges.size(); k--; )
  {
    TopologyBridge *top_bridge = all_bridges.get_and_step();    
    GeometryModifyEngine *gme = get_engine(top_bridge);    
    DLIList<TopologyBridge*> children;
    gme->get_possible_invalid_tbs(all_bridges, children);

    for( int j=children.size(); j--; )
    {
      TopologyBridge *tmp_bridge = children.get_and_step();
      if( !GeometryQueryTool::instance()->is_intermediate_geometry( tmp_bridge ) )
      {
        tmp_bridge->get_simple_attribute( "ENTITY_ID", list );
        while( list.size() )    
          tmp_bridge->remove_simple_attribute_virt(list.pop());
      }
    }
  }    

  // At this point we don't need any more attributes on the underlying
  // entities so make sure they are cleaned up.
  GeometryQueryTool::instance()->ige_remove_attributes( all_bridges );
}
CubitStatus GeometryModifyTool::remove_topology ( DLIList< RefEdge * > &  ref_edge_list,
DLIList< RefFace * > &  ref_face_list,
double  backoff_distance,
double  small_curve_size,
DLIList< Body * > &  new_body_list,
CubitBoolean  propagate,
CubitBoolean  preview 
)

Removes small topology; i.e, curves and surfaces.

Definition at line 14530 of file GeometryModifyTool.cpp.

{
  int i, j;
  CubitStatus ret = CUBIT_SUCCESS;
  DLIList<Surface*> surf_list;
  DLIList<Curve*> curve_list;
  DLIList<Body*> old_body_list;
  GeometryModifyEngine *gme_ptr1=NULL, *gme_ptr2=NULL, *gme_ptr=NULL;
  Body *b1=NULL, *b2=NULL, *b=NULL;

  if(ref_edge_list.size())
    b1 = ref_edge_list.get()->body();
  if(ref_face_list.size())
    b2 = ref_face_list.get()->body();

  if(b1 && b2)
  {
    if(b1 == b2)
      b = b1;
  }
  else if(b1)
    b = b1;
  else if(b2)
    b = b2;

  if(b)
    old_body_list.append(b);
  else
  {
    PRINT_ERROR("Failed to find an owning body for the topology being removed.\n");
    ret = CUBIT_FAILURE;
  }

  if(ret == CUBIT_SUCCESS)
  {
    if (!okay_to_modify( old_body_list, "REMOVE_TOPOLOGY" ))
      ret = CUBIT_FAILURE;
    else
    {
      // Remove any edges from the list that aren't small enough.
      DLIList<RefEdge*> edges_to_remove;
      for(i=ref_edge_list.size(); i--;)
      {
        RefEdge* re = ref_edge_list.get_and_step();
        if(re->get_arc_length() > small_curve_size)
        {
          edges_to_remove.append(re);
          PRINT_INFO("Ignoring curve %d as it is not a small curve based on the input. "
            "Try a larger small_curve_size value.\n", re->id());
        }
      }
      ref_edge_list -= edges_to_remove;

      // Remove any faces from the list that don't have at least one small edge.
      DLIList<RefFace*> faces_to_remove;
      for(i=ref_face_list.size(); i--;)
      {
        DLIList<RefEdge*> face_edges;
        RefFace* rf = ref_face_list.get_and_step();
        rf->ref_edges(face_edges);
        int face_ok = 0;
        for(j=face_edges.size(); j && !face_ok; j--)
        {
          RefEdge* cur_edge = face_edges.get_and_step();
          if(cur_edge->get_arc_length() <= small_curve_size)
            face_ok = 1;
        }
        if(!face_ok)
        {
          faces_to_remove.append(rf);
          PRINT_INFO("Ignoring surface %d as it does not have at least one small curve in it based on the input. "
            "Try a larger small_curve_size value.\n", rf->id());
        }
      }
      ref_face_list -= faces_to_remove;
    }

    if(ref_face_list.size() > 0 || ref_edge_list.size() > 0)
    {
      // If told to do so propagate the topology to be removed to include
      // other narrow surfaces and small edges.
      if(propagate)
      {
        // Get all of the small edges into a single list.
        DLIList<RefEdge*> small_edges = ref_edge_list;
        for(i=ref_face_list.size(); i--;)
        {
          RefFace *face = ref_face_list.get_and_step();
          DLIList<RefEdge*> edges;
          face->ref_edges(edges);
          for(j=edges.size(); j--;)
          {
            RefEdge *edge = edges.get_and_step();
            if(edge->get_arc_length() < small_curve_size)
              small_edges.append(edge);
          }
        }
        small_edges.uniquify_ordered();

        DLIList<RefFace*> processed_faces;
        DLIList<RefEdge*> copy_of_small_edges = small_edges;
        DLIList<RefFace*> narrow_faces;

        DLIList<RefFace*> all_faces;
        DLIList<RefEdge*> all_edges;

        // Set all of the marked flags to 0.
        b->ref_faces(all_faces);
        for(i=all_faces.size(); i>0; i--)
          all_faces.get_and_step()->marked(0);

        b->ref_edges(all_edges);
        for(i=all_edges.size(); i>0; i--)
          all_edges.get_and_step()->marked(0);

        // Mark of >0 means it has been processed.
        // Mark of 2 means it is a small edge.
        for(i=small_edges.size(); i>0; i--)
          small_edges.get_and_step()->marked(2);

        // First look at all of the edges connected to small edges
        // to see if there are other small edges.
        while(copy_of_small_edges.size())
        {
          RefEdge *edge = copy_of_small_edges.extract();
          propagate_from_small_edge(edge, small_edges,
                  narrow_faces, processed_faces, small_curve_size);
        }

        ref_face_list += narrow_faces;
        ref_face_list.uniquify_ordered();

        ref_edge_list = small_edges;
        ref_edge_list.uniquify_ordered();
        // Append to face list here so we don't lose the ones that were passed in.
      }
    }
    else
    {
      PRINT_WARNING("No entities to remove.\n");
      ret = CUBIT_FAILURE;
    }
  }

  if(ret == CUBIT_SUCCESS)
  {
    if(ref_edge_list.size())
    {
      for(i=ref_edge_list.size(); i--;)
      {
        RefEdge *re = ref_edge_list.get_and_step();
        Curve *cur = re->get_curve_ptr();
        DLIList<TopologyBridge*> tmp_curve_list;
        GeometryQueryEngine *gqe = cur->get_geometry_query_engine();
        gqe->get_underlying_curves(cur, tmp_curve_list);
        if(tmp_curve_list.size() == 0)
          tmp_curve_list.append(cur);
        for(int p=tmp_curve_list.size(); p--;)
        {
          Curve *crv = dynamic_cast<Curve*>(tmp_curve_list.get_and_step());
          if(!gme_ptr1)
            gme_ptr1 = get_engine(crv);
          curve_list.append(crv);
        }
      }
    }
    if(ref_face_list.size())
    {
      for(i=ref_face_list.size(); i--;)
      {
        RefFace *rf = ref_face_list.get_and_step();
        Surface *sur = rf->get_surface_ptr();
        DLIList<TopologyBridge*> tmp_surf_list;
        GeometryQueryEngine *gqe = sur->get_geometry_query_engine();
        gqe->get_underlying_surfaces(sur, tmp_surf_list);
        if(tmp_surf_list.size() == 0)
          tmp_surf_list.append(sur);
        for(int p=tmp_surf_list.size(); p--;)
        {
          Surface *srf = dynamic_cast<Surface*>(tmp_surf_list.get_and_step());
          if(!gme_ptr2)
            gme_ptr2 = get_engine(srf);
          surf_list.append(srf);
        }
      }
    }
    if(gme_ptr1 && gme_ptr2)
    {
      if(gme_ptr1 == gme_ptr2)
        gme_ptr = gme_ptr1;
    }
    else if(gme_ptr1)
      gme_ptr = gme_ptr1;
    else if(gme_ptr2)
      gme_ptr = gme_ptr2;

    if(!gme_ptr)
    {
      PRINT_ERROR("Failed to find a geometry modify engine.\n");
      ret = CUBIT_FAILURE;
    }
  }

  if(ret == CUBIT_SUCCESS)
  {
    if( CubitUndo::get_undo_enabled() && preview == CUBIT_FALSE )
    {
      DLIList<Body*> bodies;
      int i;
      for( i=ref_face_list.size(); i--; )
      {
        RefFace* ref_face = ref_face_list.get_and_step();
        bodies.append( ref_face->body() );
      }
      for( i=ref_edge_list.size(); i--; )
      {
        RefEdge* ref_edge = ref_edge_list.get_and_step();
        bodies.append( ref_edge->body() );
      }
      bodies.uniquify_ordered();
      CubitUndo::save_state_with_cubit_file( bodies );
    }

    if(preview == CUBIT_FALSE)
      do_attribute_setup();

    DLIList<BodySM*> body_sm_list(old_body_list.size());
    GeometryModifyEngine* gme = common_modify_engine(old_body_list, body_sm_list);

    if(preview == CUBIT_FALSE)
      push_attributes_before_modify(body_sm_list);

    DLIList<BodySM*> new_bodysm_list;
    if(gme_ptr->remove_topology(curve_list, surf_list, backoff_distance, small_curve_size,
        new_bodysm_list, preview) == CUBIT_FAILURE)
    {
      if( CubitUndo::get_undo_enabled() )
        CubitUndo::remove_last_undo();

      if(!preview)
        remove_pushed_attributes(new_bodysm_list, old_body_list);

      ret = CUBIT_FAILURE;
    }
    else
    {
      if( preview == CUBIT_FALSE )
      {
        restore_vg_after_modify(new_bodysm_list, old_body_list, gme);
        remove_pushed_attributes(new_bodysm_list, old_body_list);

        // Update DAG
        ret = finish_sm_op( old_body_list, new_bodysm_list, new_body_list );

        if( CubitUndo::get_undo_enabled() )
        {
          if( ret == CUBIT_FAILURE)
            CubitUndo::remove_last_undo();
          else
            CubitUndo::note_result_bodies( new_body_list );
        }
      }
    }

    if(preview == CUBIT_FALSE)
      do_attribute_cleanup();
  }

  return ret;
}
CubitStatus GeometryModifyTool::restore_vg_after_modify ( DLIList< BodySM * > &  new_sms,
DLIList< Body * > &  old_bodies,
GeometryModifyEngine gme 
) [private]

Definition at line 6290 of file GeometryModifyTool.cpp.

{
  DLIList<TopologyBridge*> old_bridges(old_bodies.size());
  DLIList<TopologyBridge*> new_bridges(new_sms.size());
  CAST_LIST(new_sms, new_bridges, TopologyBridge);

  // Get bridges for all of the old Bodies.
  int k;
  for(k = old_bodies.size(); k>0; k--)
  {
    Body *body = old_bodies.get_and_step();
    TopologyBridge *tb = body->bridge_manager()->topology_bridge();
    if(tb)
    {
      old_bridges.append(tb);
      DLIList<TopologyBridge*> bridge_list;
      bridge_list.append(tb);
      // Add any bodies with composites to the new_sms list so that
      // make_Body gets called on them.  This will make sure that the
      // virtual gets ref entities properly built.
      if(this->contains_composites(bridge_list))
      {
        BodySM *bsm = dynamic_cast<BodySM*>(tb);
        if(bsm)
          new_sms.append_unique(bsm);
      }
    }
  }

  // Make a list including all of the bridges passed in.
  DLIList<TopologyBridge*> all_bridges;
  all_bridges = new_bridges;
  for(k=old_bridges.size(); k--;)
    all_bridges.append_unique(old_bridges.get_and_step());

  DLIList<TopologyBridge*> tbs_to_check;
  if(gme)
    gme->get_possible_invalid_tbs(all_bridges, tbs_to_check);

  DLIList<Surface*> all_surfs;
  DLIList<Curve*> all_curves;
  DLIList<TBPoint*> all_points;
  if(tbs_to_check.size() > 0)
  {
    for(k=tbs_to_check.size(); k--;)
    {
      TopologyBridge *tb = tbs_to_check.get_and_step();
      Surface *surf = dynamic_cast<Surface*>(tb);
      if(surf)
        all_surfs.append(surf);
      else
      {
        Curve *cur = dynamic_cast<Curve*>(tb);
        if(cur)
          all_curves.append(cur);
        else
        {
          TBPoint *pt = dynamic_cast<TBPoint*>(tb);
          if(pt)
            all_points.append(pt);
        }
      }
    }
  }

  // This function has been changed to blown away any virtual (really only doing
  // composites right now).  The virtual will rebuilt from the attributes stored
  // on the  entities.
  GeometryQueryTool::instance()->ige_remove_modified(all_surfs, all_curves, all_points);

  //Restore virtual
  GeometryQueryTool::instance()->ige_import_geom( all_bridges );

  return CUBIT_SUCCESS;
}

Turn bodies inside-out.

Definition at line 9949 of file GeometryModifyTool.cpp.

{
   DLIList<Body*> reversed_bodies;
   int i;
   for( i=body_list.size(); i--; )
   {
     Body *body = body_list.get_and_step();
     BodySM* body_sm = body->get_body_sm_ptr();
     GeometryModifyEngine* gme = get_engine( body_sm );
     if (!gme) {
        PRINT_ERROR("Body %d does not have a modify engine.\n", body->id());
        continue;
     }

     CubitStatus stat = gme->reverse_body( body_sm );

     if ( CUBIT_SUCCESS != stat )
     {
       PRINT_ERROR("Reverse failed.\n");
       continue;
     }
     else
     {
       reversed_bodies.append( body );
       GeometryQueryTool::instance()->make_Body( body_sm );
       AppUtil::instance()->send_event(GeometryEvent(GeometryEvent::GEOMETRY_MODIFIED, body));
       PRINT_INFO("Reversed body %d.\n", body->id());
       continue;
     }
   }

   if( CubitUndo::get_undo_enabled() )
   {
     CubitString undo_command("reverse body ");
     for( i=reversed_bodies.size(); i--; )
     {
       undo_command += CubitString::number(reversed_bodies.get_and_step()->id());
       undo_command += " ";
     }
     CubitUndo::set_undo_by_command( undo_command );
   }

   return CUBIT_SUCCESS;
}

Reverse the given faces using the solid modeller (flip normals)

Definition at line 10001 of file GeometryModifyTool.cpp.

{
  // Check for virtual geometry
  DLIList<RefEntity*> ref_ent_list;
  CAST_LIST_TO_PARENT(ref_face_list, ref_ent_list);
  if( GeometryQueryTool::instance()->contains_intermediate_geometry(ref_ent_list) )
  {
    PRINT_ERROR("REVERSING surfaces containing virtual geometry is not\n"
      "       allowed. Delete virtual geometry on surfaces before\n"
      "       operation.\n" );
    return CUBIT_FAILURE;
  }

  // Get the owning bodies of the faces
  int i;
  DLIList<Body*> body_list;
  for( i=ref_face_list.size(); i--; )
    ref_face_list.get_and_step()->bodies( body_list );
  body_list.uniquify_ordered();

  // Handle surfaces from different modify engines.  Copy the input list since
  // we will be pulling RefFaces out of it.
  DLIList<RefFace*> copied_ref_face_list = ref_face_list;

  // Keep track of overall errors and successes
  int error_occurred = 0;
  int successful_case = 0;
  GeometryModifyEngine *gme_ptr;

  while( copied_ref_face_list.size() )
  {
    // Need to send in Surfaces
    DLIList<Surface*> surface_list;
    DLIList<RefFace*> common_face_list;

    gme_ptr = pull_common_surfs( copied_ref_face_list, common_face_list,
                                 surface_list );
    if( !gme_ptr )
      return CUBIT_FAILURE;

    if( gme_ptr->flip_normals( surface_list ) == CUBIT_FAILURE )
      error_occurred = 1;
    else
      successful_case = 1;
  }

  if( error_occurred && !successful_case )
    return CUBIT_FAILURE;

  // Update the impacted bodies
  Body *body_ptr;
  BodySM* body_sm_ptr;
  DLIList<BodySM*> new_sm_list;
  for( i=body_list.size(); i--; )
  {
    body_ptr = body_list.get_and_step();
    body_sm_ptr = body_ptr->get_body_sm_ptr();
    new_sm_list.append( body_sm_ptr );
  }

  DLIList<Body*> new_body_list;
  CubitStatus status = finish_sm_op(body_list, new_sm_list, new_body_list );

  if( CUBIT_FAILURE == status )
    return CUBIT_FAILURE;
  
  for( int k=0; k< ref_face_list.size(); k++ )
    AppUtil::instance()->send_event(GeometryEvent(GeometryEvent::GEOMETRY_MODIFIED, ref_face_list.get_and_step() ));  

  return CUBIT_SUCCESS;
}

Check to determine if all entities are of the same geometry engine.

Returns CUBIT_TRUE if all the entities have the same geometric query engine and if that is the same one as the default.

Definition at line 10971 of file GeometryModifyTool.cpp.

{
  GeometryModifyEngine *gePtr1 = get_engine(topo_list.get_and_step());
  GeometryModifyEngine *gePtr2;
  for( int i = 1; i < topo_list.size(); i++)
  {
    gePtr2 = get_engine(topo_list.get_and_step());
    if(gePtr1 != gePtr2)
    {
      return CUBIT_FALSE;
    }
  }
  return CUBIT_TRUE;
}
CubitBoolean GeometryModifyTool::same_modify_engine ( DLIList< RefEntity * > &  ref_entity_list,
CubitBoolean  check_children = CUBIT_FALSE 
) const

Check to determine if all entities are of the same geometry engine as active geometry engine.

Returns CUBIT_TRUE if all the entities have the same geometric query engine and if that is the same one as the default. If the check_children parameter is CUBIT_TRUE, all the child entities will also be checked.

Definition at line 10986 of file GeometryModifyTool.cpp.

{

  DLIList<RefEntity*> complete_entity_list;

  //Check the check_children option and check all the children if necessary
  if (check_children)
  {
    //Make a complete list of all the RefEntitys and their children
    DLIList<RefEntity*> temp = ref_entity_list;
    RefEntity* ref_entity_ptr;
    int i;
    for (i = 0; i < ref_entity_list.size(); i++)
    {
      ref_entity_ptr = ref_entity_list.get_and_step();
      complete_entity_list.clean_out();
      ref_entity_ptr->get_all_child_ref_entities(complete_entity_list);
      temp += complete_entity_list;
    }
    complete_entity_list.clean_out();
    complete_entity_list.merge_unique(temp);
  }
  else
    complete_entity_list = ref_entity_list;

  //Now make sure all the RefEntitys are from the same geometry engine
  DLIList<TopologyEntity*> te_list;
  CAST_LIST(complete_entity_list, te_list, TopologyEntity);
  return same_modify_engine(te_list);

}
CubitStatus GeometryModifyTool::scale ( Body *&  entity,
const CubitVector point,
const CubitVector factors,
bool  check_to_transform = true,
bool  preview = false,
bool  reset_preview = true 
)

Scale a body non-uniformly. (x,y,z directions)

Definition at line 7663 of file GeometryModifyTool.cpp.

{
  if( check_to_transform )
    if (!GeometryQueryTool::instance()->okay_to_transform( body ))
      return CUBIT_FAILURE;

  DLIList<Body*> body_list;
  body_list.append(body);
  if (!okay_to_modify( body_list, "NON_UNIFORM_SCALE" ))
    return CUBIT_FAILURE;

  if(reset_preview)
    GfxPreview::clear();

  if (preview)
  {
    DLIList<RefEdge*> edges;
    body->ref_edges(edges);

    //set up the matrices
    CubitTransformMatrix pre_mat, scale_mat, post_mat;
    pre_mat.translate(-point);    
    scale_mat.scale_about_origin(factors);   
    post_mat.translate(point);

    for (int i = 0; i < edges.size(); i++)
    {
      GMem poly;

      if( CUBIT_SUCCESS == edges[i]->get_graphics(poly) )
      {
        poly.transform(pre_mat);
        poly.transform(scale_mat);
        poly.transform(post_mat);
        GfxPreview::draw_polyline(poly.point_list(), poly.point_list_size(), CUBIT_BLUE_INDEX);
      }
      else if( edges[i]->start_vertex() == edges[i]->end_vertex() )
      {       
        CubitVector tmp_pt = edges[i]->start_vertex()->coordinates();
        tmp_pt = pre_mat*tmp_pt;
        tmp_pt = scale_mat*tmp_pt;
        tmp_pt = post_mat*tmp_pt;          
        GfxPreview::draw_point( tmp_pt, CUBIT_BLUE_INDEX);
      }      
    }
    GfxPreview::flush();
    return CUBIT_SUCCESS;
  }

  do_attribute_setup();

  BodySM* bodysm = body->get_body_sm_ptr();
  DLIList<BodySM*> body_sm_list;
  body_sm_list.append(bodysm);

  push_attributes_before_modify(body_sm_list);

  GeometryModifyEngine* engine = get_engine( bodysm );
  CubitStatus result;
  if( !engine )
  {
    GeometryQueryEngine* tmp_engine = bodysm->get_geometry_query_engine();
    result = tmp_engine->translate( bodysm, -point );
    result = tmp_engine->scale( bodysm, factors );
    result = tmp_engine->translate( bodysm, point );

  }
  else
  {
    GeometryQueryEngine* tmp_engine = bodysm->get_geometry_query_engine();
    result = tmp_engine->translate( bodysm, -point );
    result = engine->scale( bodysm, factors );
    result = tmp_engine->translate( bodysm, point );
  }

  // The bodysm pointer may get changed depending on the underlying
  // engine.  Make sure to put the most current pointer in the list
  // for further processing.
  body_sm_list.clean_out();
  body_sm_list.append(bodysm);
  // The old body will probably have stale data at this point
  // so don't send it down for further processing.
  body_list.clean_out();

  restore_vg_after_modify( body_sm_list, body_list, engine );
  remove_pushed_attributes( body_sm_list, body_list );

  //for non-uniform scaling, topology can change...need to update stuff
  if( factors.x() != factors.y() ||
      factors.y() != factors.z() ||
      factors.z() != factors.x() )
    body = GeometryQueryTool::instance()->make_Body(bodysm);

  do_attribute_cleanup();

  if (result)
  {

    CubitTransformMatrix pre_mat;
    pre_mat.translate(-point);

    CubitTransformMatrix scale_mat;
    scale_mat.scale_about_origin(factors);

    CubitTransformMatrix post_mat;
    post_mat.translate(point);
    GeometryQueryTool::instance()->notify_intermediate_of_transform( body, pre_mat );
    GeometryQueryTool::instance()->notify_intermediate_of_transform( body, scale_mat );
    GeometryQueryTool::instance()->notify_intermediate_of_transform( body, post_mat );
    GeometryQueryTool::instance()->notify_observers_of_transform( body );
  }
  else
    PRINT_ERROR("Scale of %s (%s %d) failed.\n",
      body->entity_name().c_str(), body->class_name(), body->id() );

  return result;
}
CubitStatus GeometryModifyTool::section ( DLIList< Body * > &  section_body_list,
const CubitVector point_1,
const CubitVector point_2,
const CubitVector point_3,
DLIList< Body * > &  new_body_list,
CubitBoolean  keep_normal_side,
CubitBoolean  keep_old = CUBIT_FALSE 
)

Cuts body with plane, throwing away one side.

Cuts the given bodies with the points defining a plane. This is mainly used for vis purposes to section a body with a plane and only retain half of it.

Definition at line 3852 of file GeometryModifyTool.cpp.

{
  if( section_body_list.size() == 0 )
    return CUBIT_FAILURE;

  if (!okay_to_modify( section_body_list, "SECTION" ))
    return CUBIT_FAILURE;
   CubitStatus rval = CUBIT_SUCCESS;

   const int count = section_body_list.size();
   DLIList<BodySM*> result_sm_list;
   DLIList<Body*> body_list(section_body_list);
   DLIList<BodySM*> engine_body_sms(count);
   DLIList<Body*> engine_bodies(count);
   GeometryModifyEngine* gme = 0;

   if( CubitUndo::get_undo_enabled() )
   {
     if( keep_old )
       CubitUndo::save_state();
     else
       CubitUndo::save_state_with_cubit_file( section_body_list );
   }

   while ( (gme = group_bodies_by_engine(body_list, engine_bodies, engine_body_sms)) )
   {
      //get all the child entities that have been merged
      DLIList<int> merged_surface_ids;
      DLIList<int> merged_curve_ids;
      get_merged_curve_and_surface_ids( engine_bodies, merged_surface_ids, merged_curve_ids );

      CubitStatus result = gme->section( engine_body_sms,
                                         point_1, point_2, point_3,
                                         result_sm_list,
                                         keep_normal_side, keep_old );

      if (!finish_sm_op( engine_bodies, result_sm_list, new_body_list ))
        result = CUBIT_FAILURE;
      if (!result)
        rval = CUBIT_FAILURE;

      if( merged_surface_ids.size() || merged_curve_ids.size() )
        fixup_merged_entities( merged_surface_ids, merged_curve_ids);

      engine_body_sms.clean_out();
      engine_bodies.clean_out();
      result_sm_list.clean_out();
   }

  if( CubitUndo::get_undo_enabled() )
  {
    if( new_body_list.size() ) //if there are new bodies...something succeeded
      CubitUndo::note_result_bodies( new_body_list );
    else
      CubitUndo::remove_last_undo();
  }

   return rval;
}
CubitStatus GeometryModifyTool::separate_body_after_webcut ( DLIList< Body * > &  input_list,
DLIList< Body * > &  output_list 
) const [private]

Separates each body in the input list to have one volume per body, and places the new list of bodies in the output_list. Should only be called after webcutting. (Checks sepAfterWebcut flag.)

Definition at line 11904 of file GeometryModifyTool.cpp.

{
    //First see if we should spearate.
  if ( !sepAfterWebcut )
  {
    output_list = input_list;
    return CUBIT_SUCCESS;
  }
  DLIList<Body*> temp_body_list;
  for ( int ii = input_list.size(); ii > 0; ii-- )
  {
    Body *body_ptr = input_list.get_and_step();
    temp_body_list.clean_out();

    bool undo_setting = CubitUndo::get_undo_enabled();
    if( undo_setting == true )
      CubitUndo::set_undo_enabled( false );

    split_body(body_ptr, temp_body_list);

    if( undo_setting == true )
      CubitUndo::set_undo_enabled( true );

    output_list += temp_body_list;
  }
  return CUBIT_SUCCESS;
}
CubitStatus GeometryModifyTool::separate_surfaces ( DLIList< RefFace * > &  ref_face_list,
DLIList< Body * > &  new_bodies 
)

Separates surfaces from sheet bodies into separate bodies. Connected.

Separates surfaces from sheet bodies into separate bodies. Connected surfaces will remain connected but be placed in a new body.


GeometryModifyTool options and settings

Definition at line 9825 of file GeometryModifyTool.cpp.

{
  int i;
  RefFace *ref_face_ptr;

  for( i=ref_face_list.size(); i--; )
  {
    ref_face_ptr = ref_face_list.get();

    // Check for no body
    DLIList<Body*> body_list;
    ref_face_ptr->bodies( body_list );
    if( body_list.size()==0 )
    {
      PRINT_ERROR( "Surface %d is not contained within a parent body.\n"
        "       It cannot be separated.\n", ref_face_ptr->id() );
      return CUBIT_FAILURE;
    }
  }

  // Check for virtual geometry
  DLIList<RefEntity*> ref_ent_list;
  CAST_LIST_TO_PARENT(ref_face_list, ref_ent_list);
  if ( GeometryQueryTool::instance()->contains_intermediate_geometry(ref_ent_list) )
  {
    PRINT_ERROR("SEPARATING surfaces containing virtual geometry is not\n"
      "       allowed. Delete virtual geometry on these surfaces\n"
      "       before operation.\n" );
    return CUBIT_FAILURE;
  }

  // Prep for undo
  DLIList<Body*> body_list;
  for( i=ref_face_list.size(); i--; )
    ref_face_list.get_and_step()->bodies( body_list );
  body_list.uniquify_ordered();

  if( CubitUndo::get_undo_enabled() )
    CubitUndo::save_state_with_cubit_file( body_list );

  // Handle surfaces from different modify engines.  Copy the input list since
  // we will be pulling RefFaces out of it.
  DLIList<RefFace*> copied_ref_face_list = ref_face_list;

  // Keep track of errors and success
  int error_occurred = 0;
  int successful_case = 0;

  GeometryModifyEngine *gme_ptr;
  while( copied_ref_face_list.size() )
  {
    // Need to send in Surfaces
    DLIList<Surface*> surface_list;
    DLIList<RefFace*> gme_face_list;

    gme_ptr = pull_common_surfs( copied_ref_face_list, gme_face_list,
                                 surface_list );
    if( !gme_ptr )
      return CUBIT_FAILURE;

    // Get the owning bodies of the faces...needed for finish_sm_op
    DLIList<Body*> gme_body_list;
    for( i=gme_face_list.size(); i--; )
      gme_face_list.get_and_step()->bodies( gme_body_list );
    gme_body_list.uniquify_ordered();

    DLIList<BodySM*> new_sm_list;
    DLIList<Body*> new_body_list;
    if( gme_ptr->separate_surfaces( surface_list, new_sm_list ) == CUBIT_FAILURE ||
        finish_sm_op(gme_body_list, new_sm_list, new_body_list ) == CUBIT_FAILURE )
    {
      error_occurred++;
      continue;
    }

    new_bodies += new_body_list;
    successful_case++;
  }

  if( error_occurred && !successful_case )
    return CUBIT_FAILURE;

  // Following is copied from split_body - to keep same behavior. When all
  // surfaces are separated from a given body, separate_surfaces just separates
  // the body. Without the code below we get new body ids.
  if ( !GeometryModifyTool::instance()->get_new_ids())
  {
    //Now reuse the body ids.
    DLIList<RefVolume*> new_ref_vols;
    for ( int ii = new_bodies.size(); ii > 0; ii-- )
    {
      Body *temp_body = new_bodies.get_and_step();
      new_ref_vols.clean_out();
      temp_body->ref_volumes(new_ref_vols);
      int vol_id = new_ref_vols.get()->id();
      if ( temp_body->id() != vol_id )
      {
        //Check to see if this id is being used by
        //some other body.
        if ( RefEntityFactory::instance()->get_body(vol_id) == NULL )
        {
          temp_body->set_id(vol_id);
        }
        //if it is in use, then we shouldn't mess around with it...
      }
    }
  }

  if( CubitUndo::get_undo_enabled() )
    CubitUndo::note_result_bodies( new_bodies );

  return CUBIT_SUCCESS;
}

Sets all edges imprint flag.

Definition at line 2485 of file GeometryModifyTool.hpp.

{allEdgesImprint = flag;}
static void GeometryModifyTool::set_copy_entity ( RefEntity ent) [inline, static]

Sets the entity being copied.

Definition at line 1157 of file GeometryModifyTool.hpp.

{ copyingEntity = ent; }

Sets the active geometry engine.

Definition at line 12514 of file GeometryModifyTool.cpp.

{
    if(!GMEPtr)
        return CUBIT_FAILURE;

    int i;
    for (i = 0; i < gmeList.size(); i++)
    {
        if(GMEPtr == gmeList.get())
            break;

        gmeList.step();
    }

    if(i == gmeList.size())
        return CUBIT_FAILURE;

    GeometryModifyEngine* temp_ptr = gmeList.get();
    gmeList.remove();
    gmeList.insert_first(temp_ptr);
    return CUBIT_SUCCESS;
}
static void GeometryModifyTool::set_group_imprint ( CubitBoolean  flag) [inline, static]

Sets group imprint flag.

Definition at line 1113 of file GeometryModifyTool.hpp.

{groupImprint = flag;}
static void GeometryModifyTool::set_new_ids ( CubitBoolean  flag) [inline, static]

Sets new ids flag.

Definition at line 1135 of file GeometryModifyTool.hpp.

{newIds = flag;}
static void GeometryModifyTool::set_old_names ( CubitBoolean  flag) [inline, static]

Sets old names flag.

Definition at line 1140 of file GeometryModifyTool.hpp.

{ oldNames = flag; }
static void GeometryModifyTool::set_sep_after_webcut_setting ( CubitBoolean  val) [inline, static]

Sets sepAfterWebcut variable.

Definition at line 1954 of file GeometryModifyTool.hpp.

{sepAfterWebcut = val;}
Body * GeometryModifyTool::sphere ( double  radius,
int  x_shift = 0,
int  y_shift = 0,
int  z_shift = 0,
double  inner_radius = 0,
bool  delete_side = false 
)

Creates a sphere.

Creates an sphere and assigns it to a Body $ {radius} input radius Returns the new Body or NULL

Definition at line 229 of file GeometryModifyTool.cpp.

{
   if (0 == gmeList.size())
   {
      PRINT_WARNING("No active geometry engine.\n");
      return NULL;
   }

     // First make sure the radius is not zero or less
   if ( radius <= 0.0 )
   {
      PRINT_ERROR("In GeometryModifyTool::sphere\n"
                  "       Cannot make a sphere of radius %f\n",
                  radius);
      return NULL ;
   }

  if( CubitUndo::get_undo_enabled() )
    CubitUndo::save_state();

  GeometryModifyEngine *gme = gmeList.get();

  BodySM* body_sm = gme->sphere(radius);

  if (x_shift != 0 || y_shift != 0 || z_shift != 0)
  {
    BodySM *brick = gme->brick( 2.0 * radius,
                                2.0 * radius,
                                2.0 * radius);

    CubitVector delta( x_shift * radius,
                       y_shift * radius,
                       z_shift * radius );

    gme->get_gqe()->translate( brick, delta );

    DLIList<BodySM*> new_sms;
    DLIList<BodySM*> from_bodies(1);
    from_bodies.append( body_sm );
    bool keep_old = true;
    CubitStatus bool_status;
    if( delete_side == false )
       bool_status = gme->intersect( brick, from_bodies, new_sms, keep_old );
    else
    {
      DLIList<BodySM*> tool_bodies(1);
      tool_bodies.append( brick );
      bool imprint = false;
      bool_status = gme->subtract( tool_bodies, from_bodies, new_sms, imprint, keep_old );
    }

    //delete the old bodies
    gme->get_gqe()->delete_solid_model_entities( body_sm );
    gme->get_gqe()->delete_solid_model_entities( brick );

    if( bool_status == CUBIT_FAILURE || new_sms.size() == 0 )
    {
      PRINT_ERROR("Problems creating sphere.\n" );
      return NULL ;
    }

    body_sm = new_sms.get();
  }

  Body *new_body = NULL;
  BodySM* inner_body_sm = NULL;
  if( inner_radius )
  {
    inner_body_sm = gme->sphere(inner_radius);
    DLIList<BodySM*> new_sms;
    DLIList<BodySM*> from_bodies(1);
    DLIList<BodySM*> tool_bodies(1);
    from_bodies.append( body_sm );
    tool_bodies.append( inner_body_sm );
    bool imprint = false;
    bool keep_old = true;
    CubitStatus subtract_status =
       gme->subtract( tool_bodies, from_bodies, new_sms, imprint, keep_old );

     //delete the old bodies
    gme->get_gqe()->delete_solid_model_entities( body_sm );
    gme->get_gqe()->delete_solid_model_entities( inner_body_sm );

    if( subtract_status == CUBIT_FAILURE || new_sms.size() == 0 )
    {
      PRINT_ERROR("Problems creating sphere with inner radius.\n" );
      return NULL ;
    }

    body_sm = new_sms.get();
  }

  if (!body_sm)
  {
     PRINT_ERROR("In GeometryModifyTool::sphere\n"
                 "       Problems building a volume from the sphere.\n");
  }
  else
    new_body = GeometryQueryTool::instance()->make_Body(body_sm);

  if( CubitUndo::get_undo_enabled() )
  {
    if( new_body )
      CubitUndo::note_result_body( new_body );
    else
      CubitUndo::remove_last_undo();
  }

  return new_body;
}
CubitStatus GeometryModifyTool::split_body ( Body body_ptr,
DLIList< Body * > &  new_bodies 
) const

Separates multi-volume bodies into single-volume bodies.

Definition at line 9720 of file GeometryModifyTool.cpp.

{
  int i;
  DLIList<RefVolume*> ref_vols;
  body_ptr->ref_volumes(ref_vols);
  if ( ref_vols.size() < 2 )
  {
    //no need to split...
    new_bodies.append(body_ptr);
    return CUBIT_SUCCESS;
  }

  DLIList<Body*> b_list;
  b_list.append(body_ptr);
  if (!okay_to_modify( b_list, "SPLIT" ))
    return CUBIT_FAILURE;

  // Call the owning GeometryModifyEngine to split the body
  // so that there is one volume per body.
  BodySM* bodysm_ptr = body_ptr->get_body_sm_ptr();
  GeometryModifyEngine* engine_ptr = get_engine(bodysm_ptr);
  if (!engine_ptr) {
    PRINT_ERROR("There is no modify engine available for this volume."
      " Volume cannot be split.\n");
    return CUBIT_FAILURE;
  }

  if( CubitUndo::get_undo_enabled() )
  {
    DLIList<Body*> bodies(1);
    bodies.append( body_ptr );
    CubitUndo::save_state_with_cubit_file( bodies );
  }

  DLIList<BodySM*> new_sm_list;
  CubitStatus stat = engine_ptr->split_body( bodysm_ptr, new_sm_list );
  if ( new_sm_list.size() == 0 )
  {
    PRINT_ERROR("failed in splitting volumes, orginal was lost.\n");
    GeometryQueryTool::instance()->destroy_dead_entity(body_ptr);
    return CUBIT_FAILURE;
  }

  bodysm_ptr = body_ptr->get_body_sm_ptr();
  if (bodysm_ptr)
  {
    remove_dead_entity_names(body_ptr);
    body_ptr = GeometryQueryTool::instance()->make_Body(bodysm_ptr);
  }
  else
  {
    GeometryQueryTool::instance()->destroy_dead_entity(body_ptr);
  }

  new_sm_list.reset();
  for (i = new_sm_list.size(); i--; )
  {
    bodysm_ptr = new_sm_list.get_and_step();
    Body* body = GeometryQueryTool::instance()->make_Body(bodysm_ptr);
    new_bodies.append(body);
  }

  if ( !GeometryModifyTool::instance()->get_new_ids())
  {
    //Now reuse the body ids.
    DLIList<RefVolume*> new_ref_vols;
    for ( int ii = new_bodies.size(); ii > 0; ii-- )
    {
      Body *temp_body = new_bodies.get_and_step();
      new_ref_vols.clean_out();
      temp_body->ref_volumes(new_ref_vols);
      int vol_id = new_ref_vols.get()->id();
      if ( temp_body->id() != vol_id )
      {
        //Check to see if this id is being used by
        //some other body.
        if ( RefEntityFactory::instance()->get_body(vol_id) == NULL )
        {
          temp_body->set_id(vol_id);
        }
        //if it is in use, then we shouldn't mess around with it...
      }
    }
  }

  if( CubitUndo::get_undo_enabled() )
    CubitUndo::note_result_bodies( new_bodies );

  GeometryQueryTool::instance()->cleanout_deactivated_geometry();
  return stat;
}
CubitStatus GeometryModifyTool::split_free_curve ( RefEdge ref_edge,
DLIList< CubitVector > &  split_locations,
DLIList< RefEdge * > &  new_ref_edges 
)

Definition at line 9666 of file GeometryModifyTool.cpp.

{
  TopologyBridge* bridge = 0;
  GeometryModifyEngine* gme_ptr = get_engine(ref_edge, &bridge);
  Curve *curve = dynamic_cast<Curve*>(bridge);

  if( CubitUndo::get_undo_enabled() )
  {
    DLIList<RefEdge*> tmp_ents(1);
    tmp_ents.append( ref_edge );
    CubitUndo::save_state_with_cubit_file( tmp_ents );
  }

  DLIList<Curve*> new_curves;
  if(split_locations.size() == 1)
    gme_ptr->split_curve(curve, (split_locations.get()), new_curves);
  else
    gme_ptr->split_free_curve( curve, split_locations, new_curves );

  if (!new_curves.size())
  {
    if( CubitUndo::get_undo_enabled() )
      CubitUndo::remove_last_undo();
    return CUBIT_FAILURE;
  }

  GeometryQueryTool::instance()->delete_RefEdge( ref_edge );

  int i;
  for( i=0; i<new_curves.size(); i++ )
  {
    Curve *new_curve = new_curves.get_and_step();
    RefEdge* new_edge = GeometryQueryTool::instance()->make_free_RefEdge(new_curve);
    if(new_edge)
      new_ref_edges.append(new_edge);
    if( CubitUndo::get_undo_enabled() )
      CubitUndo::note_result_entity( new_edge );
  }

  return CUBIT_SUCCESS;
}
CubitStatus GeometryModifyTool::split_periodic ( Body body_ptr,
Body *&  new_body_ptr 
)

Splits periodic curves and surfaces.

Definition at line 10083 of file GeometryModifyTool.cpp.

{
   DLIList<Body*> b_list(1);
   b_list.append(body_ptr);
   if (!okay_to_modify( b_list, "SPLIT" ))
     return CUBIT_FAILURE;

   BodySM* body_sm = body_ptr->get_body_sm_ptr();
   GeometryModifyEngine* gme = get_engine(body_sm);
   if (!gme) {
      PRINT_ERROR("Volume %d does not have a modify engine.\n", body_ptr->id());
      return CUBIT_FAILURE;
   }

   BodySM* new_sm = 0;

   if (CubitUndo::get_undo_enabled())
     CubitUndo::save_state_with_cubit_file(b_list);

   DLIList<BodySM*> body_sms;
   body_sms.append(body_sm);

   do_attribute_setup();
   push_attributes_before_modify(body_sms);

   // Call the default GeometryModifyEngine to create a new TBPoint
   CubitStatus stat = gme->split_periodic( body_sm, new_sm );

   DLIList<BodySM*> new_bodysm_list;
   if(new_sm)
     new_bodysm_list.append(new_sm);
   DLIList<Body*> old_body_list;
   old_body_list.append(body_ptr);
   restore_vg_after_modify(new_bodysm_list, old_body_list, gme);
   remove_pushed_attributes(new_bodysm_list, old_body_list);
   do_attribute_cleanup();

   update_body(body_ptr);

   new_body_ptr = 0;
   if (new_sm)
     new_body_ptr = GeometryQueryTool::instance()->make_Body(new_sm);

   if (new_body_ptr)
   {
     if (CubitUndo::get_undo_enabled())
       CubitUndo::note_result_body(new_body_ptr);
   }
   else
   {
     if (CubitUndo::get_undo_enabled())
       CubitUndo::remove_last_undo();
   }

   GeometryQueryTool::instance()->cleanout_deactivated_geometry();

   return stat;
}
CubitStatus GeometryModifyTool::split_surface ( RefFace ref_face_ptr,
DLIList< CubitVector * > &  locations,
DLIList< DLIList< CubitVector * > * > &  vec_lists,
CubitBoolean  preview_flg = CUBIT_FALSE,
CubitBoolean  create_ref_edges_flg = CUBIT_FALSE,
CubitBoolean  clear_previous_previews = CUBIT_TRUE 
)

Splits a surface with a curve defined by positions.

Split function for simple surface splitting. Temporary Curves are created on the RefFace and used to split the RefFace. The curves are created from the input vec_lists (straight lines, arcs or splines). The input locations are the original input locations from the user, which are displayed for user reference. If the preview_flg is CUBIT_TRUE, the curves are displayed but no splitting occurs. If the preview_flg is CUBIT_TRUE and the create_ref_edges_flg is CUBIT_TRUE, then RefEdges are created (but no splitting occurs). The clear_previous_previews flag controls whether previous previews are cleared from the graphics window (only applicable if preview_flg is CUBIT_TRUE).

Definition at line 10151 of file GeometryModifyTool.cpp.

{
  // Check for virtual geometry
  DLIList<RefFace*> ref_face_list;
  ref_face_list.append( ref_face_ptr );

  DLIList<Body*> b_list;
  Body* body = ref_face_ptr->body();
  if (body)
      b_list.append(body);
  else
  {
      PRINT_ERROR( "Surface %d is not contained within a parent body.\n"
          "      It cannot be split.\n", ref_face_ptr->id() );
      return CUBIT_FAILURE;
  }

  if (!okay_to_modify( b_list, "SPLIT_SURFACE" ))
    return CUBIT_FAILURE;

  int i;
  DLIList<Body*> old_body_list;
  for( i=ref_face_list.size(); i--; )
  {
    ref_face_ptr = ref_face_list.get_and_step();

    DLIList<Body*> body_list;
    ref_face_ptr->bodies( body_list );
    old_body_list.merge_unique( body_list );
  }

  //bad geom with no body -- dont try to imprint this...
  //quick and dirty fix by (aga@cat|1/7/04)
  if( old_body_list.size() < 1 )
  {
    PRINT_ERROR( "Surface %d is not contained within a parent body\n."
      "      It cannot be split.\n", ref_face_ptr->id() );
    return CUBIT_FAILURE;
  }

  SplitSurfaceTool sst;
  if( preview_flg == CUBIT_TRUE )
    return sst.preview( ref_face_ptr, locations, vec_lists, create_ref_edges_flg,
                        clear_previous_previews );
  else
    return sst.split_surface( ref_face_ptr, vec_lists );
}
CubitStatus GeometryModifyTool::split_surface ( DLIList< RefFace * > &  ref_face_list,
DLIList< CubitVector * > &  locations,
DLIList< DLIList< DLIList< CubitVector * > * > * > &  list_of_vec_lists,
CubitBoolean  preview_flg = CUBIT_FALSE,
CubitBoolean  create_ref_edges_flg = CUBIT_FALSE,
CubitBoolean  clear_previous_previews = CUBIT_TRUE 
)

Splits MULTIPLE surfaces with a curves defined by positions.

Same behavior as other split_surface function only it handles multiple surface and multiple lists of curves.

Definition at line 10213 of file GeometryModifyTool.cpp.

{
   // Check for virtual geometry
   DLIList<Body*> b_list;
   int gg;
   for( gg = ref_face_list.size() ; gg > 0 ; gg--)
   {
      RefFace* ref_face_ptr = ref_face_list.get_and_step();
      Body* body = ref_face_ptr->body();
      if (body)
         b_list.append(body);
      else
      {
         PRINT_ERROR( "Surface %d is not contained within a parent body.\n"
            "      It cannot be split.\n", ref_face_ptr->id() );
         return CUBIT_FAILURE;
      }
   }
   if (!okay_to_modify( b_list, "SPLIT_SURFACE" ))
      return CUBIT_FAILURE;

   int ii;

   for( ii = ref_face_list.size(); ii > 0 ; ii--)
   {
      DLIList<Body*> old_body_list;
      RefFace* ref_face_ptr = ref_face_list.get_and_step();

      DLIList<Body*> body_list;
      ref_face_ptr->bodies( body_list );
      old_body_list.merge_unique( body_list );

      if( old_body_list.size() < 1 )
      {
         PRINT_ERROR( "Surface %d is not contained within a parent body\n."
            "      It cannot be split.\n", ref_face_ptr->id() );
         return CUBIT_FAILURE;
      }
   }

   SplitSurfaceTool sst;
   if( preview_flg == CUBIT_TRUE )
      return sst.preview( ref_face_list, locations, list_of_vec_lists, create_ref_edges_flg,
      clear_previous_previews );
   else
      return sst.split_surface( ref_face_list, list_of_vec_lists );
}
void GeometryModifyTool::split_surface_with_narrow_region ( RefFace face,
DLIList< CubitVector > &  split_pos1_list,
DLIList< CubitVector > &  split_pos2_list 
)

Topology/geometry creation functions

Definition at line 19963 of file GeometryModifyTool.cpp.

{
  int k;
  if(split_pos1_list.size() > 0)
  {
    DLIList<DLIList<CubitVector*>*> vec_lists;
    DLIList<CubitVector*> pt_list;
    for(k=split_pos1_list.size(); k--;)
    {
      CubitVector split_pos1 = split_pos1_list.get_and_step();
      CubitVector split_pos2 = split_pos2_list.get_and_step();
      face->move_to_surface(split_pos1);
      face->move_to_surface(split_pos2);
      DLIList<CubitVector*> *vec_list = new DLIList<CubitVector*>;
      vec_list->append( new CubitVector(split_pos1));
      vec_list->append( new CubitVector(split_pos2));
      vec_lists.append( vec_list );
    }

    GeometryModifyTool::instance()->split_surface(face,
      pt_list, vec_lists );

    while( vec_lists.size() )
    {
      DLIList<CubitVector*> *vec_list = vec_lists.pop();
      while( vec_list->size() ) delete vec_list->pop();
      delete vec_list;
    }
    /*
    while( pt_list.size() )
      delete( pt_list.pop() );
      */
  }
}
CubitStatus GeometryModifyTool::split_surfaces ( DLIList< RefFace * > &  ref_face_list,
int  num_segs,
double  fraction,
double  distance,
RefEdge from_curve_ptr,
DLIList< RefVertex * > &  corner_vertex_list,
DLIList< RefVertex * > &  through_vertex_list,
RefEdge curve_dir_ptr = NULL,
CubitBoolean  preview_flg = CUBIT_FALSE,
CubitBoolean  create_ref_edges_flg = CUBIT_FALSE 
)

Splits a surface or connected set of surfaces in one direction.

Splits a surface or connected set of surfaces in one direction. Particularly useful for splitting fillets to prepare the model for sweeping. {ref_face_list} - list of connected surfaces to split {num_segs} - number of segments to create (i.e, 2 segments means to split the surface in the middle). {fraction} - the fraction along the surfaces to split, not valid if num_segs > 2. This value is not used if a distance is specified instead. {distance} - if 2 segments, allow the split to be at a user specified distance across the surface. Specify -1.0 to use the fraction instead. {from_curve_ptr} - (OPTIONAL) if user specified a fraction or distance, orient from this curve. If not specified, a default is chosen automatically. {corner_vertex_list} - (OPTIONAL) user can specify corners of surface patch. Optional, if ommitted routine will attempt to use smallest angle criteria to pick corners. User should specify corners in ccw order - split direction will be perpendicular to edge between first two corners, unless curve_dir_ptr is specified which overrides this direction. {curve_dir_ptr} - (OPTIONAL) user specifies split direction - valid only for a single input surface (not a chain). Can be NULL, in which case the routine will split along longest aspect ratio (ie., along a fillet) {through_vertex_list} - (OPTIONAL) user specifies forced vertices for the split to run through (on curves). Not valid with more than 2 segments. {preview_flg} - routine only displays graphics preview of split {create_ref_edges_flg} - valid only if preview_flg=CUBIT_TRUE. If CUBIT_TRUE, create RefEdges *instead* of splitting. Note: this function uses SplitSurfaceTool. Five other settings can be specified that control this function. They are (static): SplitSurfaceTool::set_parametric_flg. If TRUE, find spline locations in parametric space of surface, otherwise do in 3D and project back to surface (handy if parametric space is ill-formed). DEFAULT = CUBIT_FALSE (do in 3D). See SplitSurfaceTool for more information. SplitSurfaceTool::set_tolerance Tolerance for finding split location (determines how accurately curves are tessellated for approximating the split location, etc.). See SplitSurfaceTool for more information. SplitSurfaceTool::autoDetectTriangles. If TRUE, detect triangles on the end of surface chains automatically (see below). SplitSurfaceTool::sideAngleThreshold. The closest corner within this threshold to 180 is removed (if pointAngleThreshold criteria is also met). SplitSurfaceTool::pointAngleThreshold. The corner with angle below this becomes the triangle point (if sideAngleThreshold criteria is also met)

Definition at line 10330 of file GeometryModifyTool.cpp.

{
  // Get parent bodies - all surfs must be from same body
  int i;
  DLIList<Body*> old_body_list;
  RefFace *ref_face_ptr;
  ref_face_list.reset();
  for( i=ref_face_list.size(); i--; )
  {
    ref_face_ptr = ref_face_list.get_and_step();

    DLIList<Body*> body_list;
    ref_face_ptr->bodies( body_list );
    old_body_list.merge_unique( body_list );
  }

  if( old_body_list.size() > 1 )
  {
    PRINT_ERROR( "This operation requires all surfaces to be from the same volume\n" );
    // Note: this restriction could be pretty easily lifted by sorting the
    //       input lists and calling the SplitSurfaceTool separately for each set of
    //       surfaces on each body.
    return CUBIT_FAILURE;
  }

  //bad geom with no body -- dont try to imprint this...
  //quick and dirty fix by (aga@cat|1/7/04)
  if( old_body_list.size() < 1 )
  {
    PRINT_ERROR( "A surface is not contained within a parent body.\n"
      "       It cannot be split.\n");
    return CUBIT_FAILURE;
  }

  // Check for virtual geometry
  DLIList<RefEntity*> ref_ent_list;
  CAST_LIST_TO_PARENT(ref_face_list, ref_ent_list);
  if ( GeometryQueryTool::instance()->contains_intermediate_geometry(ref_ent_list) )
  {
    PRINT_ERROR("SPLITTING surfaces containing virtual geometry is not\n"
      "       allowed. Delete virtual geometry on these surfaces\n"
      "       before operation.\n" );
    return CUBIT_FAILURE;
  }

  // Make sure all surfaces are from same geometry engine
  if ( !same_modify_engine(ref_ent_list, CUBIT_TRUE) )
  {
    PRINT_ERROR("Performing SPLIT with surfaces containing geometry from\n"
      "different modeling engines is not allowed.\n"
      "Delete uncommon geometry on these surfaces before operation.\n\n");
    return CUBIT_FAILURE;
  }

  SplitSurfaceTool split_tool;
  return split_tool.split_surfaces( ref_face_list, num_segs, fraction,
    distance, from_curve_ptr, corner_vertex_list, through_vertex_list,
    curve_dir_ptr, preview_flg, create_ref_edges_flg );
}
CubitStatus GeometryModifyTool::split_surfaces_extend ( DLIList< RefFace * > &  ref_face_list,
DLIList< RefVertex * > &  ref_vertex_list,
CubitBoolean  preview_flg = CUBIT_FALSE,
CubitBoolean  create_ref_edges_flg = CUBIT_FALSE 
)

Splits surfaces by extending curves at the end of hardlines across the surface.

Splits surfaces by extending curves at the end of hardlines across the surface. Only works on planar surfaces and by extending linear curves. If specified vertex list is provided, only try to extend curves attached to those vertices, and error out if unable to perform the operation using any vertex. If no vertex list is provided, find appropriate vertices automatically, and limit the split to gaps less than or equal to the specified "split surface extend gap threshold". {ref_face_list} - list of connected surfaces to split {ref_vertex_list} - (OPTIONAL) - vertices to extend from. Function will error out if unable to extend from any vertex. If not supplied, function will automatically find valid vertices to extend from on the surfaces (AUTO mode), and will limit the split to gaps less than or equal to the specified extend gap threshold (see setting below). {preview_flg} - routine only displays graphics preview of splits {create_ref_edges_flg} - valid only if preview_flg=CUBIT_TRUE. If CUBIT_TRUE, create RefEdges *instead* of splitting. Note: this function uses SplitSurfaceTool. Three other settings can be specified that control this function. They are (static): SplitSurfaceTool::set_extend_gap_threshold - for AUTO mode, only split the surface if distance is less than or equal to this value. SplitSurfaceTool::set_extend_tolerance - snaps to vertices along curves within this tolerance so as to avoid creating short curves when splitting surfaces. SplitSurfaceTool:set_extend_normal - if TRUE, if a projection normal to the curve is less distance than a projection in the direction of the curve, use the normal projection instead.

Definition at line 10274 of file GeometryModifyTool.cpp.

{
  int i;
  RefFace *ref_face_ptr;

  for( i=ref_face_list.size(); i--; )
  {
    ref_face_ptr = ref_face_list.get();

    // Check for no body
    DLIList<Body*> body_list;
    ref_face_ptr->bodies( body_list );
    if( body_list.size()==0 )
    {
      PRINT_ERROR( "Surface %d is not contained within a parent body.\n"
        "       It cannot be split.\n", ref_face_ptr->id() );
      return CUBIT_FAILURE;
    }
  }

  // Check for virtual geometry
  DLIList<RefEntity*> ref_ent_list;
  CAST_LIST_TO_PARENT(ref_face_list, ref_ent_list);
  if ( GeometryQueryTool::instance()->contains_intermediate_geometry(ref_ent_list) )
  {
    PRINT_ERROR("SPLITTING surfaces containing virtual geometry is not\n"
      "       allowed. Delete virtual geometry on these surfaces\n"
      "       before operation.\n" );
    return CUBIT_FAILURE;
  }

  // Make sure all surfaces are from same geometry engine
  if ( !same_modify_engine(ref_ent_list, CUBIT_TRUE) )
  {
    PRINT_ERROR("Performing SPLIT with surfaces containing geometry from\n"
      "different modeling engines is not allowed.\n"
      "Delete uncommon geometry on these surfaces before operation.\n\n");
    return CUBIT_FAILURE;
  }

  SplitSurfaceTool sst;
  return sst.split_surfaces_extend( ref_face_list, ref_vertex_list,
    preview_flg, create_ref_edges_flg );
}
CubitStatus GeometryModifyTool::split_surfaces_offset ( DLIList< RefFace * > &  ref_face_list,
DLIList< RefEdge * > &  edge_list,
int  num_segs,
double  distance,
CubitBoolean  partition_flg = CUBIT_FALSE,
CubitBoolean  blunt_flg = CUBIT_FALSE,
CubitBoolean  preview_flg = CUBIT_FALSE,
CubitBoolean  create_ref_edges_flg = CUBIT_FALSE 
)

Splits surfaces a specified distance from curves.

Splits surfaces a specified distance from curves. {ref_face_list} - list of surfaces to split {edge_list} - list of curves to offset from {num_segs} - number of segments to create (i.e, 2 segments means to split using two offset curves). {distance} - distance to offset {partition_flg} - (OPTIONAL) creates partitions of the offset curves. This typically provides surfaces easily map meshed {blunt_flg} - (OPTIONAL) if true the endings of the input curve graph are right angles instead of arcs {preview_flg} - (OPTIONAL) user specifies forced vertices for the split to run through (on curves). Not valid with more than 2 segments. {create_ref_edges_flg} - (OPTIONAL) Create curves instead of splitting surfaces Requires the preview flag

Definition at line 10407 of file GeometryModifyTool.cpp.

{
  int i;
  DLIList<Body*> old_body_list;
  RefFace *ref_face_ptr;
  ref_face_list.reset();
  for( i=ref_face_list.size(); i--; )
  {
    ref_face_ptr = ref_face_list.get_and_step();

    DLIList<Body*> body_list;
    ref_face_ptr->bodies( body_list );
    old_body_list.merge_unique( body_list );
  }

  //check for geometry with no body
  if( old_body_list.size() < 1 )
  {
    PRINT_ERROR( "A surface is not contained within a parent body.\n"
      "       It cannot be split.\n");
    return CUBIT_FAILURE;
  }

  // Check for virtual geometry
  DLIList<RefEntity*> ref_ent_list;
  CAST_LIST_TO_PARENT(ref_face_list, ref_ent_list);
  if ( GeometryQueryTool::instance()->contains_intermediate_geometry(ref_ent_list) )
  {
    PRINT_ERROR("SPLITTING surfaces containing virtual geometry is not\n"
      "       allowed. Delete virtual geometry on these surfaces\n"
      "       before operation.\n" );
    return CUBIT_FAILURE;
  }

  // Make sure all surfaces are from same geometry engine
  // Make sure all curves are from same geometry engine
  CAST_LIST_TO_PARENT(edge_list, ref_ent_list);
  if ( !same_modify_engine(ref_ent_list, CUBIT_TRUE) )
  {
    PRINT_ERROR("Performing SPLIT with geometry from\n"
      "different modeling engines is not allowed.\n");
    return CUBIT_FAILURE;
  }

  OffsetSplitTool split_tool;
  return split_tool.split_surfaces_offset(
      ref_face_list,
      edge_list,
      num_segs,
      distance,
      partition_flg,
      blunt_flg,
      preview_flg,
      create_ref_edges_flg);
}
CubitStatus GeometryModifyTool::stitch ( DLIList< Body * > &  bodies_to_stitch,
DLIList< Body * > &  result_list,
bool  tighten_gaps,
double  tolerance = -1.0 
)

Stitches sheet bodies at common edges to form larger sheet body or solid.

Definition at line 20568 of file GeometryModifyTool.cpp.

{
  if (!okay_to_modify( bodies_to_stitch, "STITCH" ))
    return CUBIT_FAILURE;

  //get all the BodySMs from 'bodies_to_stitch'
  int i;
  for( i=bodies_to_stitch.size(); i--; )
  {
    Body *tmp_body = bodies_to_stitch.get_and_step();
    if( !tmp_body->is_sheet_body() )
    {
      PRINT_ERROR("Can't stitch body %d.  It's a solid body\n", tmp_body->id() );
      return CUBIT_FAILURE;
    }
  }

  DLIList<TopologyEntity*> entity_list(bodies_to_stitch.size());
  DLIList<TopologyBridge*> bridge_list(bodies_to_stitch.size());
  DLIList<BodySM*>         bodysm_list(bodies_to_stitch.size());
  CAST_LIST_TO_PARENT(bodies_to_stitch, entity_list);
  GeometryModifyEngine *gme = common_modify_engine(entity_list, bridge_list);

  if( entity_list.size() != bridge_list.size() )
  {
    PRINT_ERROR("Cannot stitch entities of different geometry engines.\n");
    return CUBIT_FAILURE;
  }

  if( CubitUndo::get_undo_enabled() )
    CubitUndo::save_state_with_cubit_file( bodies_to_stitch );

  CAST_LIST(bridge_list, bodysm_list, BodySM);
  DLIList<BodySM*> new_bodies;
  CubitStatus result = gme->stitch( bodysm_list, new_bodies, tighten_gaps, tolerance );

  if( result == CUBIT_FAILURE && CubitUndo::get_undo_enabled() )
    CubitUndo::remove_last_undo();

  if (!finish_sm_op(bodies_to_stitch, new_bodies, result_list))
  {
    result = CUBIT_FAILURE;
    CubitUndo::remove_last_undo();
  }

  if( CubitUndo::get_undo_enabled() )
  {
    if( result == CUBIT_SUCCESS )
      CubitUndo::note_result_bodies( result_list );
    else
      CubitUndo::remove_last_undo();
  }

  return result;
}
void GeometryModifyTool::subdivide_pie ( CubitVector dir1,
CubitVector dir2,
int  num_subdivisions,
DLIList< CubitVector > &  all_directions 
)

Beta function.

Definition at line 20790 of file GeometryModifyTool.cpp.

{
  if(num_subdivisions > 0)
  {
    CubitVector mid = dir1 + dir2;
    mid.normalize();
    all_directions.append(mid);
    if(num_subdivisions > 1)
    {
      subdivide_pie(dir1, mid, num_subdivisions-1, all_directions);
      subdivide_pie(mid, dir2, num_subdivisions-1, all_directions);
    }
  }
}
CubitStatus GeometryModifyTool::subtract ( DLIList< Body * > &  tool_body_list,
DLIList< Body * > &  from_bodies,
DLIList< Body * > &  new_bodies,
bool  imprint = false,
bool  keep_old = false 
)

Boolean subtract.

Definition at line 7226 of file GeometryModifyTool.cpp.

{
   if(tool_body_list.size() == 0 )
       return CUBIT_FAILURE;
   if(from_bodies.size() == 0 )
       return CUBIT_FAILURE;
   DLIList<Body*> tem_bodies(tool_body_list);

   // cannot subtract from self
   int old_size = from_bodies.size();
   from_bodies -= tool_body_list;
   if (from_bodies.size() != old_size)
   {
     PRINT_WARNING("Cannot subtract body from itself.  Ignoring \"from\" body.\n");
     if (!from_bodies.size())
       return CUBIT_FAILURE;
   }

   tem_bodies += from_bodies;
   if (!okay_to_modify( tem_bodies, "SUBTRACT" ))
     return CUBIT_FAILURE;

   DLIList<BodySM*> tool_sms(tool_body_list.size());
   DLIList<BodySM*> from_sms(from_bodies.size());
   GeometryModifyEngine* gme = common_modify_engine( tool_body_list, tool_sms );
   GeometryModifyEngine* gme2 = common_modify_engine( from_bodies, from_sms );
   if (!gme || gme != gme2)
   {
      PRINT_ERROR("Performing SUBTRACTION with volumes containing geometry\n"
                  "from different modeling engines is not allowed.\n"
                  "Delete uncommon geometry on these volumes before operation.\n\n");
      return CUBIT_FAILURE;
   }

   if( CubitUndo::get_undo_enabled() )
   {
     if( keep_old )
       CubitUndo::save_state();
     else
     {
       //Get all the bodies associated with the vertex
       DLIList<Body*> bodies;
       bodies += tool_body_list;
       bodies += from_bodies;
       CubitUndo::save_state_with_cubit_file( bodies );
     }
   }

   DLIList<int> merged_surface_ids;
   DLIList<int> merged_curve_ids;
   if( keep_old == CUBIT_FALSE )
     get_merged_curve_and_surface_ids( from_bodies, merged_surface_ids, merged_curve_ids );


     // Do the subtract operation
   DLIList<BodySM*> new_sms;
   CubitStatus result = gme->subtract(tool_sms, from_sms, new_sms, imprint, keep_old );

   if( CubitUndo::get_undo_enabled() && result == CUBIT_FAILURE )
     CubitUndo::remove_last_undo();

   CubitStatus result2 = finish_sm_op(tem_bodies, new_sms, new_bodies);

   if( CubitUndo::get_undo_enabled() )
   {
     if( result == CUBIT_SUCCESS )
       CubitUndo::note_result_bodies( new_bodies );
     else
       CubitUndo::remove_last_undo();
   }

   if ( result == CUBIT_FAILURE || result2 == CUBIT_FAILURE)
   {
     PRINT_ERROR("Subtract FAILED\n" );
     return CUBIT_FAILURE;
   }

   if( keep_old == CUBIT_FALSE )
     fixup_merged_entities( merged_surface_ids, merged_curve_ids);

   return CUBIT_SUCCESS;
}
CubitStatus GeometryModifyTool::subtract ( Body tool_body,
DLIList< Body * > &  from_bodies,
DLIList< Body * > &  new_bodies,
bool  imprint = false,
bool  keep_old = false 
)

Boolean subtract. Subtracts the tool from all the blanks.

Definition at line 7215 of file GeometryModifyTool.cpp.

{
  DLIList<Body*> temp_body_list;
  temp_body_list.append(tool_body);
  return subtract(temp_body_list, from_bodies, new_bodies, imprint, keep_old);
}
CubitStatus GeometryModifyTool::surface_intersection ( RefFace ref_face1,
RefFace ref_face2,
DLIList< RefEdge * > &  ref_edge_list 
)

Create curves from the intersection of two surfaces.

Definition at line 11060 of file GeometryModifyTool.cpp.

{
  DLIList<TopologyEntity*> entity_list(2);
  DLIList<TopologyBridge*> bridge_list(2);
  entity_list.append(ref_face1);
  entity_list.append(ref_face2);
  GeometryModifyEngine* gme = common_modify_engine(entity_list, bridge_list);
  if (!gme)
  {
    PRINT_ERROR("Surfaces %d and %d do not share a common solid modeller.\n",
      ref_face1->id(), ref_face2->id() );
    return CUBIT_FAILURE;
  }

  bridge_list.reset();
  Surface* surf0 = dynamic_cast<Surface*>(bridge_list.get_and_step());
  Surface* surf1 = dynamic_cast<Surface*>(bridge_list.get());

  GeometryQueryEngine* gqe = surf0->get_geometry_query_engine();
  // Note the user can set the following value through
  //  set geometry accuracy <val>
  double resabs = gqe->get_sme_resabs_tolerance();

  DLIList<Curve*> curve_list;
  CubitStatus status = gme->surface_intersection( surf0, surf1, curve_list, resabs );

  if( status == CUBIT_FAILURE )
    return CUBIT_FAILURE;

  if( CubitUndo::get_undo_enabled() && curve_list.size() )
    CubitUndo::save_state();

  int i;
  Curve *curve_ptr;
  RefEdge *ref_edge_ptr;
  curve_list.reset();
  for( i=curve_list.size(); i--; )
  {
    curve_ptr = curve_list.get_and_step();
    ref_edge_ptr = GeometryQueryTool::instance()->
      make_free_RefEdge( curve_ptr );
    if( ref_edge_ptr )
      ref_edge_list.append( ref_edge_ptr );
    else
      delete curve_ptr;
  }

  if( CubitUndo::get_undo_enabled() )
  {
    DLIList<RefEntity*> tmp_list;
    for( i=ref_edge_list.size(); i--; )
      tmp_list.append( ref_edge_list.get_and_step() );
    CubitUndo::note_result_entities( tmp_list );
  }

  return CUBIT_SUCCESS;
}
CubitStatus GeometryModifyTool::sweep_along_curve ( DLIList< RefEntity * > &  ref_ent_list,
DLIList< RefEdge * > &  ref_edge_list,
DLIList< Body * > &  output_body_list,
CubitBoolean  anchor_entity,
CubitBoolean  keep_old,
double  draft_angle = 0.0,
int  draft_type = 0,
CubitBoolean  rigid = CUBIT_FALSE 
)

Creates bodies by sweeping surfaces or curves along a curve.

Definition at line 5640 of file GeometryModifyTool.cpp.

{
  DLIList<GeometryEntity*> geom_list(ref_ent_list.size());
  DLIList<Curve*> curve_list(ref_edge_list.size());
  DLIList<Body*> body_list(ref_ent_list.size());
  GeometryModifyEngine* engine_ptr = 0;
  CubitBoolean changed_new_ids = CUBIT_FALSE;
  CubitStatus status = sweep_setup( "along_curve",
                                    ref_ent_list,
                                    body_list,
                                    engine_ptr,
                                    changed_new_ids,
                                    geom_list,
                                    keep_old,
                                    &ref_edge_list,
                                    &curve_list );
  if (status != CUBIT_SUCCESS)
  return status;

  if( CubitUndo::get_undo_enabled())
  {
    DLIList<RefEdge*> edge_list;
    DLIList<RefFace*> face_list;

    CAST_LIST( ref_ent_list, edge_list, RefEdge );
    CAST_LIST( ref_ent_list, face_list, RefFace );

    //Edges aren't consumed, so there's nothing to save out
    if( keep_old )
      CubitUndo::save_state();
    else
    {
      bool free_curves = false;
      for( int i=edge_list.size(); i--; )
      {
        if( edge_list.get_and_step()->num_parent_ref_entities() == 0 )
        {
          free_curves = true;
          break;
        }
      }

      DLIList<Body*> bodies_to_save;
      DLIList<RefEntity*> free_surfaces;
      for( int i=face_list.size(); i--; )
      {
        RefFace *ref_face = face_list.get_and_step();

        if( ref_face->num_parent_ref_entities() == 0 )
          free_surfaces.append( ref_face );
        else
          bodies_to_save.append_unique( ref_face->ref_volume()->body() );
      }
      //Faces will get consumed so you have to save out original entities
      if( bodies_to_save.size() || free_surfaces.size() )
        CubitUndo::save_state_with_cubit_file( bodies_to_save, &free_surfaces );
      else if(free_curves )
        CubitUndo::save_state_with_cubit_file( edge_list );
      else
        CubitUndo::save_state();
    }
  }

  DLIList<BodySM*> result_list;
  status = engine_ptr->sweep_along_curve( geom_list,
                                          result_list,
                                          curve_list,
                                          draft_angle,
                                          draft_type,
                                          rigid,
                                          anchor_entity,
                                          keep_old);

  if( keep_old )
    body_list.clean_out();

  if (!sweep_finish("along_curve", body_list, result_list, output_body_list, changed_new_ids))
  status = CUBIT_FAILURE;

  if( CubitUndo::get_undo_enabled())
  {
    if( status == CUBIT_FAILURE )
      CubitUndo::remove_last_undo();
    else
      CubitUndo::note_result_bodies( output_body_list );
  }

  return status;
}

Definition at line 4741 of file GeometryModifyTool.cpp.

{
    double distance1;
    double distance2;
    double distance3;
    double temp_counter=0;
    CubitVector begin_point;
    CubitVector target_begin_point;
    CubitVector get_mid_point;
    CubitVector target_mid_point;
    CubitVector end_point;
    CubitVector target_end_point;
    DLIList<RefEdge*> edge_list;
    CAST_LIST(ref_ent_list, edge_list, RefEdge);
    CubitVector result;
    double max_distance_for_edge=0;
    CubitVector max_result;
    //make sure that there are actually edges in list
    if(edge_list.size() > 0)
    {
        //this part of the code steps through all edges that could be
        //selected by user and finds the largest distance of all edges from three
        //points: midpoint, endpoint, and beginpoint
        for (int i=0;i<edge_list.size();i++)
        {
            //find the midpoint vector of the edge
            edge_list[i]->mid_point(get_mid_point);

            //Project the midpoint onto the specified plane
            target_mid_point = ref_plane.project(get_mid_point);

            //Calculate the distance between the mid_point, and target_point
            distance1 = target_mid_point.distance_between(get_mid_point);

            //the next two blocks are just copies of the above three steps
            double fraction_along_curve = 1;
            edge_list[i]->position_from_fraction(fraction_along_curve, end_point);
            target_end_point = ref_plane.project(end_point);
            distance2 = target_end_point.distance_between(end_point);

            fraction_along_curve = 0;
            edge_list[i]->position_from_fraction(fraction_along_curve, begin_point);
            target_begin_point = ref_plane.project(begin_point);
            distance3 = target_begin_point.distance_between(begin_point);

            //see which of the three distances is greater for that edge
            //and compare its distance to the other edges that have already been calculated
            //saving the vector of the largest distance
            if (distance1>distance2 && distance1>distance3)
            {
                result = 2*(target_mid_point - get_mid_point);
                max_distance_for_edge=distance1;
                if (max_distance_for_edge>temp_counter)
                {
                    temp_counter=max_distance_for_edge;
                    max_result=result;
                }
            }
            else if (distance2>distance3)
            {
                result = 2*(target_end_point - end_point);
                max_distance_for_edge=distance2;
                if (max_distance_for_edge>temp_counter)
                {
                    temp_counter=max_distance_for_edge;
                    max_result=result;
                }
            }
            else
            {
                result = 2*(target_begin_point - begin_point);
                max_distance_for_edge=distance3;
                if (max_distance_for_edge>temp_counter)
                {
                    temp_counter=max_distance_for_edge;
                    max_result=result;
                }
            }
        }

        //using the 'facet edges' defined by the drawing geometry take the leading
        //and trailing edge projection vectors of this small edge.  With that,
        //calc the dot product and if negative, the vectors are opposite of each
        //other meaning the curve travels through the plane and the sweep function will fail
        for (int ii=0;ii<edge_list.size();ii++)
        {
            Curve *facet_curve;
            facet_curve=edge_list[ii]->get_curve_ptr();
            CubitStatus response;
            GMem g_mem;

            //get number of points and their locations
            //on the curve as defined by the drawing geometry algorithm
            response = facet_curve->get_geometry_query_engine()->
                get_graphics( facet_curve, &g_mem );
            int num_points = g_mem.pointListCount;

            if (response==CUBIT_FAILURE || num_points == 0)
            {
                PRINT_WARNING("Facet Curve calling function failed\n" );
            }

            GPoint *point_data = g_mem.point_list();

            for (int jj=0; jj < (num_points-1); jj++)
            {
                //get first points vectors
                CubitVector point_1;
                point_1.x(point_data[jj].x);
                point_1.y(point_data[jj].y);
                point_1.z(point_data[jj].z);
                //get second points vectors
                CubitVector point_2;
                point_2.x(point_data[jj+1].x);
                point_2.y(point_data[jj+1].y);
                point_2.z(point_data[jj+1].z);
                //project the two points onto target plane
                CubitVector target_point_1;
                target_point_1 = ref_plane.project(point_1);
                CubitVector target_point_2;
                target_point_2 = ref_plane.project(point_2);
                //calc vector from point on curve to point on surface
                CubitVector vec_1 = point_1 - target_point_1;
                CubitVector vec_2 = point_2 - target_point_2;
                //make them unit vectors
                vec_1.normalize();
                vec_2.normalize();
                //calculate dot product
                double dot = vec_1.x()*vec_2.x()+vec_1.y()*vec_2.y()+vec_1.z()*vec_2.z();
                //check to see if dot product sign is zero
                //the and statement checks for if the first or last vertex of the edge
                //which may be sitting on the surface, this is alright
                //and should still be able to sweep
//              if (dot<0 && (jj+1!=num_points || jj==0))
                if (dot<0 && (jj!=(num_points-2) || jj==0))
                {
                    PRINT_ERROR( "The edge is traveling through the plane\n" );
                    PRINT_ERROR( "and thus forces the sweep direction to switch\n" );
                    PRINT_ERROR( "direction. Try splitting the edge.\n" );
                    return CUBIT_FAILURE;
                }
            }
        }
        DLIList<BodySM*> webcut_results_list;
        DLIList<Body*> body_list;
        DLIList<BodySM*> sweep_result_list;
        DLIList<GeometryEntity*> geom_list;
        GeometryModifyEngine* gePtr1 = 0;
        CubitBoolean change_newids;

        if (!sweep_setup("translational", ref_ent_list , body_list, gePtr1,
            change_newids, geom_list, false))
            return CUBIT_FAILURE;

        //below block is default settings to be fed into sweep_translational
        CubitBoolean rigid = CUBIT_FALSE;
        CubitBoolean switchside = CUBIT_FALSE;
        int draft_type = 0;
        double draft_angle=0.0;

        //sweep the curve through and hopefully past the target surface
        CubitStatus status = gePtr1->sweep_translational( geom_list,sweep_result_list,
            max_result,draft_angle, draft_type,switchside,rigid);

        if (status == 0)
        {
            PRINT_ERROR( "Sweep operation failed!\n" );
            //delete sweep_result_list memory
            gePtr1->get_gqe()->delete_solid_model_entities(sweep_result_list);
            return CUBIT_FAILURE;
        }

        //below lines are used to define the ref_plane with three points for webcut input
        //find normal vector to user specified plane
        CubitVector vec1 = ref_plane.normal();
        CubitVector vec2;
        CubitVector vec3;
        //get orthogonal vectors of the normal vector
        vec1.orthogonal_vectors(vec2, vec3);
        //place the orthogonal vectors at a point on the plane as opposed to the origin
        vec2=vec2+target_mid_point;
        vec3=vec3+target_mid_point;

                DLIList<BodySM*> neighbor_imprint_list;
        //do a webcut with a plane created from the three projected points above
        CubitStatus status2 = gePtr1->webcut(sweep_result_list,target_mid_point,
            vec2,vec3, neighbor_imprint_list, webcut_results_list);

        if (status2 == 0)
        {
            PRINT_ERROR( "Sweep operation worked; however, webcut operation failed.\n" );
            //delete memory since it failed
            gePtr1->get_gqe()->delete_solid_model_entities(sweep_result_list);
            return CUBIT_FAILURE;
        }

        if (webcut_results_list.size()==0)
        {
            PRINT_ERROR( "Number of bodies from webcut is zero, unable to perform rest of sweep operation\n" );
            //delete memory since it failed
            gePtr1->get_gqe()->delete_solid_model_entities(sweep_result_list);
            return CUBIT_FAILURE;
        }

        CubitVector created_curve_mid;
        CubitVector user_mid;
        DLIList<BodySM*> keep_bodies_list;
        DLIList<Curve*> curve_list;

        //generate a list of curves from the webcut_results_list
        for (int counter = 0;counter < webcut_results_list.size(); counter++)
        {
            BodySM* OO = webcut_results_list[counter];
            OO->curves(curve_list);
        }

        //step through each of the user specified edges
        for (int edge_counter = 0; edge_counter < edge_list.size(); edge_counter++)
        {
            //find the midpoint of a user specified edge
            edge_list[edge_counter]->position_from_fraction(.5,user_mid);
            double min_dist=DBL_MAX;
            double distance;
            Curve* closest_curve=0;

            //step through all of the curves
            for (int counter2 = 0; counter2 < curve_list.size(); counter2++)
            {
                //find the midpoint of the created curve
                curve_list[counter2]->position_from_fraction(.5,created_curve_mid);
                //calculate the distance between the two midpoints
                distance=created_curve_mid.distance_between(user_mid);

                //find the minimum distance between all the curves
                if (distance<min_dist)
                {
                    //reset the min_distance
                    min_dist=distance;
                    //keep track of which curve is associated with the shortest distance
                    closest_curve=curve_list[counter2];
                }
            }
            //find the parent body of the minimum distance curve
            BodySM* body_sm = closest_curve->bodysm();
            //append that body to a keep list
            keep_bodies_list.append(body_sm);
        }
        //delete bodies which repeat (useful only when in granite engine)
    keep_bodies_list.uniquify_ordered();
        //subtract the keep_list from the webcut_results_list
        webcut_results_list -=keep_bodies_list;
        //delete webcut_results_list memory
        gePtr1->get_gqe()->delete_solid_model_entities(webcut_results_list);

                if( CubitUndo::get_undo_enabled() )
                  CubitUndo::save_state();

        //builds ref bodies
    DLIList<Body*> output_body_list;
        if (!sweep_finish("translational", body_list, keep_bodies_list, output_body_list, change_newids))
        {
            gePtr1->get_gqe()->delete_solid_model_entities(keep_bodies_list);
            status = CUBIT_FAILURE;
        }

    if( CubitUndo::get_undo_enabled())
    {
      if( status == CUBIT_FAILURE )
        CubitUndo::remove_last_undo();
      else
        CubitUndo::note_result_bodies( output_body_list );
    }
    }
    else
    {
        PRINT_ERROR( "No edge(s) found - sweep creation failed.\n" );
        return CUBIT_FAILURE;
    }

    return CUBIT_SUCCESS;
}
CubitStatus GeometryModifyTool::sweep_curve_target ( DLIList< RefEdge * > &  curve_list,
Body target_body,
DLIList< Body * > &  out_bodies,
CubitVector  direction,
CubitPlane  stop_plane,
bool  unite 
)

Definition at line 5134 of file GeometryModifyTool.cpp.

{
  DLIList<BodySM*> new_bodies;
  DLIList<Curve*> curve_list;
  bool set_dist = true, set_plane = true;
  double larDist = 1.0;
  CubitVector dir = distance;
  CubitStatus status;

  // Check to make sure the target body is a sheetbody
  if (!target_body->is_sheet_body())
  {
    PRINT_ERROR("Target body must be a sheet body.\n");
    return CUBIT_FAILURE;
  }

  // Get the Curve *'s from the RefEdge *'s
  for (int i = 0; i < edge_list.size(); i++)
  {
    edge_list[i]->get_curve_ptr()->set_saved_id(edge_list[i]->id());
    curve_list.append(edge_list[i]->get_curve_ptr());
  }
  // Check if the direction vector and stop plane were specified
  if (distance.length() < 0.0001)
    set_dist = false;
  if (stop_plane.normal().length() < 0.0001)
    set_plane = false;

  // Check inputs
  if (!set_plane && !set_dist)
  {
    PRINT_ERROR("User must specify a stop plane, a direction, or both.\n");
    return CUBIT_FAILURE;
  }

  // Calculate the direction vector
  double begDist, midDist, endDist;
  for (int i = 0; i < edge_list.size(); i++)
  {
    CubitVector beg, mid, end, begP, midP, endP;
    RefEdge *temp = edge_list.get_and_step();

    // Retrieve the beginning, middle, and end coordinates of the edge
    beg = temp->start_coordinates();
    temp->mid_point(mid);
    end = temp->end_coordinates();

    if (set_plane)
    {
      // Project the start, mid, and end point onto the stop plane
      begP = stop_plane.project(beg);
      midP = stop_plane.project(mid);
      endP = stop_plane.project(end);

      // Calculate the distance between the points
      begDist = beg.distance_between(begP);
      midDist = mid.distance_between(midP);
      endDist = end.distance_between(endP);
    }
    else  // No stop plane specified
    {
      begDist = beg.distance_between(target_body->center_point());
      midDist = mid.distance_between(target_body->center_point());
      endDist = end.distance_between(target_body->center_point());
    }

    // Find the largest distance
    if (begDist > larDist)
      larDist = begDist;
    if (midDist > larDist)
      larDist = midDist;
    if (endDist > larDist)
      larDist = endDist;

    // Make sure the plane normal is pointing the right way
    if (set_plane)
    {
      double planeNorm = stop_plane.normal().interior_angle(beg-begP);
      if (planeNorm <= 90 || planeNorm >= 270)
        stop_plane.reverse();
    }

    if (!set_dist)
      dir += (midP-mid);

  } // End for loop
  if (!set_dist)
    dir /= edge_list.size();

  // Unitize the direction vector
  dir /= dir.length();

  // Add the magnitude to the direction vector and check for intersection with the stop plane
  dir *= larDist;
  if (set_plane)
  {
    double angle = dir.interior_angle(stop_plane.normal());
    if (angle >= 90 && angle <= 270)
      PRINT_WARNING("Direction vector does not intersect stop plane!\n");
  }

  // Call the geometry function
  status = get_gme()->sweep_to_body(curve_list, target_body->get_body_sm_ptr(), dir, new_bodies, unite);

  if (status != CUBIT_SUCCESS)
    return CUBIT_FAILURE;

  // Make all the new bodies
  for (int i = 0; i < new_bodies.size(); i++)
  {
    out_bodies.append(GeometryQueryTool::instance()->make_Body(new_bodies.get_and_step()));
    PRINT_INFO("Created volume in body %d\n", out_bodies[i]->id());
  }

  return CUBIT_SUCCESS;
}
CubitStatus GeometryModifyTool::sweep_finish ( const char *const  sweep_function_name,
DLIList< Body * > &  input_body_list,
DLIList< BodySM * > &  new_body_list,
DLIList< Body * > &  output_body_list,
CubitBoolean  restore_newids 
) [private]

Definition at line 4470 of file GeometryModifyTool.cpp.

{
  int i;
  DLIList<BodySM*> regen_list( new_body_list );
  GeometryQueryTool *gqt = GeometryQueryTool::instance();

  input_body_list.reset();
  for (i = input_body_list.size(); i--; )
  {
    Body* body = input_body_list.get_and_step();
    BodySM* bodysm = body->get_body_sm_ptr();
    if (bodysm)
    {
      regen_list.append_unique(bodysm);
      remove_dead_entity_names(body);
      output_body_list.append( body );
    }
    else
    {
      gqt->destroy_dead_entity(body);
    }
  }
  gqt->cleanout_deactivated_geometry();

  regen_list.reset();
  for (i = regen_list.size(); i--; )
  {
    BodySM* bodysm = regen_list.get_and_step();
    Body* body = gqt->make_Body(bodysm);
    output_body_list.append_unique( body );
    PRINT_INFO("%s volume %d\n",
      new_body_list.is_in_list(bodysm) ? "Created swept" : "Updated",
      body->ref_volume()->id());
  }

  if (changed_new_ids) set_new_ids(CUBIT_FALSE);
  gqt->cleanout_deactivated_geometry();

  return CUBIT_SUCCESS;
}
CubitStatus GeometryModifyTool::sweep_helical ( DLIList< RefEntity * > &  ref_ent_list,
CubitVector location,
CubitVector direction,
double &  thread_distance,
double &  angle,
bool  right_handed,
CubitBoolean  anchor_entity,
CubitBoolean  keep_old,
DLIList< Body * > &  output_body_list 
)

Definition at line 4603 of file GeometryModifyTool.cpp.

{
  DLIList<Body*> body_list;
  DLIList<GeometryEntity*> geom_list;
  GeometryModifyEngine* gePtr1 = 0;
  CubitBoolean change_newids;
  if (!sweep_setup("translational", ref_ent_list, body_list, gePtr1,
                   change_newids, geom_list, keep_old))
    return CUBIT_FAILURE;

  if( CubitUndo::get_undo_enabled())
  {
    DLIList<RefEdge*> edge_list;
    DLIList<RefFace*> face_list;

    CAST_LIST( ref_ent_list, edge_list, RefEdge );
    CAST_LIST( ref_ent_list, face_list, RefFace );

    //Edges aren't consumed, so there's nothing to save out
    if( edge_list.size() || keep_old )
      CubitUndo::save_state();
    else
     //Faces will get consumed so you have to save out original entities
      CubitUndo::save_state_with_cubit_file( face_list );
  }

  DLIList<BodySM*> result_list;
  CubitStatus status = gePtr1->
    sweep_helical( geom_list, result_list, location,
                   direction, thread_distance, angle, right_handed, anchor_entity, keep_old );

  if( keep_old )
    body_list.clean_out();

  if (!sweep_finish("translational", body_list, result_list, output_body_list, change_newids))
    status = CUBIT_FAILURE;

  if( CubitUndo::get_undo_enabled())
  {
    if( status == CUBIT_FAILURE )
      CubitUndo::remove_last_undo();
    else
      CubitUndo::note_result_bodies( output_body_list );
  }

  return status;





}
CubitStatus GeometryModifyTool::sweep_perpendicular ( DLIList< RefEntity * > &  ref_ent_list,
double  distance,
double  draft_angle,
int  draft_type,
CubitBoolean  switchside,
CubitBoolean  rigid,
CubitBoolean  anchor_entity,
CubitBoolean  keep_old,
DLIList< Body * > &  output_body_list 
)

Definition at line 5578 of file GeometryModifyTool.cpp.

{
  DLIList<Body*> body_list;
  DLIList<GeometryEntity*> geom_list;
  GeometryModifyEngine* gePtr1 = 0;
  CubitBoolean change_newids;
  if (!sweep_setup("translational", ref_ent_list, body_list, gePtr1,
                   change_newids, geom_list, keep_old))
    return CUBIT_FAILURE;

  if( CubitUndo::get_undo_enabled())
  {
    DLIList<RefEdge*> edge_list;
    DLIList<RefFace*> face_list;

    CAST_LIST( ref_ent_list, edge_list, RefEdge );
    CAST_LIST( ref_ent_list, face_list, RefFace );

    //Edges aren't consumed, so there's nothing to save out
    if( edge_list.size() || keep_old )
      CubitUndo::save_state();
    else
     //Faces will get consumed so you have to save out original entities
      CubitUndo::save_state_with_cubit_file( face_list );
  }

  DLIList<BodySM*> result_list;
  CubitStatus status = gePtr1->
    sweep_perpendicular( geom_list,
                         result_list,
                         distance,
                         draft_angle,
                         draft_type,
                         switchside,
                         rigid,
                         anchor_entity,
                         keep_old );

  if( keep_old )
    body_list.clean_out();

  if (!sweep_finish("perpendicular", body_list, result_list, output_body_list, change_newids))
    status = CUBIT_FAILURE;

  if( CubitUndo::get_undo_enabled())
  {
    if( status == CUBIT_FAILURE )
      CubitUndo::remove_last_undo();
    else
      CubitUndo::note_result_bodies( output_body_list );
  }

  return status;
}
CubitStatus GeometryModifyTool::sweep_rotational ( DLIList< RefEntity * > &  ref_ent_list,
const CubitVector point,
const CubitVector direction,
double  angle,
DLIList< Body * > &  output_body_list,
CubitBoolean  anchor_entity,
CubitBoolean  keep_old,
int  steps = 0,
double  draft_angle = 0.0,
int  draft_type = 0,
CubitBoolean  switchside = CUBIT_FALSE,
CubitBoolean  make_solid = CUBIT_FALSE,
CubitBoolean  rigid = CUBIT_FALSE 
)

Creates bodies by sweeping surfaces or curves about an axis.

Definition at line 4520 of file GeometryModifyTool.cpp.

{
  DLIList<Body*> body_list;
  DLIList<GeometryEntity*> geom_list;
  GeometryModifyEngine* gePtr1 = 0;
  CubitBoolean change_newids;
  if (!sweep_setup("rotational", ref_ent_list, body_list, gePtr1,
                   change_newids, geom_list, keep_old))
    return CUBIT_FAILURE;

  if( CubitUndo::get_undo_enabled())
  {
    DLIList<RefEdge*> edge_list;
    DLIList<RefFace*> face_list;

    CAST_LIST( ref_ent_list, edge_list, RefEdge );
    CAST_LIST( ref_ent_list, face_list, RefFace );

    DLIList<RefEdge*> free_edges;
    for(int i=0;i<edge_list.size();i++)
    {
      RefEdge* edge= edge_list[i];
      if(edge->num_parent_ref_entities()==0)
      {
        free_edges.append(edge);
      }
    }

    if(free_edges.size())
      CubitUndo::save_state_with_cubit_file( free_edges );
    else if( edge_list.size() || keep_old )
      CubitUndo::save_state();
    else
     //Faces will get consumed so you have to save out original entities
      CubitUndo::save_state_with_cubit_file( face_list );
  }

  DLIList<BodySM*> result_list;
  CubitStatus status = gePtr1->sweep_rotational( geom_list,
                                                 result_list,
                                                 point,
                                                 sweep_axis,
                                                 angle,
                                                 steps,
                                                 draft_angle,
                                                 draft_type,
                                                 switchside,
                                                 make_solid,
                                                 rigid,
                                                 anchor_entity,
                                                 keep_old );

  if( keep_old )
    body_list.clean_out();

  if (!sweep_finish("rotational", body_list, result_list, output_body_list, change_newids))
    status = CUBIT_FAILURE;

  if( CubitUndo::get_undo_enabled())
  {
    if( status == CUBIT_FAILURE )
      CubitUndo::remove_last_undo();
    else
      CubitUndo::note_result_bodies( output_body_list );
  }

  return status;
}
CubitStatus GeometryModifyTool::sweep_setup ( const char *  sweep_function_name,
DLIList< RefEntity * > &  entity_list,
DLIList< Body * > &  body_list,
GeometryModifyEngine *&  engine,
CubitBoolean changed_new_ids,
DLIList< GeometryEntity * > &  geom_list,
bool  keep_old,
DLIList< RefEdge * > *  edge_list = 0,
DLIList< Curve * > *  curve_list = 0 
) [protected]

Definition at line 4315 of file GeometryModifyTool.cpp.

{
  int i;

  if (input_entity_list.size() == 0)
    return CUBIT_FAILURE;

  DLIList<RefFace*> ref_face_list;
  DLIList<RefEdge*> ref_edge_list;
  CAST_LIST( input_entity_list, ref_face_list, RefFace );
  CAST_LIST( input_entity_list, ref_edge_list, RefEdge );
  if( ref_face_list.size() && ref_edge_list.size() )
  {
    PRINT_ERROR( "Currently cannot sweep curves and surfaces at the same time\n" );
    return CUBIT_FAILURE;
  }

  if( (ref_face_list.size()+ref_edge_list.size()) != input_entity_list.size() )
  {
    PRINT_ERROR( "Can only sweep surfaces or curves\n" );
    return CUBIT_FAILURE;
  }

  // Currently faces to be swept have to belong to different bodies.  It
  // doesn't work well to sweep multiple faces from the same body (also
  // current implementation in AGE crashes).
  if( ref_face_list.size() && false == keep_old )
  {
    int free_surf_cnt = 0; // Number of free surfaces being swept
    DLIList<Body*> body_list;
    RefFace *ref_face_ptr;
    for( i=ref_face_list.size(); i--; )
    {
      ref_face_ptr = ref_face_list.get_and_step();
      DLIList<Body*> tmp_body_list;
      ref_face_ptr->bodies( tmp_body_list );
      if( tmp_body_list.size() > 1 )
      {
        PRINT_ERROR( "Surface %d belongs to more than one volume; cannot sweep.\n",
          ref_face_ptr->id() );
        return CUBIT_FAILURE;
      }

      if( tmp_body_list.size() > 0 )
        body_list.append_unique( tmp_body_list.get() );
      else
        free_surf_cnt++;
    }

    if( body_list.size()+free_surf_cnt != ref_face_list.size() )
    {
      //if each is a sheet body, and every surface is in the list,
      //it is ok to sweep it

      //PRINT_ERROR("The surfaces to be swept cannot belong to the same volume\n");
      //return CUBIT_FAILURE;

      for( int k=body_list.size(); k--; )
      {
        Body *tmp_body = body_list.get_and_step();
        DLIList<RefFace*> tmp_ref_faces;
        tmp_body->ref_faces( tmp_ref_faces );

        //all surfaces must be swept
        if( tmp_body->is_sheet_body() )
        {
          tmp_ref_faces -= ref_face_list;
          if( tmp_ref_faces.size() )
          {
            PRINT_ERROR( "When sweeping a sheet body, all surfaces must be specified\n");
            return CUBIT_FAILURE;
          }
        }
        else // only 1 surface can be swept
        {
          int num_surfaces_before = tmp_ref_faces.size();
          tmp_ref_faces -= ref_face_list;

          if( (num_surfaces_before - tmp_ref_faces.size() ) > 1 )
          {
            PRINT_ERROR( "The surfaces to be swept cannot belong to the same volume\n" );
            return CUBIT_FAILURE;
          }
        }
      }
    }

    output_body_list = body_list;
  }

  // Make sure all entities are from same modify engine
  DLIList<TopologyEntity*> te_list;
  CAST_LIST(input_entity_list, te_list, TopologyEntity);

  // This is for sweeping along a curve list
  if (input_edge_list)
  {
    input_edge_list->reset();
    for( i=input_edge_list->size(); i--; )
      te_list.append( input_edge_list->get_and_step() );
  }

  DLIList<TopologyBridge*> bridge_list( te_list.size() );
  output_engine = common_modify_engine( te_list, bridge_list );
  if( output_engine == NULL )
  {
     PRINT_ERROR("Can't sweep with entities from different modeling engines.\n");
     return CUBIT_FAILURE;
  }

  // Check for virtual anywhere in participating bodies.  This will catch cases where
  // the result from sweeping would interact with some virtual somewhere. bwc 12/22/05.
  for(i=output_body_list.size(); i--;)
  {
     if(GeometryQueryTool::instance()->contains_intermediate_geometry(
        output_body_list.get_and_step()))
     {
        PRINT_ERROR("Can't sweep faces of bodies containing virtual geometry.\n");
        return CUBIT_FAILURE;
     }
  }

  changed_new_ids = CUBIT_FALSE;

  TopologyBridge* bridge_ptr;
  bridge_list.reset();
  for( i=input_entity_list.size(); i--; )
  {
    bridge_ptr = bridge_list.get_and_step();
    GeometryEntity* geom_ptr = dynamic_cast<GeometryEntity*>(bridge_ptr);
    output_geom_list.append(geom_ptr);
  }

  if( input_edge_list )
  {
    for( i=input_edge_list->size(); i--; )
    {
      bridge_ptr = bridge_list.get_and_step();
      Curve* curve_ptr = dynamic_cast<Curve*>(bridge_ptr);
      output_curve_list->append(curve_ptr);
    }
  }

  return CUBIT_SUCCESS;
}
CubitStatus GeometryModifyTool::sweep_surface_target ( RefFace face,
Body target_body,
CubitVector  distance,
CubitPlane  stop_plane,
double  magnitude = 0.0 
)

Definition at line 5025 of file GeometryModifyTool.cpp.

{
  //  Declare local variables
  Surface *source_surf;
  bool set_dist = true, set_plane = true, set_mag = true;
  CubitVector direction;
  CubitStatus status;
  DLIList<Body*> body_list;
  DLIList<GeometryEntity*> geom_list;
  GeometryModifyEngine* gePtr1 = 0;
  CubitBoolean change_newids;
  DLIList<RefEntity*> ref_ent_list;
  ref_ent_list.append(face);

  // Check to make sure the target body is a solid
  if (target_body->is_sheet_body())
  {
    PRINT_ERROR("Target body must be a solid body.\n");
    return CUBIT_FAILURE;
  }

  // Set up the sweep
  if (!sweep_setup("target", ref_ent_list, body_list, gePtr1,
                    change_newids, geom_list, false))
    return CUBIT_FAILURE;

  // Get the Surface * from the RefFace *
  source_surf = face->get_surface_ptr();

  // Check if the direction vector and stop plane were specified
  if (distance.length() < 0.0001)
    set_dist = false;
  if (stop_plane.normal().length() < 0.0001)
    set_plane = false;
  if (magnitude < 0.0001)
    set_mag = false;

  // Calculate the direction of the sweep
  if (!set_dist)
    direction = face->normal_at(face->center_point());
  else
    direction = distance;
  direction.normalize();

  double length = 0.0;
  if (!set_mag && !set_plane)
  {
    CubitVector center_body = target_body->center_point();
    CubitVector center_face = face->center_point();
    length = center_face.distance_between(center_body);
  }
  else if (set_plane)
  {
    length = stop_plane.intersect(face->center_point(), direction).distance_between(face->center_point());
  }
  else
  {
    length = magnitude;
  }
  if (set_mag && length > magnitude)
    length = magnitude;
  direction *= length;

  DLIList<BodySM*> new_bodies;
  status = gePtr1->sweep_to_body(source_surf, target_body->get_body_sm_ptr(), direction, new_bodies );

  if (status != CUBIT_SUCCESS)
    return status;

  if( CubitUndo::get_undo_enabled() )
    CubitUndo::save_state();

  // Make all the new bodies
  DLIList<Body*> output_body_list;
  if (!sweep_finish("target", body_list, new_bodies, output_body_list, change_newids))
    status = CUBIT_FAILURE;

  if( CubitUndo::get_undo_enabled())
    {
      if( status == CUBIT_FAILURE )
        CubitUndo::remove_last_undo();
      else
      {
        //For some reason the ouput_body_list contains one of the original
        //volumes that we do not want to delete when we are performing an 
        //undo on the sweep. So we remove that original volume from the 
        //"to undo" list.
        Body* to_delete = output_body_list[1];
        output_body_list.clean_out();
        output_body_list.append(to_delete);
        CubitUndo::note_result_bodies( output_body_list );
      }
    }

  /*
  for (int i = 0; i < new_bodies.size(); i++)
    GeometryQueryTool::instance()->make_Body(new_bodies.get_and_step());
    */


  return CUBIT_SUCCESS;
}

Definition at line 5258 of file GeometryModifyTool.cpp.

{
    DLIList<RefFace*> surface_list;
    CAST_LIST(ref_ent_list, surface_list, RefFace);
    double distance1;
    double distance2;
    double distance3;
    double temp_counter=0;
    CubitVector begin_point;
    CubitVector target_begin_point;
    CubitVector get_mid_point;
    CubitVector target_mid_point;
    CubitVector end_point;
    CubitVector target_end_point;
    CubitVector result;
    double max_distance_for_edge=0;
    CubitVector max_result;
    DLIList<RefEdge*> surf_edge_list;

    //make sure that only one surface has been selected
    if(surface_list.size() == 0)
    {
        PRINT_ERROR( "No surface found - sweep surface to target failed.\n" );
        return CUBIT_FAILURE;
    }

    //make sure that there are actually surfaces in list
    else if(surface_list.size() > 1)
    {
        PRINT_ERROR( "You can only use this operation \n with one surface selected at a time\n" );
        return CUBIT_FAILURE;
    }
    else
    {
        //this part of the code steps through all edges that could be
        //selected by user and finds the largest distance of all edges from three
        //points: midpoint, endpoint, and beginpoint
        for (int i=0;i<surface_list.size();i++)
        {
            surface_list[i]->ref_edges(surf_edge_list);
            for (int j=0;j<surf_edge_list.size();j++)
            {
                //get midpoint of edge on surface
                surf_edge_list[j]->mid_point(get_mid_point);
                //Project the midpoint of each surface edge onto the specified plane
                target_mid_point = ref_plane.project(get_mid_point);

                //Calculate the distance between the mid_point, and target_point
                distance1 = target_mid_point.distance_between(get_mid_point);

                //the next two blocks are just copies of the above three steps

                int fraction_along_curve = 1;
                surf_edge_list[j]->position_from_fraction(fraction_along_curve, end_point);
                target_end_point = ref_plane.project(end_point);
                distance2 = target_end_point.distance_between(end_point);

                fraction_along_curve = 0;
                surf_edge_list[j]->position_from_fraction(fraction_along_curve, begin_point);
                target_begin_point = ref_plane.project(begin_point);
                distance3 = target_begin_point.distance_between(begin_point);

                //see which of the three distances is greater of the edge
                //and compare its distance to the other edges
                if (distance1>distance2 && distance1>distance3)
                {
                    result = 2*(target_mid_point - get_mid_point);
                    max_distance_for_edge=distance1;
                    if (max_distance_for_edge>temp_counter)
                    {
                        temp_counter = max_distance_for_edge;
                        max_result=result;

                    }
                }
                else if (distance2>distance3)
                {
                    result = 2*(target_end_point - end_point);
                    max_distance_for_edge=distance2;
                    if (max_distance_for_edge>temp_counter)
                    {
                        temp_counter = max_distance_for_edge;
                        max_result=result;

                    }
                }
                else
                {
                    result = 2*(target_begin_point - begin_point);
                    max_distance_for_edge=distance3;
                    if (max_distance_for_edge>temp_counter)
                    {
                        temp_counter = max_distance_for_edge;
                        max_result=result;

                    }
                }
                //just checking to make sure the user didn't specify a surface as both
                //a target surface and sweeping surface which would result in a CUBIT crash
                if (i==surface_list.size()-1 && j==surf_edge_list.size()-1 &&
                    max_distance_for_edge < 0.000000000000001)
                {
                    PRINT_ERROR( "The sweep distance is less than the geometry tolerance\n" );
                    PRINT_ERROR( "This may be caused by selecting the same\n");
                    PRINT_ERROR( "sweep surface and target surface\n" );
                    return CUBIT_FAILURE;
                }
            }
        }
        //using the facet edges defined by the drawing geometry code; take the leading
        //and trailing edge vectors of each facet edge;  With that, calc the dot product
        //and if negative (meaning the vector directions switched) the curve travels
        //through the plane and the sweep function will fail
        surface_list.reset();
        surf_edge_list.clean_out();
        for (int kk=0;kk<surface_list.size();kk++)
        {
            surface_list[kk]->ref_edges(surf_edge_list);
            for (int ii=0;ii<surf_edge_list.size();ii++)
            {
                Curve *facet_curve;
                facet_curve=surf_edge_list[ii]->get_curve_ptr();
                CubitStatus response;
                GMem g_mem;

                //get number of points and their locations
                //on the curve as defined by the drawing geometry algorithm
                response = facet_curve->get_geometry_query_engine()->
                    get_graphics( facet_curve, &g_mem );

        int num_points = g_mem.pointListCount;

                if (response==CUBIT_FAILURE || num_points == 0)
                {
                    PRINT_WARNING("Unable to preview a curve\n" );
                }

                GPoint *point_data = g_mem.point_list();

                for (int jj=0; jj < (num_points-1); jj++)
                {
                    //get first points vectors
                    CubitVector point_1;
                    point_1.x(point_data[jj].x);
                    point_1.y(point_data[jj].y);
                    point_1.z(point_data[jj].z);
                    //get second points vectors
                    CubitVector point_2;
                    point_2.x(point_data[jj+1].x);
                    point_2.y(point_data[jj+1].y);
                    point_2.z(point_data[jj+1].z);
                    //project the two points onto target plane
                    CubitVector target_point_1;
                    target_point_1 = ref_plane.project(point_1);
                    CubitVector target_point_2;
                    target_point_2 = ref_plane.project(point_2);
                    //calc vector from point on curve to point on surface
                    CubitVector vec_1 = point_1 - target_point_1;
                    CubitVector vec_2 = point_2 - target_point_2;
                    //make them unit vectors
                    vec_1.normalize();
                    vec_2.normalize();
                    //double dot = DotProduct(vec_1,vec_2);
                    //calculate dot product
                    double dot = vec_1.x()*vec_2.x()+vec_1.y()*vec_2.y()+vec_1.z()*vec_2.z();

                    //check to see if dot product sign is zero
                    //the and statement checks for if the first or last vertex of the edge
                    //which may be sitting on the surface, this is alright
                    //and should still be able to sweep
                    if (dot<0 && 0<jj && jj<(num_points-2))
                    {
                        PRINT_ERROR( "The surface is traveling through the plane\n" );
                        PRINT_ERROR( "and thus forces the sweep direction to switch\n" );
                        PRINT_ERROR( "direction. Try splitting the surface.\n" );
                        return CUBIT_FAILURE;
                    }
                }
            }
        }

        DLIList<Body*> body_list;
        DLIList<GeometryEntity*> geom_list;
        GeometryModifyEngine* gePtr1 = 0;
        CubitBoolean change_newids;

        if (!sweep_setup("translational", ref_ent_list, body_list, gePtr1,
            change_newids, geom_list, false ))
            return CUBIT_FAILURE;

    if( CubitUndo::get_undo_enabled())
      //Faces will get consumed so you have to save out original entities
      CubitUndo::save_state_with_cubit_file( surface_list );

        DLIList<BodySM*> sweep_result_list;

        //below block is default settings to be fed into sweep_translational
        CubitBoolean rigid = CUBIT_FALSE;
        CubitBoolean switchside = CUBIT_FALSE;
        int draft_type = 0;
        double draft_angle=0.0;

        //find normal vector to user specified plane
        CubitVector vec1 = ref_plane.normal();
        CubitVector vec2;
        CubitVector vec3;
        //get orthogonal vectors of the normal vector
        vec1.orthogonal_vectors(vec2, vec3);
        //place the orthogonal vectors at a point on the plane as opposed to the origin
        vec2=vec2+target_mid_point;
        vec3=vec3+target_mid_point;
        DLIList<BodySM*> webcut_results_list;
        //get a point on the first user specified surface before it gets consumed in the sweep_translational function
        CubitVector mid_point_surface;
        mid_point_surface = surface_list[0]->center_point();

        //sweep the curve down through and hopefully past the target surface
        CubitStatus status = gePtr1->sweep_translational( geom_list,sweep_result_list,
            max_result,draft_angle, draft_type,switchside,rigid,CUBIT_FALSE,CUBIT_FALSE);

        if (status == 0)
        {
            //If in here, sweep_translational failed so delete result_list and
            //print an error to the screen for the user
            gePtr1->get_gqe()->delete_solid_model_entities(sweep_result_list);
            PRINT_ERROR( "Error occured in the sweep operation.\n" );

                        if( CubitUndo::get_undo_enabled())
                          CubitUndo::remove_last_undo();
            return CUBIT_FAILURE;
        }

                DLIList<BodySM*> neighbor_imprint_list;
        //do a webcut with a plane created from the three projected points
        CubitStatus status2 = gePtr1->webcut(sweep_result_list,target_mid_point,
            vec2,vec3,neighbor_imprint_list, webcut_results_list);

        if (status2 == 0)
        {
            //If in here, webcut operation failed so delete result_list and
            //print an error to the screen for the user
            gePtr1->get_gqe()->delete_solid_model_entities(sweep_result_list);
            gePtr1->get_gqe()->delete_solid_model_entities(webcut_results_list);
            PRINT_ERROR( "Error occured in the webcut operation.\n" );

                        if( CubitUndo::get_undo_enabled())
                          CubitUndo::remove_last_undo();
            return CUBIT_FAILURE;
        }

        DLIList<BodySM*> keep_bodies_list = webcut_results_list;
        int bodies_deleted_counter=0;
        CubitVector target_mid_point_volume;
        CubitVector mid_point_volume;
        CubitVector target_mid_point_surface;
        double volume_size;

        //project the mid_point of user specified surface onto target plane
        target_mid_point_surface = ref_plane.project(mid_point_surface);
        //calculate vector between the two points and then normalize
        CubitVector vec_1 = mid_point_surface - target_mid_point_surface;
        vec_1.normalize();

        //step through the
        for (int counter=0;counter<webcut_results_list.size();counter++)
        {
            //find the geometric midpoint of the body and project that point on the target plane
            webcut_results_list[counter]->mass_properties(mid_point_volume,volume_size);
            target_mid_point_volume = ref_plane.project(mid_point_volume);
            //generate a vector between the two points and then normalize
            CubitVector vec_2 = mid_point_volume - target_mid_point_volume;
            vec_2.normalize();

            //calculate the dot product
            double dot = vec_1.x()*vec_2.x()+vec_1.y()*vec_2.y()+vec_1.z()*vec_2.z();

            //if a negative dot product delete it because it is on the opposite side of the target plane
            if (dot < 0)
            {
                keep_bodies_list.remove(webcut_results_list[counter]);
                bodies_deleted_counter = bodies_deleted_counter + 1;
            }

        }

        //test to see if all bodies have been deleted and if so let the user know
        if (bodies_deleted_counter == webcut_results_list.size())
        {
            PRINT_ERROR( "All sweeped surfaces deleted - sweep_target failed.\n" );
            PRINT_ERROR( "This may be due to granite engine limitations and/or\n" );
            PRINT_ERROR( "angle between curve and target surface\n" );

                        if( CubitUndo::get_undo_enabled())
                          CubitUndo::remove_last_undo();
            return CUBIT_FAILURE;
        }

        //delete webcut_results_list since it is no longer of use
        webcut_results_list -= keep_bodies_list;
        gePtr1->get_gqe()->delete_solid_model_entities(webcut_results_list);

        //builds ref bodies
    DLIList<Body*> output_body_list;
        if (!sweep_finish("translational", body_list, keep_bodies_list, output_body_list, change_newids))
            status = CUBIT_FAILURE;

    if( CubitUndo::get_undo_enabled())
    {
      if( status == CUBIT_FAILURE )
        CubitUndo::remove_last_undo();
      else
        CubitUndo::note_result_bodies( output_body_list );
    }

    }
    return CUBIT_SUCCESS;
}
CubitStatus GeometryModifyTool::sweep_translational ( DLIList< RefEntity * > &  ref_ent_list,
const CubitVector sweep_vector,
double  draft_angle,
int  draft_type,
CubitBoolean  switchside,
CubitBoolean  rigid,
CubitBoolean  anchor_entity,
CubitBoolean  keep_old,
DLIList< Body * > &  output_body_list 
)

Create bodies by sweeping curves or surfaces along a vector.

Definition at line 4664 of file GeometryModifyTool.cpp.

{
  DLIList<Body*> body_list;
  DLIList<GeometryEntity*> geom_list;
  GeometryModifyEngine* gePtr1 = 0;
  CubitBoolean change_newids;
  if (!sweep_setup("translational", ref_ent_list, body_list, gePtr1,
                   change_newids, geom_list, keep_old))
    return CUBIT_FAILURE;

  if( CubitUndo::get_undo_enabled())
  {
    DLIList<RefEdge*> edge_list;
    DLIList<RefFace*> face_list;

    CAST_LIST( ref_ent_list, edge_list, RefEdge );
    CAST_LIST( ref_ent_list, face_list, RefFace );

    //find any free edges
    DLIList<RefEdge*> free_edges;
    for( int k=edge_list.size(); k--; )
    {
      RefEdge *tmp_edge = edge_list.get_and_step();
      if( tmp_edge->num_parent_ref_entities() == 0 )
        free_edges.append( tmp_edge );
    }    

    if( free_edges.size() ) 
      //Free edges will get consumed..save them out 
      CubitUndo::save_state_with_cubit_file( free_edges );
    else if( edge_list.size() || keep_old )
      CubitUndo::save_state();
    else
     //Faces will get consumed so you have to save out original entities
      CubitUndo::save_state_with_cubit_file( face_list );
  }

  DLIList<BodySM*> result_list;
  CubitStatus status = gePtr1->
    sweep_translational( geom_list,
                         result_list,
                         sweep_vector,
                         draft_angle,
                         draft_type,
                         switchside,
                         rigid,
                         anchor_entity,
                         keep_old);

  if( keep_old )
    body_list.clean_out();

  if (!sweep_finish("translational", body_list, result_list, output_body_list, change_newids))
    status = CUBIT_FAILURE;

  if( CubitUndo::get_undo_enabled())
  {
    if( status == CUBIT_FAILURE )
      CubitUndo::remove_last_undo();
    else
      CubitUndo::note_result_bodies( output_body_list );
  }

  return status;
}

Tests if a RefEntity can have any unncessary child entities removed, or simplified away.

Definition at line 10649 of file GeometryModifyTool.cpp.

{
   DLIList<RefEntity*> tmp_ref_ent_list(1);
   tmp_ref_ent_list.append( old_entity_ptr );
   if( GeometryQueryTool::instance()->contains_intermediate_geometry(tmp_ref_ent_list) )
   {
     return CUBIT_FAILURE;
   }

   BasicTopologyEntity* bte_ptr = dynamic_cast<BasicTopologyEntity*>(old_entity_ptr);
   if (!bte_ptr)
   {
     return CUBIT_FAILURE;
   }

   DLIList<TopologyBridge*> bridge_list;
   bte_ptr->bridge_manager()->get_bridge_list(bridge_list);
   bridge_list.reset();

   CubitStatus stat = CUBIT_SUCCESS;

   for (int i = bridge_list.size(); i--; )
   {
     TopologyBridge* bridge = bridge_list.get_and_step();
     GeometryEntity* geom_ptr = dynamic_cast<GeometryEntity*>(bridge);
     GeometryModifyEngine* gme = get_engine(geom_ptr);
     if (!gme) continue;

     if (!gme->test_regularize_entity( geom_ptr ))
       stat = CUBIT_FAILURE;
   }

   return stat;
}
CubitStatus GeometryModifyTool::thicken ( DLIList< Body * > &  bodies,
DLIList< Body * > &  new_bodies,
double  depth,
bool  both = false 
)

Thickens a sheet body (surface) into a solid body. Can do both directions.

Definition at line 6971 of file GeometryModifyTool.cpp.

{
  if (bodies.size() <= 0)
  {
     PRINT_WARNING("There is only one body in the list. Nothing modified\n");
     return CUBIT_FAILURE;
  }

  if (!okay_to_modify( bodies, "THICKEN" ))
    return CUBIT_FAILURE;

  // Get the GeometryEngine for each Body of the list to check
  // if they are the same and if they are GeometryModifyEngine

  const int count = bodies.size();
  DLIList<TopologyEntity*> entity_list(count);
  DLIList<TopologyBridge*> bridge_list(count);
  CAST_LIST_TO_PARENT(bodies, entity_list);
  GeometryModifyEngine* gme = common_modify_engine( entity_list, bridge_list );

  if (!gme)
  {
     PRINT_ERROR("Performing THICKEN with volumes containing geometry\n"
                 " from different modeling engines is not allowed.\n"
                 "Delete uncommon geometry on these volumes before operation.\n\n");
     return CUBIT_FAILURE;
  }

  if( CubitUndo::get_undo_enabled() )
    CubitUndo::save_state_with_cubit_file( bodies );

  DLIList<BodySM*> new_sms(count);
  DLIList<BodySM*> body_sms(count);
  CAST_LIST(bridge_list, body_sms, BodySM);
  CubitStatus result = gme->thicken( body_sms, new_sms, depth, both);

  // check for resued entities, they have been moved and we need to notify observers
  DLIList<RefEntity*> entities_to_update;
  int i;
  for(i=0; i<new_sms.size(); i++)
  {
    BodySM* bodysm = new_sms.get_and_step();
    DLIList<TopologyBridge*> to_check;
    DLIList<TopologyBridge*> tmp;
    DLIList<Surface*> surfs;
    bodysm->surfaces(surfs);
    DLIList<Curve*> curves;
    bodysm->curves(curves);
    DLIList<TBPoint*> points;
    bodysm->points(points);
    to_check.append(bodysm);
    to_check.append(bodysm->lump());
    CAST_LIST_TO_PARENT(surfs, tmp);
    to_check += tmp;
    CAST_LIST_TO_PARENT(curves, tmp);
    to_check += tmp;
    CAST_LIST_TO_PARENT(points, tmp);
    to_check += tmp;

    int k;
    for(k=0; k<to_check.size(); k++)
      if(BridgeManager* m = to_check.get_and_step()->bridge_manager())
        if(TopologyEntity* t = m->topology_entity())
          entities_to_update.append(CAST_TO(t, RefEntity));

  }

  if (!finish_sm_op(bodies, new_sms, new_bodies))
    result = CUBIT_FAILURE;

  if( CubitUndo::get_undo_enabled() )
  {
    if( new_bodies.size() )
      CubitUndo::note_result_bodies( new_bodies );
    else
      CubitUndo::remove_last_undo();
  }

  // Update graphics
  while (entities_to_update.size())
  {
    RefEntity* entity = entities_to_update.pop();
    AppUtil::instance()->send_event(GeometryEvent(GeometryEvent::GEOMETRY_MODIFIED, entity));
  }

  return result;
}
CubitStatus GeometryModifyTool::tolerant_imprint ( DLIList< RefFace * > &  ref_faces,
DLIList< RefEdge * > &  ref_edge_list,
DLIList< Body * > &  new_bodies,
bool  merge = false 
)

Tolerantly imprintings a list of curves on a list of surfaces. Should be used when you have sloppy/out-of-tolerance geometry.

Definition at line 18354 of file GeometryModifyTool.cpp.

{
  if( ref_faces.size() > 2 )
    return CUBIT_FAILURE;

  ref_faces.reset();
  RefFace *face1 = ref_faces.get_and_step();
  RefFace *face2 = ref_faces.get_and_step();

  if(ref_edge_list.size() > 0)
  {
    //collect all the bodies containing any edge on these 2 surfaces
    //so you can merge them afterward
    DLIList<Body*> bodies_to_merge;
    if( merge )
    {
      DLIList<RefEdge*> tmp_edges;
      face1->ref_edges( tmp_edges);

      int j;
      for( j=tmp_edges.size(); j--; )
      {
        RefEdge *tmp_edge = tmp_edges.get_and_step();
        DLIList<Body*> body_list;
        tmp_edge->bodies( body_list );
        bodies_to_merge += body_list;
      }

      for( j=ref_edge_list.size(); j--; )
      {
        RefEdge *tmp_edge = ref_edge_list.get_and_step();
        DLIList<Body*> body_list;
        tmp_edge->bodies( body_list );
        bodies_to_merge += body_list;
      }

      tmp_edges.clean_out();
      face2->ref_edges( tmp_edges );

      for( j=tmp_edges.size(); j--; )
      {
        RefEdge *tmp_edge = tmp_edges.get_and_step();
        DLIList<Body*> body_list;
        tmp_edge->bodies( body_list );
        bodies_to_merge += body_list;
      }
      bodies_to_merge.uniquify_ordered();
    }

    DLIList<RefEdge*> edges_to_imprint_onto_face1;
    DLIList<RefEdge*> edges_to_imprint_onto_face2;

    //sort edges...
    //edges on face1 and not on face2 will be imprinted on face2
    //edges on face2 and not on face1 will be imprinted on face1
    int i;
    for(i=ref_edge_list.size(); i--; )
    {
      RefEdge *tmp_edge = ref_edge_list.get_and_step();
      DLIList<RefFace*> tmp_faces;
      tmp_edge->ref_faces( tmp_faces );

      if( tmp_faces.move_to( face1 ) && !tmp_faces.move_to( face2 ) )
        edges_to_imprint_onto_face2.append( tmp_edge );
      else if( tmp_faces.move_to( face2 ) && !tmp_faces.move_to( face1 ) )
        edges_to_imprint_onto_face1.append( tmp_edge );
      else
        PRINT_ERROR("Will not imprint curve %d onto either surface.\n", tmp_edge->id() );
    }

    //if there are edges to impint onto both surfaces
    if( edges_to_imprint_onto_face1.size() &&
        edges_to_imprint_onto_face2.size() )
    {
      //get the modify engine
      DLIList<Surface*> surf_list( 1 );
      DLIList<Curve*> curve_list( edges_to_imprint_onto_face2.size() );
      DLIList<RefFace*> ref_face_list( 1 );
      ref_face_list.append( face2 );
      GeometryModifyEngine* gme = common_modify_engine( ref_face_list,
                                                        edges_to_imprint_onto_face2,
                                                        surf_list,
                                                        curve_list );
      if ( !gme )
      {
        PRINT_ERROR("Performing IMPRINT with entities containing geometry from\n"
                    "different modeling engines is not allowed.\n" );
        return CUBIT_FAILURE;
      }

      //copy the specified boundary curves of face1 to imprint onto face2...
      //these could be stale after we imprint face1
      DLIList<Curve*> copied_curves;
      for(i=curve_list.size(); i--; )
      {
        Curve *copied_curve = gme->make_Curve( curve_list.get_and_step() );
        copied_curves.append( copied_curve );
      }

    if( CubitUndo::get_undo_enabled() )
      CubitUndo::save_state_with_cubit_file( ref_faces );

      //do the imprint onto face1
      Body *new_body = NULL;
      CubitStatus status;
      status = tolerant_imprint( face1, edges_to_imprint_onto_face1, new_body );

      //if we failed...get out
      if( status == CUBIT_FAILURE )
      {
        //delete the copied curves
        for( i=copied_curves.size(); i--; )
          gme->get_gqe()->delete_solid_model_entities( copied_curves.get_and_step() );

        if( CubitUndo::get_undo_enabled() )
          CubitUndo::remove_last_undo();

        return CUBIT_FAILURE;
      }

      DLIList<Body*> original_body_list;
      face2->bodies( original_body_list );

      //get the Surface* ptr
      Surface *surface2 = face2->get_surface_ptr();

      DLIList<BodySM*> body_sm_list;
      for(i=original_body_list.size(); i--;)
        body_sm_list.append(original_body_list.get_and_step()->get_body_sm_ptr());

      int process_composites = 0;
      if(contains_composites(original_body_list))
        process_composites = 1;

      if(process_composites)
      {
        // Push virtual attributes down to solid model topology before
        // doing the imprint.
        do_attribute_setup();
        push_attributes_before_modify(body_sm_list);
        // This must be done after pushing the vg atts because it uses them.
        push_imprint_attributes_before_modify(body_sm_list);
      }

      //do the imprint onto face2
      BodySM *new_bodysm = NULL;
      DLIList<TopologyBridge*> temporary_bridges;
      status = gme->tolerant_imprint_surface_with_curves( surface2, copied_curves, temporary_bridges, new_bodysm);
      temporary_bridges.uniquify_ordered();
      while(temporary_bridges.size())
      {
        TopologyBridge* bridge = temporary_bridges.pop();
        bridge->get_geometry_query_engine()->delete_topology_bridge(bridge);
      }

      DLIList<BodySM*> new_body_list;
      if(new_bodysm)
        new_body_list.append(new_bodysm);


      //delete the copied curves
      for( i=copied_curves.size(); i--; )
        gme->get_gqe()->delete_solid_model_entities( copied_curves.get_and_step() );

      if( status == CUBIT_FAILURE )
      {
        if( CubitUndo::get_undo_enabled() )
          CubitUndo::remove_last_undo();

        if(process_composites)
        {
          remove_pushed_attributes(new_body_list, original_body_list);
          do_attribute_cleanup();
        }

        return CUBIT_FAILURE;
      }
      else
      {
        if(process_composites)
        {
          // Analyze the results and adjust virtual attributes as necessary.
        DLIList<TopologyBridge*> tb_list;
        CAST_LIST(new_body_list, tb_list, TopologyBridge);
          GeometryQueryTool::instance()->ige_attribute_after_imprinting(tb_list, original_body_list);

          // Clean up attributes.
          remove_imprint_attributes_after_modify(body_sm_list, new_body_list);

          // Restore the virtual geometry.
          restore_vg_after_modify(new_body_list, original_body_list, gme);
          remove_pushed_attributes(new_body_list, original_body_list);
        }
      }

      DLIList<BodySM*> new_bodies;
      new_bodies.append( new_bodysm );
      DLIList<Body*> result_bodies;
      status = finish_sm_op( original_body_list, new_bodies, result_bodies );

      if(process_composites)
        do_attribute_cleanup();

      if( status == CUBIT_FAILURE )
      {
        if( CubitUndo::get_undo_enabled() )
          CubitUndo::remove_last_undo();
        return CUBIT_FAILURE;
      }
    }
    //user specified edges that will only imprint onto face1...do it anyway
    else if( edges_to_imprint_onto_face1.size() )
    {
      if( CubitUndo::get_undo_enabled() )
      {
        DLIList<RefFace*> tmp_faces(1);
        tmp_faces.append( face1 );
        CubitUndo::save_state_with_cubit_file( tmp_faces );
      }

      bool undo_enabled = CubitUndo::get_undo_enabled();
      CubitUndo::set_undo_enabled( false );

      Body *new_body = NULL;
      CubitStatus stat = tolerant_imprint( face1, edges_to_imprint_onto_face1,
                                          new_body, merge );

    if( undo_enabled )
      CubitUndo::set_undo_enabled( true );

    if( CubitUndo::get_undo_enabled() )
    {
      if( stat == CUBIT_FAILURE )
        CubitUndo::remove_last_undo();
    }

      return stat;
    }
    //user specified edges that will only imprint onto face2...do it anyway
    else if( edges_to_imprint_onto_face2.size() )
    {
      if( CubitUndo::get_undo_enabled() )
      {
        DLIList<RefFace*> tmp_faces(1);
        tmp_faces.append( face2 );
        CubitUndo::save_state_with_cubit_file( tmp_faces );
      }

      bool undo_enabled = CubitUndo::get_undo_enabled();
      CubitUndo::set_undo_enabled( false );

      Body *new_body = NULL;
      CubitStatus stat = tolerant_imprint( face2, edges_to_imprint_onto_face2,
                                          new_body, merge );

      if( undo_enabled )
        CubitUndo::set_undo_enabled( true );

      if( CubitUndo::get_undo_enabled() )
      {
        if( stat == CUBIT_FAILURE )
          CubitUndo::remove_last_undo();
      }

      return stat;
    }

    if( merge )
      MergeTool::instance()->merge_bodies( bodies_to_merge );
  }
  else
  {
    DLIList<RefFace*> faces_not_to_merge;
    Body *body1 = face1->body();
    Body *body2 = face2->body();

    if(merge)
    {
      DLIList<RefFace*> tmp_faces;
      body1->ref_faces(tmp_faces);
      if(tmp_faces.move_to(face1))
        tmp_faces.extract();
      faces_not_to_merge = tmp_faces;

      tmp_faces.clean_out();
      body2->ref_faces(tmp_faces);
      if(tmp_faces.move_to(face2))
        tmp_faces.extract();
      faces_not_to_merge += tmp_faces;
    }

    //get the modify engine
    DLIList<Surface*> surf_list( 1 );
    DLIList<RefFace*> ref_face_list( 2 );
    ref_face_list.append( face1 );
    ref_face_list.append( face2 );
    GeometryModifyEngine* gme = common_modify_engine( ref_face_list, surf_list);

    if ( !gme )
    {
      PRINT_ERROR("Performing IMPRINT with entities containing geometry from\n"
                  "different modeling engines is not allowed.\n" );
      return CUBIT_FAILURE;
    }

    if( CubitUndo::get_undo_enabled() )
      CubitUndo::save_state_with_cubit_file( ref_faces );

    //do the imprint onto face1
    DLIList<BodySM*> new_bodysm_list;
    CubitStatus status = gme->tolerant_imprint(surf_list, new_bodysm_list);

    //if we failed...get out
    if( status == CUBIT_FAILURE )
    {
      if( CubitUndo::get_undo_enabled() )
        CubitUndo::remove_last_undo();

      return CUBIT_FAILURE;
    }

    DLIList<Body*> result_bodies;
    DLIList<Body*> original_body_list;
    original_body_list.append(body1);
    original_body_list.append(body2);
    status = finish_sm_op( original_body_list, new_bodysm_list, result_bodies );


    if( merge )
    {
      DLIList<RefFace*> faces_to_merge, tmp_faces;
      body1->ref_faces(faces_to_merge);
      body2->ref_faces(tmp_faces);
      faces_to_merge += tmp_faces;
      faces_to_merge -= faces_not_to_merge;
      if(faces_to_merge.size() > 1)
      {
        MergeTool::instance()->merge_reffaces(faces_to_merge);
      }
    }
  }

  return CUBIT_SUCCESS;
}
CubitStatus GeometryModifyTool::tolerant_imprint ( RefFace ref_face,
DLIList< RefEdge * > &  ref_edge_list,
Body *&  new_body,
bool  merge = false 
)

Tolerantly imprintings a list of curves onto a single surface. Should be used when you have sloppy/out-of-tolerance geometry.

Definition at line 18703 of file GeometryModifyTool.cpp.

{
  int i;
  DLIList<Body*> bodies_to_merge;
  DLIList<Body*> blank_bodies;
  
  DLIList<RefEdge*> tmp_edges;
  ref_face->ref_edges( tmp_edges );

  for( i=tmp_edges.size(); i--; )
  {
    RefEdge *tmp_edge = tmp_edges.get_and_step();
    DLIList<Body*> body_list;
    tmp_edge->bodies( body_list );    
    blank_bodies += body_list;
  }

  if( merge )
  {
    bodies_to_merge += blank_bodies;
  
    for( i=ref_edge_list.size(); i--; )
    {
      RefEdge *tmp_edge = ref_edge_list.get_and_step();
      DLIList<Body*> body_list;
      tmp_edge->bodies( body_list );
      bodies_to_merge += body_list;
    }

    bodies_to_merge.uniquify_ordered();
  }  

  DLIList<Body*> original_body_list;
  ref_face->bodies( original_body_list );

  DLIList<Surface*> surf_list( 1 );
  DLIList<Curve*> curve_list(ref_edge_list.size());
  DLIList<RefFace*> ref_face_list( 1 );
  ref_face_list.append( ref_face );

  //prohibit imprinting on partition bodies
  for( int k=0; k<blank_bodies.size(); k++ )  
  {
    if( NULL == get_engine( blank_bodies[k]->bridge_manager()->topology_bridge() ) )
    {
       PRINT_ERROR("Performing IMPRINT on entities with partitions\n"
                   "       is not allowed.\n" );
       return CUBIT_FAILURE;
    }
  } 

  GeometryModifyEngine* gme = common_modify_engine( ref_face_list,
                                                    ref_edge_list,
                                                    surf_list,
                                                    curve_list,
                                                    true);
  if ( !gme )
  {
    PRINT_ERROR("Performing IMPRINT with entities containing geometry from\n"
                "different modeling engines is not allowed.\n" );
    return CUBIT_FAILURE;
  }


  if( CubitUndo::get_undo_enabled() )
  {
    DLIList<RefFace*> ref_faces(1);
    ref_faces.append( ref_face );
    CubitUndo::save_state_with_cubit_file( ref_faces );
  }

  DLIList<BodySM*> body_sm_list;
  for(i=original_body_list.size(); i--;)
    body_sm_list.append(original_body_list.get_and_step()->get_body_sm_ptr());

  int process_composites = 0;
  if(contains_composites(original_body_list))
    process_composites = 1;

  DLIList<TopologyBridge*> tb_list;
  if(process_composites)
  {
    // Turn certain attributes on.
    do_attribute_setup();
    // Push virtual attributes down to solid model topology before
    // doing the imprint.
    push_attributes_before_modify(body_sm_list);
    DLIList<TopologyBridge*> tmp_tb_list;
    CAST_LIST(surf_list, tmp_tb_list, TopologyBridge);
    // Put "ORIGINAL" attributes on the bodies being imprinted and
    // the curves as these originally existed.
    push_named_attributes_to_curves_and_points(tmp_tb_list, "ORIGINAL");
    CAST_LIST(curve_list, tb_list, TopologyBridge);
    push_named_attributes_to_curves_and_points(tb_list, "ORIGINAL");
    push_named_attributes_to_curves_and_points(tb_list, "IMPRINTER");
  }

  CubitStatus status = CUBIT_FAILURE;
  DLIList<BodySM*> new_body_list;
  // The bridges doing the imprinting often get split during the process but
  // because of the way we are making copies, the IMPRINTER attribute doesn't
  // get propagated to them.  temporary_bridges will be filled in with any
  // additional IMPRINTER bridges we need to consider below when deciding whether to
  // keep composite attributes.
  DLIList<TopologyBridge*> temporary_bridges;
  for(i=surf_list.size(); i>0; i--)
  {
    Surface *cur_surf = surf_list.get_and_step();
    BodySM *new_body_sm = NULL;
    CubitStatus tmp_status = gme->tolerant_imprint_surface_with_curves(
                                                cur_surf, curve_list,
                                                temporary_bridges,
                                                new_body_sm);
    if(new_body_sm)
      new_body_list.append(new_body_sm);
    if(tmp_status == CUBIT_SUCCESS)
      status = tmp_status;
  }

  temporary_bridges.uniquify_ordered();

  if( status == CUBIT_FAILURE )
  {
    if( CubitUndo::get_undo_enabled() )
      CubitUndo::remove_last_undo();

    if(process_composites)
    {
      remove_pushed_attributes(new_body_list, original_body_list);
      do_attribute_cleanup();
    }

    while(temporary_bridges.size())
    {
      TopologyBridge* bridge = temporary_bridges.pop();
      bridge->get_geometry_query_engine()->delete_topology_bridge(bridge);
    }

    return CUBIT_FAILURE;
  }
  else
  {
    if(process_composites)
    {
      // Analyze the results and adjust virtual attributes as necessary.
      DLIList<TopologyBridge*> tmp_tb_list;
      CAST_LIST(new_body_list, tmp_tb_list, TopologyBridge);
      tb_list.merge_unique(tmp_tb_list);
      // The bridges coming back in temporary_bridges may not have IMPRINTER
      // attributes on them becuase of the way they were generated below.  Make
      // sure they get IMPRINTER attributes.
      push_named_attributes_to_curves_and_points(temporary_bridges, "IMPRINTER");
      tb_list += temporary_bridges;
      GeometryQueryTool::instance()->ige_attribute_after_imprinting(tb_list, original_body_list);


      // Clean up attributes.
      remove_imprint_attributes_after_modify(body_sm_list, new_body_list);

      // Restore the virtual geometry.
      restore_vg_after_modify(new_body_list, original_body_list, gme);
      remove_pushed_attributes(new_body_list, original_body_list);
    }
  }
  // cleanup temp bridges
  while(temporary_bridges.size())
  {
    TopologyBridge* bridge = temporary_bridges.pop();
    bridge->get_geometry_query_engine()->delete_topology_bridge(bridge);
  }

  DLIList<Body*> result_bodies;
  status = finish_sm_op( original_body_list, new_body_list, result_bodies );

  if(process_composites)
    do_attribute_cleanup();

  if( status == CUBIT_FAILURE )
  {
    if( CubitUndo::get_undo_enabled() )
      CubitUndo::remove_last_undo();
    return CUBIT_FAILURE;
  }

  if( merge )
    MergeTool::instance()->merge_bodies( bodies_to_merge );

  if( result_bodies.size() == 1 )
    new_body = result_bodies.get();
  else
    return CUBIT_FAILURE;

  return status;
}
CubitStatus GeometryModifyTool::tolerant_imprint ( DLIList< Body * > &  bodies,
DLIList< Body * > &  new_bodies,
double  overlap_tol,
double  imprint_tol,
bool  merge = false 
)

Imprints bodies onto one another. Should be used when you have sloppy/out- of-tolerance geometry.

Definition at line 19763 of file GeometryModifyTool.cpp.

{
  //make sure all bodies are from the same modify engine
  DLIList<BodySM*> body_sm_list;
  GeometryModifyEngine* gme = common_modify_engine(bodies, body_sm_list);
  if ( !gme )
  {
    PRINT_ERROR("Performing IMPRINT with volumes containing geometry\n"
                "from different modeling engines is not allowed.\n"
                "Delete uncommon geometry on these volumes before operation.\n\n");
    return CUBIT_FAILURE;
  }


  //make sure that merge tolerance is not inapproiate for model
  int i;
  CubitBox bounding_box( CubitVector(0,0,0),
                         CubitVector(CUBIT_DBL_MAX,
                                     CUBIT_DBL_MAX,
                                     CUBIT_DBL_MAX ) );
  for( i=bodies.size(); i--; )
  {
    CubitBox tmp_box = bodies.get_and_step()->bounding_box();
    if(bounding_box.max_x() == CUBIT_DBL_MAX)
      bounding_box = tmp_box;
    else if( tmp_box.diagonal().length_squared() <
        bounding_box.diagonal().length_squared() )
      bounding_box = tmp_box;
  }

  //get the merge tolerance
  double tolerance = GeometryQueryTool::get_geometry_factor()*GEOMETRY_RESABS;

  //if the merge tolerance is greater than 1/10th the length of the
  //diagonal of the bounding box of the smallest volume, fail!
  double tenth_smallest_bbox = 0.1*(bounding_box.diagonal().length());
  if( tolerance > tenth_smallest_bbox )
  {
    PRINT_ERROR("Merge tolerance is set excessively high.  Must be lower than %f\n",
                 tenth_smallest_bbox );
    PRINT_INFO("       (Merge tolerance must be less than than 1/10th of the diagonal\n"
                        "of the bounding box of the smallest volume)\n");
    return CUBIT_FAILURE;
  }

  if( CubitUndo::get_undo_enabled() )
    CubitUndo::save_state_with_cubit_file( bodies );

  // Propagate any merge tolerances on the bodies
//  propagate_merge_tolerance(bodies);

  // Push the tolerance attributes
//  push_tolerance_attribute(bodies);

  body_sm_list.clean_out();
  DLIList<Body*> old_body_list;
  old_body_list += bodies;
  bodies.reset();
  for( i=bodies.size(); i--; )
    body_sm_list.append( bodies.get_and_step()->get_body_sm_ptr() );

  int process_composites = 0;
  if(contains_composites(bodies))
    process_composites = 1;

  if(process_composites)
  {
    // Push virtual attributes down to solid model topology before
    // doing the imprint.
    do_attribute_setup();
    push_attributes_before_modify(body_sm_list);
    // This must be done after pushing the vg atts because it uses them.
    DLIList<TopologyBridge*> tb_list;
    CAST_LIST(body_sm_list, tb_list, TopologyBridge);
    push_named_attributes_to_curves_and_points(tb_list, "IMPRINTER");
    push_named_attributes_to_curves_and_points(tb_list, "ORIGINAL");
  }

  if (DEBUG_FLAG(95))
  {
    PRINT_DEBUG_95( "Calculating local tolerances for tolerant imprinting.\n");

//#ifndef _NDEBUG
//    LocalToleranceTool::instance()->print_local_tolerances( body_sm_list );
//#endif

    // Calculate local tolerances at ref entities
    LocalToleranceTool::instance()->calculate_local_tolerances( body_sm_list );

//#ifndef _NDEBUG
//    LocalToleranceTool::instance()->print_local_tolerances( body_sm_list );
//#endif
  }

  // Call tolerant imprint
  DLIList<BodySM*> new_body_list;
  CubitStatus result = gme->tolerant_imprint( body_sm_list, new_body_list, overlap_tol, imprint_tol);


  if(result == CUBIT_FAILURE)
  {
    if(process_composites)
    {
      remove_pushed_attributes(new_body_list, bodies);
      do_attribute_cleanup();
    }
    return result;
  }
  else
  {
    if(process_composites)
    {
      // Analyze the results and adjust virtual attributes as necessary.
       DLIList<TopologyBridge*> tb_list;
       CAST_LIST(new_body_list, tb_list, TopologyBridge);
      GeometryQueryTool::instance()->ige_attribute_after_imprinting(tb_list, bodies);

      // Clean up attributes.
      remove_imprint_attributes_after_modify(body_sm_list, new_body_list);

      // Restore the virtual geometry.
      restore_vg_after_modify(new_body_list, bodies, gme);
      remove_pushed_attributes(new_body_list, bodies);
    }
  }

  // RANDY - HACK!!
  //for (int i = new_body_list.size(); i--;)
  //{
  //  clean_up_from_copy_failure(new_body_list.get_and_step());
  //}

  result = finish_sm_op( bodies, body_sm_list, new_bodies );

  if(process_composites)
    do_attribute_cleanup();

  if(result == CUBIT_FAILURE)
  {
    if( CubitUndo::get_undo_enabled() )
      CubitUndo::remove_last_undo();
    return CUBIT_FAILURE;
  }

  if( merge )
    MergeTool::instance()->merge_bodies( bodies );

  return CUBIT_SUCCESS;
}
Body * GeometryModifyTool::torus ( double  r1,
double  r2 
)

Creates a torus.

Creates an torus and assigns it to a Body $ {r1} input major_radius $ {r2} input minor_radius Returns the new Body or NULL

Definition at line 712 of file GeometryModifyTool.cpp.

{   if (0 == gmeList.size())
   {
      PRINT_WARNING("No active geometry engine.\n");
      return NULL;
   }


     // First make sure that the input values make sense
   if ( r1 <= r2 || r1 <= GEOMETRY_RESABS || r2 <= 0.0)
   {
      PRINT_ERROR("In GeometryModifyTool::torus\n"
                  "  Cannot make a torus of major-radius = %f and"
                  " minor-radius = %f\n",
                  r1, r2);
      return NULL;
   }

   if( CubitUndo::get_undo_enabled() )
     CubitUndo::save_state();

     // Create a Body that represents the torus
   BodySM* bodyPtr = gmeList.get()->torus(r1, r2) ;
   Body *new_body = NULL;

   if (bodyPtr == NULL)
   {
      PRINT_ERROR("In GeometryModifyTool::torus\n"
                  "       Problems building a volume from the torus.\n") ;
   }
   else
     new_body = GeometryQueryTool::instance()->make_Body(bodyPtr);

  if( CubitUndo::get_undo_enabled() )
  {
    if( new_body )
      CubitUndo::note_result_body( new_body );
    else
      CubitUndo::remove_last_undo();
  }

   return new_body;
}
void GeometryModifyTool::trace_out_curves ( Body plane_body,
CubitVector start_point,
CubitVector march_dir,
double  step_size,
DLIList< CubitVector > &  horizontal_points,
DLIList< CubitVector > &  vertical_points 
)

Definition at line 20233 of file GeometryModifyTool.cpp.

{
  // Find a curve that the start point is on.
  DLIList<RefEdge*> curves;
  plane_body->ref_edges(curves);
  DLIList<RefEdge*> interior_curves;
  for(int i=0; i<curves.size(); i++)
  {
    RefEdge *cur_curve = curves[i];
    DLIList<RefFace*> curve_surfs;
    cur_curve->ref_faces(curve_surfs);
    if(curve_surfs.size() == 2)
      interior_curves.append(cur_curve);
  }
  RefEdge *start_curve = NULL;
  for(int i=0; i<interior_curves.size(); i++)
  {
    CubitVector closest;
    RefEdge *cur_curve = interior_curves[i];
    cur_curve->closest_point_trimmed(start_point, closest);
    if(start_point.about_equal(closest))
    {
      start_curve = cur_curve;
      break;
    }
  }
  if(start_curve)
  {
    
  }
}
CubitStatus GeometryModifyTool::trim_curve ( RefEdge trim_curve,
const CubitVector trim_vector,
const CubitVector keep_vector 
)

Trims or extends a curve, up to the trim_vector. If trimming, the.

Trims or extends a curve, up to the trim_vector. If trimming, the keep_vector determines which side of the curve to keep. If the curve is not free, the curve is automatically copied before trimming (so a new curve results).

Definition at line 11020 of file GeometryModifyTool.cpp.

{
  // Use geometry engine to find intersections
  TopologyBridge* bridge = 0;
  GeometryModifyEngine* gme_ptr = get_engine(trim_curve, &bridge);
  Curve *new_curve = 0, *curve = dynamic_cast<Curve*>(bridge);

  if (!gme_ptr || !curve)
    return CUBIT_FAILURE;

  if( CubitUndo::get_undo_enabled() )
  {
    DLIList<RefEdge*> tmp_ents(1);
    tmp_ents.append( trim_curve );
    CubitUndo::save_state_with_cubit_file( tmp_ents );
  }

  new_curve = gme_ptr->trim_curve( curve, trim_vector, keep_vector );
  if (!new_curve)
  {
    if( CubitUndo::get_undo_enabled() )
      CubitUndo::remove_last_undo();
    return CUBIT_FAILURE;
  }

  GeometryQueryTool::instance()->destroy_dead_entity( trim_curve );

  RefEdge* new_edge = GeometryQueryTool::instance()->make_free_RefEdge(new_curve);

  if( CubitUndo::get_undo_enabled() )
    CubitUndo::note_result_entity( new_edge );

  PRINT_INFO("Created curve %d\n", new_edge->id());

  return CUBIT_SUCCESS;
}
CubitStatus GeometryModifyTool::tweak_bend ( DLIList< Body * > &  bend_bodies,
DLIList< Body * > &  new_body_list,
CubitVector neutral_root,
CubitVector bend_axis,
CubitVector bend_direction,
double  radius,
double  angle,
DLIList< CubitVector > &  bend_regions,
double  width = -1,
CubitBoolean  center_bend = CUBIT_FALSE,
int  num_points = 0,
CubitBoolean  keep_old_body = CUBIT_FALSE,
CubitBoolean  preview = CUBIT_FALSE 
)

Currently unsupported.

Definition at line 14126 of file GeometryModifyTool.cpp.

{
    if (CubitUndo::get_undo_enabled() && preview == CUBIT_FALSE)
    {
        if (keep_old_body)
            CubitUndo::save_state();
        else
            CubitUndo::save_state_with_cubit_file( bend_bodies );
    }

    DLIList<BodySM*> new_body_sm_list;
    DLIList<BodySM*> bend_bodies_sm;
    GeometryModifyEngine* engine;
    engine = common_modify_engine(bend_bodies, bend_bodies_sm);

    if (!preview)
    {
        //do_attribute_setup();
        //push_attributes_before_modify(bend_bodies_sm);
    }

    CubitStatus result = engine->tweak_bend(
            bend_bodies_sm,
            new_body_sm_list,
            neutral_root,
            bend_axis,
            bend_direction,
            radius,
            angle,
            bend_regions,
            width,
            center_bend,
            num_points,
            keep_old_body,
            preview);

    if (result == CUBIT_FAILURE)
    {
        if (!preview)
        {
            //remove_pushed_attributes(bend_bodies_sm, bend_bodies);
            //do_attribute_cleanup();
        }
        if (CubitUndo::get_undo_enabled())
            CubitUndo::remove_last_undo();
        return CUBIT_FAILURE;
    }

    if (preview == CUBIT_FALSE)
    {
        //restore_vg_after_modify(new_body_sm_list, bend_bodies, engine);
        //remove_pushed_attributes(new_body_sm_list, bend_bodies);

        // Update DAG
        CubitStatus stat = finish_sm_op( bend_bodies, new_body_sm_list, new_body_list );
        if (CubitUndo::get_undo_enabled())
        {
            if (stat == CUBIT_SUCCESS)
                CubitUndo::note_result_bodies( new_body_list );
            else
                CubitUndo::remove_last_undo();
        }

        //do_attribute_cleanup();

        // Update graphics
        /*
        bend_bodies.reset();
        int i = 0;
        for (i = 0; i < bend_bodies.size(); i++)
        {
            Body* body_ptr = bend_bodies.get_and_step();
            body_ptr->notify_all_observers( GEOMETRY_MODIFIED );
        }//*/

        // get list of entities to update
        DLIList<RefEntity*> entities_to_update;
        int i;
        for(i=0; i < new_body_sm_list.size(); i++)
        {
            BodySM* bodysm = new_body_sm_list.get_and_step();
            DLIList<TopologyBridge*> to_check;
            DLIList<TopologyBridge*> tmp;
            DLIList<Surface*> surfs;
            bodysm->surfaces(surfs);
            DLIList<Curve*> curves;
            bodysm->curves(curves);
            DLIList<TBPoint*> points;
            bodysm->points(points);
            to_check.append(bodysm);
            to_check.append(bodysm->lump());
            CAST_LIST_TO_PARENT(surfs, tmp);
            to_check += tmp;
            CAST_LIST_TO_PARENT(curves, tmp);
            to_check += tmp;
            CAST_LIST_TO_PARENT(points, tmp);
            to_check += tmp;

            int k;
            for(k=0; k<to_check.size(); k++)
                if(BridgeManager* m = to_check.get_and_step()->bridge_manager())
                    if(TopologyEntity* t = m->topology_entity())
                        entities_to_update.append(CAST_TO(t, RefEntity));

        }
        // Update graphics
        while (entities_to_update.size())
            AppUtil::instance()->send_event(GeometryEvent(GeometryEvent::GEOMETRY_MODIFIED, entities_to_update.pop()));

        return stat;
    }

    return CUBIT_SUCCESS;
}
CubitStatus GeometryModifyTool::tweak_chamfer ( DLIList< RefEdge * > &  ref_edge_list,
double  left_offset,
DLIList< Body * > &  new_body_list,
double  right_offset = -1.0,
CubitBoolean  keep_old_body = CUBIT_FALSE,
CubitBoolean  preview = CUBIT_FALSE 
)

Chamfer curves on solid and sheet bodies.

Chamfer curves on solid and sheet bodies. The left and right offsets are with respect to the curve direction. If the given right offset is negative, the left offset is used. Users can preview to clarify the meaning of left and right.

Definition at line 14263 of file GeometryModifyTool.cpp.

{
  DLIList<Curve*> curve_list(ref_edge_list.size());
  DLIList<Body*> old_body_list;
  GeometryModifyEngine* gme_ptr;

  gme_ptr = tweak_setup( ref_edge_list, "Chamfering", old_body_list, curve_list, CUBIT_TRUE );
  if( !gme_ptr )
    return CUBIT_FAILURE;

  if( CubitUndo::get_undo_enabled() && preview == CUBIT_FALSE )
  {
    if( keep_old_body )
      CubitUndo::save_state();
    else
      CubitUndo::save_state_with_cubit_file( ref_edge_list );
  }

  DLIList<BodySM*> body_sms;
  for(int i=old_body_list.size(); i--;)
  {
    BodySM* bsm = old_body_list.get_and_step()->get_body_sm_ptr();
    if(bsm)
      body_sms.append_unique(bsm);
  }

  if(!preview)
  {
    do_attribute_setup();
    push_attributes_before_modify(body_sms);
  }

  // Do chamfering
  DLIList<BodySM*> new_bodysm_list;
  CubitStatus stat = gme_ptr->tweak_chamfer( curve_list, left_offset, new_bodysm_list,
                                            right_offset, keep_old_body, preview );
  if(stat == CUBIT_FAILURE )
  {
    if(!preview)
    {
      if( CubitUndo::get_undo_enabled() )
        CubitUndo::remove_last_undo();
      remove_pushed_attributes(new_bodysm_list, old_body_list);
      do_attribute_cleanup();
    }
    return stat;
  }
  else
  {
    if(!preview)
    {
      restore_vg_after_modify(new_bodysm_list, old_body_list, gme_ptr);
      remove_pushed_attributes(new_bodysm_list, old_body_list);
    }
  }

  if( preview == CUBIT_FALSE )
  {
    // Update DAG
    stat = finish_sm_op( old_body_list, new_bodysm_list, new_body_list );

    if( CubitUndo::get_undo_enabled() )
    {
      if( stat == CUBIT_SUCCESS )
        CubitUndo::note_result_bodies( new_body_list );
      else
        CubitUndo::remove_last_undo();
    }
    do_attribute_cleanup();

    return stat;
  }
  return CUBIT_SUCCESS;
}
CubitStatus GeometryModifyTool::tweak_chamfer ( DLIList< RefVertex * > &  ref_vertex_list,
double  offset1,
DLIList< Body * > &  new_body_list,
RefEdge edge1 = NULL,
double  offset2 = -1.0,
RefEdge edge2 = NULL,
double  offset3 = -1.0,
RefEdge edge3 = NULL,
CubitBoolean  keep_old_body = CUBIT_FALSE,
CubitBoolean  preview = CUBIT_FALSE 
)

Chamfer vertices on solid or sheet bodies.

Chamfer vertices on solid or sheet bodies. On a solid body there can be up to 3 offsets; on a sheet body up to 2 offsets. The offsets are in the direction of the supplied edges. If multiple vertices are supplied, only one offset value is allowed and the edges are not used.

Definition at line 14817 of file GeometryModifyTool.cpp.

{
  if( offset1 <= 0.0 )
  {
    PRINT_ERROR( "Chamfer radius not specified.\n" );
    return CUBIT_FAILURE;
  }

  DLIList<TBPoint*> point_list(ref_vertex_list.size());
  DLIList<Body*> old_body_list;
  GeometryModifyEngine* gme_ptr;

  gme_ptr = tweak_setup( ref_vertex_list, "Chamfering", old_body_list, point_list, CUBIT_TRUE );
  if( !gme_ptr )
    return CUBIT_FAILURE;

  RefVertex *ref_vertex_ptr = ref_vertex_list.get();
  if( ref_vertex_list.size() == 1 && (edge1 || edge2 || edge3) )
  {
    // Make sure input edges are attached to the input vertex
    DLIList<RefEdge*> ref_edge_list;
    ref_vertex_ptr->ref_edges( ref_edge_list );

    if( edge1 && !ref_edge_list.is_in_list( edge1 ) )
    {
      PRINT_ERROR( "Specified curve %d not attached to vertex %d\n", edge1->id(),
        ref_vertex_ptr->id() );
      return CUBIT_FAILURE;
    }

    if( edge2 && !ref_edge_list.is_in_list( edge2 ) )
    {
      PRINT_ERROR( "Specified curve %d not attached to vertex %d\n", edge1->id(),
        ref_vertex_ptr->id() );
      return CUBIT_FAILURE;
    }

    if( edge3 && !ref_edge_list.is_in_list( edge3 ) )
    {
      PRINT_ERROR( "Specified curve %d not attached to vertex %d\n", edge1->id(),
        ref_vertex_ptr->id() );
      return CUBIT_FAILURE;
    }

    // Make sure offsets supplied
    if( edge1 && offset1 < 0.0 )
    {
      PRINT_ERROR( "Offset for curve %d specified incorrectly.\n", edge1->id() );
      return CUBIT_FAILURE;
    }

    if( edge2 && offset2 < 0.0 )
    {
      PRINT_ERROR( "Offset for curve %d specified incorrectly.\n", edge2->id() );
      return CUBIT_FAILURE;
    }

    if( edge3 && offset3 < 0.0 )
    {
      PRINT_ERROR( "Offset for curve %d specified incorrectly.\n", edge3->id() );
      return CUBIT_FAILURE;
    }
  }

  if( point_list.size() > 1 && offset2 > 0.0 )
  {
    PRINT_ERROR( "Cannot supply multiple radii when chamfering multiple vertices.\n" );
    return CUBIT_FAILURE;
  }

  Curve *curve1 = NULL;
  Curve *curve2 = NULL;
  Curve *curve3 = NULL;

  if( edge1 )
  {
    TopologyBridge* bridge = 0;
    GeometryModifyEngine* edge_gme = get_engine(edge1, &bridge);
    if( gme_ptr != edge_gme )
    {
      PRINT_ERROR( "Specified curve %d must belong to same geometry engine as vertex %d.\n",
        edge1->id(), ref_vertex_ptr->id()  );
      return CUBIT_FAILURE;
    }
    curve1 = dynamic_cast<Curve*>(bridge);
  }

  if( edge2 )
  {
    TopologyBridge* bridge = 0;
    GeometryModifyEngine* edge_gme = get_engine(edge2, &bridge);
    if( gme_ptr != edge_gme )
    {
      PRINT_ERROR( "Specified curve %d must belong to same geometry engine as vertex %d.\n",
        edge2->id(), ref_vertex_ptr->id()  );
      return CUBIT_FAILURE;
    }
    curve2 = dynamic_cast<Curve*>(bridge);
  }

  if( edge3 )
  {
    TopologyBridge* bridge = 0;
    GeometryModifyEngine* edge_gme = get_engine(edge3, &bridge);
    if( gme_ptr != edge_gme )
    {
      PRINT_ERROR( "Specified curve %d must belong to same geometry engine as vertex %d.\n",
        edge3->id(), ref_vertex_ptr->id()  );
      return CUBIT_FAILURE;
    }
    curve3 = dynamic_cast<Curve*>(bridge);
  }

  if( CubitUndo::get_undo_enabled() && preview == CUBIT_FALSE )
  {
    if( keep_old_body )
      CubitUndo::save_state();
    else
      CubitUndo::save_state_with_cubit_file( ref_vertex_list );
  }

  DLIList<BodySM*> body_sms;
  for(int i=old_body_list.size(); i--;)
  {
    BodySM* bsm = old_body_list.get_and_step()->get_body_sm_ptr();
    if(bsm)
      body_sms.append_unique(bsm);
  }
  
  if(!preview)
  {
    do_attribute_setup();
    push_attributes_before_modify(body_sms);
  }

  // Do chamfering
  DLIList<BodySM*> new_bodysm_list;
  CubitStatus stat = gme_ptr->tweak_chamfer( point_list, offset1, new_bodysm_list, curve1, offset2,
                                            curve2, offset3, curve3, keep_old_body, preview );
  
  if(stat == CUBIT_FAILURE)
  {
    if( CubitUndo::get_undo_enabled() )
      CubitUndo::remove_last_undo();
    if(!preview)
    {
      remove_pushed_attributes(new_bodysm_list, old_body_list);
      do_attribute_cleanup();
    }
    return stat;
  }
  else
  {
    if(!preview)
    {
      restore_vg_after_modify(new_bodysm_list, old_body_list, gme_ptr);
      remove_pushed_attributes(new_bodysm_list, old_body_list);
    }
  }
  
  if( preview == CUBIT_FALSE )
  {
    // Update DAG
    stat = finish_sm_op( old_body_list, new_bodysm_list, new_body_list );

    if( CubitUndo::get_undo_enabled()  )
    {
      if( stat == CUBIT_FAILURE )
        CubitUndo::remove_last_undo();
      else if( keep_old_body )
        CubitUndo::note_result_bodies( new_body_list );
    }
    do_attribute_cleanup();
    return stat;
  }

  return CUBIT_SUCCESS;
}
CubitStatus GeometryModifyTool::tweak_fillet ( DLIList< RefEdge * > &  ref_edge_list,
double  radius,
DLIList< Body * > &  new_body_list,
CubitBoolean  keep_old_body = CUBIT_FALSE,
CubitBoolean  preview = CUBIT_FALSE 
)

Creates a round fillet (or blend) at the given curves on solid or sheet bodies.

Definition at line 15011 of file GeometryModifyTool.cpp.

{
  DLIList<Curve*> curve_list(ref_edge_list.size());
  DLIList<Body*> old_body_list;
  GeometryModifyEngine* gme_ptr;

  gme_ptr = tweak_setup( ref_edge_list, "Filleting", old_body_list, curve_list, CUBIT_TRUE );
  if( !gme_ptr )
    return CUBIT_FAILURE;

  if( CubitUndo::get_undo_enabled() && preview == CUBIT_FALSE )
  {
    if( keep_old_body )
      CubitUndo::save_state();
    else
      CubitUndo::save_state_with_cubit_file( ref_edge_list );
  }

  DLIList<BodySM*> body_sms;
  for(int i=old_body_list.size(); i--;)
  {
    BodySM* bsm = old_body_list.get_and_step()->get_body_sm_ptr();
    if(bsm)
      body_sms.append_unique(bsm);
  }
  
  if(!preview)
  {
    do_attribute_setup();
    push_attributes_before_modify(body_sms);
  }

  // Do filleting
  DLIList<BodySM*> new_bodysm_list;
  CubitStatus stat = gme_ptr->tweak_fillet(curve_list, radius, new_bodysm_list, keep_old_body,
                                           preview );
  
  if(stat == CUBIT_FAILURE )
  {
    if(!preview)
    {
      if( CubitUndo::get_undo_enabled() )
        CubitUndo::remove_last_undo();
      remove_pushed_attributes(new_bodysm_list, old_body_list);
      do_attribute_cleanup();
    }
    return stat;
  }
  else
  {
    if(!preview)
    {
      restore_vg_after_modify(new_bodysm_list, old_body_list, gme_ptr);
      remove_pushed_attributes(new_bodysm_list, old_body_list);
    }
  }
  
  if( preview == CUBIT_FALSE )
  {
    // Update DAG
    stat = finish_sm_op( old_body_list, new_bodysm_list, new_body_list );

    if( CubitUndo::get_undo_enabled() )
    {
      if( stat == CUBIT_FAILURE )
        CubitUndo::remove_last_undo();
      else if( keep_old_body )
        CubitUndo::note_result_bodies( new_body_list );
    }
    do_attribute_cleanup();

    return stat;
  }
  return CUBIT_SUCCESS;
}
CubitStatus GeometryModifyTool::tweak_fillet ( RefEdge ref_edge_ptr,
double  start_radius,
double  end_radius,
Body *&  new_body_ptr,
CubitBoolean  keep_old_body = CUBIT_FALSE,
CubitBoolean  preview = CUBIT_FALSE 
)

Creates a round fillet (or blend) at the given curve.

Creates a round fillet (or blend) at the given curve on a solid or sheet body. The fillet has a variable radius from the start to the end of the curve.

Definition at line 15098 of file GeometryModifyTool.cpp.

{
  DLIList<Curve*> curve_list(1);
  DLIList<Body*> old_body_list;
  GeometryModifyEngine* gme_ptr;

  DLIList<RefEdge*> ref_edge_list(1);
  ref_edge_list.append( ref_edge_ptr );

  gme_ptr = tweak_setup( ref_edge_list, "Filleting", old_body_list, curve_list, CUBIT_TRUE );
  if( !gme_ptr )
    return CUBIT_FAILURE;

  if( CubitUndo::get_undo_enabled() && preview == CUBIT_FALSE )
  {
    if( keep_old_body )
      CubitUndo::save_state();
    else
    {
      DLIList<RefEdge*> edges(1);
      edges.append( ref_edge_ptr );
      CubitUndo::save_state_with_cubit_file( edges );
    }
  }
  
  DLIList<BodySM*> body_sms;
  for(int i=old_body_list.size(); i--;)
  {
    BodySM* bsm = old_body_list.get_and_step()->get_body_sm_ptr();
    if(bsm)
      body_sms.append_unique(bsm);
  }
  
  if(!preview)
  {
    do_attribute_setup();
    push_attributes_before_modify(body_sms);
  }

  // Do filleting
  BodySM *new_bodysm_ptr;
  Curve *curve_ptr = curve_list.get();
  CubitStatus stat = gme_ptr->tweak_fillet( curve_ptr, start_radius,
                                            end_radius, new_bodysm_ptr,
                                            keep_old_body, preview );

  if( CubitUndo::get_undo_enabled() )
    if( stat == CUBIT_FAILURE)
      CubitUndo::remove_last_undo();

  DLIList<BodySM*> new_bodysm_list;
  new_bodysm_list.append(new_bodysm_ptr);
  if( stat == CUBIT_FAILURE )
  {
    remove_pushed_attributes(new_bodysm_list, old_body_list);
    do_attribute_cleanup();
    return stat;
  }
  else
  {
    restore_vg_after_modify(new_bodysm_list, old_body_list, gme_ptr);
    remove_pushed_attributes(new_bodysm_list, old_body_list);
  }

  if( preview == CUBIT_FALSE )
  {
    // Update DAG
    DLIList<BodySM*> new_bodysm_list;
    new_bodysm_list.append( new_bodysm_ptr );
    DLIList<Body*> new_body_list;
    stat = finish_sm_op( old_body_list, new_bodysm_list, new_body_list );

    if( CubitUndo::get_undo_enabled()  )
    {
      if( stat == CUBIT_FAILURE )
        CubitUndo::remove_last_undo();
      else if( keep_old_body )
        CubitUndo::note_result_bodies( new_body_list );
    }

    new_body_ptr = new_body_list.get();

    do_attribute_cleanup();

    return stat;
  }
  return CUBIT_SUCCESS;
}
CubitStatus GeometryModifyTool::tweak_fillet ( DLIList< RefVertex * > &  ref_vertex_list,
double  radius,
DLIList< Body * > &  new_body_list,
CubitBoolean  keep_old_body = CUBIT_FALSE,
CubitBoolean  preview = CUBIT_FALSE 
)

Create a round fillet (or blend) at the given vertices on sheet bodies.

Definition at line 15199 of file GeometryModifyTool.cpp.

{
  DLIList<TBPoint*> point_list(ref_vertex_list.size());
  DLIList<Body*> old_body_list;
  GeometryModifyEngine* gme_ptr;

  gme_ptr = tweak_setup( ref_vertex_list, "Filleting", old_body_list, point_list, CUBIT_TRUE );
  if( !gme_ptr )
    return CUBIT_FAILURE;

  if( CubitUndo::get_undo_enabled() && preview == CUBIT_FALSE )
  {
    if( keep_old_body )
      CubitUndo::save_state();
    else
      CubitUndo::save_state_with_cubit_file( ref_vertex_list );
  }
  
  DLIList<BodySM*> body_sms;
  for(int i=old_body_list.size(); i--;)
  {
    BodySM* bsm = old_body_list.get_and_step()->get_body_sm_ptr();
    if(bsm)
      body_sms.append_unique(bsm);
  }
  
  if(!preview)
  {
    do_attribute_setup();
    push_attributes_before_modify(body_sms);
  }

  // Do filleting
  DLIList<BodySM*> new_bodysm_list;
  CubitStatus stat = gme_ptr->tweak_fillet( point_list, radius,
                                            new_bodysm_list, keep_old_body,
                                            preview );
  if(stat == CUBIT_FAILURE )
  {
    if(!preview)
    {
      if( CubitUndo::get_undo_enabled() )
        CubitUndo::remove_last_undo();
      remove_pushed_attributes(new_bodysm_list, old_body_list);
      do_attribute_cleanup();
    }
    return stat;
  }
  else
  {
    if(!preview)
    {
      restore_vg_after_modify(new_bodysm_list, old_body_list, gme_ptr);
      remove_pushed_attributes(new_bodysm_list, old_body_list);
    }
  }

  if( preview == CUBIT_FALSE )
  {
    // Update DAG
    stat = finish_sm_op( old_body_list, new_bodysm_list, new_body_list );

    if( CubitUndo::get_undo_enabled()  )
    {
      if( stat == CUBIT_FAILURE )
        CubitUndo::remove_last_undo();
      else if( keep_old_body )
        CubitUndo::note_result_bodies( new_body_list );
    }
    
    do_attribute_cleanup();

    return stat;
  }
  return CUBIT_SUCCESS;
}
CubitStatus GeometryModifyTool::tweak_move ( DLIList< RefFace * > &  ref_face_list,
const CubitVector delta,
DLIList< Body * > &  new_body_list,
CubitBoolean  keep_old_body = CUBIT_FALSE,
CubitBoolean  preview = CUBIT_FALSE 
)

Tweak specified faces of a volume or volumes along a vector.

Definition at line 15285 of file GeometryModifyTool.cpp.

{
  DLIList<Surface*> surface_list(ref_face_list.size());
  DLIList<Body*> old_body_list;
  GeometryModifyEngine* gme_ptr;

  gme_ptr = tweak_setup( ref_face_list, "Moving", old_body_list, surface_list, CUBIT_TRUE );
  if (!gme_ptr)
    return CUBIT_FAILURE;

  if( CubitUndo::get_undo_enabled() && preview == CUBIT_FALSE )
  {
    if( keep_old_body )
      CubitUndo::save_state();
    else
    {
      int i;
      DLIList<RefEdge*> ref_edges;
      for( i=ref_face_list.size(); i--; )
        ref_face_list.get_and_step()->ref_edges( ref_edges );
      ref_edges.uniquify_unordered();
      CubitUndo::save_state_with_cubit_file( ref_edges );
    }
  }

  int i;
  DLIList<BodySM*> body_sms;
  for(i=old_body_list.size(); i--;)
  {
    BodySM* bsm = old_body_list.get_and_step()->get_body_sm_ptr();
    if(bsm)
      body_sms.append_unique(bsm);
  }

  if(!preview)
  {
    do_attribute_setup();
    push_attributes_before_modify(body_sms);
  }

  // Do move
  DLIList<BodySM*> new_bodysm_list;
  CubitStatus stat = gme_ptr->tweak_move( surface_list, delta,
                                          new_bodysm_list, keep_old_body,
                                          preview );


  if( CubitUndo::get_undo_enabled() )
    if( stat == CUBIT_FAILURE)
      CubitUndo::remove_last_undo();

  if( stat == CUBIT_FAILURE )
  {
    if(!preview)
    {
      remove_pushed_attributes(new_bodysm_list, old_body_list);
      do_attribute_cleanup();
    }
    return stat;
  }
  else
  {
    if(!preview)
    {
      restore_vg_after_modify(new_bodysm_list, old_body_list, gme_ptr);
      remove_pushed_attributes(new_bodysm_list, old_body_list);
    }
  }

  // loop body sm list and find surfaces that need updating.
  // this is to account for some cases where the topology doesn't change, but the geometry does.
  DLIList<RefEntity*> entities_to_update;
  for(i=0; i<new_bodysm_list.size(); i++)
  {
    BodySM* bodysm = new_bodysm_list.get_and_step();
    DLIList<Surface*> surfs;
    bodysm->surfaces(surfs);
    int j;
    // find a surface that is also found in our input list
    for(j=0; j<surfs.size(); j++, surfs.step())
    {
      BridgeManager* man = surfs.get()->bridge_manager();
      if(man)
      {
        RefFace* ref_face = CAST_TO(man->topology_entity(), RefFace);
        if(ref_face && ref_face_list.is_in_list(ref_face))
        {
          // get neighbors
          DLIList<TBPoint*> neighbor_points;
          surfs.get()->points(neighbor_points);
          DLIList<Curve*> neighbor_curves;
          DLIList<Surface*> neighbor_surfaces;
          DLIList<TopologyBridge*> neighbors;
          DLIList<TopologyBridge*> tmp;
          int k;
          for(k=0; k<neighbor_points.size(); k++)
            neighbor_points.get_and_step()->surfaces(neighbor_surfaces);
          for(k=0; k<neighbor_points.size(); k++)
            neighbor_points.get_and_step()->curves(neighbor_curves);

          CAST_LIST_TO_PARENT(neighbor_points, tmp);
          neighbors += tmp;
          neighbor_curves.uniquify_ordered();
          CAST_LIST_TO_PARENT(neighbor_curves, tmp);
          neighbors += tmp;
          neighbor_surfaces.uniquify_ordered();
          CAST_LIST_TO_PARENT(neighbor_surfaces, tmp);
          neighbors += tmp;
          neighbors.append(surfs.get()->lump());
          neighbors.append(surfs.get()->bodysm());

          for(k=0; k<neighbors.size(); k++)
            if(BridgeManager* m = neighbors.get_and_step()->bridge_manager())
              if(TopologyEntity* t = m->topology_entity())
                entities_to_update.append(CAST_TO(t, RefEntity));
        }
      }
    }
  }

  if( preview == CUBIT_FALSE )
  {
    // Update DAG
    stat = finish_sm_op( old_body_list, new_bodysm_list, new_body_list );

    if( CubitUndo::get_undo_enabled()  )
    {
      if( stat == CUBIT_FAILURE )
        CubitUndo::remove_last_undo();
      else if( keep_old_body )
        CubitUndo::note_result_bodies( new_body_list );
    }

    // Update graphics
    while (entities_to_update.size())
      AppUtil::instance()->send_event(GeometryEvent(GeometryEvent::GEOMETRY_MODIFIED, entities_to_update.pop()));

    do_attribute_cleanup();
  }


  //collect all the new faces
  DLIList<RefFace*> new_faces;
  for( i=new_body_list.size(); i--; )
  {
    Body *new_body = new_body_list.get_and_step();
    DLIList<RefFace*> tmp_faces;
    new_body->ref_faces( tmp_faces );
    new_faces += tmp_faces;
  }

  //unmerge any merged adjacent surfaces or
  //merged curves in unmerged adjacent surfaces
  DLIList<RefFace*> adjacent_faces_to_unmerge;
  DLIList<RefEdge*> adjacent_edges_to_unmerge;
  for(i=ref_face_list.size(); i--;)
  {
    RefFace *tweaked_face = ref_face_list.get_and_step();
    if( !new_faces.move_to( tweaked_face ) )
      continue;

    //get all the edges of the face you tweaked
    DLIList<RefEdge*> tweaked_face_edges;
    tweaked_face->ref_edges( tweaked_face_edges );
    adjacent_edges_to_unmerge += tweaked_face_edges;

    //get all the adjacent faces to this edge
    int j;
    for( j=tweaked_face_edges.size(); j--; )
    {
      RefEdge *tmp_edge = tweaked_face_edges.get_and_step();
      DLIList<RefFace*> tmp_faces;
      tmp_edge->ref_faces( tmp_faces );
      tmp_faces.remove( tweaked_face );
      adjacent_faces_to_unmerge += tmp_faces;
    }

    //get all edges not in the surface,
    //sharing vertices with the surface
    DLIList<RefVertex*> ref_vertices;
    tweaked_face->ref_vertices( ref_vertices );
    for( j=ref_vertices.size(); j--; )
    {
      RefVertex *tmp_vert = ref_vertices.get_and_step();
      DLIList<RefEdge*>  ref_edges;
      tmp_vert->ref_edges( ref_edges );

      int k;
      for( k=ref_edges.size(); k--; )
      {
        RefEdge *tmp_edge = ref_edges.get_and_step();
        if( !tweaked_face_edges.move_to( tmp_edge ) )
          adjacent_edges_to_unmerge.append( tmp_edge );
      }
    }
  }

  //unmerge any adjacent faces
  adjacent_faces_to_unmerge.uniquify_unordered();
  for( i=adjacent_faces_to_unmerge.size(); i--; )
  {
    RefFace *ref_face = adjacent_faces_to_unmerge.get_and_step();

    DLIList<TopologyBridge*> bridge_list;
    ref_face->bridge_manager()->get_bridge_list(bridge_list);
    if (bridge_list.size() > 1)
    {
      if( MergeTool::instance()->unmerge( ref_face ) )
        PRINT_WARNING("Unmerging Surface %d\n", ref_face->id() );
    }
  }

  //unmerge any adjacent edges
  adjacent_edges_to_unmerge.uniquify_unordered();
  for( i=adjacent_edges_to_unmerge.size(); i--; )
  {
    RefEdge *ref_edge = adjacent_edges_to_unmerge.get_and_step();
    DLIList<TopologyBridge*> bridge_list;
    ref_edge->bridge_manager()->get_bridge_list(bridge_list);
    if (bridge_list.size() > 1)
    {
      if( MergeTool::instance()->unmerge( ref_edge) )
        PRINT_WARNING("Unmerging Curve %d\n", ref_edge->id() );
    }
  }


  return stat;
}
CubitStatus GeometryModifyTool::tweak_move ( DLIList< RefEdge * > &  ref_edge_list,
const CubitVector delta,
DLIList< Body * > &  new_body_list,
CubitBoolean  keep_old_body = CUBIT_FALSE,
CubitBoolean  preview = CUBIT_FALSE 
)

Tweak specified curves of a sheet body along a vector.

Definition at line 15524 of file GeometryModifyTool.cpp.

{
  DLIList<Curve*> curve_list(ref_edge_list.size());
  DLIList<Body*> old_body_list;
  GeometryModifyEngine* gme_ptr;

  gme_ptr = tweak_setup( ref_edge_list, "Moving", old_body_list, curve_list );
  if (!gme_ptr)
    return CUBIT_FAILURE;

  if( CubitUndo::get_undo_enabled() && preview == CUBIT_FALSE )
  {
    if( keep_old_body )
      CubitUndo::save_state();
    else
      CubitUndo::save_state_with_cubit_file( ref_edge_list );
  }

  // Do move
  DLIList<BodySM*> new_bodysm_list;
  CubitStatus stat = gme_ptr->tweak_move( curve_list, delta,
                                          new_bodysm_list, keep_old_body,
                                          preview );

  if( CubitUndo::get_undo_enabled() )
    if( stat == CUBIT_FAILURE)
      CubitUndo::remove_last_undo();

  if( stat == CUBIT_FAILURE )
    return stat;

  if( preview == CUBIT_FALSE )
  {
    // Update DAG
    stat = finish_sm_op( old_body_list, new_bodysm_list, new_body_list );

    if( CubitUndo::get_undo_enabled()  )
    {
      if( stat == CUBIT_FAILURE )
        CubitUndo::remove_last_undo();
      else if( keep_old_body )
        CubitUndo::note_result_bodies( new_body_list );
    }
  }

  // Update graphics
  DLIList<Body*> moved_bodies(new_body_list);
  moved_bodies.intersect(old_body_list);
  while (moved_bodies.size())
    moved_bodies.pop()->notify_sub_all_observers( GeometryEvent::GEOMETRY_MODIFIED );

  return stat;
}
CubitStatus GeometryModifyTool::tweak_offset ( DLIList< RefFace * > &  ref_face_list,
double  offset_distance,
DLIList< RefFace * > *  add_ref_face_list_ptr,
DLIList< double > *  add_offset_list_ptr,
DLIList< Body * > &  new_body_list,
CubitBoolean  keep_old_body = CUBIT_FALSE,
CubitBoolean  preview = CUBIT_FALSE 
)

Offsets a surface(s) on a volume(s).

Tweak specified faces of a volume or volumes by offsetting those faces by the offset distance. Optionally supply additional faces with different offset distances.

Definition at line 15588 of file GeometryModifyTool.cpp.

{
  DLIList<RefFace*> all_ref_face_list(ref_face_list.size());
  all_ref_face_list = ref_face_list;
  if( add_ref_face_list_ptr->size() )
    all_ref_face_list += *add_ref_face_list_ptr;

  DLIList<Surface*> surface_list(ref_face_list.size());
  DLIList<Body*> old_body_list;
  GeometryModifyEngine* gme_ptr;

  gme_ptr = tweak_setup( ref_face_list, "Offsetting", old_body_list, surface_list, CUBIT_TRUE );
  if (!gme_ptr)
    return CUBIT_FAILURE;

  DLIList<Surface*> add_surface_list;
  if( add_ref_face_list_ptr && add_ref_face_list_ptr->size() )
  {
    DLIList<Body*> old_body_list2;
    GeometryModifyEngine* gme_ptr2 = tweak_setup( *add_ref_face_list_ptr, "Offsetting",
      old_body_list2, add_surface_list, CUBIT_TRUE );
    if (!gme_ptr2)
      return CUBIT_FAILURE;
    if( gme_ptr != gme_ptr2 )
    {
      PRINT_ERROR("Offsetting surfaces on volumes containing surfaces from different\n"
        "       geometry engines is not allowed.\n");
      return CUBIT_FAILURE;
    }
    old_body_list.merge_unique( old_body_list2 );
  }

  if( CubitUndo::get_undo_enabled() && preview == CUBIT_FALSE )
  {
    if( keep_old_body )
      CubitUndo::save_state();
    else
    {
      int i;
      DLIList<RefEdge*> ref_edges;
      for( i=ref_face_list.size(); i--; )
        all_ref_face_list.get_and_step()->ref_edges( ref_edges );
      ref_edges.uniquify_unordered();
      CubitUndo::save_state_with_cubit_file( ref_edges );
    }
  }

  int i;
  if(!preview)
  {
    DLIList<BodySM*> body_sms;
    for(i=old_body_list.size(); i--;)
    {
      BodySM* bsm = old_body_list.get_and_step()->get_body_sm_ptr();
      if(bsm)
        body_sms.append_unique(bsm);
    }

    do_attribute_setup();
    push_attributes_before_modify(body_sms);
  }

  // Do offset
  DLIList<BodySM*> new_bodysm_list;
  CubitStatus stat;
  if( add_surface_list.size() )
    stat = gme_ptr->tweak_offset( surface_list, offset_distance,
                                  &add_surface_list, add_offset_list_ptr,
                                  new_bodysm_list, keep_old_body, preview );
  else
    stat = gme_ptr->tweak_offset( surface_list, offset_distance, NULL, NULL,
                                  new_bodysm_list, keep_old_body, preview );

  if( CubitUndo::get_undo_enabled() )
    if( stat == CUBIT_FAILURE)
      CubitUndo::remove_last_undo();

  if( stat == CUBIT_FAILURE )
  {
    if(!preview)
    {
      remove_pushed_attributes(new_bodysm_list, old_body_list);
      do_attribute_cleanup();
    }
    return stat;
  }
  else
  {
    if(!preview)
    {
      restore_vg_after_modify(new_bodysm_list, old_body_list, gme_ptr);
      remove_pushed_attributes(new_bodysm_list, old_body_list);
    }
  }

  // Collect all of the old faces to be compared later with the new faces...DJQ
  DLIList<RefFace*> old_faces;
  for (i = 0; i < old_body_list.size(); i++)
  {
      Body *old_body = old_body_list.get_and_step();
      DLIList<RefFace*> tmp_faces;
      old_body->ref_faces(tmp_faces);
      old_faces +=tmp_faces;
  }

  if( preview == CUBIT_FALSE )
  {
    // Update DAG
    stat = finish_sm_op( old_body_list, new_bodysm_list, new_body_list );

    if( CubitUndo::get_undo_enabled()  )
    {
      if( stat == CUBIT_FAILURE )
        CubitUndo::remove_last_undo();
      else if( keep_old_body )
        CubitUndo::note_result_bodies( new_body_list );
    }
    do_attribute_cleanup();
  }

  //collect all the new faces
  DLIList<RefFace*> new_faces;
  for( i=new_body_list.size(); i--; )
  {
    Body *new_body = new_body_list.get_and_step();
    DLIList<RefFace*> tmp_faces;
    new_body->ref_faces( tmp_faces );
    new_faces += tmp_faces;
  }

  // Compare the new_faces list with the old_faces list to determine which faces are created
  // Add these faces to the all_ref_face_list to check for its neighbors...DJQ
  DLIList<RefFace*> difference = new_faces;
  difference -= old_faces;
  all_ref_face_list += difference;

  // loop body sm list and find surfaces that need updating.
  // this is to account for some cases where the topology
  //doesn't change, but the geometry does.

  DLIList<RefEntity*> entities_to_update;
  for(i=0; i<new_bodysm_list.size(); i++)
  {
    BodySM* bodysm = new_bodysm_list.get_and_step();
    DLIList<Surface*> surfs;
    bodysm->surfaces(surfs);
    int j;
    // find a surface that is also found in our input list
    for(j=0; j<surfs.size(); j++, surfs.step())
    {
      BridgeManager* man = surfs.get()->bridge_manager();
      if(man)
      {
        RefFace* ref_face = CAST_TO(man->topology_entity(), RefFace);
        if(ref_face && all_ref_face_list.is_in_list(ref_face))
        {
          // get neighbors
          DLIList<TBPoint*> neighbor_points;
          surfs.get()->points(neighbor_points);
          DLIList<Curve*> neighbor_curves;
          DLIList<Surface*> neighbor_surfaces;
          DLIList<TopologyBridge*> neighbors;
          DLIList<TopologyBridge*> tmp;
          int k;
          for(k=0; k<neighbor_points.size(); k++)
            neighbor_points.get_and_step()->surfaces(neighbor_surfaces);
          for(k=0; k<neighbor_points.size(); k++)
            neighbor_points.get_and_step()->curves(neighbor_curves);

          CAST_LIST_TO_PARENT(neighbor_points, tmp);
          neighbors += tmp;
          neighbor_curves.uniquify_ordered();
          CAST_LIST_TO_PARENT(neighbor_curves, tmp);
          neighbors += tmp;
          neighbor_surfaces.uniquify_ordered();
          CAST_LIST_TO_PARENT(neighbor_surfaces, tmp);
          neighbors += tmp;
          neighbors.append(surfs.get()->lump());
          neighbors.append(surfs.get()->bodysm());

          for(k=0; k<neighbors.size(); k++)
            if(BridgeManager* m = neighbors.get_and_step()->bridge_manager())
              if(TopologyEntity* t = m->topology_entity())
                entities_to_update.append(CAST_TO(t, RefEntity));
        }
      }
    }
  }


  //unmerge any merged adjacent surfaces or
  //merged curves in unmerged adjacent surfaces
  DLIList<RefFace*> adjacent_faces_to_unmerge;
  DLIList<RefEdge*> adjacent_edges_to_unmerge;
  for(i=ref_face_list.size(); i--;)
  {
    RefFace *tweaked_face = ref_face_list.get_and_step();
    if( !new_faces.move_to( tweaked_face ) )
      continue;

    //get all the edges of the face you tweaked
    DLIList<RefEdge*> tweaked_face_edges;
    tweaked_face->ref_edges( tweaked_face_edges );
    adjacent_edges_to_unmerge += tweaked_face_edges;

    //get all the adjacent faces to this edge
    int j;
    for( j=tweaked_face_edges.size(); j--; )
    {
      RefEdge *tmp_edge = tweaked_face_edges.get_and_step();
      DLIList<RefFace*> tmp_faces;
      tmp_edge->ref_faces( tmp_faces );
      tmp_faces.remove( tweaked_face );
      adjacent_faces_to_unmerge += tmp_faces;
    }

    //get all edges not in the surface,
    //sharing vertices with the surface
    DLIList<RefVertex*> ref_vertices;
    tweaked_face->ref_vertices( ref_vertices );
    for( j=ref_vertices.size(); j--; )
    {
      RefVertex *tmp_vert = ref_vertices.get_and_step();
      DLIList<RefEdge*>  ref_edges;
      tmp_vert->ref_edges( ref_edges );

      int k;
      for( k=ref_edges.size(); k--; )
      {
        RefEdge *tmp_edge = ref_edges.get_and_step();
        if( !tweaked_face_edges.move_to( tmp_edge ) )
          adjacent_edges_to_unmerge.append( tmp_edge );
      }
    }
  }

  //unmerge any adjacent faces
  adjacent_faces_to_unmerge.uniquify_unordered();
  for( i=adjacent_faces_to_unmerge.size(); i--; )
  {
    RefFace *ref_face = adjacent_faces_to_unmerge.get_and_step();

    DLIList<TopologyBridge*> bridge_list;
    ref_face->bridge_manager()->get_bridge_list(bridge_list);
    if (bridge_list.size() > 1)
    {
      if( MergeTool::instance()->unmerge( ref_face ) )
        PRINT_WARNING("Unmerging Surface %d\n", ref_face->id() );
    }
  }

  //unmerge any adjacent edges
  adjacent_edges_to_unmerge.uniquify_unordered();
  for( i=adjacent_edges_to_unmerge.size(); i--; )
  {
    RefEdge *ref_edge = adjacent_edges_to_unmerge.get_and_step();
    DLIList<TopologyBridge*> bridge_list;
    ref_edge->bridge_manager()->get_bridge_list(bridge_list);
    if (bridge_list.size() > 1)
    {
      if( MergeTool::instance()->unmerge( ref_edge) )
        PRINT_WARNING("Unmerging Curve %d\n", ref_edge->id() );
    }
  }

  // Update graphics
  while (entities_to_update.size())
    AppUtil::instance()->send_event(GeometryEvent(GeometryEvent::GEOMETRY_MODIFIED, entities_to_update.pop()));

  return stat;
}
CubitStatus GeometryModifyTool::tweak_offset ( DLIList< RefEdge * > &  ref_edge_list,
double  offset_distance,
DLIList< RefEdge * > *  add_ref_face_list_ptr,
DLIList< double > *  add_offset_list_ptr,
DLIList< Body * > &  new_body_list,
CubitBoolean  keep_old_body = CUBIT_FALSE,
CubitBoolean  preview = CUBIT_FALSE 
)

Offset curves on sheet bodies.

Tweak specified curves of a sheet body or bodies by offsetting those curves by the offset distance. Optionally supply additional curves with different offset distances.

Definition at line 15872 of file GeometryModifyTool.cpp.

{
  DLIList<RefEdge*> all_ref_edge_list(ref_edge_list.size());
  all_ref_edge_list = ref_edge_list;
  if( add_ref_edge_list_ptr )
    all_ref_edge_list += *add_ref_edge_list_ptr;

  DLIList<Curve*> curve_list(ref_edge_list.size());
  DLIList<Body*> old_body_list;
  GeometryModifyEngine* gme_ptr;

  gme_ptr = tweak_setup( ref_edge_list, "Offsetting", old_body_list, curve_list );
  if (!gme_ptr)
    return CUBIT_FAILURE;

  DLIList<Curve*> add_curve_list;
  if( add_ref_edge_list_ptr && add_ref_edge_list_ptr->size() )
  {
    DLIList<Body*> old_body_list2;
    GeometryModifyEngine* gme_ptr2 = tweak_setup( *add_ref_edge_list_ptr, "Offsetting",
      old_body_list2, add_curve_list );
    if (!gme_ptr2)
      return CUBIT_FAILURE;
    if( gme_ptr != gme_ptr2 )
    {
      PRINT_ERROR("Offsetting curves on entities containing surfaces from different\n"
      "       geometry engines is not allowed.\n");
      return CUBIT_FAILURE;
    }
    old_body_list.merge_unique( old_body_list2 );
  }

  if( CubitUndo::get_undo_enabled() && preview == CUBIT_FALSE )
  {
    if( keep_old_body )
      CubitUndo::save_state();
    else
      CubitUndo::save_state_with_cubit_file( all_ref_edge_list );
  }

  // Do offset
  DLIList<BodySM*> new_bodysm_list;
  CubitStatus stat;
  if( add_curve_list.size() )
    stat = gme_ptr->tweak_offset( curve_list, offset_distance, &add_curve_list,
    add_offset_list_ptr, new_bodysm_list, keep_old_body, preview );
  else
    stat = gme_ptr->tweak_offset( curve_list, offset_distance, NULL, NULL,
    new_bodysm_list, keep_old_body, preview );

  if( CubitUndo::get_undo_enabled() && preview == CUBIT_FALSE )
    if( stat == CUBIT_FAILURE)
      CubitUndo::remove_last_undo();

  if( stat == CUBIT_FAILURE )
    return CUBIT_FAILURE;

  DLIList<RefEntity*> entities_to_update;
  if( preview == CUBIT_FALSE )
  {
    // check for resued entities, they have been moved and we need to notify observers
    for(int i=0; i<new_bodysm_list.size(); i++)
    {
      BodySM* bodysm = new_bodysm_list.get_and_step();
      DLIList<TopologyBridge*> to_check;
      DLIList<TopologyBridge*> tmp;
      DLIList<Surface*> surfs;
      bodysm->surfaces(surfs);
      DLIList<Curve*> curves;
      bodysm->curves(curves);
      DLIList<TBPoint*> points;
      bodysm->points(points);
      to_check.append(bodysm);
      to_check.append(bodysm->lump());
      CAST_LIST_TO_PARENT(surfs, tmp);
      to_check += tmp;
      CAST_LIST_TO_PARENT(curves, tmp);
      to_check += tmp;
      CAST_LIST_TO_PARENT(points, tmp);
      to_check += tmp;

      int k;
      for(k=0; k<to_check.size(); k++)
        if(BridgeManager* m = to_check.get_and_step()->bridge_manager())
          if(TopologyEntity* t = m->topology_entity())
            entities_to_update.append(CAST_TO(t, RefEntity));
    }

    stat = finish_sm_op( old_body_list, new_bodysm_list, new_body_list );

    if( CubitUndo::get_undo_enabled()  )
    {
      if( stat == CUBIT_FAILURE )
        CubitUndo::remove_last_undo();
      else if( keep_old_body )
        CubitUndo::note_result_bodies( new_body_list );
    }
  }

  // Update graphics
  while (entities_to_update.size())
    AppUtil::instance()->send_event(GeometryEvent(GeometryEvent::GEOMETRY_MODIFIED, entities_to_update.pop()));

  // Update graphics
  DLIList<Body*> moved_bodies(new_body_list);
  moved_bodies.intersect(old_body_list);
  while (moved_bodies.size())
    moved_bodies.pop()->notify_sub_all_observers( GeometryEvent::GEOMETRY_MODIFIED );

  return stat;
}
CubitStatus GeometryModifyTool::tweak_remove ( DLIList< RefEdge * > &  ref_edge_list,
DLIList< Body * > &  new_body_list,
CubitBoolean  keep_old_body = CUBIT_FALSE,
CubitBoolean  preview = CUBIT_FALSE 
)

Removes a surface from a volume, extending neighboring surfaces.

Remove curves from a sheet body or bodies and then extend the remaining curves to fill the gap. If an internal loop of curves is removed the hole is removed.

Definition at line 16399 of file GeometryModifyTool.cpp.

{
  DLIList<Curve*> curve_list(ref_edge_list.size());
  DLIList<Body*> old_body_list;
  GeometryModifyEngine* gme_ptr;

  // clear any preview previews
  GfxPreview::clear();

  gme_ptr = tweak_setup( ref_edge_list, "Removing", old_body_list, curve_list );
  if( !gme_ptr )
    return CUBIT_FAILURE;

  if( CubitUndo::get_undo_enabled() && preview == CUBIT_FALSE )
  {
    if( keep_old_body )
      CubitUndo::save_state();
    else
      CubitUndo::save_state_with_cubit_file( ref_edge_list );
  }

  // Do remove
  DLIList<BodySM*> new_bodysm_list;
  CubitStatus stat = gme_ptr->tweak_remove( curve_list, new_bodysm_list,
                                            keep_old_body, preview );
  //collect all neighboring curves to those in the list
   int i, j;
   DLIList<RefEdge*> neighboring_curves;
   for( i=ref_edge_list.size(); i--; )
   {
     RefEdge *tmp_edge = ref_edge_list.get_and_step();
     DLIList<RefVertex*> tmp_ref_vertex_list;
     tmp_edge->ref_vertices( tmp_ref_vertex_list );
     for( j=tmp_ref_vertex_list.size(); j--; )
       tmp_ref_vertex_list.get_and_step()->ref_edges( neighboring_curves );
   }

  //uniquify and add other curves
  neighboring_curves.uniquify_unordered();
  //neighboring_curves += ref_edge_list;

  if( CubitUndo::get_undo_enabled() && preview == CUBIT_FALSE )
    if( stat == CUBIT_FAILURE )
      CubitUndo::remove_last_undo();

  if( stat == CUBIT_FAILURE)
    return stat;

  // loop body sm list and find curves that need updating.
  // this is to account for some cases where the topology doesn't change, but the geometry does.
  DLIList<RefEntity*> entities_to_update;
  for(i=0; i<new_bodysm_list.size(); i++)
  {
    BodySM* bodysm = new_bodysm_list.get_and_step();
    DLIList<Curve*> curves;
    bodysm->curves(curves);
    int j;
    // find a surface that is also found in our input list
    for(j=0; j<curves.size(); j++, curves.step())
    {
      BridgeManager* man = curves.get()->bridge_manager();
      if(man)
      {
        RefEdge* ref_edge = CAST_TO(man->topology_entity(), RefEdge);
        if( ref_edge && neighboring_curves.is_in_list(ref_edge) )
        {
          // get neighbors
          DLIList<TBPoint*> neighbor_points;
          curves.get()->points(neighbor_points);
          DLIList<Curve*> neighbor_curves;
          DLIList<Surface*> neighbor_surfaces;
          DLIList<TopologyBridge*> neighbors;
          DLIList<TopologyBridge*> tmp;
          int k;
          for(k=0; k<neighbor_points.size(); k++)
            neighbor_points.get_and_step()->surfaces(neighbor_surfaces);
          for(k=0; k<neighbor_points.size(); k++)
            neighbor_points.get_and_step()->curves(neighbor_curves);

          CAST_LIST_TO_PARENT(neighbor_points, tmp);
          neighbors += tmp;
          neighbor_curves.uniquify_ordered();
          CAST_LIST_TO_PARENT(neighbor_curves, tmp);
          neighbors += tmp;
          neighbor_surfaces.uniquify_ordered();
          CAST_LIST_TO_PARENT(neighbor_surfaces, tmp);
          neighbors += tmp;
          //neighbors.append(curves.get()->lump());
          //neighbors.append(curves.get()->bodysm());

          for(k=0; k<neighbors.size(); k++)
          {
            if(BridgeManager* m = neighbors.get_and_step()->bridge_manager())
            {
              if(TopologyEntity* t = m->topology_entity())
              {
                RefEntity *ref_ent = CAST_TO(t, RefEntity );
                entities_to_update.append(ref_ent);
              }
            }
          }
        }
      }
    }
  }

  if(preview == CUBIT_FALSE )
  {
    // Update DAG
    stat = finish_sm_op( old_body_list, new_bodysm_list, new_body_list );

    // Update graphics
    while (entities_to_update.size())
      AppUtil::instance()->send_event(GeometryEvent(GeometryEvent::GEOMETRY_MODIFIED, entities_to_update.pop()));

    if( CubitUndo::get_undo_enabled()  )
    {
      if( stat == CUBIT_FAILURE )
        CubitUndo::remove_last_undo();
      else if( keep_old_body )
        CubitUndo::note_result_bodies( new_body_list );
    }
  }

  return stat;
}
CubitStatus GeometryModifyTool::tweak_remove ( DLIList< RefFace * > &  ref_face_list,
DLIList< Body * > &  new_body_list,
CubitBoolean  extend_adjoining = CUBIT_TRUE,
CubitBoolean  keep_surface = CUBIT_FALSE,
CubitBoolean  keep_old_body = CUBIT_FALSE,
CubitBoolean  preview = CUBIT_FALSE 
) [private]

Remove surfaces from a body or bodies and then extend the adjoining surfaces to fill the gap or remove the hole. Only called by tweak_remove_individually, tweak_remove_together.

Definition at line 16155 of file GeometryModifyTool.cpp.

{
   DLIList<Surface*> surface_list(ref_face_list.size());
   DLIList<Body*> old_body_list;
   GeometryModifyEngine* gme_ptr;

   // clear any preview previews
   GfxPreview::clear();

   //collect all neighboring surfaces to those in the list
   int i,j;
   DLIList<RefFace*> neighboring_surfaces;
   DLIList<RefEdge*> merged_ref_edges_before;
   for( i=ref_face_list.size(); i--; )
   {
     RefFace *tmp_face = ref_face_list.get_and_step();
     DLIList<RefEdge*> ref_edge_list;
     tmp_face->ref_edges( ref_edge_list );
     for( j=ref_edge_list.size(); j--; )
       ref_edge_list.get_and_step()->ref_faces( neighboring_surfaces );

     DLIList<RefVertex*> tmp_verts;
     tmp_face->ref_vertices( tmp_verts );
     for( j=tmp_verts.size(); j--; )
     {
       RefVertex *tmp_vert = tmp_verts.get_and_step();
       DLIList<RefEdge*> tmp_edges;
       tmp_vert->ref_edges( tmp_edges );
       int kk;
       for( kk=tmp_edges.size(); kk--; )
       {
         RefEdge *tmp_edge = tmp_edges.get_and_step();
         if( tmp_edge->is_merged() )
           merged_ref_edges_before.append( tmp_edge);
       }
     }
   }

  //uniquify and add other surfaces
  neighboring_surfaces.uniquify_unordered();
  neighboring_surfaces += ref_face_list;

   gme_ptr = tweak_setup( ref_face_list, "Removing", old_body_list, surface_list, CUBIT_TRUE );
   if (!gme_ptr)
     return CUBIT_FAILURE;

   DLIList<Surface*> kept_surface_list;
   if( keep_surface )
   {
     int kk;
     for( kk=surface_list.size(); kk--; )
     {
       Surface *new_surf = gme_ptr->make_Surface( surface_list.get_and_step() );
       kept_surface_list.append( new_surf );
     }
   }

   DLIList<BodySM*> body_sms;
   for(i=old_body_list.size(); i--;)
   {
     BodySM* bsm = old_body_list.get_and_step()->get_body_sm_ptr();
     if(bsm)
       body_sms.append_unique(bsm);
   }

   if(!preview)
   {
    do_attribute_setup();
    push_attributes_before_modify(body_sms);
   }

   // Do remove
   DLIList<BodySM*> new_bodysm_list;
   CubitStatus removal_status =
       gme_ptr->tweak_remove( surface_list,
                              new_bodysm_list,
                              extend_adjoining,
                              keep_old_body,
                              preview );


   if( removal_status == CUBIT_FAILURE )
   {
     if(!preview)
      remove_pushed_attributes(new_bodysm_list, old_body_list);
     if( keep_surface )
     {
       int kk;
       for( kk=kept_surface_list.size(); kk--; )
       {
         Surface *surf = kept_surface_list.get_and_step();
         gme_ptr->get_gqe()->delete_solid_model_entities( surf );
       }
     }
     if(!preview)
      do_attribute_cleanup();
     return CUBIT_FAILURE;
   }
   else
   {
     if(!preview)
     {
        restore_vg_after_modify(new_bodysm_list, old_body_list, gme_ptr);
        remove_pushed_attributes(new_bodysm_list, old_body_list);
     }
   }

  // for each new bodysm, find surfaces that need updating.
  // this is to account for some cases where the topology doesn't change, but the geometry does.
  DLIList<RefEntity*> entities_to_update;
  for(i=0; i<new_bodysm_list.size(); i++)
  {
    BodySM* bodysm = new_bodysm_list.get_and_step();
    DLIList<Surface*> surfs;
    bodysm->surfaces(surfs);
    int j;
    // find a surface that is also found in our input list
    for(j=0; j<surfs.size(); j++, surfs.step())
    {
      BridgeManager* man = surfs.get()->bridge_manager();
      if(man)
      {
        RefFace* ref_face = CAST_TO(man->topology_entity(), RefFace);
        if( ref_face && neighboring_surfaces.is_in_list(ref_face) )
        {
          // get neighbors
          DLIList<TBPoint*> neighbor_points;
          surfs.get()->points(neighbor_points);
          DLIList<Curve*> neighbor_curves;
          DLIList<Surface*> neighbor_surfaces;
          DLIList<TopologyBridge*> neighbors;
          DLIList<TopologyBridge*> tmp;
          int k;
          for(k=0; k<neighbor_points.size(); k++)
            neighbor_points.get_and_step()->surfaces(neighbor_surfaces);
          for(k=0; k<neighbor_points.size(); k++)
            neighbor_points.get_and_step()->curves(neighbor_curves);

          CAST_LIST_TO_PARENT(neighbor_points, tmp);
          neighbors += tmp;
          neighbor_curves.uniquify_ordered();
          CAST_LIST_TO_PARENT(neighbor_curves, tmp);
          neighbors += tmp;
          neighbor_surfaces.uniquify_ordered();
          CAST_LIST_TO_PARENT(neighbor_surfaces, tmp);
          neighbors += tmp;
          neighbors.append(surfs.get()->lump());
          neighbors.append(surfs.get()->bodysm());

          for(k=0; k<neighbors.size(); k++)
          {
            if(BridgeManager* m = neighbors.get_and_step()->bridge_manager())
            {
              if(TopologyEntity* t = m->topology_entity())
              {
                RefEntity *ref_ent = CAST_TO(t, RefEntity );
                entities_to_update.append(ref_ent);
              }
            }
          }
        }
      }
    }
  }


  DLIList<Body*> kept_surface_bodies;
  if( preview == CUBIT_FALSE && keep_surface )
  {
    int kk;
    for( kk=kept_surface_list.size(); kk--; )
    {
      Surface *surf = kept_surface_list.get_and_step();
      Body *new_body = make_Body( surf );
      kept_surface_bodies.append( new_body );
    }
  }

    // Update DAG
  CubitStatus stat = finish_sm_op( old_body_list, new_bodysm_list, new_body_list );

  if(!preview)
    do_attribute_cleanup();

  if( keep_surface )
    new_body_list += kept_surface_bodies;

  if( stat == CUBIT_FAILURE)
      return CUBIT_FAILURE;

    // Update graphics
  while (entities_to_update.size())
    AppUtil::instance()->send_event(GeometryEvent(GeometryEvent::GEOMETRY_MODIFIED, entities_to_update.pop()));


  //unmerge all curves attached to these vertices after
  DLIList<RefEdge*> merged_ref_edges_after;
  for( i=new_body_list.size(); i--; )
  {
    Body *new_body = new_body_list.get_and_step();
    DLIList<RefVertex*> tmp_verts;
    new_body->ref_vertices( tmp_verts);

    for( j=tmp_verts.size(); j--; )
    {
      RefVertex *tmp_vert = tmp_verts.get_and_step();
      DLIList<RefEdge*> tmp_edges;
      if( tmp_vert->is_merged() )
      {
        tmp_vert->ref_edges( tmp_edges );
        int k;
        for( k=tmp_edges.size(); k--; )
        {
          RefEdge *tmp_edge = tmp_edges.get_and_step();
          if( tmp_edge->is_merged() )
            merged_ref_edges_after.append( tmp_edge );
        }
      }
    }
  }

  merged_ref_edges_before.uniquify_unordered();
  for( i=merged_ref_edges_before.size(); i--; )
  {
    RefEdge *tmp_edge = merged_ref_edges_before.get_and_step();
    if( merged_ref_edges_after.is_in_list( tmp_edge ) )
      MergeTool::instance()->unmerge( tmp_edge );
  }

  return CUBIT_SUCCESS;
}
CubitStatus GeometryModifyTool::tweak_remove_individually ( DLIList< RefFace * > &  ref_face_list,
DLIList< Body * > &  new_body_list,
CubitBoolean  keep_surface = CUBIT_FALSE,
CubitBoolean  keep_old_body = CUBIT_FALSE,
CubitBoolean  preview = CUBIT_FALSE 
)

Performs tweak_remove operation on surfaces individually.

Definition at line 15991 of file GeometryModifyTool.cpp.

{
  if( CubitUndo::get_undo_enabled() && preview == CUBIT_FALSE )
  {
    if( keep_old_body )
      CubitUndo::save_state();
    else
      CubitUndo::save_state_with_cubit_file( ref_face_list );
  }

  // Split things up if individual
  //build a surfae to volume map
  std::map<RefFace*, RefVolume*> surface_to_volume_map;

  int i;
  for (i = ref_face_list.size(); i--; )
  {
    RefFace *tmp_face = ref_face_list.get_and_step();
    RefVolume *tmp_vol = tmp_face->ref_volume();
    surface_to_volume_map.insert( std::map<RefFace*, RefVolume*>::value_type( tmp_face, tmp_vol));
  }

  DLIList<RefFace*> one_ref_face;
  DLIList<Body*> tmp_new_body_list;
  CubitStatus total_rv = CUBIT_FAILURE;
  bool extend = true;

  // Succeed if any one surface succeeds.
  for (i = ref_face_list.size(); i--; )
  {
    //make sure that the surface to remove is still in the body...
    //that it hasn't been removed from a previous tweak operation
    RefFace *tmp_face = ref_face_list.get_and_step();
    std::map<RefFace*, RefVolume*>::iterator tmp_iter;
    tmp_iter = surface_to_volume_map.find( tmp_face );
    RefVolume *tmp_vol = tmp_iter->second;
    DLIList<RefFace*> ref_face_list;
    tmp_vol->ref_faces( ref_face_list );
    if( !ref_face_list.move_to( tmp_face ) )
      continue;

    one_ref_face.clean_out();
    one_ref_face.append( tmp_face );
    int id = one_ref_face.get()->id();

    //See if the owning body of the face is a multi-volume body
    Body *owning_body = one_ref_face.get()->body();
    int number_volumes_before = owning_body->num_ref_volumes();

    tmp_new_body_list.clean_out();

    CubitStatus rv = this->tweak_remove(one_ref_face, tmp_new_body_list,
      extend, keep_surface, keep_old_body, preview );
    if (rv)
    {
      total_rv = CUBIT_SUCCESS;
      if( !preview )
        PRINT_INFO("Successfully removed Surface %d\n\n", id);
      else
        PRINT_INFO("Successfully removed Surface %d in preview\n\n", id);

      //see if we have a multi-volume body or multiple bodies
      //if so, we know the original volume was destroyed, so we
      //cannot remove any more surfaces because the check above is
      //highly likely to crash
      bool volume_destroyed = false;
      int number_volumes_after = tmp_new_body_list.get()->num_ref_volumes();
      if( number_volumes_after > number_volumes_before  )
        volume_destroyed = true;

      new_body_list += tmp_new_body_list;

      if( volume_destroyed == true )
      {
        PRINT_WARNING("Unable to remove more surfaces because multiple bodies\n"
                      "       have been produced from removing surfaces individually\n" );
        if( CubitUndo::get_undo_enabled() && preview == CUBIT_FALSE )
        {
          if( total_rv == CUBIT_FAILURE )  //didn't remove any surfaces
            CubitUndo::remove_last_undo();
          else
            CubitUndo::note_result_bodies( new_body_list );
        }

        return total_rv;
      }
    }
    else
    {
      if( !preview )
        PRINT_INFO("Unable to remove Surface %d\n\n", id);
      else
        PRINT_INFO("Unable to remove Surface %d in preview\n\n", id);
    }
  }

  if( CubitUndo::get_undo_enabled() && preview == CUBIT_FALSE )
  {
    if( total_rv == CUBIT_FAILURE)
      CubitUndo::remove_last_undo();
    else if( keep_old_body || keep_surface )
      CubitUndo::note_result_bodies( new_body_list );
  }

  return total_rv;
}
CubitStatus GeometryModifyTool::tweak_remove_together ( DLIList< RefFace * > &  ref_face_list,
DLIList< Body * > &  new_body_list,
CubitBoolean  extend_adjoining = CUBIT_TRUE,
CubitBoolean  keep_surface = CUBIT_FALSE,
CubitBoolean  keep_old_body = CUBIT_FALSE,
CubitBoolean  preview = CUBIT_FALSE 
)

Performs tweak_remove operation on surfaces collectively.

Definition at line 16110 of file GeometryModifyTool.cpp.

{

  if( CubitUndo::get_undo_enabled() && preview == CUBIT_FALSE )
  {
    if( keep_old_body )
      CubitUndo::save_state();
    else
      CubitUndo::save_state_with_cubit_file( ref_face_list );
  }

  CubitStatus stat = tweak_remove( ref_face_list, new_body_list,
                                   extend_adjoining, keep_surface,
                                   keep_old_body, preview );

  if( stat == CUBIT_FAILURE )
  {
    if( CubitUndo::get_undo_enabled() && preview == CUBIT_FALSE )
      CubitUndo::remove_last_undo();

    return CUBIT_FAILURE;
  }


  if( preview == CUBIT_FALSE )
  {
    if( CubitUndo::get_undo_enabled()  )
    {
      if( stat == CUBIT_FAILURE )
        CubitUndo::remove_last_undo();
      else if( keep_old_body || keep_surface )
        CubitUndo::note_result_bodies( new_body_list );
    }
  }

  return CUBIT_SUCCESS;
}
GeometryModifyEngine * GeometryModifyTool::tweak_setup ( DLIList< RefFace * > &  input_faces,
const char *  tweak_function_name,
DLIList< Body * > &  old_bodies_out,
DLIList< Surface * > &  surfaces_out,
CubitBoolean  allow_composites = CUBIT_FALSE 
) [protected]

Definition at line 12543 of file GeometryModifyTool.cpp.

{
  if( input_faces.size() == 0 )
  {
    PRINT_ERROR( "No surfaces specified\n" );
    return 0;
  }

  //are any of the input faces merged? ...disallow that
  int i;
  for( i=input_faces.size(); i--; )
  {
    RefFace *tmp_face = input_faces.get();
    if( tmp_face->is_merged() )
    {
      input_faces.change_to( NULL );
      PRINT_ERROR("Surface %d is a merged surface.  Cannot perform %s operation on it.\n"
                  "       Unmerge it first\n",  tmp_face->id(), name );
    }
    input_faces.step();
  }
  input_faces.remove_all_with_value( NULL );
  if( input_faces.size() == 0 )
    return 0;

  // Get parent bodies
  DLIList<TopologyEntity*> query_input(input_faces.size()), query_output;
  CAST_LIST_TO_PARENT(input_faces, query_input);
  ModelQueryEngine::instance()
    ->query_model( query_input, DagType::body_type(), query_output );
  CAST_LIST(query_output, output_bodies, Body);

  if(allow_composites)
  {
    if (!okay_to_modify( output_bodies, "TWEAK" ))
      return 0;
  }
  else
  {
    if ( contains_intermediate_geom(output_bodies))
    {
      PRINT_ERROR("%s surfaces on volumes containing virtual geometry\n"
        "       is not allowed.\n"
        "       Delete virtual geometry on these volumes before operation.\n",
        name);
      return 0;
    }
  }

  // Get engine and corresponding geom entities
  GeometryModifyEngine* gme_ptr;
  gme_ptr = common_modify_engine( input_faces, output_surfaces, allow_composites );
  if (!gme_ptr)
  {
    PRINT_ERROR("%s surfaces on volumes containing surfaces from different\n"
      "       geometry engines is not allowed.\n", name);
  }

  return gme_ptr;
}
GeometryModifyEngine * GeometryModifyTool::tweak_setup ( DLIList< RefEdge * > &  input_edges,
const char *  tweak_function_name,
DLIList< Body * > &  old_bodies_out,
DLIList< Curve * > &  curves_out,
CubitBoolean  allow_composites = CUBIT_FALSE 
) [protected]

Definition at line 12614 of file GeometryModifyTool.cpp.

{
  if( input_curves.size() == 0 )
  {
    PRINT_ERROR( "No curves specified\n" );
    return 0;
  }

  //are any of the input curves merged? ...disallow that
  int i;
  for( i=input_curves.size(); i--; )
  {
    RefEdge *tmp_edge = input_curves.get();
    if( tmp_edge->is_merged() )
    {
      input_curves.change_to( NULL );
      PRINT_ERROR("Curve %d is a merged curve.  Cannot perform %s operation on it.\n"
                  "       Unmerge it first\n",  tmp_edge->id(), name );
    }
    input_curves.step();
  }
  input_curves.remove_all_with_value( NULL );
  if( input_curves.size() == 0 )
    return 0;

  // Get parent bodies
  DLIList<TopologyEntity*> query_input(input_curves.size()), query_output;
  CAST_LIST_TO_PARENT(input_curves, query_input);
  ModelQueryEngine::instance()
    ->query_model( query_input, DagType::body_type(), query_output );
  CAST_LIST(query_output, output_bodies, Body);

  if(allow_composites)
  {
    if (!okay_to_modify( output_bodies, "TWEAK" ))
      return 0;
  }
  else
  {
    if ( contains_intermediate_geom(output_bodies))
    {
      PRINT_ERROR("%s surfaces on volumes containing virtual geometry\n"
                  "       is not allowed.\n"
                  "       Delete virtual geometry on these volumes before operation.\n",
                  name);
      return 0;
    }
  }

  // Get engine and corresponding geom entities
  GeometryModifyEngine* gme_ptr;
  gme_ptr = common_modify_engine( input_curves, output_curves );
  if (!gme_ptr)
  {
    PRINT_ERROR("%s curves on entities containing surfaces from different\n"
      "       geometry engines is not allowed.\n", name);
  }

  return gme_ptr;
}
GeometryModifyEngine * GeometryModifyTool::tweak_setup ( DLIList< RefVertex * > &  input_vertices,
const char *  name,
DLIList< Body * > &  output_bodies,
DLIList< TBPoint * > &  output_points,
CubitBoolean  allow_composites = CUBIT_FALSE 
) [protected]

Definition at line 12685 of file GeometryModifyTool.cpp.

{
  if( input_vertices.size() == 0 )
  {
    PRINT_ERROR( "No vertices specified\n" );
    return 0;
  }

  //are any of the input vertices merged? ...disallow that
  int i;
  for( i=input_vertices.size(); i--; )
  {
    RefVertex *tmp_vert = input_vertices.get();
    if( tmp_vert->is_merged() )
    {
      input_vertices.change_to( NULL );
      PRINT_ERROR("Vertex %d is a merged vertex.  Cannot perform %s operation on it.\n"
                  "       Unmerge it first\n",  tmp_vert->id(), name );
    }
    input_vertices.step();
  }
  input_vertices.remove_all_with_value( NULL );
  if( input_vertices.size() == 0 )
    return 0;

  // Get parent bodies
  DLIList<TopologyEntity*> query_input(input_vertices.size()), query_output;
  CAST_LIST_TO_PARENT(input_vertices, query_input);
  ModelQueryEngine::instance()
    ->query_model( query_input, DagType::body_type(), query_output );
  CAST_LIST(query_output, output_bodies, Body);

  if(allow_composites)
  {
    if (!okay_to_modify( output_bodies, "TWEAK" ))
      return 0;
  }
  else
  {
    if ( contains_intermediate_geom(output_bodies))
    {
      PRINT_ERROR("%s surfaces on volumes containing virtual geometry\n"
                  "       is not allowed.\n"
                  "       Delete virtual geometry on these volumes before operation.\n",
                  name);
      return 0;
    }
  }

  // Get engine and corresponding geom entities
  GeometryModifyEngine* gme_ptr;
  gme_ptr = common_modify_engine( input_vertices, output_points, allow_composites );
  if (!gme_ptr)
  {
    PRINT_ERROR("%s vertices on entities containing surfaces from different\n"
      "       geometry engines is not allowed.\n", name);
  }

  return gme_ptr;
}
CubitStatus GeometryModifyTool::tweak_target ( DLIList< RefFace * > &  ref_face_list,
DLIList< RefFace * > &  target_face_list,
DLIList< Body * > &  new_body_list,
CubitBoolean  extend_flg = CUBIT_TRUE,
CubitPlane limit_plane = NULL,
CubitBoolean  reverse_flg = CUBIT_FALSE,
CubitBoolean  keep_old_body = CUBIT_FALSE,
CubitBoolean  preview = CUBIT_FALSE 
)

Extends (tweaks) surfaces up to a target surface.

Tweak specified faces of a volume or volumes up to target surface. If extend flag is true, extend out the targets before tweaking to them (only used for multiple targets; single targets are always extended). The optional limit plane is only valid if extend_flg is TRUE; it will limit the tweak to not go past this plane in the case where the tweaked body would only partially intersect the extended targets.The reverse flag should never be needed - if it is there may be a bug or a bad normal on a body (i.e., negative volume body), and is only retained for debugging.

Definition at line 16536 of file GeometryModifyTool.cpp.

{
  DLIList<Surface*> surface_list(ref_face_list.size());
  DLIList<Surface*> target_surf_list(target_face_list.size());
  DLIList<Body*> old_body_list;
  GeometryModifyEngine *gme_ptr1, *gme_ptr2;

  gme_ptr1 = tweak_setup( ref_face_list, "Tweaking", old_body_list, surface_list, CUBIT_TRUE );
  if (!gme_ptr1)
    return CUBIT_FAILURE;

  DLIList<Body*> old_body_list2;
  gme_ptr2 = tweak_setup( target_face_list, "Tweaking", old_body_list2, target_surf_list, CUBIT_TRUE );
  if (!gme_ptr2)
    return CUBIT_FAILURE;

  if( gme_ptr1 != gme_ptr2 )
  {
    PRINT_ERROR( "Target surfaces must belong to same geometry engine as tweaked surfaces.\n" );
    return CUBIT_FAILURE;
  }

  if( CubitUndo::get_undo_enabled() && preview == CUBIT_FALSE )
  {
    if( keep_old_body )
      CubitUndo::save_state();
    else
      CubitUndo::save_state_with_cubit_file( ref_face_list );
  }

  int i;
  DLIList<Body*> all_bodies = old_body_list;
  all_bodies += old_body_list2;
  DLIList<BodySM*> body_sms;
  for(i=all_bodies.size(); i--;)
  {
    BodySM* bsm = all_bodies.get_and_step()->get_body_sm_ptr();
    if(bsm)
      body_sms.append_unique(bsm);
  }

  if(!preview)
  {
    do_attribute_setup();
    push_attributes_before_modify(body_sms);
  }

  // Do tweak to target
  DLIList<BodySM*> new_bodysm_list;
  CubitStatus stat = gme_ptr1->tweak_target( surface_list, target_surf_list,
                                             new_bodysm_list, extend_flg,
                                             limit_plane, reverse_flg,
                                             keep_old_body, preview );


  if( stat == CUBIT_FAILURE )
  {
    if(!preview)
      remove_pushed_attributes(new_bodysm_list, all_bodies);
    if( CubitUndo::get_undo_enabled() && preview == CUBIT_FALSE )
      CubitUndo::remove_last_undo();
    if(!preview)
      do_attribute_cleanup();
    return CUBIT_FAILURE;
  }
  else
  {
    if(!preview)
    {
      restore_vg_after_modify(new_bodysm_list, all_bodies, gme_ptr1);
      remove_pushed_attributes(new_bodysm_list, all_bodies);
    }
  }

  // Collect all the old_faces to be compared against new_faces later...DJQ
  DLIList<RefFace*> old_faces;
  for (i = 0; i < old_body_list.size(); i++)
  {
      Body *old_body = old_body_list.get_and_step();
      DLIList<RefFace*> tmp_faces;
      old_body->ref_faces(tmp_faces);
      old_faces +=tmp_faces;
  }

  // Update DAG
  stat = finish_sm_op( old_body_list, new_bodysm_list, new_body_list );

  if(!preview)
    do_attribute_cleanup();

  if( stat == CUBIT_FAILURE )
  {
    if( CubitUndo::get_undo_enabled() && preview == CUBIT_FALSE )
      CubitUndo::remove_last_undo();
    return CUBIT_FAILURE;
  }

  //collect all the new faces
  DLIList<RefFace*> new_faces;
  for( i=new_body_list.size(); i--; )
  {
    Body *new_body = new_body_list.get_and_step();
    DLIList<RefFace*> tmp_faces;
    new_body->ref_faces( tmp_faces );
    new_faces += tmp_faces;
  }

  // Compare the new_faces list with the old_faces list to determine which faces are created
  // Add these faces to the all_ref_face_list to check for its neighbors...DJQ
  DLIList<RefFace*> difference = new_faces;
  difference -= old_faces;
  ref_face_list += difference;


  // loop body sm list and find surfaces that need updating.
  // this is to account for some cases where the topology doesn't change, but the geometry does.
  DLIList<RefEntity*> entities_to_update;
  for(i=0; i<new_bodysm_list.size(); i++)
  {
    BodySM* bodysm = new_bodysm_list.get_and_step();
    DLIList<Surface*> surfs;
    bodysm->surfaces(surfs);
    int j;
    // find a surface that is also found in our input list
    // some times the target surface gets modified
    for(j=0; j<surfs.size(); j++, surfs.step())
    {
      BridgeManager* man = surfs.get()->bridge_manager();
      if(man)
      {
        RefFace* ref_face = CAST_TO(man->topology_entity(), RefFace);
        if(ref_face && (ref_face_list.is_in_list(ref_face) ||
            target_face_list.is_in_list(ref_face)))
        {
          // get neighbors
          DLIList<TBPoint*> neighbor_points;
          surfs.get()->points(neighbor_points);
          DLIList<Curve*> neighbor_curves;
          DLIList<Surface*> neighbor_surfaces;
          DLIList<TopologyBridge*> neighbors;
          DLIList<TopologyBridge*> tmp;
          int k;
          for(k=0; k<neighbor_points.size(); k++)
            neighbor_points.get_and_step()->surfaces(neighbor_surfaces);
          for(k=0; k<neighbor_points.size(); k++)
            neighbor_points.get_and_step()->curves(neighbor_curves);

          CAST_LIST_TO_PARENT(neighbor_points, tmp);
          neighbors += tmp;
          neighbor_curves.uniquify_ordered();
          CAST_LIST_TO_PARENT(neighbor_curves, tmp);
          neighbors += tmp;
          neighbor_surfaces.uniquify_ordered();
          CAST_LIST_TO_PARENT(neighbor_surfaces, tmp);
          neighbors += tmp;
          neighbors.append(surfs.get()->lump());
          neighbors.append(surfs.get()->bodysm());

          for(k=0; k<neighbors.size(); k++)
            if(BridgeManager* m = neighbors.get_and_step()->bridge_manager())
              if(TopologyEntity* t = m->topology_entity())
                entities_to_update.append(CAST_TO(t, RefEntity));
        }
      }
    }
  }

  //unmerge any merged adjacent surfaces or
  //merged curves in unmerged adjacent surfaces
  DLIList<RefFace*> adjacent_faces_to_unmerge;
  DLIList<RefEdge*> adjacent_edges_to_unmerge;
  for(i=ref_face_list.size(); i--;)
  {
    RefFace *tweaked_face = ref_face_list.get_and_step();
    if( !new_faces.move_to( tweaked_face ) )
      continue;

    //get all the edges of the face you tweaked
    DLIList<RefEdge*> tweaked_face_edges;
    tweaked_face->ref_edges( tweaked_face_edges );
    adjacent_edges_to_unmerge += tweaked_face_edges;

    //get all the adjacent faces to this edge
    int j;
    for( j=tweaked_face_edges.size(); j--; )
    {
      RefEdge *tmp_edge = tweaked_face_edges.get_and_step();
      DLIList<RefFace*> tmp_faces;
      tmp_edge->ref_faces( tmp_faces );
      tmp_faces.remove( tweaked_face );
      adjacent_faces_to_unmerge += tmp_faces;
    }

    //get all edges not in the surface,
    //sharing vertices with the surface
    DLIList<RefVertex*> ref_vertices;
    tweaked_face->ref_vertices( ref_vertices );
    for( j=ref_vertices.size(); j--; )
    {
      RefVertex *tmp_vert = ref_vertices.get_and_step();
      DLIList<RefEdge*>  ref_edges;
      tmp_vert->ref_edges( ref_edges );

      int k;
      for( k=ref_edges.size(); k--; )
      {
        RefEdge *tmp_edge = ref_edges.get_and_step();
        if( !tweaked_face_edges.move_to( tmp_edge ) )
          adjacent_edges_to_unmerge.append( tmp_edge );
      }
    }
  }

  //unmerge any adjacent faces
  adjacent_faces_to_unmerge.uniquify_unordered();
  for( i=adjacent_faces_to_unmerge.size(); i--; )
  {
    RefFace *ref_face = adjacent_faces_to_unmerge.get_and_step();

    DLIList<TopologyBridge*> bridge_list;
    ref_face->bridge_manager()->get_bridge_list(bridge_list);
    if (bridge_list.size() > 1)
    {
      if( MergeTool::instance()->unmerge( ref_face ) )
        PRINT_WARNING("Unmerging Surface %d\n", ref_face->id() );
    }
  }

  //unmerge any adjacent edges
  adjacent_edges_to_unmerge.uniquify_unordered();
  for( i=adjacent_edges_to_unmerge.size(); i--; )
  {
    RefEdge *ref_edge = adjacent_edges_to_unmerge.get_and_step();
    DLIList<TopologyBridge*> bridge_list;
    ref_edge->bridge_manager()->get_bridge_list(bridge_list);
    if (bridge_list.size() > 1)
    {
      if( MergeTool::instance()->unmerge( ref_edge) )
        PRINT_WARNING("Unmerging Curve %d\n", ref_edge->id() );
    }
  }

  if( CubitUndo::get_undo_enabled() && keep_old_body )
    CubitUndo::note_result_bodies( new_body_list );

  // Update graphics
  while (entities_to_update.size())
    AppUtil::instance()->send_event(GeometryEvent(GeometryEvent::GEOMETRY_MODIFIED, entities_to_update.pop()));


  return CUBIT_SUCCESS;
}
CubitStatus GeometryModifyTool::tweak_target ( DLIList< RefFace * > &  ref_face_list,
CubitPlane plane,
DLIList< Body * > &  new_body_list,
CubitBoolean  reverse_flg = CUBIT_FALSE,
CubitBoolean  keep_old_body = CUBIT_FALSE,
CubitBoolean  preview = CUBIT_FALSE 
)

Extends (tweaks) surfaces up to a target plane.

Tweak specified faces of a volume or volumes up to target plane. If extend flag is true, extend out the targets before tweaking to them (only used for multiple targets; single targets are always extended). The optional limit plane is only valid if extend_flg is TRUE; it will limit the tweak to not go past this plane in the case where the tweaked body would only partially intersect the extended targets.The reverse flag should never be needed - if it is there may be a bug or a bad normal on a body (i.e., negative volume body), and is only retained for debugging.

Definition at line 16802 of file GeometryModifyTool.cpp.

{
  DLIList<Surface*> surface_list(ref_face_list.size()+1);
  DLIList<Body*> old_body_list;
  GeometryModifyEngine* gme_ptr;

  gme_ptr = tweak_setup( ref_face_list, "Tweaking", old_body_list, surface_list, CUBIT_TRUE );
  if (!gme_ptr)
    return CUBIT_FAILURE;

  // Create a target Surface from the plane (arbitrarily 10.0 X 10.0 in size)

  // Get corners of the surface
  CubitVector normal = plane.normal();
  CubitVector x, y;
  normal.orthogonal_vectors( x, y );
  CubitVector p1 = plane.point_on_plane();
  CubitVector p2, p3, p4;
  p1.next_point( x, 5.0, p1 );
  p1.next_point( y, 5.0, p1 );
  p1.next_point( -x, 10.0, p2 );
  p2.next_point( -y, 10.0, p3 );
  p3.next_point( x, 10.0, p4 );

  BodySM* bodysm_ptr = gme_ptr->planar_sheet( p1, p2, p3, p4 );
  if( !bodysm_ptr )
  {
    PRINT_ERROR( "unable to create target surface from plane\n" );
    return CUBIT_FAILURE;
  }

  DLIList<Surface*> target_surf_list;
  bodysm_ptr->surfaces( target_surf_list );
  if( !target_surf_list.size() )
  {
    PRINT_ERROR( "unable to create target surface from plane\n" );
    return CUBIT_FAILURE;
  }

  int i;
  DLIList<BodySM*> body_sms;
  for(i=old_body_list.size(); i--;)
  {
    BodySM* bsm = old_body_list.get_and_step()->get_body_sm_ptr();
    if(bsm)
      body_sms.append_unique(bsm);
  }

  if(!preview)
  {
    do_attribute_setup();
    push_attributes_before_modify(body_sms);
  }

  // Do tweak to target
  DLIList<BodySM*> new_bodysm_list;
  CubitStatus stat = gme_ptr->tweak_target( surface_list, target_surf_list,
                                            new_bodysm_list, CUBIT_TRUE,
                                            NULL, reverse_flg, keep_old_body,
                                            preview );


  if( stat == CUBIT_FAILURE )
  {
    if(!preview)
      remove_pushed_attributes(new_bodysm_list, old_body_list);
    if( CubitUndo::get_undo_enabled() && preview == CUBIT_FALSE )
      CubitUndo::remove_last_undo();
    if(!preview)
      do_attribute_cleanup();
    return CUBIT_FAILURE;
  }
  else
  {
    if(!preview)
    {
      restore_vg_after_modify(new_bodysm_list, old_body_list, gme_ptr);
      remove_pushed_attributes(new_bodysm_list, old_body_list);
    }
  }

  // Delete temporary sheet body
  bodysm_ptr->get_geometry_query_engine()->delete_solid_model_entities( bodysm_ptr );

  // Update DAG
  stat = finish_sm_op( old_body_list, new_bodysm_list, new_body_list );

  if(!preview)
    do_attribute_cleanup();

  if( stat == CUBIT_FAILURE )
  {
    if( CubitUndo::get_undo_enabled() && preview == CUBIT_FALSE )
      CubitUndo::remove_last_undo();
    return CUBIT_FAILURE;
  }

  // Update graphics
  DLIList<Body*> moved_bodies(new_body_list);
  moved_bodies.intersect(old_body_list);
  while (moved_bodies.size())
    moved_bodies.pop()->notify_sub_all_observers( GeometryEvent::GEOMETRY_MODIFIED );

  return CUBIT_SUCCESS;
}
CubitStatus GeometryModifyTool::tweak_target ( DLIList< RefEdge * > &  ref_edge_list,
DLIList< RefFace * > &  target_face_list,
DLIList< Body * > &  new_body_list,
CubitBoolean  extend_flg = CUBIT_TRUE,
CubitPlane limit_plane = NULL,
CubitBoolean  reverse_flg = CUBIT_FALSE,
CubitBoolean  keep_old_body = CUBIT_FALSE,
CubitBoolean  preview = CUBIT_FALSE,
double  max_area_increase = 0 
)

Extends (tweaks) curves up to a target surface.

Tweak specified edges of a surface or set of surfaces (in sheet bodies) up to target surfaces or plane. This essentially extends or trims the attached surfaces of the sheet body. If extend flag is true, extend out the targets before tweaking to them (only used for multiple targets; single targets are always extended). The optional limit plane is only valid if extend_flg is TRUE; it will limit the tweak to not go past this plane in the case where the tweaked body would only partially intersect the extended targets.The reverse flag should never be needed - if it is there may be a bug or a bad normal on a body (i.e., negative volume body), and is only retained for debugging.

Definition at line 16919 of file GeometryModifyTool.cpp.

{
  DLIList<Curve*> curve_list(ref_edge_list.size());
  DLIList<Surface*> target_surf_list(target_face_list.size());
  DLIList<Body*> old_body_list;
  GeometryModifyEngine *gme_ptr1, *gme_ptr2;

  gme_ptr1 = tweak_setup( ref_edge_list, "Tweaking", old_body_list, curve_list );
  if( !gme_ptr1 )
    return CUBIT_FAILURE;

  DLIList<Body*> old_body_list2;
  gme_ptr2 = tweak_setup( target_face_list, "Tweaking", old_body_list2, target_surf_list );
  if( !gme_ptr2 )
    return CUBIT_FAILURE;

  if( gme_ptr1 != gme_ptr2 )
  {
    PRINT_ERROR( "Target surface(s) must belong to same geometry engine as tweaked curves.\n" );
    return CUBIT_FAILURE;
  }

  if( CubitUndo::get_undo_enabled() && preview == CUBIT_FALSE )
  {
    if( keep_old )
      CubitUndo::save_state();
    else
      CubitUndo::save_state_with_cubit_file( ref_edge_list );
  }

  // Do tweak to target
  DLIList<BodySM*> new_bodysm_list;
  CubitStatus stat = gme_ptr1->tweak_target( curve_list, target_surf_list,
                                             new_bodysm_list, extend_flg,
                                             limit_plane, reverse_flg,
                                             keep_old, preview, max_area_increase );

  if( stat == CUBIT_FAILURE )
  {
    if( CubitUndo::get_undo_enabled() && preview == CUBIT_FALSE )
      CubitUndo::remove_last_undo();
    return CUBIT_FAILURE;
  }

  // Update DAG
  stat = finish_sm_op( old_body_list, new_bodysm_list, new_body_list );


  if( stat == CUBIT_FAILURE )
  {
    if( CubitUndo::get_undo_enabled() && preview == CUBIT_FALSE )
      CubitUndo::remove_last_undo();
    return CUBIT_FAILURE;
  }

  if( CubitUndo::get_undo_enabled() && preview == CUBIT_FALSE )
  {
    if( keep_old )
      CubitUndo::note_result_bodies( new_body_list );
  }

  // Update graphics
  DLIList<Body*> moved_bodies(new_body_list);
  moved_bodies.intersect(old_body_list);
  while (moved_bodies.size())
  moved_bodies.pop()->notify_sub_all_observers( GeometryEvent::GEOMETRY_MODIFIED );

  return CUBIT_SUCCESS;
}
CubitStatus GeometryModifyTool::tweak_target ( DLIList< RefEdge * > &  ref_edge_list,
CubitPlane plane,
DLIList< Body * > &  new_body_list,
CubitBoolean  reverse_flg = CUBIT_FALSE,
CubitBoolean  keep_old_body = CUBIT_FALSE,
CubitBoolean  preview = CUBIT_FALSE 
)

Definition at line 17003 of file GeometryModifyTool.cpp.

{
  DLIList<Curve*> curve_list(ref_edge_list.size());
  DLIList<Body*> old_body_list;
  GeometryModifyEngine* gme_ptr;

  gme_ptr = tweak_setup( ref_edge_list, "Tweaking", old_body_list, curve_list );
  if( !gme_ptr )
    return CUBIT_FAILURE;

  // Create a target Surface from the plane (arbitrarily 10.0 X 10.0 in size)

  // Get corners of the surface
  CubitVector normal = plane.normal();
  CubitVector x, y;
  normal.orthogonal_vectors( x, y );
  CubitVector p1 = plane.point_on_plane();
  CubitVector p2, p3, p4;
  p1.next_point( x, 5.0, p1 );
  p1.next_point( y, 5.0, p1 );
  p1.next_point( -x, 10.0, p2 );
  p2.next_point( -y, 10.0, p3 );
  p3.next_point( x, 10.0, p4 );

  BodySM* bodysm_ptr = gme_ptr->planar_sheet( p1, p2, p3, p4 );
  if( !bodysm_ptr )
  {
    PRINT_ERROR( "unable to create target surface from plane\n" );
    return CUBIT_FAILURE;
  }

  DLIList<Surface*> target_surf_list;
  bodysm_ptr->surfaces( target_surf_list );
  if( !target_surf_list.size() )
  {
    PRINT_ERROR( "unable to create target surface from plane\n" );
    return CUBIT_FAILURE;
  }

  if( CubitUndo::get_undo_enabled() && preview == CUBIT_FALSE )
  {
    if( keep_old )
      CubitUndo::save_state();
    else
      CubitUndo::save_state_with_cubit_file( ref_edge_list );
  }

  // Do tweak to target
  DLIList<BodySM*> new_bodysm_list;
  CubitStatus stat = gme_ptr->tweak_target( curve_list, target_surf_list,
                                            new_bodysm_list, CUBIT_TRUE,
                                            NULL, reverse_flg, keep_old,
                                            preview );

  if( stat == CUBIT_FAILURE )
  {
    if( CubitUndo::get_undo_enabled() && preview == CUBIT_FALSE )
      CubitUndo::remove_last_undo();
    return CUBIT_FAILURE;
  }

  // Delete temporary sheet body
  bodysm_ptr->get_geometry_query_engine()->delete_solid_model_entities( bodysm_ptr );

  // Update DAG
  stat = finish_sm_op( old_body_list, new_bodysm_list, new_body_list );

  if( stat == CUBIT_FAILURE )
  {
    if( CubitUndo::get_undo_enabled() && preview == CUBIT_FALSE )
      CubitUndo::remove_last_undo();
    return CUBIT_FAILURE;
  }

  if( CubitUndo::get_undo_enabled() && keep_old )
    CubitUndo::note_result_bodies( new_body_list );

  // Update graphics
  DLIList<Body*> moved_bodies(new_body_list);
  moved_bodies.intersect(old_body_list);
  while (moved_bodies.size())
    moved_bodies.pop()->notify_sub_all_observers( GeometryEvent::GEOMETRY_MODIFIED );

  return CUBIT_SUCCESS;
}
CubitStatus GeometryModifyTool::tweak_target ( DLIList< RefEdge * > &  ref_edge_list,
DLIList< RefEdge * > &  target_edge_list,
DLIList< Body * > &  new_body_list,
CubitBoolean  extend_flg = CUBIT_TRUE,
CubitPlane limit_plane = NULL,
CubitBoolean  reverse_flg = CUBIT_FALSE,
CubitBoolean  keep_old_body = CUBIT_FALSE,
CubitBoolean  preview = CUBIT_FALSE,
double  max_area_increase = 0 
)

Extends (tweaks) curves up to a target plane.

Tweak specified edges of a surface or set of surfaces (in sheet bodies) up to target plane. This essentially extends or trims the attached surfaces of the sheet body. If extend flag is true, extend out the targets before tweaking to them (only used for multiple targets; single targets are always extended). The optional limit plane is only valid if extend_flg is TRUE; it will limit the tweak to not go past this plane in the case where the tweaked body would only partially intersect the extended targets.The reverse flag should never be needed - if it is there may be a bug or a bad normal on a body (i.e., negative volume body), and is only retained for debugging. Tweak specified edges of a sheet body or bodies up to target curves that are part of a sheet body. The target is a surface or surfaces created by thickening the owning surface of the target curve(s). If extend flag is true, extend out the targets before tweaking to them (only used for multiple targets; single targets are always extended). The optional limit plane is only valid if extend_flg is TRUE; it will limit the tweak to not go past this plane in the case where the tweaked body would only partially intersect the extended targets. The reverse flag should never be needed - if it is there may be a bug or a bad normal on a body (i.e., negative volume body), and is only retained for debugging.

Definition at line 17101 of file GeometryModifyTool.cpp.

{
  DLIList<Curve*> curve_list(ref_edge_list.size());
  DLIList<Curve*> target_curve_list(target_edge_list.size());
  DLIList<Body*> old_body_list;
  GeometryModifyEngine *gme_ptr1, *gme_ptr2;

  gme_ptr1 = tweak_setup( ref_edge_list, "Tweaking", old_body_list, curve_list );
  if( !gme_ptr1 )
    return CUBIT_FAILURE;

  DLIList<Body*> old_body_list2;
  gme_ptr2 = tweak_setup( target_edge_list, "Tweaking", old_body_list2, target_curve_list );
  if( !gme_ptr2 )
    return CUBIT_FAILURE;

  if( gme_ptr1 != gme_ptr2 )
  {
    PRINT_ERROR( "Target curves must belong to same geometry engine as tweaked curves.\n" );
    return CUBIT_FAILURE;
  }

  if( CubitUndo::get_undo_enabled() && preview == CUBIT_FALSE )
  {
    if( keep_old )
      CubitUndo::save_state();
    else
      CubitUndo::save_state_with_cubit_file( ref_edge_list );
  }

  // Do tweak to target
  DLIList<BodySM*> new_bodysm_list;
  CubitStatus stat = gme_ptr1->tweak_target( curve_list, target_curve_list,
                                             new_bodysm_list, extend_flg,
                                             limit_plane, reverse_flg,
                                             keep_old, preview, max_area_increase );

  if( CubitUndo::get_undo_enabled() && preview == CUBIT_FALSE )
    if( stat == CUBIT_FAILURE )
      CubitUndo::remove_last_undo();

  if( stat == CUBIT_FAILURE)
    return stat;

  DLIList<RefEntity*> entities_to_update;
  if( preview == CUBIT_FALSE )
  {
    // check for resued entities, they have been moved and we need to notify observers
    int i;
    for(i=0; i<new_bodysm_list.size(); i++)
    {
      BodySM* bodysm = new_bodysm_list.get_and_step();
      DLIList<TopologyBridge*> to_check;
      DLIList<TopologyBridge*> tmp;
      DLIList<Surface*> surfs;
      bodysm->surfaces(surfs);
      DLIList<Curve*> curves;
      bodysm->curves(curves);
      DLIList<TBPoint*> points;
      bodysm->points(points);
      to_check.append(bodysm);
      to_check.append(bodysm->lump());
      CAST_LIST_TO_PARENT(surfs, tmp);
      to_check += tmp;
      CAST_LIST_TO_PARENT(curves, tmp);
      to_check += tmp;
      CAST_LIST_TO_PARENT(points, tmp);
      to_check += tmp;

      int k;
      for(k=0; k<to_check.size(); k++)
        if(BridgeManager* m = to_check.get_and_step()->bridge_manager())
          if(TopologyEntity* t = m->topology_entity())
            entities_to_update.append(CAST_TO(t, RefEntity));
    }

    // Update DAG
    stat = finish_sm_op( old_body_list, new_bodysm_list, new_body_list );

    if( CubitUndo::get_undo_enabled()  )
    {
      if( stat == CUBIT_FAILURE )
        CubitUndo::remove_last_undo();
      else if( keep_old )
        CubitUndo::note_result_bodies( new_body_list );
    }
  }

  // Update graphics
  while (entities_to_update.size())
    AppUtil::instance()->send_event(GeometryEvent(GeometryEvent::GEOMETRY_MODIFIED, entities_to_update.pop()));

  // Update graphics
  DLIList<Body*> moved_bodies(new_body_list);
  moved_bodies.intersect(old_body_list);
  while (moved_bodies.size())
    AppUtil::instance()->send_event(GeometryEvent(GeometryEvent::GEOMETRY_MODIFIED, moved_bodies.pop()));

  return stat;
}
CubitStatus GeometryModifyTool::tweak_target ( RefVertex ref_vertex_ptr,
DLIList< RefFace * > &  modify_ref_face_list,
CubitVector target_loc,
Body *&  new_Body_ptr,
CubitBoolean  keep_old_body = CUBIT_FALSE,
CubitBoolean  preview = CUBIT_FALSE 
)

Tweak specified vertex of a sheet body to a given location.

Definition at line 17219 of file GeometryModifyTool.cpp.

{
  if( modify_ref_face_list.size() == 0 )
  {
    PRINT_ERROR( "No surfaces found to modify\n" );
    return CUBIT_FAILURE;
  }

  int i;
  RefFace *ref_face_ptr;

  // Check to make sure vertex is part of all given surfaces
  modify_ref_face_list.reset();
  for( i=modify_ref_face_list.size(); i--; )
  {
    ref_face_ptr = modify_ref_face_list.get_and_step();

    if( !ref_face_ptr->is_directly_related( ref_vertex_ptr ) )
    {
      PRINT_ERROR( "Vertex %d is not part of 'modify' Surface %d\n",
        ref_vertex_ptr->id(), ref_face_ptr->id() );
      return CUBIT_FAILURE;
    }
  }

  GeometryModifyEngine *gme_ptr;
  DLIList<RefVertex*> ref_vertex_list(1);
  ref_vertex_list.append( ref_vertex_ptr );
  DLIList<Body*> old_body_list;
  DLIList<TBPoint*> point_list(1);
  gme_ptr = tweak_setup( ref_vertex_list, "Tweaking", old_body_list, point_list );
  if( !gme_ptr )
    return CUBIT_FAILURE;

  // We already made sure the vertex is part of all of the modify faces, so
  // just use the common_modify_engine function to get the surface_list
  DLIList<Surface*> surface_list;
  if( !common_modify_engine( modify_ref_face_list, surface_list ) )
    return CUBIT_FAILURE;

  // Make sure part of a sheet body, not a solid body
  Body *body_ptr = ref_vertex_ptr->body();
  if( !body_ptr->is_sheet_body() )
  {
    PRINT_ERROR( "Vertex %d is not in a sheet body - Body %d is solid.\n"
      "       Tweaking a vertex to a target currently not possible on solid bodies.\n",
      ref_vertex_ptr->id(), body_ptr->id() );
    return CUBIT_FAILURE;
  }

  // Make sure all the given surfaces are planar
  modify_ref_face_list.reset();
  for( i=modify_ref_face_list.size(); i--; )
  {
    ref_face_ptr = modify_ref_face_list.get_and_step();

    if( !ref_face_ptr->is_planar() )
    {
      PRINT_ERROR( "Surfaces to modify must be planar - Surface %d is not planar\n", ref_face_ptr->id() );
      return CUBIT_FAILURE;
    }
  }

  // Make sure all curves (on modify surfaces) attached to the given vertex are linear
  // Get all attached curves
  int j;
  DLIList<RefEdge*> ref_edge_list;
  ref_vertex_ptr->ref_edges( ref_edge_list );
  RefEdge *ref_edge_ptr;
  for( i=ref_edge_list.size(); i--; )
  {
    ref_edge_ptr = ref_edge_list.get_and_step();

    // Check to see if this edge is linear, if it is in one of the modify surfaces
    modify_ref_face_list.reset();
    for( j=modify_ref_face_list.size(); j--; )
    {
      ref_face_ptr = modify_ref_face_list.get_and_step();
      if( ref_face_ptr->is_directly_related( ref_edge_ptr ) )
      {
        Curve *curve_ptr = ref_edge_ptr->get_curve_ptr();
        GeometryType curve_type = curve_ptr->geometry_type();
        if( curve_type != STRAIGHT_CURVE_TYPE )
        {
          PRINT_ERROR( "Curve %d is not linear. Curves that are in the 'modify'\n"
            "       surfaces attached to the tweak vertex must be linear.\n",
            ref_edge_ptr->id() );
          return CUBIT_FAILURE;
        }
        else
          break;
      }
    }
  }

  // Project the location to the given surfaces and make sure all of these locations
  // are the same
  modify_ref_face_list.reset();

  CubitVector ref_loc( target_loc ); // Reference location
  ref_face_ptr = modify_ref_face_list.get_and_step();
  ref_face_ptr->move_to_surface( ref_loc );
  int ref_surf_id = ref_face_ptr->id();

  for( i=modify_ref_face_list.size()-1; i--; )
  {
    ref_face_ptr = modify_ref_face_list.get_and_step();

    CubitVector proj_loc( target_loc );
    ref_face_ptr->move_to_surface( proj_loc );

    if( !ref_loc.about_equal( proj_loc ) )
    {
      PRINT_ERROR( "Target location must project to all of the 'modify' surfaces at\n"
        "       exactly the same location - the tweaked Vertex %d will move to this\n"
        "       common (same) projected location, tweaking the modify surfaces with it.\n"
        "       Given target location = %f, %f, %f\n"
        "       Projected location on Surface %d = %f, %f, %f\n"
        "       Projected location on Surface %d = %f, %f, %f\n",
        ref_vertex_ptr->id(),
        target_loc.x(), target_loc.y(), target_loc.z(),
        ref_surf_id, ref_loc.x(), ref_loc.y(), ref_loc.z(),
        ref_face_ptr->id(), proj_loc.x(), proj_loc.y(), proj_loc.z() );

      return CUBIT_FAILURE;
    }
  }

  // It looks like the inputs are valid so get ready to do the tweak
  if( CubitUndo::get_undo_enabled() && preview == CUBIT_FALSE )
  {
    if( keep_old )
      CubitUndo::save_state();
    else
      CubitUndo::save_state_with_cubit_file( ref_vertex_list );
  }

  TBPoint *point_ptr = point_list.get();

  // Do tweak to target
  BodySM *new_bodysm_ptr;
  CubitStatus stat = gme_ptr->tweak_target( point_ptr, surface_list,
                                            ref_loc,
                                            new_bodysm_ptr,
                                            keep_old, preview );

  if( CubitUndo::get_undo_enabled() && preview == CUBIT_FALSE )
    if( stat == CUBIT_FAILURE )
      CubitUndo::remove_last_undo();

  if( stat == CUBIT_FAILURE)
    return stat;

  DLIList<BodySM*> new_bodysm_list;
  new_bodysm_list.append( new_bodysm_ptr );
  DLIList<Body*> new_body_list;

  if( preview == CUBIT_FALSE )
  {
    // Update DAG
    stat = finish_sm_op( old_body_list, new_bodysm_list, new_body_list );

    if( CubitUndo::get_undo_enabled() )
    {
      if( stat == CUBIT_FAILURE )
        CubitUndo::remove_last_undo();
      else if( keep_old )
        CubitUndo::note_result_bodies( new_body_list );
    }
  }

  // Update graphics
  DLIList<Body*> moved_bodies(new_body_list);
  moved_bodies.intersect(old_body_list);
  while (moved_bodies.size())
    moved_bodies.pop()->notify_sub_all_observers( GeometryEvent::GEOMETRY_MODIFIED );

  return stat;
}
CubitStatus GeometryModifyTool::unite ( DLIList< Body * > &  bodies,
DLIList< Body * > &  newBodies,
bool  keep_old = false 
)

Boolean unite.

Definition at line 6448 of file GeometryModifyTool.cpp.

{
  if( bodies.size() <= 1 )
  {
    PRINT_WARNING("There is only one volume in the list. Nothing modified.\n");
    return CUBIT_FAILURE;
  }
  if (!okay_to_modify( bodies, "UNITE" ))
    return CUBIT_FAILURE;

  int i;
  const int count = bodies.size();
  DLIList<TopologyEntity*> entity_list(count);
  DLIList<TopologyBridge*> bridge_list(count);
  bodies.reset();
  for (i = bodies.size(); i--; )
    entity_list.append_unique(bodies.get_and_step());
  GeometryModifyEngine* gme = common_modify_engine( entity_list, bridge_list );

  if( !gme )
  {
    PRINT_ERROR("Performing UNITE with volumes containing geometry from\n"
      "different modeling engines is not allowed.\n"
      "Delete uncommon geometry on these volumes before operation.\n\n");
    return CUBIT_FAILURE;
  }

  // Cubit can't mesh mixed sheet/solid bodies that are united together. If
  // required, separate the unite between these types.
  CubitStatus result;
  if( GeometryModifyTool::instance()->unite_mixed_models() )
    result = unite_all( gme, bodies, new_body_list, keep_old );
  else
    result = unite_separately( gme, bodies, new_body_list, keep_old );

  if( result == CUBIT_FAILURE )
    PRINT_ERROR("UNITE failed\n");

  return result;
}
CubitStatus GeometryModifyTool::unite ( DLIList< BodySM * > &  body_sm_list,
DLIList< BodySM * > &  new_body_sm_list,
bool  keep_old = false 
)

Boolean unite.

Definition at line 6437 of file GeometryModifyTool.cpp.

{
  //this assumes that all bodies have the same modify engine
  GeometryModifyEngine *gme = get_engine( body_sm_list.get() );
  CubitStatus result = gme->unite(body_sm_list, new_body_sm_list, keep_old);
  return result;
}
CubitStatus GeometryModifyTool::unite_all ( GeometryModifyEngine gme_ptr,
DLIList< Body * > &  body_list,
DLIList< Body * > &  new_body_list,
bool  keep_old 
) [private]

Private functions called to unite bodies. First form separates the body list into sheets & solids and unites each group together separately. Second one unites all bodies together (including sheets & solids.

Definition at line 6567 of file GeometryModifyTool.cpp.

{
  // Setup undo
  if( CubitUndo::get_undo_enabled() )
  {
    if( keep_old )
      CubitUndo::save_state();
    else
      CubitUndo::save_state_with_cubit_file( bodies );
  }

  // Unite solids with each other, and sheets with each other separately
  CubitStatus result = unite_private( gme_ptr, bodies, new_body_list, keep_old );

  // Finish undo
  if( CubitUndo::get_undo_enabled() )
  {
    if( new_body_list.size() )
      CubitUndo::note_result_bodies( new_body_list );
    else
      CubitUndo::remove_last_undo();
  }

  return result;
}

Gets unite mixed models flag.

Definition at line 2495 of file GeometryModifyTool.hpp.

{return uniteMixedModels;}
void GeometryModifyTool::unite_mixed_models ( CubitBoolean  flag) [inline, static]

Sets unite mixed models flag.

Definition at line 2497 of file GeometryModifyTool.hpp.

{uniteMixedModels = flag;}
CubitStatus GeometryModifyTool::unite_private ( GeometryModifyEngine gme_ptr,
DLIList< Body * > &  body_list,
DLIList< Body * > &  new_body_list,
bool  keep_old 
) [private]

Private lower level function called to unite bodies

Definition at line 6598 of file GeometryModifyTool.cpp.

{
  if( !body_list.size() )
    return CUBIT_SUCCESS;

  int i, j;
  Body *body_ptr;
  CubitStatus result;

  // Give 1st body all the names of all bodies being united
  std::list<CubitString> names_list;
  DLIList<CubitString> entity_names;

  body_list.reset();
  for( i=body_list.size(); i--; )
  {
    body_ptr = body_list.get_and_step();

    // See if body has names
    if( body_ptr->num_names() )
    {
      // Put the names in a list
      body_ptr->entity_names( entity_names );
      entity_names.reset();

      // Loop through names
      for( j=entity_names.size(); j--; )
        names_list.push_back( entity_names.get_and_step() );

      entity_names.clean_out();
      body_ptr->remove_entity_names();
    }
  }

  do_attribute_setup();

  DLIList<TopologyEntity*> entity_list(body_list.size());
  DLIList<TopologyBridge*> bridge_list(body_list.size());
  body_list.reset();
  for( i=body_list.size(); i--; )
    entity_list.append_unique(body_list.get_and_step());
  common_modify_engine( entity_list, bridge_list );

  DLIList<BodySM*> body_sm_list(body_list.size());
  CAST_LIST(bridge_list, body_sm_list, BodySM);

  push_attributes_before_modify(body_sm_list);

  DLIList<int> merged_surface_ids;
  DLIList<int> merged_curve_ids;

  get_merged_curve_and_surface_ids( body_list, merged_surface_ids, merged_curve_ids );

  DLIList<BodySM*> new_body_sm_list;
  result = unite( body_sm_list, new_body_sm_list, keep_old );

  restore_vg_after_modify( new_body_sm_list, body_list, gme_ptr );
  remove_pushed_attributes( new_body_sm_list, body_list );

  DLIList<Body*> result_list;
  if( !finish_sm_op(body_list, new_body_sm_list, result_list) )
    result = CUBIT_FAILURE;

  if( keep_old == CUBIT_FALSE )
    fixup_merged_entities( merged_surface_ids, merged_curve_ids );

  do_attribute_cleanup();

  if( result )
  {
    new_body_list += result_list;

    for( j=result_list.size(); j--; )
    {
      //Add names to 1st body
      std::list<CubitString>::iterator iter, end = names_list.end();
      for (iter = names_list.begin(); iter != end; ++iter)
        result_list.get_and_step()->entity_name( *iter );
    }
  }

  return result;
}
CubitStatus GeometryModifyTool::unite_separately ( GeometryModifyEngine gme_ptr,
DLIList< Body * > &  body_list,
DLIList< Body * > &  new_body_list,
bool  keep_old 
) [private]

Definition at line 6492 of file GeometryModifyTool.cpp.

{
  // Cubit can't mesh mixed sheet/solid bodies that are united together. Sort
  // based on these types.
  int i;
  Body *body_ptr;
  DLIList<Body*> solid_body_list;
  DLIList<Body*> sheet_body_list;
  bodies.reset();
  for( i=bodies.size(); i--; )
  {
    body_ptr = bodies.get_and_step();

    if( body_ptr->is_sheet_body() )
      sheet_body_list.append( body_ptr );
    else
      solid_body_list.append( body_ptr );
  }

  if( sheet_body_list.size() == 1 && solid_body_list.size() == 1 )
  {
    PRINT_ERROR( "Cannot unite solid and sheet bodies together\n" );
    return CUBIT_FAILURE;
  }

  // Setup undo
  if( CubitUndo::get_undo_enabled() )
  {
    if( keep_old )
      CubitUndo::save_state();
    else
      CubitUndo::save_state_with_cubit_file( bodies );
  }

  // Unite solids with each other, and sheets with each other separately
  CubitStatus result1 = CUBIT_SUCCESS;
  CubitStatus result2 = CUBIT_SUCCESS;
  if( solid_body_list.size() > 1 )
    result1 = unite_private( gme_ptr, solid_body_list, new_body_list, keep_old );
  if( sheet_body_list.size() > 1 )
    result2 = unite_private( gme_ptr, sheet_body_list, new_body_list, keep_old );

  // Finish undo
  if( CubitUndo::get_undo_enabled() )
  {
    if( new_body_list.size() )
      CubitUndo::note_result_bodies( new_body_list );
    else
      CubitUndo::remove_last_undo();
  }

  // Return success if both unites successful
  if( result1 == CUBIT_SUCCESS && result2 == CUBIT_SUCCESS )
    return CUBIT_SUCCESS;

  // Return success if either unite was successful
  if( ( solid_body_list.size() > 1 && result1 == CUBIT_SUCCESS ) ||
      ( sheet_body_list.size() > 1 && result2 == CUBIT_SUCCESS ) )
  {
    // Give warning if one or the other failed
    if( result1 == CUBIT_FAILURE )
      PRINT_WARNING( "Unite of solid volumes failed\n" );
    if( result2 == CUBIT_FAILURE )
      PRINT_WARNING( "Unite of sheet bodies failed\n" );

    return CUBIT_SUCCESS;
  }

  return CUBIT_FAILURE;
}
CubitStatus GeometryModifyTool::unmerge_and_return_merge_partners ( RefVertex input_vertex,
DLIList< DLIList< RefVertex * > * > &  vert_merge_lists,
DLIList< DLIList< RefEdge * > * > &  curve_merge_lists,
DLIList< DLIList< RefFace * > * > &  surf_merge_lists 
)

Definition at line 18989 of file GeometryModifyTool.cpp.

{
  if(!input_vertex->is_merged())
    return CUBIT_FAILURE;

  DLIList<RefFace*> vert_surfs;
  input_vertex->ref_faces(vert_surfs);
  for(int i=vert_surfs.size(); i>0; i--)
  {
    RefFace *cur_surf = vert_surfs.get_and_step();
    if(cur_surf->is_merged())
    {
      DLIList<RefVolume*> surf_vols;
      DLIList<RefFace*> all_surfs_on_both_vols;
      cur_surf->ref_volumes(surf_vols);
      for(int j=surf_vols.size(); j>0; j--)
      {
        RefVolume *cur_vol = surf_vols.get_and_step();
        cur_vol->ref_faces(all_surfs_on_both_vols);
      }
      all_surfs_on_both_vols.uniquify_unordered();
      DLIList<RefFace*> all_surfs_on_both_vols_after_unmerge;
      OldUnmergeCode::instance().unmerge(cur_surf, false);
      for(int j=surf_vols.size(); j>0; j--)
      {
        RefVolume *cur_vol = surf_vols.get_and_step();
        cur_vol->ref_faces(all_surfs_on_both_vols_after_unmerge);
      }
      all_surfs_on_both_vols_after_unmerge.uniquify_unordered();
      all_surfs_on_both_vols_after_unmerge -= all_surfs_on_both_vols;
      if(all_surfs_on_both_vols_after_unmerge.size() != 1)
        return CUBIT_FAILURE;
      all_surfs_on_both_vols_after_unmerge.append(cur_surf);
      DLIList<RefFace*> *new_list = new DLIList<RefFace*>();
      for(int r=all_surfs_on_both_vols_after_unmerge.size(); r>0; r--)
      {
        RefFace *cur_surf = all_surfs_on_both_vols_after_unmerge.get_and_step();
        new_list->append(cur_surf);
      }
      surf_merge_lists.append(new_list);
    }
  }
  DLIList<RefEdge*> vert_curves;
  input_vertex->ref_edges(vert_curves);
  for(int i=vert_curves.size(); i>0; i--)
  {
    RefEdge *cur_curve = vert_curves.get_and_step();
    if(cur_curve->is_merged())
    {
      DLIList<RefFace*> curve_surfs;
      DLIList<RefEdge*> all_curves_on_all_surfs;
      cur_curve->ref_faces(curve_surfs);
      for(int j=curve_surfs.size(); j>0; j--)
      {
        RefFace *cur_surf = curve_surfs.get_and_step();
        cur_surf->ref_edges(all_curves_on_all_surfs);
      }
      all_curves_on_all_surfs.uniquify_unordered();
      DLIList<RefEdge*> all_curves_on_all_surfs_after_unmerge;
      OldUnmergeCode::instance().unmerge(cur_curve, false);
      for(int j=curve_surfs.size(); j>0; j--)
      {
        RefFace *cur_surf = curve_surfs.get_and_step();
        cur_surf->ref_edges(all_curves_on_all_surfs_after_unmerge);
      }
      all_curves_on_all_surfs_after_unmerge.uniquify_unordered();
      all_curves_on_all_surfs_after_unmerge -= all_curves_on_all_surfs;
      if(all_curves_on_all_surfs_after_unmerge.size() < 1)
        return CUBIT_FAILURE;
      all_curves_on_all_surfs_after_unmerge.append_unique(cur_curve);
      DLIList<RefEdge*> *new_list = new DLIList<RefEdge*>();
      for(int r=all_curves_on_all_surfs_after_unmerge.size(); r>0; r--)
      {
        RefEdge *cur_edge = all_curves_on_all_surfs_after_unmerge.get_and_step();
        new_list->append(cur_edge);
      }
      curve_merge_lists.append(new_list);
    }
  }
  vert_curves.clean_out();
  input_vertex->ref_edges(vert_curves);
  DLIList<RefVertex*> curve_verts;
  for(int i=vert_curves.size(); i>0; i--)
  {
    RefEdge *cur_curve = vert_curves.get_and_step();
    cur_curve->ref_vertices(curve_verts);
  }
  curve_verts.uniquify_unordered();
  DLIList<RefVertex*> verts_after_unmerge;
  OldUnmergeCode::instance().unmerge(input_vertex);
  for(int j=vert_curves.size(); j>0; j--)
  {
    RefEdge *cur_curve = vert_curves.get_and_step();
    cur_curve->ref_vertices(verts_after_unmerge);
  }
  verts_after_unmerge.uniquify_unordered();
  verts_after_unmerge -= curve_verts;
  if(verts_after_unmerge.size() < 1)
    return CUBIT_FAILURE;
  verts_after_unmerge.append_unique(input_vertex);
  DLIList<RefVertex*> *new_list = new DLIList<RefVertex*>();
  for(int r=verts_after_unmerge.size(); r>0; r--)
  {
    RefVertex *cur_vert = verts_after_unmerge.get_and_step();
    new_list->append(cur_vert);
  }
  vert_merge_lists.append(new_list);

  return CUBIT_SUCCESS;
}
CubitStatus GeometryModifyTool::unmerge_and_return_merge_partners ( RefEdge input_curve,
DLIList< DLIList< RefEdge * > * > &  curve_merge_lists,
DLIList< DLIList< RefFace * > * > &  surf_merge_lists 
) [private]

Definition at line 18901 of file GeometryModifyTool.cpp.

{
  if(!input_curve->is_merged())
    return CUBIT_FAILURE;

  DLIList<RefFace*> vert_surfs;
  input_curve->start_vertex()->ref_faces(vert_surfs);
  input_curve->end_vertex()->ref_faces(vert_surfs);
  vert_surfs.uniquify_unordered();
  for(int i=vert_surfs.size(); i>0; i--)
  {
    RefFace *cur_surf = vert_surfs.get_and_step();
    if(cur_surf->is_merged())
    {
      DLIList<RefVolume*> surf_vols;
      DLIList<RefFace*> all_surfs_on_both_vols;
      cur_surf->ref_volumes(surf_vols);
      for(int j=surf_vols.size(); j>0; j--)
      {
        RefVolume *cur_vol = surf_vols.get_and_step();
        cur_vol->ref_faces(all_surfs_on_both_vols);
      }
      all_surfs_on_both_vols.uniquify_unordered();
      DLIList<RefFace*> all_surfs_on_both_vols_after_unmerge;
      OldUnmergeCode::instance().unmerge(cur_surf, false);
      for(int j=surf_vols.size(); j>0; j--)
      {
        RefVolume *cur_vol = surf_vols.get_and_step();
        cur_vol->ref_faces(all_surfs_on_both_vols_after_unmerge);
      }
      all_surfs_on_both_vols_after_unmerge.uniquify_unordered();
      all_surfs_on_both_vols_after_unmerge -= all_surfs_on_both_vols;
      if(all_surfs_on_both_vols_after_unmerge.size() != 1)
        return CUBIT_FAILURE;
      all_surfs_on_both_vols_after_unmerge.append(cur_surf);
      DLIList<RefFace*> *new_list = new DLIList<RefFace*>();
      for(int r=all_surfs_on_both_vols_after_unmerge.size(); r>0; r--)
      {
        RefFace *cur_surf = all_surfs_on_both_vols_after_unmerge.get_and_step();
        new_list->append(cur_surf);
      }
      surf_merge_lists.append(new_list);
    }
  }
  DLIList<RefEdge*> vert_curves;
  input_curve->start_vertex()->ref_edges(vert_curves);
  input_curve->end_vertex()->ref_edges(vert_curves);
  vert_curves.uniquify_unordered();
  for(int i=vert_curves.size(); i>0; i--)
  {
    RefEdge *cur_curve = vert_curves.get_and_step();
    if(cur_curve->is_merged())
    {
      DLIList<RefFace*> curve_surfs;
      DLIList<RefEdge*> all_curves_on_all_surfs;
      cur_curve->ref_faces(curve_surfs);
      for(int j=curve_surfs.size(); j>0; j--)
      {
        RefFace *cur_surf = curve_surfs.get_and_step();
        cur_surf->ref_edges(all_curves_on_all_surfs);
      }
      all_curves_on_all_surfs.uniquify_unordered();
      DLIList<RefEdge*> all_curves_on_all_surfs_after_unmerge;
      OldUnmergeCode::instance().unmerge(cur_curve, true);
      for(int j=curve_surfs.size(); j>0; j--)
      {
        RefFace *cur_surf = curve_surfs.get_and_step();
        cur_surf->ref_edges(all_curves_on_all_surfs_after_unmerge);
      }
      all_curves_on_all_surfs_after_unmerge.uniquify_unordered();
      all_curves_on_all_surfs_after_unmerge -= all_curves_on_all_surfs;
      if(all_curves_on_all_surfs_after_unmerge.size() < 1)
        return CUBIT_FAILURE;
      all_curves_on_all_surfs_after_unmerge.append_unique(cur_curve);
      DLIList<RefEdge*> *new_list = new DLIList<RefEdge*>();
      for(int r=all_curves_on_all_surfs_after_unmerge.size(); r>0; r--)
      {
        RefEdge *cur_edge = all_curves_on_all_surfs_after_unmerge.get_and_step();
        new_list->append(cur_edge);
      }
      curve_merge_lists.append(new_list);
    }
  }
  return CUBIT_SUCCESS;
}
CubitStatus GeometryModifyTool::unmerge_input ( RefEdge curve1,
RefEdge curve2,
DLIList< DLIList< RefEdge * > * > &  curve_merge_lists,
DLIList< DLIList< RefFace * > * > &  surf_merge_lists 
) [private]

Definition at line 19103 of file GeometryModifyTool.cpp.

{
  if(curve1->is_merged())
  {
    this->unmerge_and_return_merge_partners(curve1, curve_merge_lists, surf_merge_lists);
  }
  if(curve2->is_merged())
  {
    this->unmerge_and_return_merge_partners(curve2, curve_merge_lists, surf_merge_lists);
  }
  return CUBIT_SUCCESS;
}
Body * GeometryModifyTool::update_body ( Body body) const [protected]

Definition at line 18344 of file GeometryModifyTool.cpp.

{
  BodySM* body_sm = body->get_body_sm_ptr();
  if (body_sm)
    return GeometryQueryTool::instance()->make_Body(body_sm);

  GeometryQueryTool::instance()->destroy_dead_entity(body);
  return 0;
}
CubitStatus GeometryModifyTool::validate_normals ( DLIList< Body * > &  bodies,
RefFace surf_ref,
bool  reverse 
)

Checks for consistent normals across body. Uses surf_ref as a reference surface. All other surfaces in volume should have normal point in likewise direction (in or out of volume).

Checks for consistent normals across body.

Definition at line 7063 of file GeometryModifyTool.cpp.

{
   if (bodies.size() <= 0)
   {
      PRINT_WARNING("There are no entities in the list. Nothing modified\n");
      return CUBIT_FAILURE;
   }

   DLIList<RefEntity*> temp;
   CAST_LIST_TO_PARENT(bodies, temp);
   if ( !same_modify_engine(temp, CUBIT_TRUE))
   {
      PRINT_ERROR("Performing VALIDATE NORMALS with volumes containing geometry\n"
            "      from different modeling engines is not allowed. Delete uncommon\n"
            "      geometry on these volumes before operation.\n\n");
      return CUBIT_FAILURE;
   }

   // Get the GeometryEngine for each Body of the list to check
   // if they are the same and if they are GeometryModifyEngine
   GeometryModifyEngine* gePtr1 = get_engine(bodies.get());
   GeometryModifyEngine* gePtr2;
   Body* Body_ptr = NULL;
   bodies.reset();
   for( int i = bodies.size(); i > 0; i--)
   {
      Body_ptr = bodies.get_and_step();
      gePtr2 = get_engine(Body_ptr);
      if (gePtr1 != gePtr2)
      {
         PRINT_ERROR("In GeometryModifyTool::validate_normals\n"
            "  Volumes are associated with different GMEs. \n");
         return CUBIT_FAILURE;
      }
      if ( gePtr2 == NULL)
      {
         PRINT_ERROR("In GeometryModifyTool::validate_normals\n"
            "       Body %d is not associated with a SME.\n",
            Body_ptr->id());
         return CUBIT_FAILURE;
      }
   }


   DLIList<RefFace*> ref_face_list;
   DLIList<RefFace*> free_face_list;
   DLIList<RefFace*> bad_face_list;

   //gather all the faces from all the bodies
   bodies.reset();
   for( int i=bodies.size(); i--; )
   {
     Body* BodyPtr = bodies.get_and_step();
     BodyPtr->ref_faces(free_face_list);
   }

   RefFace *ref_face_ptr;
   RefFace *inter_face_ptr;

   if(surf_ref != NULL)   // getting the starting surface
   {
     ref_face_ptr = surf_ref;
   }
   else
   {
     ref_face_ptr = free_face_list.get_and_step();
   }

   ref_face_list.append(ref_face_ptr);
   free_face_list.remove(ref_face_ptr);
   free_face_list.reset();

   while(free_face_list.size())
   {
      DLIList<RefEdge*> curve_list;
      ref_face_ptr->ref_edges(curve_list);
      free_face_list.reset();
      for(int jj=free_face_list.size(); jj > 0; jj--)  // getting a new searching surface
      {
         inter_face_ptr = free_face_list.get_and_step();
         DLIList<RefEdge*> inter_curve_list;
         inter_face_ptr->ref_edges(inter_curve_list);
         curve_list.reset();
        // PRINT_INFO("base face %d working on face %d\n", ref_face_ptr->id(),inter_face_ptr->id());

         for (int k= curve_list.size(); k > 0; k--)  // looping through all of the surface curves
         {
            RefEdge *ref_check_curve = curve_list.step_and_get();
            inter_curve_list.reset();

            for (int kk = inter_curve_list.size(); kk > 0; kk--)
            {
               RefEdge *check_curve = inter_curve_list.step_and_get();

               if(ref_check_curve == check_curve)  // finding if a surface is connected
               {
                  DLIList<CoEdge*> coedge_list;
                  check_curve->co_edges(coedge_list);

                  CoEdge* first_coedge = coedge_list.get_and_step();
                  CoEdge* second_coedge = coedge_list.get_and_step();

                  if((first_coedge->get_sense() == second_coedge->get_sense() &&
                     !bad_face_list.is_in_list(ref_face_ptr) ) ||
                     (first_coedge->get_sense() != second_coedge->get_sense() &&
                     bad_face_list.is_in_list(ref_face_ptr) ))    // finding if a surface has a fliped normal
                  {
                     bad_face_list.append(inter_face_ptr);
                     PRINT_INFO("Surface %d is not consistent\n", inter_face_ptr->id());
                  }

                  ref_face_list.append(inter_face_ptr);  // adding to the searched list
                  free_face_list.remove(inter_face_ptr); // removing from the unsearched list
               }

            }

         }

      }

      ref_face_list.remove(ref_face_ptr);     // removeing from the searched list
      ref_face_list.last();
      if(ref_face_list.size() <= 0)
      {
         PRINT_ERROR("In GeometryModifyTool::validate_normals\n"
            "       all surfaces must be connected\n");
         return CUBIT_FAILURE;
      }
      ref_face_ptr = ref_face_list.get();
  }

  if (reverse && bad_face_list.size())
  {
     //CubitStatus result = gePtr1->flip_normals(bad_face_list);
     CubitStatus result = GeometryModifyTool::instance()->reverse(bad_face_list);
     if ( result == CUBIT_FAILURE )
     {
       return CUBIT_FAILURE;
    }
  }
  else if(!bad_face_list.size())
  {
    PRINT_INFO("All surfaces are consistent\n");
  }
  return CUBIT_SUCCESS;
}
CubitStatus GeometryModifyTool::webcut_with_body ( DLIList< Body * > &  webcut_body_list,
Body body,
DLIList< Body * > &  results_list,
DLIList< Body * > &  neighbor_list,
ImprintType  imprint_type = NO_IMPRINT,
CubitBoolean  merge = CUBIT_FALSE,
CubitBoolean  preview = CUBIT_FALSE 
)

Webcuts bodies with a tool body.

Returns:
int
- Number of bodies that were webcut ( >= 0 )
  • webcut_body_list The list of bodies to be webcut
  • plane The plane to be used for webcutting.
  • merge A flag to decide whether the new bodies created by the webcutting process should be merged or not.
  • imprint A flag to decide whether the new bodies created by the webcutting process should be imprinted or not.
This function webcuts a list of bodies through a plane. The newly created bodies are merged and imprinted depeding on the respective flags.

Definition at line 3733 of file GeometryModifyTool.cpp.

{

  CubitStatus ret;

  if (!okay_to_modify( webcut_body_list, "WEBCUT" ))
    return CUBIT_FAILURE;

  CubitBox tool_bounding_box = tool_body->bounding_box();
  remove_bodies_outside_bounding_box( webcut_body_list, tool_bounding_box );

  if( webcut_body_list.size() == 0 )
  {
    PRINT_INFO("Tool does not intersect any bodies/volumes.\n");
    return CUBIT_FAILURE;
  }

  DLIList<BodySM*> body_sm_list(webcut_body_list.size()), result_sm_list;
  BodySM* tool_sm = tool_body->get_body_sm_ptr();
  GeometryModifyEngine* gme = 0;
  if (!tool_sm || !(gme = get_engine(tool_sm)))
  {
    PRINT_DEBUG_153("No modify engine available for body %d.\n", tool_body->id());
    PRINT_ERROR("No modify engine available for volume %d.\n", tool_body->ref_volume()->id());
    return CUBIT_FAILURE;
  }

  webcut_body_list.reset();
  int i;
  for (i = webcut_body_list.size(); i--; )
  {
    Body* body_ptr = webcut_body_list.get_and_step();
    BodySM* sm_ptr = body_ptr->get_body_sm_ptr();
    if (!sm_ptr || get_engine(sm_ptr) != gme)
    {
      PRINT_DEBUG_153("ERROR: Body %d does not belong to the same geometric engine "
                  "as body %d\n", body_ptr->id(), tool_body->id());
      PRINT_ERROR("Volume %d does not belong to the same geometric engine "
                  "as volume %d\n", body_ptr->ref_volume()->id(), tool_body->ref_volume()->id());
      return CUBIT_FAILURE;
    }

    body_sm_list.append(sm_ptr);
  }

  DLIList<int> merged_surface_ids;
  DLIList<int> merged_curve_ids;
  DLIList<BodySM*> neighbor_imprint_list;
  DLIList<Body*> bodies_to_modify;

  if (!preview)
  {
    if( CubitUndo::get_undo_enabled() && preview == CUBIT_FALSE )
    {
      DLIList<Body*> bodies_to_save;
      bodies_to_save += webcut_body_list;
      bodies_to_save += neighboring_bodies;
      CubitUndo::save_state_with_cubit_file( bodies_to_save );
    }

    int i;
    for( i=neighboring_bodies.size(); i--; )
    {
      Body *neighbor_body = neighboring_bodies.get_and_step();
      BodySM *tmp_body = neighbor_body->get_body_sm_ptr();
      GeometryModifyEngine *neighbor_gme = get_engine( tmp_body );

      if( gme == neighbor_gme )
        neighbor_imprint_list.append( tmp_body );
    }

    do_attribute_setup();
    DLIList<BodySM*> bodies_sm_to_modify;
    bodies_sm_to_modify += body_sm_list;
    bodies_sm_to_modify += neighbor_imprint_list;
    push_attributes_before_modify( bodies_sm_to_modify );
    bodies_to_modify += webcut_body_list;
    bodies_to_modify += neighboring_bodies;
    get_merged_curve_and_surface_ids( bodies_to_modify, merged_surface_ids, merged_curve_ids );
  }


  int count = gme->webcut(body_sm_list, tool_sm,
                          neighbor_imprint_list,
                          result_sm_list, imprint_type, preview);

  // finish up if we're doing the real thing
  if (!preview)
  {
    restore_vg_after_modify(result_sm_list, bodies_to_modify, gme);
    remove_pushed_attributes(result_sm_list, bodies_to_modify );

    ret = finish_webcut(webcut_body_list, result_sm_list, merge,
                          count > 0 ? CUBIT_SUCCESS : CUBIT_FAILURE,
                          results_list, &merged_surface_ids, &merged_curve_ids );

    do_attribute_cleanup();
  }
  else
    ret = count > 0 ? CUBIT_SUCCESS : CUBIT_FAILURE;

  if( preview == CUBIT_FALSE && CubitUndo::get_undo_enabled() )
  {
    if( ret == CUBIT_SUCCESS )
      CubitUndo::note_result_bodies( results_list );
    else
      CubitUndo::remove_last_undo();
  }

  return ret;
}
CubitStatus GeometryModifyTool::webcut_with_brick ( DLIList< Body * > &  webcut_body_list,
const CubitVector center,
const CubitVector  axes[3],
const CubitVector extension,
DLIList< Body * > &  results_list,
DLIList< Body * > &  neighbor_list,
ImprintType  imprint_type = NO_IMPRINT,
CubitBoolean  merge = CUBIT_FALSE,
CubitBoolean  preview = CUBIT_FALSE 
)

Webcuts bodies with a brick (cube).

Webcuts the bodies in the list with a cutting brick. The brick is created by the given parameters - center of brick, xyz axes, and extension. Extension is 1/2 width, height and depth. If one of the brick dimensions is zero the resultant planar sheet is used to webcut (webcut_with_ planar_sheet is called). Brick creation is done in the solid modeling engine to reduce the impact on body ids.

Definition at line 5794 of file GeometryModifyTool.cpp.

{
   // Make sure that entity creation is possible.  Allow at most
   // only one of the dimensions to be zero - in which case a planar
   // sheet is used to do the cutting.
   double width = 2.0*extension.x();
   double height = 2.0*extension.y();
   double depth = 2.0*extension.z();
   if ( width < 0.0 || height < 0.0 || depth < 0.0 )
   {
      PRINT_ERROR( "Cannot make a brick of size %f x %f x %f\n"
                   "     Negative dimensions are not allowed.\n",
                   width, height, depth );
      return CUBIT_FAILURE ;
   }

   BodySM *cutting_tool_ptr = NULL;
   CubitBoolean is_sheet_body = CUBIT_FALSE;
   CubitVector p1, p2, p3, p4;
   int wz = width < GEOMETRY_RESABS;
   int hz = height < GEOMETRY_RESABS;
   int dz = depth < GEOMETRY_RESABS;
   int num_zero_dim = wz + hz + dz;
   if( num_zero_dim > 0 )
   {
      if( num_zero_dim > 1 )
      {
         PRINT_ERROR( "Cannot make a sheet of size %f x %f x %f\n"
            "     At least two dimensions must be nonzero.\n",
            width, height, depth );
         return CUBIT_FAILURE ;
      }

      // Make a sheet body instead of a cuboid
      CubitVector sheet_axes[2];
      if( wz )
      {
         sheet_axes[0] = axes[1];
         sheet_axes[1] = axes[2];
         width = depth;
      }
      else if( hz )
      {
         sheet_axes[0] = axes[2];
         sheet_axes[1] = axes[0];
         height = depth;
      }
      else
      {
         sheet_axes[0] = axes[0];
         sheet_axes[1] = axes[1];
      }

      // Get the corners of the sheet ready
      center.next_point( axes[0], width/2.0, p1 );
      p1.next_point( axes[1], -height/2.0, p1 );
      p1.next_point( axes[1], height, p2 );
      p2.next_point( axes[0], -width, p3 );
      p3.next_point( axes[1], -height, p4 );
   }

   if (!okay_to_modify( webcut_body_list, "WEBCUT" ))
     return CUBIT_FAILURE;

   CubitVector tmp_vec( center.x()+width, center.y()+height, center.z()+depth );
   CubitBox tmp_box(tmp_vec);
   tmp_vec.set( center.x()-width, center.y()-height, center.z()-depth );
   tmp_box |= tmp_vec;
   remove_bodies_outside_bounding_box( webcut_body_list, tmp_box );

   if( webcut_body_list.size() == 0 )
   {
     PRINT_INFO("Tool does not intersect any bodies/volumes.\n");
     return CUBIT_FAILURE;
   }

   if( CubitUndo::get_undo_enabled() )
   {
     DLIList<Body*> bodies_to_save;
     bodies_to_save += webcut_body_list;
     bodies_to_save += neighboring_bodies;
     CubitUndo::save_state_with_cubit_file( bodies_to_save );
   }

   CubitStatus rval = CUBIT_SUCCESS;

   const int count = webcut_body_list.size();
   DLIList<BodySM*> result_sm_list;
   DLIList<Body*> body_list(webcut_body_list);
   DLIList<BodySM*> engine_body_sms(count);
   DLIList<Body*> engine_bodies(count);
   GeometryModifyEngine* gme = 0;

   while ( (gme = group_bodies_by_engine(body_list, engine_bodies, engine_body_sms)) )
   {
     DLIList<int> merged_surface_ids;
     DLIList<int> merged_curve_ids;
     DLIList<BodySM*> neighbor_imprint_list;
     if (!preview)
     {
       int i;
       for( i=neighboring_bodies.size(); i--; )
       {
         Body *neighbor_body = neighboring_bodies.get_and_step();
         BodySM *tmp_body = neighbor_body->get_body_sm_ptr();
         GeometryModifyEngine *neighbor_gme = get_engine( tmp_body );

         if( gme == neighbor_gme )
         {
           neighbor_imprint_list.append( tmp_body );
           engine_bodies.append( neighbor_body );
         }
       }

       do_attribute_setup();
       DLIList<BodySM*> bodies_to_modify;
       bodies_to_modify += engine_body_sms;
       bodies_to_modify += neighbor_imprint_list;
       push_attributes_before_modify( bodies_to_modify );
       get_merged_curve_and_surface_ids( engine_bodies, merged_surface_ids, merged_curve_ids );
     }

     // Create the brick to cut with
    if (is_sheet_body)
      cutting_tool_ptr = gme->planar_sheet(p1,p2,p3,p4);
    else
      cutting_tool_ptr = gme->brick( center, axes, extension );
    if( cutting_tool_ptr == NULL )
       return CUBIT_FAILURE;

    CubitStatus status = gme->webcut (
      engine_body_sms, cutting_tool_ptr,
      neighbor_imprint_list,
      result_sm_list, imprint_type, preview );

    // Delete the BodySM that was created to be used as a tool
    gme->get_gqe()->delete_solid_model_entities(cutting_tool_ptr) ;

      // just continue the loop if previewing
      if (preview)
      {
        rval = status;
        continue;
      }

      restore_vg_after_modify(result_sm_list, engine_bodies, gme);
      remove_pushed_attributes(result_sm_list, engine_bodies);

      status = finish_webcut( engine_bodies, result_sm_list, merge, status, results_list,
                              &merged_surface_ids, &merged_curve_ids );

      if (!status)
        rval = CUBIT_FAILURE;

      engine_bodies.clean_out();
      engine_body_sms.clean_out();
      result_sm_list.clean_out();
   }

   if (!preview)
     do_attribute_cleanup();

   if( CubitUndo::get_undo_enabled() && preview == CUBIT_FALSE )
   {
     if( results_list.size() ) //if there are new bodies...something succeeded
       CubitUndo::note_result_bodies( results_list );
     else
       CubitUndo::remove_last_undo();
   }

   return rval;
}
CubitStatus GeometryModifyTool::webcut_with_Cone ( DLIList< Body * > &  webcut_body_list,
DLIList< BodySM * > &  webcut_bodySM_list,
double  outer_radius,
double  top_radius,
CubitVector Axispt1,
CubitVector Axispt2,
DLIList< Body * > &  results_list,
DLIList< Body * > &  neighboring_bodies,
ImprintType  imprint_type = NO_IMPRINT,
CubitBoolean  merge = CUBIT_FALSE,
CubitBoolean  preview = CUBIT_FALSE 
)

Webcuts bodies with a cone.

Webcuts the bodies in the list with a cutting cone. The cone is created by the given parameters. This is done in the solid modeling engine to reduce the impact on body ids.

Definition at line 2833 of file GeometryModifyTool.cpp.

{
    if (!okay_to_modify( webcut_body_list, "WEBCUT" ))
        return CUBIT_FAILURE;

    CubitStatus rval = CUBIT_SUCCESS;


    GfxPreview::clear();


    // find the height
    double dHeight  =  sqrt( (AxisPt2.x()-AxisPt1.x()) * (AxisPt2.x()-AxisPt1.x())+
                            (AxisPt2.y()-AxisPt1.y()) * (AxisPt2.y()-AxisPt1.y())+
                            (AxisPt2.z()-AxisPt1.z()) * (AxisPt2.z()-AxisPt1.z()) );

    // Find the Tan Angle
    double Diff        = fabs(outer_radius - inner_radius);
           Diff       /= dHeight;
    double dTanAngle   = atan ( Diff ) ;

    if (preview)
    {
        // find the bounding box for the cylinder
        CubitBox bounding_box;
        Body* body_ptr = webcut_body_list.get_and_step();
        bounding_box = body_ptr->bounding_box();

        int i;
        for( i=1; i<webcut_body_list.size(); i++ )
        {
            body_ptr = webcut_body_list.get_and_step();
            bounding_box |= body_ptr->bounding_box();
        }

        CubitVector axis;
        axis.x( AxisPt2.x()-AxisPt1.x() ); axis.y( AxisPt2.y()-AxisPt1.y() );
        axis.z( AxisPt2.z()-AxisPt1.z() );


        CubitVector start;
        CubitVector end;
        double dExtendedOuterRadius;
        double dExtendedInnerRadius;


        // Now extend the 2 end points to extend beyond the BBox limits. In case it converges, stop at the Apex.

         FindExtendedPoints( AxisPt1 , AxisPt2 , outer_radius , inner_radius , axis, dHeight , bounding_box ,
                             dTanAngle, start , end, dExtendedOuterRadius , dExtendedInnerRadius );

        int color = CUBIT_BLUE_INDEX;
        GfxPreview::draw_frustum(axis, start, end, dExtendedOuterRadius, dExtendedInnerRadius ,bounding_box , color);
        GfxPreview::flush();
        return rval;
    }

    if( CubitUndo::get_undo_enabled() )
    {
        DLIList<Body*> bodies_to_save;
        bodies_to_save += webcut_body_list;
        bodies_to_save += neighboring_bodies;
        CubitUndo::save_state_with_cubit_file( bodies_to_save );
    }

    const int count = webcut_body_list.size();
    DLIList<BodySM*> result_sm_list;
    DLIList<Body*> body_list(webcut_body_list);
    DLIList<BodySM*> engine_body_sms(count);
    DLIList<Body*> engine_bodies(count);
    GeometryModifyEngine* gme = 0;

    if(!preview)
        do_attribute_setup();

    while ( (gme = group_bodies_by_engine(webcut_body_list, engine_bodies, engine_body_sms)) )
    {
        //get all bodysms that we might modify in this operation
        DLIList<BodySM*> neighbor_imprint_list;
        DLIList<BodySM*> bodies_sm_to_modify;
        DLIList<Body*> bodies_to_modify;
        bodies_to_modify += engine_bodies;
        int i;
        for( i=neighboring_bodies.size(); i--; )
        {
            Body *tmp_body = neighboring_bodies.get_and_step();
            BodySM *tmp_body_sm = tmp_body->get_body_sm_ptr();
            if( gme == get_engine(tmp_body_sm ) )
            {
                neighbor_imprint_list.append( tmp_body_sm );
                bodies_to_modify.append( tmp_body );
            }
        }


        DLIList<BodySM*> Body_to_Cut_SM;

        for( i = 0 ;i<webcut_body_list.size(); i++  )
        {
            Body* body           = webcut_body_list.get_and_step();
            BodySM *Body_To_Cut  = body->get_body_sm_ptr();

            Body_to_Cut_SM.append( Body_To_Cut ) ;
        }



        DLIList<int> merged_surface_ids;
        DLIList<int> merged_curve_ids;

        if(!preview)
        {
            bodies_sm_to_modify += neighbor_imprint_list;

            push_attributes_before_modify( bodies_sm_to_modify );
            //get all the child entities that have been merged
            get_merged_curve_and_surface_ids( bodies_to_modify, merged_surface_ids, merged_curve_ids );
        }


        // Get the overall bounding box of the bodies list
        Body* body_ptr = NULL;
        CubitBox bounding_box;
        if(body_list.size())
        {
            body_ptr  = body_list.get_and_step();
            bounding_box = body_ptr->bounding_box();
            for( i=1; i<webcut_body_list.size(); i++ )
            {
                body_ptr = body_list.get_and_step();
                bounding_box |= body_ptr->bounding_box();
            }
        }



        // Get the Geometry engine
        GeometryModifyEngine* gme =
            GeometryModifyTool::instance()->get_engine( body_ptr );


        //CubitStatus status = CreateCircularBody(webcut_body_list );

        CubitStatus status = CUBIT_SUCCESS;


        CubitVector axis;
        axis.x( AxisPt2.x()-AxisPt1.x() ); axis.y( AxisPt2.y()-AxisPt1.y() );
        axis.z( AxisPt2.z()-AxisPt1.z() );




        // Set The important deciders.

        bool bIfReverseAxis = false;
        if( outer_radius < inner_radius )
        {
            bIfReverseAxis = true;
        }


        //**************************************//
        // find the extension of the narrow end.
        //**************************************//

        // For this find the extended end point, at the smaller end
        // and assign zero radius, setting that point to be the AxisPt2.

        // Will be done only if outerRad is bigger than innerRad
        // Else set a bool to remember that, the inner_radius is set as the outer.

        CubitVector endpt ;
        if( outer_radius > inner_radius )
        {
            //EndPt  = FindExtendedEndPt( outer_radius , inner_radius , AxisPt2 , axis,  dHeight );


            double Diff     = (outer_radius - inner_radius);
            Diff    /= dHeight;
            double dAngle   = atan ( Diff ) ;
            axis.normalize();

            double dTan         = tan( dAngle );
            double dExtendvalue = inner_radius / dTan;

            endpt.x( ( axis.x() * dExtendvalue )  + AxisPt2.x() );
            endpt.y( ( axis.y() * dExtendvalue )  + AxisPt2.y() );
            endpt.z( ( axis.z() * dExtendvalue )  + AxisPt2.z() );



            dHeight = sqrt( (endpt.x() - AxisPt1.x()) * (endpt.x() - AxisPt1.x())+
                (endpt.y() - AxisPt1.y()) * (endpt.y() - AxisPt1.y())+
                (endpt.z() - AxisPt1.z()) * (endpt.z() - AxisPt1.z()) );

            AxisPt2.x( endpt.x() );
            AxisPt2.y( endpt.y() );
            AxisPt2.z( endpt.z() );
        }
        else
        {
            // reverse the axis.

            axis.x( -axis.x());
            axis.y( -axis.y());
            axis.z( -axis.z());

            //endpt  = FindExtendedendpt( inner_radius , outer_radius , AxisPt1 , axis,  dHeight );


            double Diff     = (inner_radius - outer_radius);
            Diff    /= dHeight;
            double dAngle   = atan ( Diff ) ;
            axis.normalize();

            double dTan        = tan( dAngle );
            double dExtendvalue = outer_radius / dTan;

            endpt.x( ( axis.x() * dExtendvalue )  + AxisPt1.x() );
            endpt.y( ( axis.y() * dExtendvalue )  + AxisPt1.y() );
            endpt.z( ( axis.z() * dExtendvalue )  + AxisPt1.z() );




            dHeight = sqrt( (endpt.x() - AxisPt2.x()) * (endpt.x() - AxisPt2.x())+
                (endpt.y() - AxisPt2.y()) * (endpt.y() - AxisPt2.y())+
                (endpt.z() - AxisPt2.z()) * (endpt.z() - AxisPt2.z()) );

            AxisPt1.x( endpt.x() );
            AxisPt1.y( endpt.y() );
            AxisPt1.z( endpt.z() );

             // reset the axis.

            axis.x( -axis.x());
            axis.y( -axis.y());
            axis.z( -axis.z());

        }



        //*****************************************//
        // Now find the extension of the bigger end.
        //*****************************************//

        //CubitVector EndPt ;
        double dExtendedRadius;
        if( outer_radius > inner_radius )
        {
            // reverse the axis.
            axis.x( -axis.x());
            axis.y( -axis.y());
            axis.z( -axis.z());


            //EndPt  = FindExtendedStartPt( bounding_box , outer_radius , inner_radius , AxisPt1 , axis,  dHeight , dTanAngle , dExtendedRadius );



            CubitVector Extended_Start_Pt;

            // Find the Difference between the Max and thre min values in all 3 directions.
            // Incase the point is within the box limits, then add the difference values
            // in all 3 directions , witht he " Axis " as the direction vector and extend the point.

            // After that find the Radius of this bigger end.

            CubitVector DiffVec;

            axis.normalize();

            DiffVec.x( fabs( bounding_box.max_x() - bounding_box.min_x() ));
            DiffVec.y( fabs( bounding_box.max_y() - bounding_box.min_y() ));
            DiffVec.z( fabs( bounding_box.max_z() - bounding_box.min_z() ));

            // Extend the start Pt

            Extended_Start_Pt.x( AxisPt1.x() + ( axis.x() * DiffVec.x() ) );
            Extended_Start_Pt.y( AxisPt1.y() + ( axis.y() * DiffVec.y() ) );
            Extended_Start_Pt.z( AxisPt1.z() + ( axis.z() * DiffVec.z() ) );


            // Find the length

            double dLength = sqrt( (( AxisPt1.x() - Extended_Start_Pt.x()) *  (AxisPt1.x() - Extended_Start_Pt.x()) ) +
                (( AxisPt1.y() - Extended_Start_Pt.y()) *  (AxisPt1.y() - Extended_Start_Pt.y()) ) +
                (( AxisPt1.z() - Extended_Start_Pt.z()) *  (AxisPt1.z() - Extended_Start_Pt.z()) ) );



            // Find the Extended Radius

            dExtendedRadius = outer_radius + ( tan( dTanAngle ) * dLength ) ;


            dHeight = sqrt( (Extended_Start_Pt.x() - AxisPt2.x()) * (Extended_Start_Pt.x() - AxisPt2.x())+
                (Extended_Start_Pt.y() - AxisPt2.y()) * (Extended_Start_Pt.y() - AxisPt2.y())+
                (Extended_Start_Pt.z() - AxisPt2.z()) * (Extended_Start_Pt.z() - AxisPt2.z()) );

            if( dExtendedRadius == 0 )
                dExtendedRadius = outer_radius;

            AxisPt1.x( Extended_Start_Pt.x() );
            AxisPt1.y( Extended_Start_Pt.y() );
            AxisPt1.z( Extended_Start_Pt.z() );

            // reverse the axis.
            axis.x( -axis.x());
            axis.y( -axis.y());
            axis.z( -axis.z());

        }
        else
        {
            //EndPt  = FindExtendedStartPt( bounding_box ,  inner_radius , outer_radius , AxisPt2 , axis,  dHeight , dTanAngle , dExtendedRadius );




            CubitVector Extended_Start_Pt;

            // Find the Difference between the Max and thre min values in all 3 directions.
            // Incase the point is within the box limits, then add the difference values
            // in all 3 directions , witht he " Axis " as the direction vector and extend the point.

            // After that find the Radius of this bigger end.

            CubitVector DiffVec;

            axis.normalize();

            DiffVec.x( fabs( bounding_box.max_x() - bounding_box.min_x() ));
            DiffVec.y( fabs( bounding_box.max_y() - bounding_box.min_y() ));
            DiffVec.z( fabs( bounding_box.max_z() - bounding_box.min_z() ));

            // Extend the start Pt

            Extended_Start_Pt.x( AxisPt2.x() + ( axis.x() * DiffVec.x() ) );
            Extended_Start_Pt.y( AxisPt2.y() + ( axis.y() * DiffVec.y() ) );
            Extended_Start_Pt.z( AxisPt2.z() + ( axis.z() * DiffVec.z() ) );


            // Find the length

            double dLength = sqrt( (( AxisPt2.x() - Extended_Start_Pt.x()) *  (AxisPt2.x() - Extended_Start_Pt.x()) ) +
                (( AxisPt2.y() - Extended_Start_Pt.y()) *  (AxisPt2.y() - Extended_Start_Pt.y()) ) +
                (( AxisPt2.z() - Extended_Start_Pt.z()) *  (AxisPt2.z() - Extended_Start_Pt.z()) ) );



            // Find the Extended Radius

            dExtendedRadius = inner_radius + ( tan( dTanAngle ) * dLength ) ;


            dHeight = sqrt( (Extended_Start_Pt.x() - AxisPt1.x()) * (Extended_Start_Pt.x() - AxisPt1.x())+
                (Extended_Start_Pt.y() - AxisPt1.y()) * (Extended_Start_Pt.y() - AxisPt1.y())+
                (Extended_Start_Pt.z() - AxisPt1.z()) * (Extended_Start_Pt.z() - AxisPt1.z()) );

            AxisPt2.x( Extended_Start_Pt.x() );
            AxisPt2.y( Extended_Start_Pt.y() );
            AxisPt2.z( Extended_Start_Pt.z() );

            if( dExtendedRadius == 0 )
                dExtendedRadius = outer_radius;

        }



        //Create the cylinder

        BodySM* bodySM_Ptr = NULL;
        outer_radius       = dExtendedRadius;
        inner_radius       = 0;
        bodySM_Ptr         = gmeList.get()->cylinder( dHeight, outer_radius, outer_radius, inner_radius );


        if( !bodySM_Ptr )
        {
            return CUBIT_FAILURE;
        }


        DLIList<Curve*> curve_list;

        bodySM_Ptr->curves(curve_list);

        // infor for the Frustum Axis

        CubitVector Frustum_Axis;

        Frustum_Axis.x(0);
        Frustum_Axis.y(0);
        Frustum_Axis.z(dHeight);




        if( bIfReverseAxis )
            axis.z( -axis.z() );


        // Get Cross product for the resultant vector, which will be the axis for rotation
        CubitVector cross;
        cross = Frustum_Axis * axis;


        // 2. Find the Angle Between them
        CubitVector Angle;
        double dAngle  = Angle.vector_angle( Frustum_Axis , axis );



        //Now find the angle and the axis to rotate about...

        dAngle = 180.0*dAngle/CUBIT_PI;

        if( bIfReverseAxis )
            dAngle = 360 - dAngle ;



        // 3. Rotate the body for the received cross product axis ( cross ) as the axis
        // and for the angle, dAngle
        //GeometryQueryTool::instance()->rotate( cutting_tool_ptr , cross , dAngle );

        GeometryQueryEngine* engine = bodySM_Ptr->get_geometry_query_engine();
        CubitStatus result = engine->rotate( bodySM_Ptr, cross, dAngle );


        // 4. Now find the mid-point of the specified 2 vertices, and assign that as the
        //    2'nd parameter, for the Pt at which the center of the, created frustum should lie.

        CubitVector Pt;
        Pt.x( (AxisPt1.x() + AxisPt2.x() )/2  );
        Pt.y( (AxisPt1.y() + AxisPt2.y() )/2  );
        Pt.z( (AxisPt1.z() + AxisPt2.z() )/2  );



        // 5 . Now move the body to the location of the target_center.

        CubitTransformMatrix xform;
        xform.translate( Pt );
        result = engine->translate( bodySM_Ptr, Pt );




        if (!result )
        {
            if(!preview)
            {
                restore_vg_after_modify(result_sm_list, bodies_to_modify, gme);
                remove_pushed_attributes(result_sm_list, bodies_to_modify);
            }
            status = finish_webcut( engine_bodies, result_sm_list, merge, status,
                results_list, &merged_surface_ids, &merged_curve_ids );
        }
        else
        {
            if(!preview)
                remove_pushed_attributes(result_sm_list, engine_bodies);
        }

        if ( !result )
        {
            rval = CUBIT_FAILURE;
            engine_bodies.clean_out();
            engine_body_sms.clean_out();
            result_sm_list.clean_out();
            return rval;
        }

        DLIList<BodySM*> results_list_SM;
        DLIList<BodySM*> neighboring_bodies_SM;
        // Use the BODY to perform webcut
        rval = gme->webcut(engine_body_sms, bodySM_Ptr,
            neighboring_bodies_SM, results_list_SM, imprint_type, preview );

        if( GeometryQueryTool::instance()->history().is_tracking() )
        {
            if( rval == CUBIT_SUCCESS )
            {
                gme->get_gqe()->delete_solid_model_entities(bodySM_Ptr);
            }
        }

        // if we're doing the real thing (not preview) finish the process
        if (!preview)
        {
            restore_vg_after_modify(results_list_SM, body_list, gme);
            remove_pushed_attributes(results_list_SM, body_list);
            rval = finish_webcut( bodies_to_modify, results_list_SM, merge,
                rval, results_list);
            do_attribute_cleanup();

            //GeometryQueryTool::instance()->delete_Body( cutting_tool_ptr );
            GeometryQueryEngine* gqe = bodySM_Ptr->get_geometry_query_engine();
            gqe->delete_solid_model_entities(bodySM_Ptr);
        }

        if( CubitUndo::get_undo_enabled() && preview == CUBIT_FALSE )
        {
            if( rval == CUBIT_SUCCESS )
                CubitUndo::note_result_bodies( results_list );
            else
                CubitUndo::remove_last_undo();
        }

        engine_bodies.clean_out();
        engine_body_sms.clean_out();
        result_sm_list.clean_out();
    }
    return rval;
}
CubitStatus GeometryModifyTool::webcut_with_curve_loop ( DLIList< Body * > &  webcut_body_list,
DLIList< RefEdge * > &  refedge_list,
DLIList< Body * > &  results_list,
DLIList< Body * > &  neighbor_list,
ImprintType  imprint_type = NO_IMPRINT,
CubitBoolean  merge = CUBIT_FALSE,
CubitBoolean  preview = CUBIT_FALSE 
)

Webcuts bodies with a surface defined by a curve loop.

Returns:
int
- Number of bodies that were webcut ( >= 0 )
  • webcut_body_list The list of bodies to be webcut
  • refedge_list The refEdge list to be used to construct the sheet body for webcutting.
  • merge A flag to decide whether the new bodies created by the webcutting process should be merged or not.
  • imprint A flag to decide whether the new bodies created by the webcutting process should be imprinted or not.
This function webcuts a list of bodies through a sheet body defined by a set of curves. The newly created bodies are merged and imprinted depending on the respective flags. It returns the number of bodies that were webcut.

Definition at line 3547 of file GeometryModifyTool.cpp.

{
  if (!okay_to_modify( webcut_body_list, "WEBCUT" ))
    return CUBIT_FAILURE;

  GfxPreview::clear();

   int i;
   const int count = webcut_body_list.size() + refedge_list.size();
   DLIList<TopologyEntity*> entity_list(count);
   DLIList<TopologyBridge*> bridge_list(count);
   CAST_LIST_TO_PARENT(webcut_body_list, entity_list);
   refedge_list.reset();
   for (i = refedge_list.size(); i--; )
     entity_list.append(refedge_list.get_and_step());
   GeometryModifyEngine* gme = common_modify_engine( entity_list, bridge_list );

   if ( !gme )
   {
      PRINT_ERROR("Performing WEBCUTS on volumes containing geometry from\n"
                  "different modeling engines is not allowed.\n"
                  "Delete uncommon geometry on these volumes before operation.\n\n");
      return CUBIT_FAILURE;
   }

   if( CubitUndo::get_undo_enabled() && preview == CUBIT_FALSE )
   {
     DLIList<Body*> bodies_to_save;
     bodies_to_save += webcut_body_list;
     bodies_to_save += neighboring_bodies;
     CubitUndo::save_state_with_cubit_file( bodies_to_save );
   }

   DLIList<BodySM*> body_sm_list(webcut_body_list.size()), result_sm_list;
   DLIList<Curve*> curve_list(refedge_list.size());
   CAST_LIST(bridge_list, body_sm_list, BodySM);
   CAST_LIST(bridge_list, curve_list, Curve);
   assert(body_sm_list.size() == webcut_body_list.size());
   assert(curve_list.size() == refedge_list.size());

   DLIList<int> merged_surface_ids;
   DLIList<int> merged_curve_ids;
   DLIList<BodySM*> neighbor_imprint_list;
   DLIList<Body*> bodies_to_modify;

   //make copies of the curves.
   DLIList<Curve*> copied_curves;
   Curve* temp_curve = NULL;
   for (int i = curve_list.size(); i--;)
     {
       temp_curve = gme->make_Curve(curve_list.get_and_step());
       if(temp_curve != NULL)
         copied_curves.append(temp_curve);
     }

   //make a face out of the curves
   Surface * surf = gme->make_Surface(PLANE_SURFACE_TYPE, copied_curves, NULL, false );
   if (surf == NULL)
     {
       PRINT_ERROR("webcut tool surface is not created from occ.\n");
       return CUBIT_FAILURE;
     }


   //get cutting tool BodySM.
   BodySM* cutting_tool_ptr = gme->make_BodySM(surf);
   assert(cutting_tool_ptr );

   if (!preview)
   {
     int i;
     for( i=neighboring_bodies.size(); i--; )
     {
       Body *neighbor_body = neighboring_bodies.get_and_step();
       BodySM *tmp_body = neighbor_body->get_body_sm_ptr();
       GeometryModifyEngine *neighbor_gme = get_engine( tmp_body );

       if( gme == neighbor_gme )
         neighbor_imprint_list.append( tmp_body );
     }

     do_attribute_setup();
     DLIList<BodySM*> bodies_sm_to_modify;
     bodies_sm_to_modify += body_sm_list;
     bodies_sm_to_modify += neighbor_imprint_list;
     push_attributes_before_modify( bodies_sm_to_modify );
     bodies_to_modify += webcut_body_list;
     bodies_to_modify += neighboring_bodies;
     get_merged_curve_and_surface_ids( bodies_to_modify, merged_surface_ids, merged_curve_ids );
   }


   CubitStatus result_val = gme->webcut(
                     body_sm_list, cutting_tool_ptr,
                     neighbor_imprint_list,
                     result_sm_list,
                     imprint_type, preview) ;

   // Delete the BodySM that was created to be used as a tool
   gme->get_gqe()->delete_solid_model_entities(cutting_tool_ptr) ;

   // finish up if we're doing the real thing
   if (!preview)
   {
     restore_vg_after_modify(result_sm_list, bodies_to_modify, gme);
     remove_pushed_attributes(result_sm_list, bodies_to_modify);

     result_val = finish_webcut( webcut_body_list, result_sm_list, merge,
                                 result_val, results_list,
                                 &merged_surface_ids, &merged_curve_ids );
     do_attribute_cleanup();
   }

  if( CubitUndo::get_undo_enabled() && preview == CUBIT_FALSE )
  {
    if( result_val == CUBIT_SUCCESS )
      CubitUndo::note_result_bodies( results_list );
    else
      CubitUndo::remove_last_undo();
  }

   return result_val;
}
CubitStatus GeometryModifyTool::webcut_with_cylinder ( DLIList< Body * > &  webcut_body_list,
double  radius,
const CubitVector axis,
const CubitVector center,
DLIList< Body * > &  results_list,
DLIList< Body * > &  neighboring_bodies,
ImprintType  imprint_type = NO_IMPRINT,
CubitBoolean  merge = CUBIT_FALSE,
CubitBoolean  preview = CUBIT_FALSE 
)

Webcuts bodies with a cylinder.

Automatically create a midsurface from a volume. {body_list_in} - list of bodies to midsurface {body_list_out} - resulting midsurfaces {thickness_list} - list of matching thickness values for the body out list {lower_tol} - lower tolerance for finding surface pairs {upper_tol} - upper tolerance for finding surface pairs {preview} - preview midsurfaces

Webcuts the bodies in the list with a cutting cylinder. The cylinder is created by the given parameters. This is done in the solid modeling engine to reduce the impact on body ids.

Definition at line 2692 of file GeometryModifyTool.cpp.

{
  if (!okay_to_modify( webcut_body_list, "WEBCUT" ))
    return CUBIT_FAILURE;

  GfxPreview::clear();

  CubitStatus rval = CUBIT_SUCCESS;

  if (preview)
  {
    // find the bounding box for the cylinder
    CubitBox bounding_box;
    Body* body_ptr = webcut_body_list.get_and_step();
    bounding_box = body_ptr->bounding_box();

    int i;
    for( i=1; i<webcut_body_list.size(); i++ )
    {
       body_ptr = webcut_body_list.get_and_step();
       bounding_box |= body_ptr->bounding_box();
    }

    int color = CUBIT_BLUE_INDEX;
    GfxPreview::draw_cylinder(axis, center, bounding_box, (float) radius, color);
    GfxPreview::flush();
    return rval;
  }

  if( CubitUndo::get_undo_enabled() )
  {
    DLIList<Body*> bodies_to_save;
    bodies_to_save += webcut_body_list;
    bodies_to_save += neighboring_bodies;
    CubitUndo::save_state_with_cubit_file( bodies_to_save );
  }

  const int count = webcut_body_list.size();
  DLIList<BodySM*> result_sm_list;
  DLIList<Body*> body_list(webcut_body_list);
  DLIList<BodySM*> engine_body_sms(count);
  DLIList<Body*> engine_bodies(count);
  GeometryModifyEngine* gme = 0;

  if(!preview)
    do_attribute_setup();

  while ( (gme = group_bodies_by_engine(body_list, engine_bodies, engine_body_sms)) )
  {
    //get all bodysms that we might modify in this operation
    DLIList<BodySM*> neighbor_imprint_list;
    DLIList<BodySM*> bodies_sm_to_modify;
    DLIList<Body*> bodies_to_modify;
    bodies_to_modify += engine_bodies;
    int i;
    for( i=neighboring_bodies.size(); i--; )
    {
      Body *tmp_body = neighboring_bodies.get_and_step();
      BodySM *tmp_body_sm = tmp_body->get_body_sm_ptr();
      if( gme == get_engine(tmp_body_sm ) )
      {
        neighbor_imprint_list.append( tmp_body_sm );
        bodies_to_modify.append( tmp_body );
      }
    }

    DLIList<int> merged_surface_ids;
    DLIList<int> merged_curve_ids;

    if(!preview)
    {
      bodies_sm_to_modify += neighbor_imprint_list;

      push_attributes_before_modify( bodies_sm_to_modify );
      //get all the child entities that have been merged
      get_merged_curve_and_surface_ids( bodies_to_modify, merged_surface_ids, merged_curve_ids );
    }

    // note that preview actually gets handled before this point
    CubitStatus status = webcut_w_cylinder(engine_body_sms, radius, axis,
              center, neighbor_imprint_list, result_sm_list, imprint_type );

    if ( status != CUBIT_FAILURE )
    {
      if(!preview)
      {
        restore_vg_after_modify(result_sm_list, bodies_to_modify, gme);
        remove_pushed_attributes(result_sm_list, bodies_to_modify);
      }
      status = finish_webcut( engine_bodies, result_sm_list, merge, status,
                              results_list, &merged_surface_ids, &merged_curve_ids );
    }
    else
    {
      if(!preview)
        remove_pushed_attributes(result_sm_list, engine_bodies);
    }


    engine_bodies.clean_out();
    engine_body_sms.clean_out();
    result_sm_list.clean_out();

    if ( status == CUBIT_FAILURE )
    {
      rval = CUBIT_FAILURE;
      break;
    }
  }

  if(!preview)
    do_attribute_cleanup();

  if( CubitUndo::get_undo_enabled() )
  {
    if( rval == CUBIT_SUCCESS )
      CubitUndo::note_result_bodies( results_list );
    else
      CubitUndo::remove_last_undo();
  }

  return rval;
}
CubitStatus GeometryModifyTool::webcut_with_extended_sheet ( DLIList< Body * > &  webcut_body_list,
DLIList< RefFace * > &  ref_face_list,
DLIList< Body * > &  new_bodies,
DLIList< Body * > &  neighbor_list,
int &  num_cut,
ImprintType  imprint_type = NO_IMPRINT,
CubitBoolean  merge = CUBIT_FALSE,
CubitBoolean  preview = CUBIT_FALSE 
)

Webcuts bodies by with an extended surface(s).

Create a sheet extended from the tool surfaces and then uses it to webcut the bodies.

Definition at line 8945 of file GeometryModifyTool.cpp.

{
   if (!okay_to_modify( webcut_body_list, "WEBCUT" ))
     return CUBIT_FAILURE;

   GfxPreview::clear();

   DLIList<RefEntity*> ref_entity_list;
   CAST_LIST( ref_face_list, ref_entity_list, RefEntity );
   if( !same_modify_engine( ref_entity_list ) )
   {
     PRINT_ERROR( "Extending surfaces from different geometry engines is\n"
       "       not allowed.\n\n" );
     return CUBIT_FAILURE;
   }

   DLIList<BodySM*> body_sm_list(webcut_body_list.size()), new_sms;
   GeometryModifyEngine* gme = common_modify_engine(webcut_body_list, body_sm_list);

   if( !gme )
   {
     PRINT_ERROR("Performing WEBCUTS on volumes containing geometry from\n"
                  "different modeling engines is not allowed.\n"
                  "Delete uncommon geometry on these volumes before operation.\n\n");
      return CUBIT_FAILURE;
   }

   const char* modeler =
          ref_face_list.get()->get_geometry_query_engine()->modeler_type();
   if (strncmp("virtual", modeler, 7) == 0)
   {
     PRINT_ERROR("Cannot extend virtual surfaces.\n"
                 "Remove virtual layer before operation.\n");
     return CUBIT_FAILURE;
   }

   Surface* surf_ptr = 0;
   TopologyBridge* bridge = ref_face_list.get()->bridge_manager()->topology_bridge(gme->get_gqe());
   surf_ptr = dynamic_cast<Surface*>(bridge);

   if ( !surf_ptr )
   {
      PRINT_ERROR("Performing WEBCUTS on volumes containing geometry from a\n"
                  "different modeling engine than the extended surfaces is\n"
                  "not allowed.\n"
                  "Delete uncommon geometry on these volumes before operation.\n\n");
      return CUBIT_FAILURE;
   }

   GeometryQueryEngine *gqe = gme->get_gqe();

   int i;
   RefFace *ref_face_ptr;
   DLIList<Surface*> surf_list;
   for( i=ref_face_list.size(); i--; )
   {
     ref_face_ptr = ref_face_list.get_and_step();
     bridge = ref_face_ptr->bridge_manager()->topology_bridge(gqe);
     surf_ptr = dynamic_cast<Surface*>(bridge);
     surf_list.append( surf_ptr );
   }

   DLIList<int> merged_surface_ids;
   DLIList<int> merged_curve_ids;
   DLIList<BodySM*> neighbor_imprint_list;
   DLIList<Body*> bodies_to_modify;

   if (!preview)
   {
     if( CubitUndo::get_undo_enabled() )
     {
       DLIList<Body*> bodies_to_save;
       bodies_to_save += webcut_body_list;
       bodies_to_save += neighboring_bodies;
       CubitUndo::save_state_with_cubit_file( bodies_to_save );
     }

     int i;
     for( i=neighboring_bodies.size(); i--; )
     {
       Body *neighbor_body = neighboring_bodies.get_and_step();
       BodySM *tmp_body = neighbor_body->get_body_sm_ptr();
       GeometryModifyEngine *neighbor_gme = get_engine( tmp_body );

       if( gme == neighbor_gme )
         neighbor_imprint_list.append( tmp_body );
     }

     do_attribute_setup();
     DLIList<BodySM*> bodies_sm_to_modify;
     bodies_sm_to_modify += body_sm_list;
     bodies_sm_to_modify += neighbor_imprint_list;
     push_attributes_before_modify( bodies_sm_to_modify );
     bodies_to_modify += webcut_body_list;
     bodies_to_modify += neighboring_bodies;
     get_merged_curve_and_surface_ids( bodies_to_modify, merged_surface_ids, merged_curve_ids );
   }

   CubitStatus stat = gme->webcut_with_extended_sheet( body_sm_list,
     surf_list, neighbor_imprint_list, new_sms, num_cut, imprint_type,
     preview );

   if (!preview)
   {
     restore_vg_after_modify(new_sms, bodies_to_modify, gme);
     remove_pushed_attributes(new_sms, bodies_to_modify);
     stat = finish_webcut(webcut_body_list, new_sms, merge, stat, new_bodies,
                          &merged_surface_ids, &merged_curve_ids );
     do_attribute_cleanup();

     if( CubitUndo::get_undo_enabled() )
     {
       if( stat == CUBIT_SUCCESS )
         CubitUndo::note_result_bodies( new_bodies );
       else
         CubitUndo::remove_last_undo();
     }
   }

   return stat;
}
CubitStatus GeometryModifyTool::webcut_with_planar_sheet ( DLIList< Body * > &  webcut_body_list,
const CubitVector center,
const CubitVector  axes[2],
double  width,
double  height,
DLIList< Body * > &  results_list,
DLIList< Body * > &  neighbor_list,
ImprintType  imprint_type = NO_IMPRINT,
CubitBoolean  merge = CUBIT_FALSE,
CubitBoolean  preview = CUBIT_FALSE 
)

Webcuts bodies with a planar sheet.

Webcuts the bodies in the list with a cutting planar sheet. The sheet is created by the given parameters - center of sheet, xy axes, and width and height. Sheet creation is done in the solid modeling engine to reduce the impact on body ids.

Definition at line 5976 of file GeometryModifyTool.cpp.

{
   if ( width <= GEOMETRY_RESABS || height <= GEOMETRY_RESABS )
   {
      PRINT_ERROR( "Cannot webcut with a sheet of size %f x %f\n"
                   "     Negative or zero dimensions are not allowed.\n",
                   width, height );
      return CUBIT_FAILURE ;
   }

   if (!okay_to_modify( webcut_body_list, "WEBCUT" ))
     return CUBIT_FAILURE;

   CubitStatus rval = CUBIT_SUCCESS;

  if( CubitUndo::get_undo_enabled() )
  {
    DLIList<Body*> bodies_to_save;
    bodies_to_save += webcut_body_list;
    bodies_to_save += neighboring_bodies;
    CubitUndo::save_state_with_cubit_file( bodies_to_save );
  }

   const int count = webcut_body_list.size();
   DLIList<BodySM*> result_sm_list;
   DLIList<Body*> body_list(webcut_body_list);
   DLIList<BodySM*> engine_body_sms(count);
   DLIList<Body*> engine_bodies(count);
   GeometryModifyEngine* gme = 0;

   while ( (gme = group_bodies_by_engine(body_list, engine_bodies, engine_body_sms)) )
   {
     DLIList<int> merged_surface_ids;
     DLIList<int> merged_curve_ids;
     DLIList<BodySM*> neighbor_imprint_list;
     if (!preview)
     {
       int i;
       for( i=neighboring_bodies.size(); i--; )
       {
         Body *neighbor_body = neighboring_bodies.get_and_step();
         BodySM *tmp_body = neighbor_body->get_body_sm_ptr();
         GeometryModifyEngine *neighbor_gme = get_engine( tmp_body );

         if( gme == neighbor_gme )
         {
           neighbor_imprint_list.append( tmp_body );
           engine_bodies.append( neighbor_body );
         }
       }

       do_attribute_setup();
       DLIList<BodySM*> bodies_sms_to_modify;
       bodies_sms_to_modify += engine_body_sms;
       bodies_sms_to_modify += neighbor_imprint_list;
       push_attributes_before_modify( bodies_sms_to_modify );
       get_merged_curve_and_surface_ids( engine_bodies, merged_surface_ids, merged_curve_ids );
     }

     // Create the planar sheet to cut with
     CubitVector p1, p2, p3, p4;

     // Get the corners of the sheet
     center.next_point( axes[0], width/2.0, p1 );
     p1.next_point( axes[1], -height/2.0, p1 );
     p1.next_point( axes[1], height, p2 );
     p2.next_point( axes[0], -width, p3 );
     p3.next_point( axes[1], -height, p4 );

     BodySM *cutting_tool_ptr = gme->planar_sheet(p1,p2,p3,p4);
     if( cutting_tool_ptr == NULL )
        return CUBIT_FAILURE;

     CubitStatus status = gme->webcut (
       engine_body_sms, cutting_tool_ptr,
       neighbor_imprint_list,
       result_sm_list, imprint_type, preview );

     // Delete the BodySM that was created to be used as a tool
     gme->get_gqe()->delete_solid_model_entities(cutting_tool_ptr) ;

      // just continue the loop if previewing
      if (preview)
      {
        rval = status;
        continue;
      }

      restore_vg_after_modify(result_sm_list, engine_bodies, gme);
      remove_pushed_attributes(result_sm_list, engine_bodies);

      status = finish_webcut( engine_bodies, result_sm_list, merge, status, results_list,
                              &merged_surface_ids, &merged_curve_ids );
      if (!status)
        rval = CUBIT_FAILURE;

      engine_bodies.clean_out();
      engine_body_sms.clean_out();
      result_sm_list.clean_out();
   }

   if (!preview)
     do_attribute_cleanup();

  if( preview == CUBIT_FALSE && CubitUndo::get_undo_enabled() )
  {
    if( rval == CUBIT_SUCCESS )
      CubitUndo::note_result_bodies( results_list );
    else
      CubitUndo::remove_last_undo();
  }

   return rval;
}
CubitStatus GeometryModifyTool::webcut_with_plane ( DLIList< Body * > &  webcut_body_list,
const CubitVector vector1,
const CubitVector vector2,
const CubitVector vector3,
DLIList< Body * > &  results_list,
DLIList< Body * > &  neighbor_list,
ImprintType  imprint_type = NO_IMPRINT,
CubitBoolean  merge = CUBIT_FALSE,
CubitBoolean  preview = CUBIT_FALSE 
)

Webcuts bodies with a plane.

Returns:
int
- Number of bodies that were webcut ( >= 0 )
  • webcut_body_list The list of bodies to be webcut
  • plane The plane to be used for webcutting.
  • merge A flag to decide whether the new bodies created by the webcutting process should be merged or not.
  • imprint A flag to decide whether the new bodies created by the webcutting process should be imprinted or not.
This function webcuts a list of bodies through a plane. The newly created bodies are merged and imprinted depeding on the respective flags.

Definition at line 6100 of file GeometryModifyTool.cpp.

{
  if (!okay_to_modify( webcut_body_list, "WEBCUT" ))
    return CUBIT_FAILURE;

  GfxPreview::clear();

  CubitStatus rval = CUBIT_SUCCESS;
  if (preview)
  {
    GeometryModifyTool::plane_preview(webcut_body_list, vector1, vector2, vector3);
    return rval;
  }

  //remove bodies that won't intersect plane bounding box
  remove_bodies_outside_bounding_box( webcut_body_list, vector1, vector2, vector3 );

  if( webcut_body_list.size() == 0 )
  {
    PRINT_INFO("Tool does not intersect any bodies/volumes.\n");
    return CUBIT_FAILURE;
  }

  if( CubitUndo::get_undo_enabled() && preview == CUBIT_FALSE )
  {
    DLIList<Body*> bodies_to_save;
    bodies_to_save += webcut_body_list;
    bodies_to_save += neighboring_bodies;
    CubitUndo::save_state_with_cubit_file( bodies_to_save );
  }

  const int count = webcut_body_list.size();
  DLIList<BodySM*> temp_sm_list(webcut_body_list.size());
  DLIList<BodySM*> result_sm_list;
  DLIList<Body*> body_list(webcut_body_list);
  DLIList<BodySM*> engine_body_sms(count);
  DLIList<Body*> engine_bodies(count);
  GeometryModifyEngine* gme = 0;

  // all preview stuff handled before this point
  if(!preview)
    do_attribute_setup();

  while ( (gme = group_bodies_by_engine(body_list, engine_bodies, engine_body_sms)) )
  {

    //get all the child entities that have been merged
    DLIList<int> merged_surface_ids;
    DLIList<int> merged_curve_ids;
    DLIList<BodySM*> neighbor_imprint_list;

    if (!preview)
    {
      int i;
      for( i=neighboring_bodies.size(); i--; )
      {
        Body *neighbor_body = neighboring_bodies.get_and_step();
        BodySM *tmp_body = neighbor_body->get_body_sm_ptr();
        GeometryModifyEngine *neighbor_gme = get_engine( tmp_body );

        if( gme == neighbor_gme )
        {
          neighbor_imprint_list.append( tmp_body );
          engine_bodies.append( neighbor_body );
        }
      }

      DLIList<BodySM*> bodies_sms_to_modify;
      bodies_sms_to_modify += engine_body_sms;
      bodies_sms_to_modify += neighbor_imprint_list;
      push_attributes_before_modify( bodies_sms_to_modify );
      get_merged_curve_and_surface_ids( engine_bodies, merged_surface_ids, merged_curve_ids );
    }

    CubitStatus status = gme->webcut(engine_body_sms, vector1, vector2,
              vector3, neighbor_imprint_list, result_sm_list, imprint_type, preview );

    if ( status != CUBIT_FAILURE )
    {
      if(!preview)
      {
        restore_vg_after_modify(result_sm_list, engine_bodies, gme);
        remove_pushed_attributes(result_sm_list, engine_bodies);
      }
      status = finish_webcut( engine_bodies, result_sm_list, merge, status, results_list,
                              &merged_surface_ids, &merged_curve_ids );
    }
    else
    {
      if(!preview)
        remove_pushed_attributes(result_sm_list, engine_bodies);
    }

    engine_bodies.clean_out();
    engine_body_sms.clean_out();
    result_sm_list.clean_out();

    if ( status == CUBIT_FAILURE )
    {
      rval = CUBIT_FAILURE;
      break;
    }
  }

  if( CubitUndo::get_undo_enabled() && preview == CUBIT_FALSE )
  {
    if( rval == CUBIT_SUCCESS )
      CubitUndo::note_result_bodies( results_list );
    else
      CubitUndo::remove_last_undo();
  }

  if(!preview)
    do_attribute_cleanup();

  return rval;
}
CubitStatus GeometryModifyTool::webcut_with_sheet ( DLIList< Body * > &  webcut_body_list,
Body sheet_body,
DLIList< Body * > &  new_bodies,
DLIList< Body * > &  neighbor_list,
ImprintType  imprint_type = NO_IMPRINT,
CubitBoolean  merge = CUBIT_FALSE,
CubitBoolean  preview = CUBIT_FALSE 
)

Webcut bodies using a surface, need to be planar.

Webcut the bodies using the surface as the cutting tool. This is the real webcut with surface. The others are just for planes... The sheet body is a body with 0 volume.

Definition at line 8826 of file GeometryModifyTool.cpp.

{
   if (!okay_to_modify( webcut_body_list, "WEBCUT" ))
     return CUBIT_FAILURE;

   GfxPreview::clear();

   //remove any bodies with bbox that does not intersect tool body bbox
   CubitBox tool_bounding_box = sheet_body->bounding_box();
   remove_bodies_outside_bounding_box( webcut_body_list, tool_bounding_box );

   if( webcut_body_list.size() == 0 )
   {
     PRINT_INFO("Tool does not intersect any bodies/volumes.\n");
     return CUBIT_FAILURE;
   }

   DLIList<Body*> original_body_list = webcut_body_list;
   webcut_body_list.append(sheet_body);
   DLIList<BodySM*> body_sm_list(webcut_body_list.size()), new_sms;
   GeometryModifyEngine* gme = common_modify_engine(webcut_body_list, body_sm_list);
   if ( !gme )
   {
      PRINT_ERROR("Performing WEBCUTS with volumes containing geometry from\n"
                  "different modeling engines is not allowed.\n"
                  "Delete uncommon geometry on these volumes before operation.\n\n");
      return CUBIT_FAILURE;
   }
   BodySM* tool_sm = body_sm_list.pop();

   DLIList<int> merged_surface_ids;
   DLIList<int> merged_curve_ids;
   DLIList<BodySM*> neighbor_imprint_list;
   DLIList<Body*> bodies_to_modify;

   if (!preview)
   {
     if( CubitUndo::get_undo_enabled() )
     {
       DLIList<Body*> bodies_to_save;
       bodies_to_save += webcut_body_list;
       bodies_to_save += neighboring_bodies;
       CubitUndo::save_state_with_cubit_file( bodies_to_save );
     }

     int i;
     for( i=neighboring_bodies.size(); i--; )
     {
       Body *neighbor_body = neighboring_bodies.get_and_step();
       BodySM *tmp_body = neighbor_body->get_body_sm_ptr();
       GeometryModifyEngine *neighbor_gme = get_engine( tmp_body );

       if( gme == neighbor_gme )
         neighbor_imprint_list.append( tmp_body );
     }

     do_attribute_setup();
     DLIList<BodySM*> bodies_sm_to_modify;
     bodies_sm_to_modify += body_sm_list;
     bodies_sm_to_modify += neighbor_imprint_list;
     push_attributes_before_modify( bodies_sm_to_modify );
     bodies_to_modify += webcut_body_list;
     bodies_to_modify += neighboring_bodies;
     get_merged_curve_and_surface_ids( bodies_to_modify, merged_surface_ids, merged_curve_ids );
   }

   CubitStatus stat = gme->webcut (
       body_sm_list, tool_sm, neighbor_imprint_list,
       new_sms, imprint_type, preview  );

   if (!preview)
   {
     restore_vg_after_modify(new_sms, bodies_to_modify, gme);
     remove_pushed_attributes(new_sms, bodies_to_modify );
   }

   if( stat == CUBIT_FAILURE )
   {
     do_attribute_cleanup();

     if( CubitUndo::get_undo_enabled() && preview == CUBIT_FALSE )
     {
       if( stat == CUBIT_SUCCESS )
         CubitUndo::note_result_bodies( new_bodies );
       else
         CubitUndo::remove_last_undo();
     }
     return CUBIT_FAILURE;
   }

   // finish up if not a preview
   if (!preview)
   {
     stat = finish_webcut( webcut_body_list, new_sms, merge, stat, new_bodies,
                           &merged_surface_ids, &merged_curve_ids );
      // leave webcut_body_list as we found it -- remove appended tool body
     webcut_body_list.pop();

     do_attribute_cleanup();

     if( CubitUndo::get_undo_enabled() )
     {
       if( stat == CUBIT_SUCCESS )
         CubitUndo::note_result_bodies( new_bodies );
       else
         CubitUndo::remove_last_undo();
     }
   }


   return stat;
}
CubitStatus GeometryModifyTool::webcut_with_surface ( DLIList< Body * > &  webcut_body_list,
RefFace refFace,
DLIList< Body * > &  results_list,
DLIList< Body * > &  neighbor_list,
ImprintType  imprint_type = NO_IMPRINT,
CubitBoolean  merge = CUBIT_FALSE,
CubitBoolean  preview = CUBIT_FALSE 
)

Webcuts bodies with a surface -- must be planar.

Returns:
int
- Number of bodies that were webcut ( >= 0 )
  • webcut_body_list The list of bodies to be webcut
  • refFace The refFace to be used to construct the plane for webcutting.
  • merge A flag to decide whether the new bodies created by the webcutting process should be merged or not.
  • imprint A flag to decide whether the new bodies created by the webcutting process should be imprinted or not.
This function webcuts a list of bodies through a plane defined by a refFace. The newly created bodies are merged and imprinted depeding on the respective flags. It returns the number of bodies that were webcut.

Definition at line 3691 of file GeometryModifyTool.cpp.

{
  //make sure that this refface is planar, or you'll get unexpected results
  if( refFace->geometry_type() != PLANE_SURFACE_TYPE )
  {
    PRINT_ERROR("Surface %d is not planar.\n", refFace->id() );
    return CUBIT_FAILURE;
  }

     // Using the face, get three positions (CubitVectors :) :) )
     // The positions can be used by a GeometryModifyEngine to generate its
     // own webcutting tool and perform the webcut.
   CubitVector vector1 = refFace->position_from_u_v(0, 1) ;
   CubitVector vector3 = refFace->position_from_u_v(1, 0) ;
   CubitVector vector2 = refFace->position_from_u_v(0, 0) ;

   CubitStatus result_val = this->webcut_with_plane(webcut_body_list, vector1,
                                  vector2, vector3, results_list, neighboring_bodies,
                                  imprint_type, merge, preview) ;

   return result_val;
}
CubitStatus GeometryModifyTool::webcut_with_sweep_curves ( DLIList< Body * > &  webcut_body_list,
DLIList< RefEdge * > &  tool_curves,
const CubitVector  sweep_vector,
bool  through_all,
RefFace stop_surf,
RefEdge edge_to_sweep_along,
DLIList< Body * > &  new_bodies,
DLIList< Body * > &  neighbor_list,
ImprintType  imprint_type = NO_IMPRINT,
CubitBoolean  merge = false,
CubitBoolean  preview = false 
)

Webcuts bodies with a tool surface created by sweeping curves along a vector.

Definition at line 9333 of file GeometryModifyTool.cpp.

{
   if (!okay_to_modify( webcut_body_list, "WEBCUT" ))
     return CUBIT_FAILURE;

   GfxPreview::clear();

   DLIList<BodySM*> body_sm_list(webcut_body_list.size()), new_sms;
   GeometryModifyEngine* gme = common_modify_engine(webcut_body_list, body_sm_list);
   DLIList<Curve*> curves_to_sweep;
   if (gme)
   {
     DLIList<RefFace*> dummy1;
     DLIList<Surface*> dummy2;
     GeometryModifyEngine* surf_gme = common_modify_engine( dummy1, tool_curves,
                                                            dummy2, curves_to_sweep );
     if( gme != surf_gme ){
       PRINT_ERROR("All geometry not from the same modeling engine.\n");
       return CUBIT_FAILURE;
     }
   }
   else{
     PRINT_ERROR("All volumes not from the same modeling engine.\n");
     return CUBIT_FAILURE;
   }

   Surface *stop_surface = NULL;
   if( stop_surf )
   {
     GeometryModifyEngine *tmp_gme = get_engine(stop_surf);

     if( gme != tmp_gme )
     {
       PRINT_ERROR("Stop surface %d is not of same modeling engine as other input geometry.\n",
                    stop_surf->id() );
       return CUBIT_FAILURE;
     }

     stop_surface = stop_surf->get_surface_ptr();
   }

   Curve *curve_to_sweep_along = NULL;
   if( edge_to_sweep_along )
   {
     GeometryModifyEngine *tmp_gme = get_engine(edge_to_sweep_along);

     if( gme != tmp_gme )
     {
       PRINT_ERROR("Curve %d does is not of same modeling as other input geometry.\n",
                    edge_to_sweep_along->id() );
       return CUBIT_FAILURE;
     }

     curve_to_sweep_along = edge_to_sweep_along->get_curve_ptr();
   }

   DLIList<int> merged_surface_ids;
   DLIList<int> merged_curve_ids;
   DLIList<BodySM*> neighbor_imprint_list;
   DLIList<Body*> bodies_to_modify;

   if (!preview)
   {
     if( CubitUndo::get_undo_enabled() )
     {
       DLIList<Body*> bodies_to_save;
       bodies_to_save += webcut_body_list;
       bodies_to_save += neighboring_bodies;
       CubitUndo::save_state_with_cubit_file( bodies_to_save );
     }

     int i;
     for( i=neighboring_bodies.size(); i--; )
     {
       Body *neighbor_body = neighboring_bodies.get_and_step();
       BodySM *tmp_body = neighbor_body->get_body_sm_ptr();
       GeometryModifyEngine *neighbor_gme = get_engine( tmp_body );

       if( gme == neighbor_gme )
         neighbor_imprint_list.append( tmp_body );
     }

     do_attribute_setup();
     DLIList<BodySM*> bodies_sm_to_modify;
     bodies_sm_to_modify += body_sm_list;
     bodies_sm_to_modify += neighbor_imprint_list;
     push_attributes_before_modify( bodies_sm_to_modify );
     bodies_to_modify += webcut_body_list;
     bodies_to_modify += neighboring_bodies;
     get_merged_curve_and_surface_ids( bodies_to_modify, merged_surface_ids, merged_curve_ids );
   }

   CubitVector tmp_sweep_vector = sweep_vector;
    //get model bbox info...will scale sweep vector by its diagonal
    //so that we go far enough
    if( through_all || stop_surf )
      {
        CubitBox bounding_box = GeometryQueryTool::instance()->model_bounding_box();
        tmp_sweep_vector.normalize();
        tmp_sweep_vector*=(2*bounding_box.diagonal().length());
      }

    DLIList<GeometryEntity*> ref_ent_list;
    for(int i = 0; i < curves_to_sweep.size(); i++)
      ref_ent_list.append((GeometryEntity*)(curves_to_sweep.get_and_step()));
    DLIList<BodySM*> swept_bodies;
    CubitStatus stat;

    if( curve_to_sweep_along )
    {
      DLIList<Curve*> curves_to_sweep_along;
      curves_to_sweep_along.append(curve_to_sweep_along);
      stat = gme->sweep_along_curve(ref_ent_list, swept_bodies,
                               curves_to_sweep_along,0.0,0,false,stop_surface);

      if (!stat && swept_bodies.size() == 0)
        return stat;
    }

    else
    {
      stat = gme->sweep_translational(ref_ent_list, swept_bodies,
                             tmp_sweep_vector,0.0,0, false, false, stop_surface);

      if (!stat && swept_bodies.size() == 0)
        return stat;
    }

    //stitch faces together
    BodySM* cutting_tool_ptr = NULL;
    DLIList<BodySM*> cutting_tools;
    stat = gme->stitch(swept_bodies, cutting_tools, CUBIT_FALSE, 1E-6);

    if(cutting_tools.size() > 1 || cutting_tools.size() == 0)
    {
        //delete all swept faces
        for(int i = 0; i < cutting_tools.size(); i++)
          gme->get_gqe()->delete_solid_model_entities(cutting_tools.get_and_step()) ;
        return CUBIT_FAILURE;
    }
    else
    {
        cutting_tool_ptr = cutting_tools.get();
        stat = gme->webcut( body_sm_list, cutting_tool_ptr, neighbor_imprint_list,
                            new_sms, imprint_type, preview );

        // Delete the BodySM that was created to be used as a tool
        gme->get_gqe()->delete_solid_model_entities(cutting_tool_ptr) ;
    }

   if (!preview)
   {
     restore_vg_after_modify(new_sms, bodies_to_modify, gme);
     remove_pushed_attributes(new_sms, bodies_to_modify);
     stat = finish_webcut(webcut_body_list, new_sms, merge, stat, new_bodies,
                          &merged_surface_ids, &merged_curve_ids );
     do_attribute_cleanup();

     if( CubitUndo::get_undo_enabled() )
     {
       if( stat == CUBIT_SUCCESS )
         CubitUndo::note_result_bodies( new_bodies );
       else
         CubitUndo::remove_last_undo();
     }
   }

   return stat;
}
CubitStatus GeometryModifyTool::webcut_with_sweep_curves_rotated ( DLIList< Body * > &  webcut_body_list,
DLIList< RefEdge * > &  tool_curves,
CubitVector point,
CubitVector sweep_axis,
double  angle,
RefFace stop_surf,
DLIList< Body * > &  new_bodies,
DLIList< Body * > &  neighbor_list,
ImprintType  imprint_type = NO_IMPRINT,
CubitBoolean  merge = false,
CubitBoolean  preview = false 
)

Webcuts bodies with a tool surface created by rotating curves about an axis.

Definition at line 9196 of file GeometryModifyTool.cpp.

{

   if (!okay_to_modify( webcut_body_list, "WEBCUT" ))
     return CUBIT_FAILURE;

   GfxPreview::clear();

   DLIList<BodySM*> body_sm_list(webcut_body_list.size()), new_sms;
   GeometryModifyEngine* gme = common_modify_engine(webcut_body_list, body_sm_list);
   DLIList<Curve*> curves_to_sweep;
   if (gme)
   {
     DLIList<RefFace*> dummy1;
     DLIList<Surface*> dummy2;
     GeometryModifyEngine* surf_gme = common_modify_engine( dummy1, tool_curves,
                                                            dummy2, curves_to_sweep );
     if( gme != surf_gme )
       PRINT_ERROR("All geometry not from the same modeling engine.\n");
   }

   Surface *stop_surface = NULL;
   if( stop_surf )
   {
     GeometryModifyEngine *tmp_gme = get_engine(stop_surf);

     if( gme != tmp_gme )
     {
       PRINT_ERROR("Stop surface %d is not of same modeling engine as other input geometry.\n",
                    stop_surf->id() );
       return CUBIT_FAILURE;
     }

     stop_surface = stop_surf->get_surface_ptr();
   }

   DLIList<int> merged_surface_ids;
   DLIList<int> merged_curve_ids;
   DLIList<BodySM*> neighbor_imprint_list;
   DLIList<Body*> bodies_to_modify;

   if (!preview)
   {
     if( CubitUndo::get_undo_enabled() )
     {
       DLIList<Body*> bodies_to_save;
       bodies_to_save += webcut_body_list;
       bodies_to_save += neighboring_bodies;
       CubitUndo::save_state_with_cubit_file( bodies_to_save );
     }

     int i;
     for( i=neighboring_bodies.size(); i--; )
     {
       Body *neighbor_body = neighboring_bodies.get_and_step();
       BodySM *tmp_body = neighbor_body->get_body_sm_ptr();
       GeometryModifyEngine *neighbor_gme = get_engine( tmp_body );

       if( gme == neighbor_gme )
         neighbor_imprint_list.append( tmp_body );
     }

     do_attribute_setup();
     DLIList<BodySM*> bodies_sm_to_modify;
     bodies_sm_to_modify += body_sm_list;
     bodies_sm_to_modify += neighbor_imprint_list;
     push_attributes_before_modify( bodies_sm_to_modify );
     bodies_to_modify += webcut_body_list;
     bodies_to_modify += neighboring_bodies;
     get_merged_curve_and_surface_ids( bodies_to_modify, merged_surface_ids, merged_curve_ids );
   }

   //sweep the curves.
   DLIList<GeometryEntity*> ref_ent_list;
   for(int i = 0; i < curves_to_sweep.size(); i++)
     ref_ent_list.append((GeometryEntity*)(curves_to_sweep.get_and_step()));

   DLIList<BodySM*> swept_bodies;
   CubitStatus stat = gme->sweep_rotational(ref_ent_list,swept_bodies,point,
                                      sweep_axis,angle,0, 0.0, 0,false,false,
                                      false,stop_surface);
   if(stat == CUBIT_FAILURE  && swept_bodies.size() == 0)
     return stat;

   //stitch faces together
   BodySM* cutting_tool_ptr = NULL;
   DLIList<BodySM*> cutting_tools;
   stat = gme->stitch(swept_bodies, cutting_tools, CUBIT_FALSE, 1E-6);

   if(cutting_tools.size() > 1 || cutting_tools.size() == 0)
     {
       //delete all swept faces
       for(int i = 0; i < cutting_tools.size(); i++)
         gme->get_gqe()->delete_solid_model_entities(cutting_tools.get_and_step()) ;
       return stat;
     }
   else
   {
     cutting_tool_ptr = cutting_tools.get();
     stat = gme->webcut( body_sm_list, cutting_tool_ptr, neighbor_imprint_list,
                         new_sms, imprint_type, preview);

     // Delete the BodySM that was created to be used as a tool
     gme->get_gqe()->delete_solid_model_entities(cutting_tool_ptr) ;
   }

   if (!preview)
   {
     restore_vg_after_modify(new_sms, bodies_to_modify, gme);
     remove_pushed_attributes(new_sms, bodies_to_modify);
     stat = finish_webcut(webcut_body_list, new_sms, merge, stat, new_bodies,
                          &merged_surface_ids, &merged_curve_ids );
     do_attribute_cleanup();

     if( CubitUndo::get_undo_enabled() )
     {
       if( stat == CUBIT_SUCCESS )
         CubitUndo::note_result_bodies( new_bodies );
       else
         CubitUndo::remove_last_undo();
     }
   }

   return stat;
}
CubitStatus GeometryModifyTool::webcut_with_sweep_surfaces ( DLIList< Body * > &  webcut_body_list,
DLIList< RefFace * > &  tool_faces,
const CubitVector  sweep_vector,
bool  sweep_perp,
bool  through_all,
bool  outward,
bool  up_to_next,
RefFace stop_surf,
RefEdge edge_to_sweep_along,
DLIList< Body * > &  new_bodies,
DLIList< Body * > &  neighbor_list,
ImprintType  imprint_type = NO_IMPRINT,
CubitBoolean  merge = false,
CubitBoolean  preview = false 
)

Webcuts bodies with a tool solid created by sweeping surfaces along a vector.

Definition at line 9514 of file GeometryModifyTool.cpp.

{
   if (!okay_to_modify( webcut_body_list, "WEBCUT" ))
     return CUBIT_FAILURE;

   GfxPreview::clear();

   DLIList<BodySM*> body_sm_list(webcut_body_list.size()), new_sms;
   GeometryModifyEngine* gme = common_modify_engine(webcut_body_list, body_sm_list);
   DLIList<Surface*> surfaces_to_sweep;
   if (gme)
   {
     GeometryModifyEngine* surf_gme = common_modify_engine( tool_faces, surfaces_to_sweep );
     if( gme != surf_gme ){
       PRINT_ERROR("All geometry not from the same modeling engine.\n");
       return CUBIT_FAILURE;
     }
   }
   else{
     PRINT_ERROR("All volumes not from the same modeling engine.\n");
     return CUBIT_FAILURE;
   }

   Surface *stop_surface = NULL;
   if( stop_surf )
   {
     GeometryModifyEngine *tmp_gme = get_engine(stop_surf);

     if( gme != tmp_gme )
     {
       PRINT_ERROR("Stop surface %d is not of same modeling engine as other input geometry.\n",
                    stop_surf->id() );
       return CUBIT_FAILURE;
     }

     stop_surface = stop_surf->get_surface_ptr();
   }

   Curve *curve_to_sweep_along = NULL;
   if( edge_to_sweep_along )
   {
     GeometryModifyEngine *tmp_gme = get_engine(edge_to_sweep_along);

     if( gme != tmp_gme )
     {
       PRINT_ERROR("Curve %d does is not of same modeling as other input geometry.\n",
                    edge_to_sweep_along->id() );
       return CUBIT_FAILURE;
     }

     //make sure that the curve is not part of the surface(s) being swept
     DLIList<RefFace*> faces_of_edge;
     edge_to_sweep_along->ref_faces( faces_of_edge );

     int kk;
     for( kk=faces_of_edge.size(); kk--; )
     {
       if( tool_faces.is_in_list( faces_of_edge.get_and_step() ) )
       {
         faces_of_edge.back();
         PRINT_ERROR("Cannot perform sweep.  Curve %d is in Surface %d\n",
                      edge_to_sweep_along->id(), faces_of_edge.get()->id() );
         return CUBIT_FAILURE;
       }
     }

     curve_to_sweep_along = edge_to_sweep_along->get_curve_ptr();
   }

   DLIList<BodySM*> neighbor_imprint_list;
   DLIList<int> merged_surface_ids;
   DLIList<int> merged_curve_ids;
   DLIList<Body*> bodies_to_modify;

   if (!preview)
   {
     if( CubitUndo::get_undo_enabled() )
     {
       DLIList<Body*> bodies_to_save;
       bodies_to_save += webcut_body_list;
       bodies_to_save += neighboring_bodies;
       CubitUndo::save_state_with_cubit_file( bodies_to_save );
     }

     int i;
     for( i=neighboring_bodies.size(); i--; )
     {
       Body *neighbor_body = neighboring_bodies.get_and_step();
       BodySM *tmp_body = neighbor_body->get_body_sm_ptr();
       GeometryModifyEngine *neighbor_gme = get_engine( tmp_body );

       if( gme == neighbor_gme )
         neighbor_imprint_list.append( tmp_body );
     }

     do_attribute_setup();
     DLIList<BodySM*> bodies_sm_to_modify;
     bodies_sm_to_modify += body_sm_list;
     bodies_sm_to_modify += neighbor_imprint_list;
     push_attributes_before_modify( bodies_sm_to_modify );
     bodies_to_modify += webcut_body_list;
     bodies_to_modify += neighboring_bodies;
     get_merged_curve_and_surface_ids( bodies_to_modify, merged_surface_ids, merged_curve_ids );
   }

   BodySM* cutting_tool_ptr = NULL;
   CubitStatus stat = prepare_surface_sweep(
      body_sm_list, surfaces_to_sweep, sweep_vector, sweep_perp, through_all, outward,
      up_to_next, stop_surface, curve_to_sweep_along, cutting_tool_ptr );
   if (stat == CUBIT_SUCCESS)
   {
      stat = gme->webcut( body_sm_list, cutting_tool_ptr, neighbor_imprint_list,
                          new_sms, imprint_type, preview );

      // Delete the BodySM that was created to be used as a tool
      gme->get_gqe()->delete_solid_model_entities(cutting_tool_ptr) ;
   }

   if (!preview)
   {
     restore_vg_after_modify(new_sms, bodies_to_modify, gme);
     remove_pushed_attributes(new_sms, bodies_to_modify);
     stat = finish_webcut(webcut_body_list, new_sms, merge, stat, new_bodies,
                          &merged_surface_ids, &merged_curve_ids );
     do_attribute_cleanup();

     if( CubitUndo::get_undo_enabled() )
     {
       if( stat  == CUBIT_SUCCESS )
         CubitUndo::note_result_bodies( new_bodies );
       else
         CubitUndo::remove_last_undo();
     }
   }

   return stat;
}
CubitStatus GeometryModifyTool::webcut_with_sweep_surfaces_rotated ( DLIList< Body * > &  webcut_body_list,
DLIList< RefFace * > &  tool_faces,
CubitVector point,
CubitVector sweep_axis,
double  angle,
RefFace stop_surf,
bool  up_to_next,
DLIList< Body * > &  new_bodies,
DLIList< Body * > &  neighbor_list,
ImprintType  imprint_type = NO_IMPRINT,
CubitBoolean  merge = false,
CubitBoolean  preview = false 
)

Webcuts bodies with a tool solid created by rotating surfaces about an axis.

Definition at line 9075 of file GeometryModifyTool.cpp.

{

   if (!okay_to_modify( webcut_body_list, "WEBCUT" ))
     return CUBIT_FAILURE;

   GfxPreview::clear();

   DLIList<BodySM*> body_sm_list(webcut_body_list.size()), new_sms;
   GeometryModifyEngine* gme = common_modify_engine(webcut_body_list, body_sm_list);
   DLIList<Surface*> surfaces_to_sweep;
   if (gme)
   {
     GeometryModifyEngine* surf_gme = common_modify_engine( tool_faces, surfaces_to_sweep );
     if( gme != surf_gme )
       PRINT_ERROR("All geometry not from the same modeling engine.\n");
   }

   Surface *stop_surface = NULL;
   if( stop_surf )
   {
     GeometryModifyEngine *tmp_gme = get_engine(stop_surf);

     if( gme != tmp_gme )
     {
       PRINT_ERROR("Stop surface %d is not of same modeling engine as other input geometry.\n",
                    stop_surf->id() );
       return CUBIT_FAILURE;
     }

     stop_surface = stop_surf->get_surface_ptr();
   }

   DLIList<int> merged_surface_ids;
   DLIList<int> merged_curve_ids;
   DLIList<BodySM*> neighbor_imprint_list;
   DLIList<Body*> bodies_to_modify;

   if (!preview)
   {
     if( CubitUndo::get_undo_enabled() )
     {
       DLIList<Body*> bodies_to_save;
       bodies_to_save += webcut_body_list;
       bodies_to_save += neighboring_bodies;
       CubitUndo::save_state_with_cubit_file( bodies_to_save );
     }

     int i;
     for( i=neighboring_bodies.size(); i--; )
     {
       Body *neighbor_body = neighboring_bodies.get_and_step();
       BodySM *tmp_body = neighbor_body->get_body_sm_ptr();
       GeometryModifyEngine *neighbor_gme = get_engine( tmp_body );

       if( gme == neighbor_gme )
         neighbor_imprint_list.append( tmp_body );
     }

     do_attribute_setup();
     DLIList<BodySM*> bodies_sm_to_modify;
     bodies_sm_to_modify += body_sm_list;
     bodies_sm_to_modify += neighbor_imprint_list;
     push_attributes_before_modify( bodies_sm_to_modify );
     bodies_to_modify += webcut_body_list;
     bodies_to_modify += neighboring_bodies;
     get_merged_curve_and_surface_ids( bodies_to_modify, merged_surface_ids, merged_curve_ids );
   }

   BodySM* cutting_tool_ptr = NULL;
   CubitStatus stat = prepare_surface_sweep(body_sm_list,surfaces_to_sweep,
                           sweep_axis,false,false,false,
                           up_to_next,stop_surface, NULL, cutting_tool_ptr, &point, &angle);
   if(stat == CUBIT_SUCCESS )
   {
     stat = gme->webcut( body_sm_list, cutting_tool_ptr, neighbor_imprint_list,
                         new_sms, imprint_type, preview );

     // Delete the BodySM that was created to be used as a tool
     gme->get_gqe()->delete_solid_model_entities(cutting_tool_ptr) ;
   }

   else
   {
     PRINT_ERROR("Can't create a swept surface for webcut.\n");
     return CUBIT_FAILURE;
   }

   // if not previewing do the rest of the creation
   if (!preview)
   {
     restore_vg_after_modify(new_sms, bodies_to_modify, gme);
     remove_pushed_attributes(new_sms, bodies_to_modify);
     stat = finish_webcut(webcut_body_list, new_sms, merge, stat, new_bodies,
                          &merged_surface_ids, &merged_curve_ids );
     do_attribute_cleanup();

     if( CubitUndo::get_undo_enabled() )
     {
       if( stat == CUBIT_SUCCESS )
         CubitUndo::note_result_bodies( new_bodies );
       else
         CubitUndo::remove_last_undo();
     }
   }

   return stat;
}

Friends And Related Function Documentation

friend class MergeTool [friend]

Definition at line 69 of file GeometryModifyTool.hpp.


Member Data Documentation

Option for to know if we should imprint all of the edges or only relevant ones. For now, default is false, but check the .cc file. The user can control this by a "set" nonregimprint command. Default: true.

Definition at line 2258 of file GeometryModifyTool.hpp.

Regularized booleans are performed. Default: true.

Definition at line 2261 of file GeometryModifyTool.hpp.

RefEntity * GeometryModifyTool::copyingEntity = NULL [static, private]

This pointer points to the entity that is being copied.

Pointer to the entity being copied. When copying an entity, used to prevent to copying of unique id and saved-merged-ids attributes.

Definition at line 2270 of file GeometryModifyTool.hpp.

The list of geometry modify engines.

Definition at line 2273 of file GeometryModifyTool.hpp.

Use group imprinting, which is much faster. Default: true.

Definition at line 2233 of file GeometryModifyTool.hpp.

Static pointer to the unique instance of this class.

Definition at line 2230 of file GeometryModifyTool.hpp.

An object will be unmeshed if modified or deleted. Default: true.

Definition at line 2236 of file GeometryModifyTool.hpp.

An object will be cached if the mesh is autodeleted and can be remeshed later. Default: false.

Definition at line 2240 of file GeometryModifyTool.hpp.

Causes code to reuse old ids, which are more persistent. Default: false.

Definition at line 2243 of file GeometryModifyTool.hpp.

Attempt entity naming backwards compatible with v8/pre-bool-on-merged. Default: false.

Definition at line 2247 of file GeometryModifyTool.hpp.

Separate the result bodies of webcutting into single-body volumes. Default: true.

Definition at line 2251 of file GeometryModifyTool.hpp.

Unite operations can mix sheet bodies with solid bodies. Default: true.

Definition at line 2264 of file GeometryModifyTool.hpp.


The documentation for this class was generated from the following files:
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines