cgma
VirtualQueryEngine Class Reference

#include <VirtualQueryEngine.hpp>

Inheritance diagram for VirtualQueryEngine:
GeometryQueryEngine

List of all members.

Public Member Functions

virtual int curve_is_on_ignored_surface (Curve *curve, Surface *surf)
void remove_virtual_geometry (RefEntity *entity_ptr, CubitBoolean all_children)
void remove_virtual_geometry (Body *body, bool all_children)
void remove_virtual_geometry (RefVolume *vol, bool all_children)
void remove_virtual_geometry (RefFace *face)
void register_attributes ()
 ~VirtualQueryEngine ()
virtual const std::type_info & entity_type_info () const
const char * modeler_type ()
virtual int get_major_version ()
virtual int get_minor_version ()
virtual int get_subminor_version ()
virtual CubitString get_engine_version_string ()
virtual bool is_intermediate_engine ()
virtual CubitStatus get_graphics (Surface *surface_ptr, GMem *gmem, std::vector< TopologyBridge * > &vertex_edge_to_point_vector, std::vector< std::pair< TopologyBridge *, std::pair< int, int > > > &facet_edges_on_curves, unsigned short normal_tolerance, double distance_tolerance, double max_edge_length) const
virtual CubitStatus get_graphics (Surface *surface_ptr, GMem *gMem, unsigned short normal_tolerance, double distance_tolerance, double max_edge_length) const
virtual CubitStatus get_graphics (Curve *curve_ptr, GMem *gMem, double angle_tolerance=0, double distance_tolerance=0, double max_edge_length=0) const
virtual CubitStatus get_isoparametric_points (Surface *ref_face_ptr, int &nu, int &nv, GMem *&gMem) const
virtual CubitStatus get_u_isoparametric_points (Surface *ref_face_ptr, double v, int &n, GMem *&gMem) const
virtual CubitStatus get_v_isoparametric_points (Surface *ref_face_ptr, double u, int &n, GMem *&gMem) const
virtual CubitStatus transform_vec_position (CubitVector const &position_vector, BodySM *OSME_ptr, CubitVector &transformed_vector) const
CubitStatus translate (BodySM *body, const CubitVector &offset)
CubitStatus rotate (BodySM *body, const CubitVector &axis, double angle)
CubitStatus scale (BodySM *body, double factor)
CubitStatus scale (BodySM *body, const CubitVector &factors)
CubitStatus reflect (BodySM *body, const CubitVector &axis)
CubitStatus restore_transform (BodySM *body)
CubitStatus translate (GeometryEntity *ent, const CubitVector &offset)
CubitStatus rotate (GeometryEntity *ent, const CubitVector &axis, double degrees)
CubitStatus scale (GeometryEntity *ent, double factor)
CubitStatus scale (GeometryEntity *ent, const CubitVector &factors)
CubitStatus reflect (GeometryEntity *ent, const CubitVector &axis)
virtual CubitStatus get_visible_entities (TopologyBridge *hidden_tb, DLIList< TopologyBridge * > &real_tbs)
virtual TopologyBridgeget_visible_entity_at_point (TopologyBridge *hidden_tb, CubitVector *point)
CubitBoolean virtuals_created () const
CubitBoolean is_partition (RefEntity *ref_entity)
CubitStatus get_sister_partitions (RefEntity *ref_entity, DLIList< RefEntity * > &sisters)
CubitStatus sort_edges (DLIList< RefEdge * > &edge_list) const
virtual CubitStatus get_underlying_curves (Curve *curve_ptr, DLIList< TopologyBridge * > &curve_list)
virtual CubitStatus get_underlying_surfaces (Surface *surf_ptr, DLIList< TopologyBridge * > &surf_list)
virtual CubitStatus get_underlying_bridges (TopologyBridge *bridge_ptr, DLIList< TopologyBridge * > &bridge_list)
virtual CubitBoolean bodies_overlap (BodySM *body_ptr_1, BodySM *body_ptr_2) const
virtual CubitBoolean volumes_overlap (Lump *lump1, Lump *lump2) const
virtual CubitStatus get_intersections (Curve *curve, CubitVector &point1, CubitVector &point2, DLIList< CubitVector > &intersection_list, CubitBoolean bounded, CubitBoolean closest)
virtual CubitStatus get_intersections (Curve *ref_edge1, Curve *ref_edge2, DLIList< CubitVector > &intersection_list, bool bounded=CUBIT_FALSE, bool closest=CUBIT_FALSE)
virtual CubitStatus get_intersections (Curve *ref_edge, Surface *ref_face, DLIList< CubitVector > &intersection_list, bool bounded=CUBIT_FALSE)
virtual CubitStatus entity_extrema (DLIList< GeometryEntity * > &ref_entity_list, const CubitVector *dir1, const CubitVector *dir2, const CubitVector *dir3, CubitVector &extrema, GeometryEntity *&extrema_entity_ptr)
virtual CubitStatus entity_entity_distance (GeometryEntity *ref_entity_ptr1, GeometryEntity *ref_entity_ptr2, CubitVector &pos1, CubitVector &pos2, double &distance)

Static Public Member Functions

static VirtualQueryEngineinstance ()
static void delete_instance ()
static void get_VEs (RefVolume *volume_ptr, DLIList< TopologyBridge * > &ve_list, CubitBoolean visible=CUBIT_FALSE, const CubitBoolean children_too=CUBIT_TRUE)
static void get_VEs (RefFace *face_ptr, DLIList< TopologyBridge * > &ve_list, CubitBoolean visible=CUBIT_FALSE, const CubitBoolean children_too=CUBIT_TRUE)
static void get_VEs (RefEdge *edge_ptr, DLIList< TopologyBridge * > &ve_list, CubitBoolean visible=CUBIT_FALSE, const CubitBoolean children_too=CUBIT_TRUE)
static void get_VEs (RefVertex *vertex_ptr, DLIList< TopologyBridge * > &ve_list, CubitBoolean visible=CUBIT_FALSE, const CubitBoolean children_too=CUBIT_TRUE)
static void get_VEs (TopologyEntity *te_ptr, DLIList< TopologyBridge * > &ve_list, CubitBoolean visible=CUBIT_FALSE, const CubitBoolean children_too=CUBIT_TRUE)
static CubitBoolean has_virtual (TopologyEntity *entity)
static CubitBoolean is_virtual (TopologyEntity *entity, const CubitBoolean children_too=CUBIT_FALSE)
static CubitBoolean is_virtual (DLIList< Body * > &entity_list, const CubitBoolean children_too=CUBIT_FALSE)
static CubitBoolean is_virtual (DLIList< RefEntity * > &entity_list, const CubitBoolean children_too=CUBIT_FALSE)
static CubitStatus associate_curves (DLIList< Curve * > &target_set, RefEdge *edge_ptr, DLIList< Curve * > &reset_set)

Static Public Attributes

static const double param_epsilon_fraction = 1000000

Protected Member Functions

 VirtualQueryEngine ()
CubitStatus get_composite_curve_facetting (CompositeCurve *ccurve_ptr, GMem *gMem, double angle_tolerance=0, double distance_tolerance=0, double max_edge_length=0) const
CubitStatus get_partition_curve_facetting (PartitionCurve *pcurve_ptr, GMem *gMem, double angle_tolerance=0, double distance_tolerance=0, double max_edge_length=0) const
CubitStatus get_composite_surface_facetting (CompositeSurface *surf_ptr, GMem *gMem, std::vector< TopologyBridge * > *vertex_edge_to_point_vector, std::vector< std::pair< TopologyBridge *, std::pair< int, int > > > *facet_edges_on_curves, unsigned short normal_tol, double absolute_tol, double longest_edge) const
CubitStatus get_partition_surface_facetting (PartitionSurface *surf_ptr, GMem *gMem, std::vector< TopologyBridge * > *vertex_edge_to_point_vector, std::vector< std::pair< TopologyBridge *, std::pair< int, int > > > *facet_edges_on_curves, unsigned short normal_tol, double absolute_tol, double longest_edge) const
virtual CubitStatus export_solid_model (DLIList< TopologyBridge * > &bridge_list, const char *file_name, Model_File_Type file_type, const CubitString &cubit_version, ModelExportOptions &export_options)
virtual CubitStatus export_solid_model (DLIList< TopologyBridge * > &bridge_list, char *&p_buffer, int &n_buffer_size, bool b_export_buffer)
virtual CubitStatus save_temp_geom_file (DLIList< TopologyBridge * > &bridge_list, const char *file_name, const CubitString &cubit_version, CubitString &created_file, CubitString &created_file_type)
virtual CubitStatus import_solid_model (const char *file_name, Model_File_Type file_type, DLIList< TopologyBridge * > &imported_entities, ModelImportOptions &import_options)
virtual CubitStatus import_solid_model (DLIList< TopologyBridge * > &imported_entities, const char *pBuffer, const int n_buffer_size)
virtual void delete_solid_model_entities (DLIList< BodySM * > &) const
virtual CubitStatus delete_solid_model_entities (BodySM *body_ptr) const
virtual CubitStatus delete_solid_model_entities (Surface *surf_ptr) const
virtual CubitStatus delete_solid_model_entities (Curve *curve_ptr) const
virtual CubitStatus delete_solid_model_entities (TBPoint *point_ptr) const
virtual CubitStatus fire_ray (CubitVector &origin, CubitVector &direction, DLIList< TopologyBridge * > &at_entity_list, DLIList< double > &ray_params, int max_hits, double ray_radius, DLIList< TopologyBridge * > *hit_entity_list=0) const
virtual double get_sme_resabs_tolerance () const
virtual double set_sme_resabs_tolerance (double new_resabs)
virtual CubitStatus set_int_option (const char *opt_name, int val)
virtual CubitStatus set_dbl_option (const char *opt_name, double val)
virtual CubitStatus set_str_option (const char *opt_name, const char *val)

Static Protected Attributes

static VirtualQueryEngineinstance_ = NULL

Private Member Functions

void default_error_message (const char callers_name[]) const

Static Private Attributes

static const int VGE_MAJOR_VERSION = 10
static const int VGE_MINOR_VERSION = 0
static const int VGE_SUBMINOR_VERSION = 0

Detailed Description

Definition at line 66 of file VirtualQueryEngine.hpp.


Constructor & Destructor Documentation

Definition at line 109 of file VirtualQueryEngine.cpp.

{
//  destroy_all_virtual_entities();
//  if( virtual_entity_list_.size() )
//      PRINT_WARNING("Not all virtual geometry has been removed.  "
//                    "This is a bug (memory leak).  Please report it.\n");
//  assert( virtual_entity_list_.size() == 0 );

  PartitionEngine::delete_instance();
  CompositeEngine::delete_instance();

  instance_ = NULL;
}

Definition at line 814 of file VirtualQueryEngine.cpp.

{
  assert( !instance_);
    //Add the VirtualQueryEngine to the GeometryQueryTool's gqeList and
    //set the VGE to the GQT's default engine.
   //GeometryQueryTool::instance()->add_gqe(this);
   //GeometryQueryTool::instance()->set_default_engine(this); 
  CompositeEngine::instance();
  PartitionEngine::instance();
}

Member Function Documentation

static CubitStatus VirtualQueryEngine::associate_curves ( DLIList< Curve * > &  target_set,
RefEdge edge_ptr,
DLIList< Curve * > &  reset_set 
) [static]
CubitBoolean VirtualQueryEngine::bodies_overlap ( BodySM body_ptr_1,
BodySM body_ptr_2 
) const [virtual]

Implements GeometryQueryEngine.

Definition at line 2356 of file VirtualQueryEngine.cpp.

{
  PartitionBody* partition_body1 = dynamic_cast<PartitionBody*>(body_ptr_1);
  PartitionBody* partition_body2 = dynamic_cast<PartitionBody*>(body_ptr_2);

  BodySM *body1 = body_ptr_1;
  if( partition_body1 )
    body1 = partition_body1->real_body();

  BodySM *body2 = body_ptr_2;
  if( partition_body2 )
    body2 = partition_body2->real_body();
  
  GeometryQueryEngine *gqe = body1->get_geometry_query_engine();
  if( gqe != body2->get_geometry_query_engine() )
  {
    PRINT_ERROR("Volumes must be of the same type (, SolidWorks, etc) to\n"
                "find if they overlap.\n");
    return CUBIT_FALSE;
  }

  return gqe->bodies_overlap( body1, body2 );

}
int VirtualQueryEngine::curve_is_on_ignored_surface ( Curve curve,
Surface surf 
) [virtual]

Reimplemented from GeometryQueryEngine.

Definition at line 1414 of file VirtualQueryEngine.cpp.

{ 
  int i, ret = 0;

  CompositeSurface *cs = dynamic_cast<CompositeSurface*>(surf);
  if(cs && curve_in)
  {
    DLIList<Surface*> ignored_surfs;
    cs->get_ignored_surfs(ignored_surfs);
    for(i=ignored_surfs.size(); i>0 && !ret; i--)
    {
      Surface *surf = ignored_surfs.get_and_step();
      DLIList<Curve*> crvs;
      surf->curves(crvs);
      if(crvs.is_in_list(curve_in))
        ret = 1;
    }
  }

  return ret;
}
void VirtualQueryEngine::default_error_message ( const char  callers_name[]) const [private]

Definition at line 1346 of file VirtualQueryEngine.cpp.

{
  PRINT_ERROR("A call was made to:\n");
  PRINT_ERROR("VirtualQueryEngine::");
  PRINT_ERROR("%s", callers_name);
  PRINT_ERROR("\n");
  PRINT_ERROR("Although this function is inhereted from GeometryQueryEngine\n");
  PRINT_ERROR("it is not applicable or implememtend in VirtualQueryEngine.\n");
  PRINT_ERROR("\nTHIS IS A BUG.  This function should NEVER be called.\n");
  PRINT_ERROR("\nThis function exists only because it is pure virtual in\n");
  PRINT_ERROR("the abstract class GeometryQueryEngine, and must be\n");
  PRINT_ERROR("defined in VirtualQueryEngine for the class to be\n");
  PRINT_ERROR("instantiated.\n");
}

Definition at line 123 of file VirtualQueryEngine.cpp.

{
  if( NULL != instance_ )
  {
    delete instance_;
    instance_ = NULL;
  }
}    
void VirtualQueryEngine::delete_solid_model_entities ( DLIList< BodySM * > &  list) const [protected, virtual]

Implements GeometryQueryEngine.

Definition at line 1876 of file VirtualQueryEngine.cpp.

{
  for ( int i = list.size(); i--; )
    delete_solid_model_entities( list.get_and_step() );
}
CubitStatus VirtualQueryEngine::delete_solid_model_entities ( BodySM body_ptr) const [protected, virtual]

Implements GeometryQueryEngine.

Definition at line 1884 of file VirtualQueryEngine.cpp.

{ 
  CompositeBody* compbod = dynamic_cast<CompositeBody*>(bodysm);
  if (compbod)
  {
    while (compbod->num_bodies())
    {
      BodySM* dead_body = compbod->get_body( compbod->num_bodies() - 1 );
      dead_body->get_geometry_query_engine()->delete_solid_model_entities( dead_body );
    }
  
    CompositeEngine::instance().clean_out_deactivated_geometry();
    return CUBIT_SUCCESS;
  }
  
  
  PartitionBody* bod = dynamic_cast<PartitionBody*>(bodysm);
  if ( !bod )
    return CUBIT_FAILURE;
  
  PartitionEngine::instance().delete_solid_model_entities( bod, bodysm );
  if ( bodysm ) {
    bodysm->get_geometry_query_engine()->delete_solid_model_entities(bodysm);
  }
  return CUBIT_SUCCESS;
}
CubitStatus VirtualQueryEngine::delete_solid_model_entities ( Surface surf_ptr) const [protected, virtual]

Implements GeometryQueryEngine.

Definition at line 1912 of file VirtualQueryEngine.cpp.

{
  PartitionSurface* ps_ptr = dynamic_cast<PartitionSurface*>(surf_ptr);
  CompositeSurface* cs_ptr = dynamic_cast<CompositeSurface*>(surf_ptr);
  
  if (cs_ptr)
  {
    while(cs_ptr->num_surfs())
    {
      Surface* dead_surf = cs_ptr->get_surface(cs_ptr->num_surfs()-1);
      dead_surf->get_geometry_query_engine()->delete_solid_model_entities(dead_surf);
    }
    
    CompositeEngine::instance().clean_out_deactivated_geometry();
  }
  
  else if( ps_ptr )
  {
    PartitionEngine::instance().delete_solid_model_entities( ps_ptr, surf_ptr );
    if ( surf_ptr )
      surf_ptr->get_geometry_query_engine()->delete_solid_model_entities(surf_ptr);
  }
  
  return CUBIT_SUCCESS;
}
CubitStatus VirtualQueryEngine::delete_solid_model_entities ( Curve curve_ptr) const [protected, virtual]

Implements GeometryQueryEngine.

Definition at line 1939 of file VirtualQueryEngine.cpp.

{
  CompositeCurve* cc_ptr = dynamic_cast<CompositeCurve*>(curve_ptr);
  PartitionCurve* pc_ptr = dynamic_cast<PartitionCurve*>(curve_ptr);

  if( cc_ptr )
  {
    while(cc_ptr->num_curves())
    {
      Curve* dead_curv = cc_ptr->get_curve(cc_ptr->num_curves()-1);
      dead_curv->get_geometry_query_engine()->delete_solid_model_entities(dead_curv);
    }
    
    CompositeEngine::instance().clean_out_deactivated_geometry();
  }
  else if( pc_ptr )
  {
    PartitionEngine::instance().delete_solid_model_entities( pc_ptr, curve_ptr );
    if ( curve_ptr )
      curve_ptr->get_geometry_query_engine()->delete_solid_model_entities(curve_ptr);
  }
 
  return CUBIT_SUCCESS;
}
CubitStatus VirtualQueryEngine::delete_solid_model_entities ( TBPoint point_ptr) const [protected, virtual]

Implements GeometryQueryEngine.

Definition at line 1965 of file VirtualQueryEngine.cpp.

{
  return CUBIT_FAILURE;
}
CubitStatus VirtualQueryEngine::entity_entity_distance ( GeometryEntity ref_entity_ptr1,
GeometryEntity ref_entity_ptr2,
CubitVector pos1,
CubitVector pos2,
double &  distance 
) [virtual]

Implements GeometryQueryEngine.

Definition at line 1602 of file VirtualQueryEngine.cpp.

{
  CompositeCurve *cc1 = dynamic_cast<CompositeCurve*>(ge1);
  CompositeCurve *cc2 = dynamic_cast<CompositeCurve*>(ge2);
  CompositeSurface *cs1 = dynamic_cast<CompositeSurface*>(ge1);
  CompositeSurface *cs2 = dynamic_cast<CompositeSurface*>(ge2);

  DLIList<GeometryEntity*> geometry_entities_1;
  DLIList<GeometryEntity*> geometry_entities_2;
  DLIList<GeometryQueryEngine*> gqes_1;
  DLIList<GeometryQueryEngine*> gqes_2;

  int i, j;
  int still_ok = 1;

  if(cc1)
  {
    for(i=cc1->num_curves()-1; i>-1 && still_ok; i--)
    {
      GeometryEntity *ge = cc1->get_curve(i);
      if(dynamic_cast<PartitionEntity*>(ge))
        still_ok = 0;
      GeometryQueryEngine *gqe = ge->get_geometry_query_engine();
      geometry_entities_1.append(ge);
      gqes_1.append(gqe);
    }
  }
  else if(cs1)
  {
    for(i=cs1->num_surfs()-1; i>-1 && still_ok; i--)
    {
      GeometryEntity *ge = cs1->get_surface(i);
      if(dynamic_cast<PartitionEntity*>(ge))
        still_ok = 0;
      GeometryQueryEngine *gqe = ge->get_geometry_query_engine();
      geometry_entities_1.append(ge);
      gqes_1.append(gqe);
    }
  }
  else
  {
    if(dynamic_cast<PartitionEntity*>(ge1))
      still_ok = 0;
    else if(dynamic_cast<Curve*>(ge1) || dynamic_cast<Surface*>(ge1))
    {
      GeometryQueryEngine *gqe = ge1->get_geometry_query_engine();
      geometry_entities_1.append(ge1);
      gqes_1.append(gqe);
    }
    else
    {
      PRINT_ERROR("Entity-entity distance not yet supported for virtual geometry.\n");
      return CUBIT_FAILURE;
    }
  }
  if(cc2)
  {
    for(i=cc2->num_curves()-1; i>-1 && still_ok; i--)
    {
      GeometryEntity *ge = cc2->get_curve(i);
      if(dynamic_cast<PartitionEntity*>(ge))
        still_ok = 0;
      GeometryQueryEngine *gqe = ge->get_geometry_query_engine();
      geometry_entities_2.append(ge);
      gqes_2.append(gqe);
    }
  }
  else if(cs2)
  {
    for(i=cs2->num_surfs()-1; i>-1 && still_ok; i--)
    {
      GeometryEntity *ge = cs2->get_surface(i);
      if(dynamic_cast<PartitionEntity*>(ge))
        still_ok = 0;
      GeometryQueryEngine *gqe = ge->get_geometry_query_engine();
      geometry_entities_2.append(ge);
      gqes_2.append(gqe);
    }
  }
  else
  {
    if(dynamic_cast<PartitionEntity*>(ge2))
      still_ok = 0;
    else if(dynamic_cast<Curve*>(ge2) || dynamic_cast<Surface*>(ge2))
    {
      GeometryQueryEngine *gqe = ge2->get_geometry_query_engine();
      geometry_entities_2.append(ge2);
      gqes_2.append(gqe);
    }
    else
    {
      PRINT_ERROR("Entity-entity distance not yet supported for virtual geometry.\n");
      return CUBIT_FAILURE;
    }
  }

  if(still_ok)
  {
    double smallest_distance = CUBIT_DBL_MAX;
    for(i=geometry_entities_1.size(); i--;)
    {
      GeometryEntity *ge1 = geometry_entities_1.get_and_step();
      GeometryQueryEngine *gqe1 = gqes_1.get_and_step();
      for(j=geometry_entities_2.size(); j--;)
      {
        GeometryEntity *ge2 = geometry_entities_2.get_and_step();
        //GeometryQueryEngine *gqe2 = gqes_2.get_and_step();

        CubitVector cur_pos1, cur_pos2;
        double cur_distance;

        gqe1->entity_entity_distance(ge1, ge2, cur_pos1, cur_pos2, cur_distance);

        if(cur_distance < smallest_distance)
        {
          smallest_distance = cur_distance;
          distance = cur_distance;
          p1 = cur_pos1;
          p2 = cur_pos2;
        }
      }
    }
  }
  else
  {
    PRINT_ERROR("Entity-entity distance not yet supported for virtual geometry.\n");
    return CUBIT_FAILURE;
  }

  return CUBIT_SUCCESS;
}
CubitStatus VirtualQueryEngine::entity_extrema ( DLIList< GeometryEntity * > &  ref_entity_list,
const CubitVector dir1,
const CubitVector dir2,
const CubitVector dir3,
CubitVector extrema,
GeometryEntity *&  extrema_entity_ptr 
) [virtual]

Implements GeometryQueryEngine.

Definition at line 1585 of file VirtualQueryEngine.cpp.

{
  PRINT_ERROR("Entity extrema calculation not yet supported for virtual geometry.\n");
  return CUBIT_FAILURE;
}
virtual const std::type_info& VirtualQueryEngine::entity_type_info ( ) const [inline, virtual]

Definition at line 103 of file VirtualQueryEngine.hpp.

    { return typeid(VirtualQueryEngine); }
CubitStatus VirtualQueryEngine::export_solid_model ( DLIList< TopologyBridge * > &  bridge_list,
const char *  file_name,
Model_File_Type  file_type,
const CubitString cubit_version,
ModelExportOptions export_options 
) [protected, virtual]

R CubitStatus R- CUBIT_SUCCESS/CUBIT_FAILURE I ref_entity_list I- A list of RefEntities to be exported or saved to a file. I file_name I- The name of the file to write to. I file_type I- An optional type of file.

  • Export the current CUBIT geometry (everything in the Model) to a
  • solid model format. Valid file types are:
  • "IGES" -- IGES file
  • "STEP" -- STEP file I logfile_name I- Optional - name of logfile.
  • No logfile gets created for SAB/SAT files, but for IGES and
  • STEP file a logfile always gets created. Default filenames
  • are assigned if one is not given (iges_export.log, step_export.log).
  • The function returns CUBIT_FAILURE if anything goes wrong with
  • export - improper file type, inaccessible file, mismatch between
  • the underlying representation and file type. It returns
  • CUBIT_SUCCESS if everything goes well.

Implements GeometryQueryEngine.

Definition at line 1847 of file VirtualQueryEngine.cpp.

{
  return CUBIT_FAILURE;
}
virtual CubitStatus VirtualQueryEngine::export_solid_model ( DLIList< TopologyBridge * > &  bridge_list,
char *&  p_buffer,
int &  n_buffer_size,
bool  b_export_buffer 
) [inline, protected, virtual]

Implements GeometryQueryEngine.

Definition at line 336 of file VirtualQueryEngine.hpp.

{return CUBIT_FAILURE;}
CubitStatus VirtualQueryEngine::fire_ray ( CubitVector origin,
CubitVector direction,
DLIList< TopologyBridge * > &  at_entity_list,
DLIList< double > &  ray_params,
int  max_hits,
double  ray_radius,
DLIList< TopologyBridge * > *  hit_entity_list = 0 
) const [protected, virtual]

Implements GeometryQueryEngine.

Definition at line 1970 of file VirtualQueryEngine.cpp.

{
  // Note: for now assume we will only get curves or surfaces

  int i;
  int prev_num_hits = ray_params.size();
  GeometryQueryEngine *gqe = 0;
  TopologyBridge *bridge_ptr;

  // This is only needed because this function is "const"
  VirtualQueryEngine *vqe = VirtualQueryEngine::instance();

  at_entity_list.reset();
  for( i=at_entity_list.size(); i--; )
  {
    prev_num_hits = ray_params.size();
    bridge_ptr = at_entity_list.get_and_step();

    gqe = bridge_ptr->get_geometry_query_engine();
    if( !gqe )
    {
      PRINT_ERROR( "Unable to find geometry engine associated with an entity!\n" );
      return CUBIT_FAILURE;
    }

    Curve *curve_ptr = CAST_TO( bridge_ptr, Curve );
    if( curve_ptr )
    {
      DLIList<TopologyBridge*> tb_curve_list;
      vqe->get_underlying_curves( curve_ptr, tb_curve_list );

      if( tb_curve_list.size() > 0 )
      {
        gqe = tb_curve_list.get()->get_geometry_query_engine();

        gqe->fire_ray( origin, direction, tb_curve_list, ray_params, max_hits,
          ray_radius, hit_entity_list_ptr );

        // If curve_ptr is a PartitionCurve, it could be smaller than the underlying curve.
        // This means we have to check to make sure any hit points lie inside the curve. Remove if they don't.
        if (CAST_TO(curve_ptr, PartitionCurve))
        {
            // start iterating at the first new ray_param
            ray_params.reset();
            ray_params.step(prev_num_hits);
            hit_entity_list_ptr->reset();
            hit_entity_list_ptr->step(prev_num_hits);
            
            int j;
            for (j=prev_num_hits; j<ray_params.size(); j++)
            {
                CubitVector *loc_ptr;
                double param = ray_params.get();

                loc_ptr = new CubitVector;
                origin.next_point( direction, param, *loc_ptr );
                
                CubitPointContainment containment = CUBIT_PNT_UNKNOWN;
                containment = curve_ptr->point_containment(*loc_ptr);
                if ( (containment != CUBIT_PNT_ON) && (containment != CUBIT_PNT_BOUNDARY) )
                {
                    //remove from the hit list
                    ray_params.remove();
                    hit_entity_list_ptr->remove();
                }
                else
                {
                    ray_params.step();
                    hit_entity_list_ptr->step();
                }
            }
        }

      }
    }

    Surface *surface_ptr = CAST_TO( bridge_ptr, Surface );
    if( surface_ptr )
    {
      DLIList<TopologyBridge*> tb_surface_list;
      vqe->get_underlying_surfaces( surface_ptr, tb_surface_list );

      if( tb_surface_list.size() > 0 )
      {
        gqe = tb_surface_list.get()->get_geometry_query_engine();

        gqe->fire_ray( origin, direction, tb_surface_list, ray_params, max_hits,
          ray_radius, hit_entity_list_ptr );
        
        // If surface_ptr is a PartitionSurface, it could be smaller than the underlying surface.
        // This means we have to check to make sure any hit points lie inside the surface. Remove if they don't.
        if (CAST_TO(surface_ptr, PartitionSurface))
        {
            // start iterating at the first new ray_param
            ray_params.reset();
            ray_params.step(prev_num_hits);
            hit_entity_list_ptr->reset();
            hit_entity_list_ptr->step(prev_num_hits);
            
            int j;
            for (j=prev_num_hits; j<ray_params.size(); j++)
            {
                CubitVector *loc_ptr;
                double param = ray_params.get();

                loc_ptr = new CubitVector;
                origin.next_point( direction, param, *loc_ptr );
                
                CubitPointContainment containment = CUBIT_PNT_UNKNOWN;
                containment = surface_ptr->point_containment(*loc_ptr);
                if ( (containment != CUBIT_PNT_ON) && (containment != CUBIT_PNT_BOUNDARY) )
                {
                    //remove from the hit list
                    ray_params.remove();
                    hit_entity_list_ptr->remove();
                }
                else
                {
                    ray_params.step();
                    hit_entity_list_ptr->step();
                }
            }
        }

      }
    }

  }

  if( hit_entity_list_ptr && hit_entity_list_ptr->size() != ray_params.size() )
    PRINT_WARNING( "Hit entity list size not equal to number of hits\n" );

  // Account for max hits
  if( max_hits != 0 )
  {
    if( ray_params.size() <= max_hits )
      return CUBIT_SUCCESS;

    for( i=ray_params.size()-max_hits; i--; )
    {
      ray_params.last();
      ray_params.remove();
      if( hit_entity_list_ptr )
      {
        hit_entity_list_ptr->last();
        hit_entity_list_ptr->remove();
      }
    }
  }

  return CUBIT_SUCCESS;
}
CubitStatus VirtualQueryEngine::get_composite_curve_facetting ( CompositeCurve ccurve_ptr,
GMem gMem,
double  angle_tolerance = 0,
double  distance_tolerance = 0,
double  max_edge_length = 0 
) const [protected]

Definition at line 324 of file VirtualQueryEngine.cpp.

{
    // Just return if gMem is NULL
  if (gMem == NULL)
  {
    return CUBIT_SUCCESS;
  }
  
  GMem current_gmem; 
  int point_count = 0; //Current total of points returned
    // from underlying edges
  
  int next_index = 0; //index of next insert spot in passed GMem object.
  
    //Get points for each underlying curve
  current_gmem.clean_out();
  for( int i = 0; i < ccurve_ptr->num_curves(); i++ )
  {
      // Get the next curve and its GME
    Curve* curve_ptr = ccurve_ptr->get_curve(i);
    GeometryQueryEngine* GQE_ptr = 
      curve_ptr->get_geometry_query_engine();
    
      // Get the GME to facet the curve
    CubitStatus current_status = 
      GQE_ptr->get_graphics( curve_ptr, &current_gmem, angle_tolerance,
                              distance_tolerance, max_edge_length );
    if( current_status == CUBIT_FAILURE )
      return CUBIT_FAILURE;
    
    int this_point_count = current_gmem.pointListCount;
      
    // Make sure the passed in gmem is big enough
    gMem->allocate_more_polylines(this_point_count-1);
      //assert( gMem->pts_size >= point_count );
    
      // If this isn't the first curve, we don't need to
      // repeat one of the end nodes.
    if (point_count != 0)
      this_point_count--;
      // Add to the total number of points so far
    point_count += this_point_count;
    
      //Copy points to passed GMem, in the correct order
      //for the sense of the underlying edge wrt the
      //composite.
    CubitSense sense = ccurve_ptr->get_sense( i );
    
    if( sense == CUBIT_FORWARD )
    {
      if (next_index == 0)
        for(int j = 0; j < point_count; j++)
        {
          gMem->point_list()[j] = current_gmem.point_list()[j];
        }
      else
          // cur_gmem has one more point than we will access,
          // so last index is point_count-next_index.
        for(int j = next_index; j < point_count; j++)
        {
          gMem->point_list()[j] = current_gmem.point_list()[j - next_index + 1];
        }
    }
    else //( sense == CUBIT_REVERSED )
    {
        // All but the first curve will not use one of its points.
        // This is taken into account by decrementing point_count
        // earlier.
      for(int j = next_index; j < point_count; j++)
      {
        gMem->point_list()[j] = current_gmem.point_list()[point_count-j-1];
      }
    }
    next_index = point_count;
    gMem->pointListCount = point_count;
  }
  
  gMem->pointListCount = point_count;
  return CUBIT_SUCCESS;
}
CubitStatus VirtualQueryEngine::get_composite_surface_facetting ( CompositeSurface surf_ptr,
GMem gMem,
std::vector< TopologyBridge * > *  vertex_edge_to_point_vector,
std::vector< std::pair< TopologyBridge *, std::pair< int, int > > > *  facet_edges_on_curves,
unsigned short  normal_tol,
double  absolute_tol,
double  longest_edge 
) const [protected]

Definition at line 446 of file VirtualQueryEngine.cpp.

{
  if( gMem == NULL )
    return CUBIT_FAILURE;
   
  if (surf_ptr->get_graphics(*gMem))
  {
    /*
    if( vertex_edge_to_point_vector )
    {
      vertex_edge_to_point_vector->resize( gMem->pointListCount, NULL );
      //get all the points on the surface
      DLIList<TBPoint*> points;
      surf_ptr->points( points );    

      for( int i=points.size(); i--; )
      {
        TBPoint *tb_pt = points.get_and_step();
        CompositePoint *comp_pt = CAST_TO( tb_pt, CompositePoint );

        if( comp_pt )
        {
          CubitPoint *facet_point = comp_pt->facet_point();
          (*vertex_edge_to_point_vector)[facet_point->marked()] = comp_pt;
        }
      }
    }

    if( facet_edges_on_curves )
    {
      DLIList<Curve*> tmp_curves;
      surf_ptr->curves( tmp_curves );

      for( int i=tmp_curves.size(); i--; )
      {
        Curve *tmp_curve = tmp_curves.get_and_step();
        CompositeCurve *comp_curve = CAST_TO( tmp_curve, CompositeCurve );

        if( comp_curve )
        {
          DLIList<CubitFacetEdgeData*> facet_edges;
          comp_curve->get_facet_data( facet_edges );

          for( int j=facet_edges.size(); j--; )
          {
            CubitFacetEdge *facet_edge = facet_edges.get_and_step();

            facet_edges_on_curves->push_back( std::make_pair( tmp_curve, 
              std::make_pair( facet_edge->point(0)->marked(), 
              facet_edge->point(1)->marked() )));
          }
        }
      }
    }
*/
    return CUBIT_SUCCESS;
  }
    

    // Get the underlying Surfaces
  GeometryQueryEngine* gqe_ptr;
  GMem *gMem_list = new GMem[ surf_ptr->num_surfs() ];
  
  int total_number_points = 0;
  int total_number_facets = 0;
  
    // Get the facets of each Surface
  int i;
  for(i = 0; i < surf_ptr->num_surfs(); i++)
  {
    Surface* surface_ptr = surf_ptr->get_surface(i);
    
    gqe_ptr = surface_ptr->get_geometry_query_engine();
    
    gqe_ptr->get_graphics( surface_ptr, &(gMem_list[i]),
                                  normal_tol, dist_tol, longest_edge );
    
    total_number_facets += gMem_list[i].fListCount;
    total_number_points += gMem_list[i].pointListCount;
  }
  
  int point_offset = 0;
  int face_offset = 0;
  gMem->replace_point_list(new GPoint[total_number_points],
                           total_number_points, total_number_points);
  gMem->replace_facet_list(new int[total_number_facets],
                           total_number_facets, total_number_facets);
  
  for( i = 0; i < surf_ptr->num_surfs(); i++ )
  {
    int j;
    for(  j = 0; j < gMem_list[i].pointListCount; j++ )
    {
      assert((point_offset + j) < gMem->pointListCount );
      gMem->point_list()[j + point_offset].x = gMem_list[i].point_list()[j].x;
      gMem->point_list()[j + point_offset].y = gMem_list[i].point_list()[j].y;
      gMem->point_list()[j + point_offset].z = gMem_list[i].point_list()[j].z;
    }
    
    int k;
    for( k = 0; k < gMem_list[i].fListCount;)
    {
      int count = gMem_list[i].facet_list()[k];
      assert( k + count < gMem->fListCount );
      
      gMem->facet_list()[k + face_offset] = count;
      k++;
      for( int l = 0; l < count; l++, k++ )
      {
        assert( k + face_offset < gMem->fListCount );
        assert( k < gMem_list[i].fListCount );
        gMem->facet_list()[k + face_offset] = gMem_list[i].facet_list()[k] 
          + point_offset;
      }
    }
    
    point_offset += j;
    face_offset += k;
  }
  
  gMem->consolidate_points(10*GEOMETRY_RESABS);
//     // Debug!!!
//   int q;
//   for (q = 0; q < bte_list.size(); q++)
//   {
//     PRINT_INFO("Printing Points for Surface %d.\n", q);
//     int r;
//     for (r = 0; r < gMem_list[q].pointListCount; r++)
//     {
//       PRINT_INFO("%g %g %g\n",
//                  gMem_list[q].point_list()[r].x,
//                  gMem_list[q].point_list()[r].y,
//                  gMem_list[q].point_list()[r].z);
//     }
//     PRINT_INFO("Printing FList for Surface %d.\n", q);
//     for (r = 0; r < gMem_list[q].fListCount; r++)
//     {
//       PRINT_INFO("%d %s",
//                  gMem_list[q].facet_list()[r],
//                  r % 4 ? "" : "\n");
//     }
//   }
//   PRINT_INFO("Composite points:\n");
//   for (q = 0; q < gMem->pointListCount; q++)
//   {
//     PRINT_INFO("%g %g %g\n",
//                gMem->point_list()[q].x,
//                gMem->point_list()[q].y,
//                gMem->point_list()[q].z);
//   }
//   PRINT_INFO("Composite facet list:\n");
//   for (q = 0; q < gMem->fListCount; q++)
//   {
//     PRINT_INFO("%d %s",
//                gMem->facet_list()[q],
//                q % 4 ? "" : "\n");
//   }

  if( vertex_edge_to_point_vector )
  {
    vertex_edge_to_point_vector->resize( gMem->pointListCount, NULL );
    //get all the points on the surface
    DLIList<TBPoint*> points;
    surf_ptr->points( points );    

    for( int i=points.size(); i--; )
    {
      TBPoint *tb_pt = points.get_and_step();
      PartitionPoint *ppt = CAST_TO( tb_pt, PartitionPoint );

      if( ppt )
      {
        CubitPoint *facet_point = ppt->facet_point();
        (*vertex_edge_to_point_vector)[facet_point->marked()] = ppt;
      }
    }
  }

  if( facet_edges_on_curves )
  {
    DLIList<Curve*> tmp_curves;
    surf_ptr->curves( tmp_curves );

    for( int i=tmp_curves.size(); i--; )
    {
      Curve *tmp_curve = tmp_curves.get_and_step();
      PartitionCurve *pt_curve = CAST_TO( tmp_curve, PartitionCurve );

      if( pt_curve )
      {
        DLIList<CubitFacetEdgeData*> facet_edges;
        pt_curve->get_facet_data( facet_edges );

        for( int j=facet_edges.size(); j--; )
        {
          CubitFacetEdge *facet_edge = facet_edges.get_and_step();

          facet_edges_on_curves->push_back( std::make_pair( tmp_curve, 
            std::make_pair( facet_edge->point(0)->marked(), 
                            facet_edge->point(1)->marked() )));

        }
      }
    }
  }
  
  delete [] gMem_list;  
  return CUBIT_SUCCESS;
}

Implements GeometryQueryEngine.

Definition at line 157 of file VirtualQueryEngine.cpp.

{
  CubitString return_this(
    "VirtualQueryEngine v1.2 by Jason Kraftcheck.\n" );
  return_this += "I-CARVE Lab., University of Wisconsin - Madison,  August 1, 1997.\n";
  return_this += "This ModelingEngine performs the necessary topological ";
  return_this += "operations for working with VirtualEntities, including ";
  return_this += "objects of type CompositeEntity, PartitionEntity, and ";
  return_this += "ParasiteEntity.  ComposinteModelingEngine also ";
  return_this += "provides the interface for creating, destroying, and ";
  return_this += "modifying VirtualEntities.\n";
  
  return return_this;
}
CubitStatus VirtualQueryEngine::get_graphics ( Surface surface_ptr,
GMem gmem,
std::vector< TopologyBridge * > &  vertex_edge_to_point_vector,
std::vector< std::pair< TopologyBridge *, std::pair< int, int > > > &  facet_edges_on_curves,
unsigned short  normal_tolerance,
double  distance_tolerance,
double  max_edge_length 
) const [virtual]

Reimplemented from GeometryQueryEngine.

Definition at line 181 of file VirtualQueryEngine.cpp.

{
  PartitionSurface* ps_ptr = CAST_TO(surf_ptr, PartitionSurface );
  if( ps_ptr != NULL )
  {
    return get_partition_surface_facetting( ps_ptr, gmem, &vertex_edge_to_point_vector, &facet_edges_on_curves,
                                            normal_tol, dist_tol, max_edge_length );
  }
  
  CompositeSurface* cs_ptr = CAST_TO(surf_ptr, CompositeSurface );
  if( cs_ptr != NULL )
  {
    return get_composite_surface_facetting( cs_ptr, gmem, &vertex_edge_to_point_vector, &facet_edges_on_curves,
                                            normal_tol, dist_tol, max_edge_length );
  }
    //PRINT_INFO("VirtualQueryEngine::get_graphics_facets"
    //           "( s%p, %p, %d, %f ) = CUBIT_FAILURE\n",
    //           surf_ptr, gmem, normal_tol, dist_tol);
  return CUBIT_FAILURE;
}
CubitStatus VirtualQueryEngine::get_graphics ( Surface surface_ptr,
GMem gMem,
unsigned short  normal_tolerance,
double  distance_tolerance,
double  max_edge_length 
) const [virtual]

Implements GeometryQueryEngine.

Definition at line 220 of file VirtualQueryEngine.cpp.

{
  CompositeSurface* cs_ptr = CAST_TO(surf_ptr, CompositeSurface );
  PartitionSurface* ps_ptr = CAST_TO(surf_ptr, PartitionSurface );
  if( cs_ptr != NULL )
  {
    return get_composite_surface_facetting( cs_ptr, gMem, NULL, NULL,
                                            normal_tol, dist_tol, max_edge_length );
  }
  else if( ps_ptr != NULL )
  {
    return get_partition_surface_facetting( ps_ptr, gMem, NULL, NULL,
                                            normal_tol, dist_tol, max_edge_length );
  }
  else
  {
    PRINT_INFO("VirtualQueryEngine::get_graphics_facets"
               "( s%p, %p, %d, %f ) = CUBIT_FAILURE\n",
               (void*)surf_ptr, (void*)gMem, normal_tol, dist_tol);
    return CUBIT_FAILURE;
  }
}
CubitStatus VirtualQueryEngine::get_graphics ( Curve curve_ptr,
GMem gMem,
double  angle_tolerance = 0,
double  distance_tolerance = 0,
double  max_edge_length = 0 
) const [virtual]

Implements GeometryQueryEngine.

Definition at line 258 of file VirtualQueryEngine.cpp.

{
  CompositeCurve* ccurve = CAST_TO( curve_ptr, CompositeCurve );
  PartitionCurve* pcurve = CAST_TO( curve_ptr, PartitionCurve );
  
  CubitStatus result;
  
  if( ccurve != NULL )
  {
    result = get_composite_curve_facetting( ccurve, gMem, angle_tolerance, 
                                          distance_tolerance, max_edge_length );
  }
  else if( pcurve != NULL )
  {
    result = get_partition_curve_facetting( pcurve, gMem, angle_tolerance, 
                                          distance_tolerance, max_edge_length );
  }
  else
  {
    PRINT_ERROR("Unknown curve type or NULL curve passed to "
                "VirtualQueryEngine::get_graphics_edges()\n");
    return CUBIT_FAILURE;
  }
  
  return result;
}
CubitStatus VirtualQueryEngine::get_intersections ( Curve curve,
CubitVector point1,
CubitVector point2,
DLIList< CubitVector > &  intersection_list,
CubitBoolean  bounded,
CubitBoolean  closest 
) [virtual]

Definition at line 1385 of file VirtualQueryEngine.cpp.

{
  DLIList<TopologyBridge*> curve_list;
  get_underlying_curves( curve, curve_list );
  int i;
  for (i = 0; i < curve_list.size(); i++)
  {
    // Get the next curve and its GME
    Curve* curve_ptr = CAST_TO(curve_list.get_and_step(), Curve);
    GeometryQueryEngine* GQE_ptr =
      curve_ptr->get_geometry_query_engine();
    GQE_ptr->get_intersections(curve_ptr, point1, point2, intersection_list,
                               bounded, closest);
  }
  return CUBIT_SUCCESS;
}
virtual CubitStatus VirtualQueryEngine::get_intersections ( Curve ref_edge1,
Curve ref_edge2,
DLIList< CubitVector > &  intersection_list,
bool  bounded = CUBIT_FALSE,
bool  closest = CUBIT_FALSE 
) [virtual]

Implements GeometryQueryEngine.

virtual CubitStatus VirtualQueryEngine::get_intersections ( Curve ref_edge,
Surface ref_face,
DLIList< CubitVector > &  intersection_list,
bool  bounded = CUBIT_FALSE 
) [virtual]

Implements GeometryQueryEngine.

CubitStatus VirtualQueryEngine::get_isoparametric_points ( Surface ref_face_ptr,
int &  nu,
int &  nv,
GMem *&  gMem 
) const [virtual]

Implements GeometryQueryEngine.

Definition at line 290 of file VirtualQueryEngine.cpp.

{
  nu = nv = 0;
  return CUBIT_FAILURE;
}

Implements GeometryQueryEngine.

Definition at line 142 of file VirtualQueryEngine.cpp.

{
  return VGE_MAJOR_VERSION;
}

Implements GeometryQueryEngine.

Definition at line 147 of file VirtualQueryEngine.cpp.

{
  return VGE_MINOR_VERSION;
}
CubitStatus VirtualQueryEngine::get_partition_curve_facetting ( PartitionCurve pcurve_ptr,
GMem gMem,
double  angle_tolerance = 0,
double  distance_tolerance = 0,
double  max_edge_length = 0 
) const [protected]

Definition at line 423 of file VirtualQueryEngine.cpp.

{
  assert( gMem != NULL );
  CubitStatus result = pcurve_ptr->get_graphics( *gMem, angle_tolerance, 
                                    distance_tolerance, max_edge_length );
  return result;
}
CubitStatus VirtualQueryEngine::get_partition_surface_facetting ( PartitionSurface surf_ptr,
GMem gMem,
std::vector< TopologyBridge * > *  vertex_edge_to_point_vector,
std::vector< std::pair< TopologyBridge *, std::pair< int, int > > > *  facet_edges_on_curves,
unsigned short  normal_tol,
double  absolute_tol,
double  longest_edge 
) const [protected]

Definition at line 672 of file VirtualQueryEngine.cpp.

{
  int i, j;
  
  DLIList<CubitFacetData*> surf_facets;
  DLIList<CubitPoint*> surf_points;
  
    // get surface facets
  surf_ptr->get_facet_data( surf_facets );

    // get list of points from list of facets
  for( i = surf_facets.size(); i--; )
  {
    CubitFacetData* facet = surf_facets.step_and_get();
    for( j = 0; j< 3; j++ )
      facet->point(j)->marked(1);
  }
  for( i = surf_facets.size(); i--; )
  {
    CubitFacetData* facet = surf_facets.step_and_get();
    for( j = 0; j< 3; j++ )
    {
      if( facet->point(j)->marked() )
      {
        facet->point(j)->marked(0);
        surf_points.append( facet->point(j) );
      }
    }
  }

  if( ! gMem ) return CUBIT_SUCCESS;

    // allocate storage for facet data
  gMem->allocate_tri( surf_facets.size() );
  gMem->fListCount = surf_facets.size() * 4;
  gMem->pointListCount = surf_points.size();
    
    // put points in GMem and mark each point with
    // its index in the array
  surf_points.reset();
  for( i = 0; i < gMem->pointListCount; i++ )
  {
    GPoint* gpt = gMem->point_list() + i;
    CubitPoint* pt = surf_points.get_and_step();
    pt->marked(i);
    gpt->x = (float)(pt->coordinates().x() );
    gpt->y = (float)(pt->coordinates().y() );
    gpt->z = (float)(pt->coordinates().z() );
  }
  
    // put each facet in the GMem.  retreive
    // point indices from marks.
  surf_facets.reset();
  int* gfacet_ptr = gMem->facet_list();
  for( i = 0; i < surf_facets.size(); i++ )
  {
    CubitFacetData* facet = surf_facets.get_and_step();
    *gfacet_ptr = 3;
    gfacet_ptr++;
    for( j = 0; j < 3; j++ )
    {
      *gfacet_ptr = facet->point(j)->marked();
      gfacet_ptr++;
    }
  }

  if( vertex_edge_to_point_vector )
  {
    vertex_edge_to_point_vector->resize( gMem->pointListCount, NULL );
    //get all the points on the surface
    DLIList<TBPoint*> points;
    surf_ptr->points( points );    

    for( int i=points.size(); i--; )
    {
      TBPoint *tb_pt = points.get_and_step();
      PartitionPoint *ppt = CAST_TO( tb_pt, PartitionPoint );

      if( ppt )
      {
        CubitPoint *facet_point = ppt->facet_point();
        (*vertex_edge_to_point_vector)[facet_point->marked()] = ppt;
      }
    }
  }

  if( facet_edges_on_curves )
  {
    DLIList<Curve*> tmp_curves;
    surf_ptr->curves( tmp_curves );

    for( int i=tmp_curves.size(); i--; )
    {
      Curve *tmp_curve = tmp_curves.get_and_step();
      PartitionCurve *pt_curve = CAST_TO( tmp_curve, PartitionCurve );

      if( pt_curve )
      {
        DLIList<CubitFacetEdgeData*> facet_edges;
        pt_curve->get_facet_data( facet_edges );

        for( int j=facet_edges.size(); j--; )
        {
          CubitFacetEdge *facet_edge = facet_edges.get_and_step();

          facet_edges_on_curves->push_back( std::make_pair( tmp_curve, 
            std::make_pair( facet_edge->point(0)->marked(), 
                            facet_edge->point(1)->marked() )));

        }
      }
    }
  }
  
    // clear point marks
  for( i = surf_points.size(); i--; )
    surf_points.step_and_get()->marked(0);
  
  return CUBIT_SUCCESS;
}

Definition at line 1210 of file VirtualQueryEngine.cpp.

{
  RefEdge *ref_edge = CAST_TO( ref_entity, RefEdge );

  if( ref_edge )
  {
    Curve *curve_ptr = ref_edge->get_curve_ptr();
    PartitionCurve *part_curve = CAST_TO(curve_ptr, PartitionCurve);

    if( part_curve )
    {
      DLIList<TopologyBridge*> tb_list;
      part_curve->sub_entity_set().get_owners( tb_list );
      
      int k;
      for( k=tb_list.size(); k--; )
      {
        TopologyBridge *tmp_bridge = tb_list.get_and_step();
        TopologyEntity *te = tmp_bridge->topology_entity();
        if( te )
        {
          RefEntity *sister = CAST_TO(te, RefEntity ); 
          if( sister )
            sisters.append( sister );
        }
      }
    }
  }

  return CUBIT_SUCCESS;
}
double VirtualQueryEngine::get_sme_resabs_tolerance ( ) const [protected, virtual]

Implements GeometryQueryEngine.

Definition at line 2129 of file VirtualQueryEngine.cpp.

{
  return GEOMETRY_RESABS;
}

Implements GeometryQueryEngine.

Definition at line 152 of file VirtualQueryEngine.cpp.

CubitStatus VirtualQueryEngine::get_u_isoparametric_points ( Surface ref_face_ptr,
double  v,
int &  n,
GMem *&  gMem 
) const [virtual]

Implements GeometryQueryEngine.

Definition at line 299 of file VirtualQueryEngine.cpp.

{
  return CUBIT_FAILURE;
}
CubitStatus VirtualQueryEngine::get_underlying_bridges ( TopologyBridge bridge_ptr,
DLIList< TopologyBridge * > &  bridge_list 
) [virtual]

Reimplemented from GeometryQueryEngine.

Definition at line 1507 of file VirtualQueryEngine.cpp.

{
   assert (bridge_ptr);
   CompositeSurface *comp_surf = CAST_TO(bridge_ptr, CompositeSurface);
   PartitionSurface *part_surf = CAST_TO(bridge_ptr, PartitionSurface);
   CompositeCurve *comp_curve = CAST_TO(bridge_ptr, CompositeCurve);
   PartitionCurve *part_curve = CAST_TO(bridge_ptr, PartitionCurve);
   CompositePoint *comp_point = CAST_TO(bridge_ptr, CompositePoint);
   PartitionPoint *part_point = CAST_TO(bridge_ptr, PartitionPoint);
   PartitionBody *part_body = CAST_TO(bridge_ptr, PartitionBody);

   if (part_body )
   {
     bridge_list.append( part_body->partitioned_entity() );
   }
   else if ( comp_surf )
   {
     int i;
     for (i = 0; i < comp_surf->num_surfs(); i ++)
     {
       part_surf = CAST_TO(comp_surf->get_surface(i), PartitionSurface);
       if (!part_surf)
         bridge_list.append_unique(CAST_TO(comp_surf->get_surface(i),
                                  TopologyBridge));
       else
       {
         if(dynamic_cast<Surface*>(part_surf->partitioned_entity()))
         {
           bridge_list.append_unique(CAST_TO(part_surf->partitioned_entity(),
                                    TopologyBridge));
         }
       }
     }
   }
   else if ( part_surf )
     bridge_list.append( part_surf->partitioned_entity() );
   else if ( comp_curve )
   {
     int i;
     for (i = 0; i < comp_curve->num_curves(); i ++)
     {
       part_curve = CAST_TO(comp_curve->get_curve(i), PartitionCurve);
       if (!part_curve)
         bridge_list.append_unique(comp_curve->get_curve(i));
       else
       {
         if(dynamic_cast<Curve*>(part_curve->partitioned_entity()))
         {
           bridge_list.append_unique( part_curve->partitioned_entity() );
         }
       }
     }
   }
   else if ( part_curve )
     bridge_list.append( part_curve->partitioned_entity() );
   else if ( part_point )
   {
     TopologyBridge *tb_point = part_point->real_point();
     if( tb_point )
       bridge_list.append( tb_point ); 
   }
   else if ( comp_point )
   {
     TopologyBridge *tb_point = comp_point->get_point();
     if( tb_point )
       bridge_list.append( tb_point ); 
   }
   
   return CUBIT_SUCCESS;
}
CubitStatus VirtualQueryEngine::get_underlying_curves ( Curve curve_ptr,
DLIList< TopologyBridge * > &  curve_list 
) [virtual]

Reimplemented from GeometryQueryEngine.

Definition at line 1445 of file VirtualQueryEngine.cpp.

{
   assert (curve_ptr);
   CompositeCurve *comp_curve = CAST_TO(curve_ptr, CompositeCurve);
   PartitionCurve *part_curve = CAST_TO(curve_ptr, PartitionCurve);
   if ( comp_curve )
   {
     int i;
     for (i = 0; i < comp_curve->num_curves(); i ++)
     {
       part_curve = CAST_TO(comp_curve->get_curve(i), PartitionCurve);
       if (!part_curve)
         curve_list.append_unique(CAST_TO(comp_curve->get_curve(i),
                                  TopologyBridge));
       else
       {
         if(dynamic_cast<Curve*>(part_curve->partitioned_entity()))
         {
           curve_list.append_unique(CAST_TO(part_curve->partitioned_entity(),
                                    TopologyBridge));
         }
       }
     }
   }
   else if ( part_curve )
     curve_list.append(CAST_TO(part_curve->partitioned_entity(),
                       TopologyBridge));
   return CUBIT_SUCCESS;
}
CubitStatus VirtualQueryEngine::get_underlying_surfaces ( Surface surf_ptr,
DLIList< TopologyBridge * > &  surf_list 
) [virtual]

Reimplemented from GeometryQueryEngine.

Definition at line 1476 of file VirtualQueryEngine.cpp.

{
   assert (surf_ptr);
   CompositeSurface *comp_surf = CAST_TO(surf_ptr, CompositeSurface);
   PartitionSurface *part_surf = CAST_TO(surf_ptr, PartitionSurface);
   if ( comp_surf )
   {
     int i;
     for (i = 0; i < comp_surf->num_surfs(); i ++)
     {
       part_surf = CAST_TO(comp_surf->get_surface(i), PartitionSurface);
       if (!part_surf)
         surf_list.append_unique(CAST_TO(comp_surf->get_surface(i),
                                  TopologyBridge));
       else
       {
         if(dynamic_cast<Surface*>(part_surf->partitioned_entity()))
         {
           surf_list.append_unique(CAST_TO(part_surf->partitioned_entity(),
                                    TopologyBridge));
         }
       }
     }
   }
   else if ( part_surf )
     surf_list.append(CAST_TO(part_surf->partitioned_entity(),
                       TopologyBridge));
   return CUBIT_SUCCESS;
}
CubitStatus VirtualQueryEngine::get_v_isoparametric_points ( Surface ref_face_ptr,
double  u,
int &  n,
GMem *&  gMem 
) const [virtual]

Implements GeometryQueryEngine.

Definition at line 307 of file VirtualQueryEngine.cpp.

{
  return CUBIT_FAILURE;
}
void VirtualQueryEngine::get_VEs ( RefVolume volume_ptr,
DLIList< TopologyBridge * > &  ve_list,
CubitBoolean  visible = CUBIT_FALSE,
const CubitBoolean  children_too = CUBIT_TRUE 
) [static]

Definition at line 935 of file VirtualQueryEngine.cpp.

{
  DLIList<BasicTopologyEntity*> bte_list;
  int i;
  
  DLIList<TopologyBridge*> tb_list;
  volume_ptr->bridge_manager()->get_bridge_list( tb_list );
  
  for( i = tb_list.size(); i--; )
  {  
    TopologyBridge* tb_ptr = tb_list.get_and_step();
    PartitionEntity* ve_ptr = dynamic_cast<PartitionEntity*>(tb_ptr);
    CompositeLump* ce_ptr = dynamic_cast<CompositeLump*>(tb_ptr);
    if( ve_ptr || ce_ptr )
    {
      ve_list.append( tb_ptr );
    }
  }
  
  if (!children_too) return;
  DLIList<TopologyBridge*> child_list;
  
  DLIList<RefFace*> face_list;
  volume_ptr->ref_faces( face_list );
  DLIList<BasicTopologyEntity*> temp_face_list;
  CAST_LIST_TO_PARENT( face_list, temp_face_list );
  bte_list.merge_unique( temp_face_list );
//  bte_list.merge_unique( face_list );
  for( i = bte_list.size();i > 0;i--)
  {
    child_list.clean_out();
    get_VEs( bte_list.get_and_step(), child_list, visible );
    ve_list.merge_unique( child_list );
  }
}
void VirtualQueryEngine::get_VEs ( RefFace face_ptr,
DLIList< TopologyBridge * > &  ve_list,
CubitBoolean  visible = CUBIT_FALSE,
const CubitBoolean  children_too = CUBIT_TRUE 
) [static]

Definition at line 974 of file VirtualQueryEngine.cpp.

{
  DLIList<BasicTopologyEntity*> bte_list;
  DLIList<TopologyBridge*> tb_list;
  int i;
  
  face_ptr->bridge_manager()->get_bridge_list( tb_list );
  tb_list.reset();
  
  for( i = tb_list.size(); i--; )
  {
  
    TopologyBridge* ve_ptr = tb_list.get_and_step();
    if( dynamic_cast<PartitionEntity*>(ve_ptr) ||
        dynamic_cast<CompositeSurface*>(ve_ptr) )
    {
      ve_list.append( ve_ptr );
    }
  }
  
  
  if (!children_too) return;

  DLIList<TopologyBridge*> child_list;
  DLIList<RefEdge*> edge_list;
  face_ptr->ref_edges( edge_list );
  DLIList<BasicTopologyEntity*> temp_edge_list;
  CAST_LIST_TO_PARENT( edge_list, temp_edge_list );
  bte_list.merge_unique( temp_edge_list );

  for( i = bte_list.size();i > 0;i--)
  {
    child_list.clean_out();
    get_VEs( bte_list.get_and_step(), child_list, visible );
    ve_list.merge_unique( child_list );
  }
}
void VirtualQueryEngine::get_VEs ( RefEdge edge_ptr,
DLIList< TopologyBridge * > &  ve_list,
CubitBoolean  visible = CUBIT_FALSE,
const CubitBoolean  children_too = CUBIT_TRUE 
) [static]

Definition at line 1015 of file VirtualQueryEngine.cpp.

{
  DLIList<BasicTopologyEntity*> bte_list;
  DLIList<TopologyBridge*> tb_list;
  int i;
  
  edge_ptr->bridge_manager()->get_bridge_list( tb_list );
  tb_list.reset();
  
  for( i = tb_list.size(); i--; )
  {
  
    TopologyBridge* ve_ptr = tb_list.get_and_step();
    if( dynamic_cast<PartitionCurve*>(ve_ptr) ||
        dynamic_cast<CompositeCurve*>(ve_ptr) )
    {
      ve_list.append( ve_ptr );
    }
  }
  
  if (!children_too) return;
  DLIList<TopologyBridge*> child_list;
  DLIList<RefVertex*> vex_list;
  edge_ptr->ref_vertices( vex_list );
  DLIList<BasicTopologyEntity*> temp_vex_list;
  CAST_LIST_TO_PARENT( vex_list, temp_vex_list );
  bte_list.merge_unique( temp_vex_list );

  for( i = bte_list.size();i > 0;i--)
  {
    child_list.clean_out();
    get_VEs( bte_list.get_and_step(), child_list, visible );
    ve_list.merge_unique( child_list );
  }
}
void VirtualQueryEngine::get_VEs ( RefVertex vertex_ptr,
DLIList< TopologyBridge * > &  ve_list,
CubitBoolean  visible = CUBIT_FALSE,
const CubitBoolean  children_too = CUBIT_TRUE 
) [static]

Definition at line 1054 of file VirtualQueryEngine.cpp.

{
  DLIList<TopologyBridge*> tb_list;
  vex_ptr->bridge_manager()->get_bridge_list( tb_list );
  tb_list.reset();
  for( int i = tb_list.size(); i--; )
  {
    TopologyBridge* tb = tb_list.get_and_step();
    if( dynamic_cast<PartitionPoint*>(tb) ||
        dynamic_cast<CompositePoint*>(tb) )
      ve_list.append( tb );
  }
}
void VirtualQueryEngine::get_VEs ( TopologyEntity te_ptr,
DLIList< TopologyBridge * > &  ve_list,
CubitBoolean  visible = CUBIT_FALSE,
const CubitBoolean  children_too = CUBIT_TRUE 
) [static]

Definition at line 835 of file VirtualQueryEngine.cpp.

{
  DLIList<TopologyBridge*> child_list;
  Body*      body_ptr   = CAST_TO( te_ptr, Body );
  CoVolume*  covol_ptr  = CAST_TO( te_ptr, CoVolume );
  RefVolume* vol_ptr    = CAST_TO( te_ptr, RefVolume );
  Shell*     shell_ptr  = CAST_TO( te_ptr, Shell );
  CoFace*    coface_ptr = CAST_TO( te_ptr, CoFace );
  RefFace*   face_ptr   = CAST_TO( te_ptr, RefFace );
  Loop*      loop_ptr   = CAST_TO( te_ptr, Loop );
  CoEdge*    coedge_ptr = CAST_TO( te_ptr, CoEdge );
  RefEdge*   edge_ptr   = CAST_TO( te_ptr, RefEdge );
  Chain*     chain_ptr  = CAST_TO( te_ptr, Chain );
  CoVertex*  covex_ptr  = CAST_TO( te_ptr, CoVertex );
  RefVertex* vex_ptr    = CAST_TO( te_ptr, RefVertex );
  
  if( (body_ptr != NULL) || (covol_ptr != NULL) )
  {
    if (children_too) {
      DLIList<RefVolume*> vol_list;
      te_ptr->ref_volumes( vol_list );
      for( int i = vol_list.size(); i > 0; i-- )
      {
        child_list.clean_out();
        get_VEs( vol_list.get_and_step(), child_list, visible,
                 children_too);
        ve_list.merge_unique( child_list );
      }
    }
  }
  else if( vol_ptr != NULL )
  {
    get_VEs( vol_ptr, ve_list, visible, children_too );
  }
  else if( (shell_ptr != NULL) || (coface_ptr != NULL) )
  {
    if (children_too) {
      DLIList<RefFace*> face_list;
      te_ptr->ref_faces( face_list );
      for( int i = face_list.size(); i> 0; i-- )
      {
        child_list.clean_out();
        get_VEs( face_list.get_and_step(), child_list, visible,
                 children_too);
        ve_list.merge_unique( child_list );
      }
    }
  }
  else if( face_ptr != NULL )
  {
    get_VEs( face_ptr, ve_list, visible, children_too );
  }
  else if( (loop_ptr != NULL) || (coedge_ptr != NULL) )
  {
    if (children_too) {
      DLIList<RefEdge*> edge_list;
      te_ptr->ref_edges( edge_list );
      for( int i = edge_list.size(); i > 0; i-- )
      {
        child_list.clean_out();
        get_VEs( edge_list.get_and_step(), child_list, visible,
                 children_too);
        ve_list.merge_unique( child_list );
      }
    }
  }
  else if( edge_ptr != NULL )
  {
    get_VEs( edge_ptr, ve_list, visible, children_too );
  }
  else if( (chain_ptr != NULL) || (covex_ptr != NULL ) )
  {
    if (children_too) {
      DLIList<RefVertex*> vertex_list;
      te_ptr->ref_vertices( vertex_list );
      for( int i = vertex_list.size(); i > 0; i-- )
      {
        child_list.clean_out();
        get_VEs( vertex_list.get_and_step(), child_list, visible,
                 children_too);
        ve_list.merge_unique( child_list );
      }
    }
  }
  else if( vex_ptr != NULL )
  {
    get_VEs( vex_ptr, ve_list, visible, children_too );
  }
  else
    {
      PRINT_ERROR("Unknown type of TopologyEntity passed to "
                    "VirtualQueryEngine::get_VEs(..).  Passed pointer"
                                " may be stale.\n");
    }
}

Reimplemented from GeometryQueryEngine.

Definition at line 2635 of file VirtualQueryEngine.cpp.

{
    int j;  
    TopologyBridge* bridge_ptr = NULL;
    TopologyBridge* tb_owner = NULL;

    TopologyBridge* visible_tb = NULL;

  DLIList<TopologyBridge*> tbs_to_search;
  tbs_to_search.append( hidden_tb );

    while(tbs_to_search.size())
    {
    bridge_ptr = tbs_to_search.pop();

        tb_owner = dynamic_cast<TopologyBridge*>(bridge_ptr->owner());
        if( tb_owner )
        {
            if( tb_owner->topology_entity() )
            {
                visible_tb = tb_owner;
                real_tbs.append( visible_tb ); 
        continue;
            }       
        }
        else
        {
            if( bridge_ptr->topology_entity() )
            {
                visible_tb = bridge_ptr;
                real_tbs.append( visible_tb );        
        continue;
            }           
        }


        TopologyBridge *tb_ptr;
        if( tb_owner )
            tb_ptr = tb_owner;
        else
            tb_ptr = bridge_ptr;

        TBOwner* tb_owner = tb_ptr->owner();
        if (CAST_TO(tb_owner, HiddenEntitySet)) // it is a composite
        {
            TopologyBridge* parent = NULL;
            while (CAST_TO(tb_owner, HiddenEntitySet)) // virtual geometry
            {
                HiddenEntitySet* hidden_set_ptr = CAST_TO(tb_owner, HiddenEntitySet);
                parent = dynamic_cast<TopologyBridge*>(hidden_set_ptr->owner());
                if (parent)
                    tb_owner = parent->owner();
            }
            if (parent)
            {
                tbs_to_search.append( parent );
                continue;
            }
        }
        else if (CAST_TO(tb_owner, SubEntitySet)) // partition geometry
    {
            SubEntitySet* sub_set_ptr = CAST_TO(tb_owner, SubEntitySet);

            DLIList<TopologyBridge*> owner_list;
            sub_set_ptr->get_owners(owner_list);
            owner_list.reset();
            // need to traverse all the entities that make up the original geometry
            //  if intersected a surface, and the surface is partitioned into mult surfaces,
            //  which surface did we hit? Did we hit the curve in between? The vertices? gahhhh...
            for (j=0; j<owner_list.size(); j++)
            {
                TopologyBridge* owner_partition = owner_list.get_and_step();
        tbs_to_search.append( owner_partition );        
            }
        }
  }

  real_tbs.uniquify_ordered();

  return CUBIT_SUCCESS;
}

Reimplemented from GeometryQueryEngine.

Definition at line 2381 of file VirtualQueryEngine.cpp.

{
    // Determine entity type; should only be Curve or TBPoint

    int j, k;
    bool added_entity = false;
    TopologyBridge* bridge_ptr = hidden_tb;
    TopologyBridge* tb_owner = NULL;
    bool hidden = CUBIT_TRUE;

    TopologyBridge* visible_tb = NULL;

    while (hidden)
    {
        tb_owner = dynamic_cast<TopologyBridge*>(bridge_ptr->owner());
        if( tb_owner )
        {
            if( tb_owner->topology_entity() )
            {
                visible_tb = tb_owner;
                hidden = CUBIT_FALSE;
                added_entity = true;
                continue;
            }
            else
                hidden = CUBIT_TRUE;      
        }
        else
        {
            if( bridge_ptr->topology_entity() )
            {
                visible_tb = bridge_ptr;
                hidden = CUBIT_FALSE;
                added_entity = true;
                continue;
            }
            else
            {
                hidden = CUBIT_TRUE;
            }
        }


        TopologyBridge *tb_ptr;
        if( tb_owner )
            tb_ptr = tb_owner;
        else
            tb_ptr = bridge_ptr;

        TBOwner* tb_owner = tb_ptr->owner();
        if (CAST_TO(tb_owner, HiddenEntitySet)) // virtual geometry
        {
            TopologyBridge* parent = NULL;
            while (CAST_TO(tb_owner, HiddenEntitySet)) // virtual geometry
            {
                HiddenEntitySet* hidden_set_ptr = CAST_TO(tb_owner, HiddenEntitySet);
                parent = dynamic_cast<TopologyBridge*>(hidden_set_ptr->owner());
                if (parent)
                    tb_owner = parent->owner();
            }
            if (parent)
            {
                bridge_ptr = parent;
                added_entity = true;
                continue;
            }
        }
        else if (CAST_TO(tb_owner, SubEntitySet)) // partition geometry
    {
            SubEntitySet* sub_set_ptr = CAST_TO(tb_owner, SubEntitySet);

            DLIList<TopologyBridge*> owner_list;
            sub_set_ptr->get_owners(owner_list);
            owner_list.reset();
            // need to traverse all the entities that make up the original geometry
            //  if intersected a surface, and the surface is partitioned into mult surfaces,
            //  which surface did we hit? Did we hit the curve in between? The vertices? gahhhh...
            for (j=0; j<owner_list.size(); j++)
            {
                TopologyBridge* owner_partition = owner_list.get_and_step();
                //determine geometry type and call point_containment

                CubitPointContainment containment = CUBIT_PNT_UNKNOWN;

                if (CAST_TO(owner_partition, Surface))
                {
                    containment = CAST_TO(owner_partition, Surface)->point_containment(*point);
                    switch (containment)
                    {
                    case CUBIT_PNT_OFF:
                        break;
                    case CUBIT_PNT_ON:
                        bridge_ptr = owner_partition;
                        added_entity = true;
                        break;
                    case CUBIT_PNT_UNKNOWN:
                        break;
                    case CUBIT_PNT_BOUNDARY:
                        {
                            DLIList<TopologyBridge*> children, related_loops, related_coedges;
                            DLIList<TopologyBridge*> related_curves, temp;

                            // Goal: get curves (incl. virtual ones)
                            // Note: can't use ->curves() func b/c it won't grab the virtual curves

                            // get all Loops, including virtual
                            owner_partition->get_children( related_loops, true );

                            related_loops.reset();
                            int ii;

                            // get all CoEdges
                            for (ii = related_loops.size(); ii--;)
                            {
                                temp.clean_out();
                                related_loops.get_and_step()->get_children(temp, true);
                                related_coedges.merge_unique(temp);
                            }
                            // get all Curves
                            for (ii = related_coedges.size(); ii--;)
                            {
                                temp.clean_out();
                                related_coedges.get_and_step()->get_children(temp, true);
                                related_curves.merge_unique(temp);
                            }

                            CAST_LIST(related_curves, children, TopologyBridge);
                            for (k=0; k<children.size(); k++)
                            {
                                // CAST and do point_containment for each curve
                                containment = CUBIT_PNT_UNKNOWN;
                                TopologyBridge* partition_curve = children.get_and_step();
                                containment = CAST_TO(partition_curve, Curve)->point_containment(*point);
                                switch (containment)
                                {
                                case CUBIT_PNT_OFF:
                                case CUBIT_PNT_UNKNOWN:
                                    break;
                                case CUBIT_PNT_ON:
                                    bridge_ptr = partition_curve;
                                    added_entity = true;
                                    break;
                                case CUBIT_PNT_BOUNDARY:
                                    {
                                        // CAST and do point_containment for each vertex
                                        children.clean_out();
                                        partition_curve->get_children(children, true);
                                        int kk;
                                        for (kk=0; kk<children.size(); kk++)
                                        {
                                            TopologyBridge* partition_vertex = children.get_and_step();
                                            containment = CUBIT_PNT_UNKNOWN;
                                            CubitVector coords = CAST_TO(partition_vertex, TBPoint)->coordinates();
                                            if (coords.distance_between_squared(*point) < GEOMETRY_RESABS*GEOMETRY_RESABS)
                                            {
                                                containment = CUBIT_PNT_ON;
                                                bridge_ptr = partition_vertex;
                                                added_entity = true;
                                                break;
                                            }
                                            else
                                                containment = CUBIT_PNT_OFF;
                                        }
                                    }
                                }

                                if (added_entity)
                                    break;
                            }                              
                            break;
                        }
                    }
                    if (added_entity)
                        break;
                }
                else if (CAST_TO(owner_partition, Curve))
                {
                    // CAST and do point_containment for each curve
                    containment = CUBIT_PNT_UNKNOWN;
                    containment = CAST_TO(owner_partition, Curve)->point_containment(*point);
                    switch (containment)
                    {
                    case CUBIT_PNT_OFF:
                    case CUBIT_PNT_UNKNOWN:
                        break;
                    case CUBIT_PNT_ON:
                        bridge_ptr = owner_partition;
                        added_entity = true;
                        break;
                    case CUBIT_PNT_BOUNDARY:
                        {
                            // CAST and do point_containment for each vertex
                            DLIList<TopologyBridge*> children;
                            children.clean_out();
                            owner_partition->get_children(children, true);
                            int kk;
                            for (kk=0; kk<children.size(); kk++)
                            {
                                TopologyBridge* partition_vertex = children.get_and_step();
                                containment = CUBIT_PNT_UNKNOWN;
                                CubitVector coords = CAST_TO(partition_vertex, TBPoint)->coordinates();
                                if (coords.distance_between_squared(*point) < GEOMETRY_RESABS*GEOMETRY_RESABS)
                                {
                                    containment = CUBIT_PNT_ON;
                                    bridge_ptr = partition_vertex;
                                    added_entity = true;
                                    break;
                                }
                                else
                                    containment = CUBIT_PNT_OFF;
                            }
                            break;
                        }
                    }

                    if (added_entity)
                        break;
                }

                else if (CAST_TO(owner_partition, TBPoint))
                {
                    CubitVector coords = CAST_TO(owner_partition, TBPoint)->coordinates();
                    if (coords.distance_between_squared(*point) < GEOMETRY_RESABS*GEOMETRY_RESABS)
                    {
                        containment = CUBIT_PNT_ON;
                        bridge_ptr = owner_partition;
                        added_entity = true;
                        break;
                    }
                    else
                        containment = CUBIT_PNT_OFF;
                }

                else
                    PRINT_WARNING("Hit unknown partition entity.\n");


            }
            if (!added_entity)
            {
                visible_tb = NULL;
                hidden = CUBIT_FALSE;
                //break;
            }

        }


    } //while

    return visible_tb;
}

Definition at line 1083 of file VirtualQueryEngine.cpp.

{
  if (te_ptr == NULL)
    return CUBIT_FALSE;
  
  if (is_virtual(te_ptr))
    return CUBIT_TRUE;
  
    // check if children has partition or composite entities
  int i;
  Body      * body_ptr = CAST_TO (te_ptr, Body);
  RefVolume * vol_ptr  = CAST_TO (te_ptr, RefVolume);
  RefFace   * face_ptr = CAST_TO (te_ptr, RefFace);
  CubitBoolean has_vir = CUBIT_FALSE;
  
  if (body_ptr != NULL)
  {
    DLIList<RefVolume*> vol_list;
    te_ptr->ref_volumes(vol_list);
    for (i = vol_list.size(); i > 0; i--)
    {
      if (has_virtual(vol_list.get_and_step()))
      {
        has_vir = CUBIT_TRUE;
        break;
      }
    }
  }
                                                                                
  if (vol_ptr != NULL)
  {
    DLIList<RefFace*> face_list;
    te_ptr->ref_faces(face_list);
    for (i = face_list.size(); i > 0; i --)
    {
       if (has_virtual(face_list.get_and_step()))
       { 
         has_vir = CUBIT_TRUE;
         break;
       }
    }
  }
                                                                                
  if (face_ptr != NULL)
  {
    DLIList<RefEdge *> edge_list;
    te_ptr->ref_edges(edge_list);
    for (i = edge_list.size(); i > 0; i --)
    {
       if (is_virtual(edge_list.get_and_step()))
       {
         has_vir = CUBIT_TRUE;
         break;
       }
    }
  }

  return has_vir;
} 
CubitStatus VirtualQueryEngine::import_solid_model ( const char *  file_name,
Model_File_Type  file_type,
DLIList< TopologyBridge * > &  imported_entities,
ModelImportOptions &  import_options 
) [protected, virtual]

R CubitStatus R- CUBIT_SUCCESS/CUBIT_FAILURE I file_ptr I- A pointer to the file to read (can be NULL for IGES and STEP files). I file_type I- Type of file.

  • Reads in geometry and creates the necessary Reference entities
  • associated with the input geometry.
  • Valid file types are:
  • "IGES" -- IGES file
  • "STEP" -- STEP file I heal_step - auto-healing of step bodies on import. This is recommended because they always need it. I import_bodies (etc...) I- Should bodies be import.
  • Function can selectively import solid bodies, free surfaces, free
  • curves, or free vertices. For example, the user may not want
  • to import any free entities.
  • The function returns CUBIT_FAILURE if anything goes wrong with
  • import - improper file type, inaccessible file, mismatch between
  • the underlying representation and file type. It returns
  • CUBIT_SUCCESS if everything goes well.

Implements GeometryQueryEngine.

Definition at line 1865 of file VirtualQueryEngine.cpp.

{
  PRINT_INFO("VirtualQueryEngine::import_solid_model\n");
  
  default_error_message( "import_solid_model()");
  return CUBIT_FAILURE;
}
virtual CubitStatus VirtualQueryEngine::import_solid_model ( DLIList< TopologyBridge * > &  imported_entities,
const char *  pBuffer,
const int  n_buffer_size 
) [inline, protected, virtual]

Implements GeometryQueryEngine.

Definition at line 354 of file VirtualQueryEngine.hpp.

{return CUBIT_FAILURE;}
VirtualQueryEngine * VirtualQueryEngine::instance ( void  ) [inline, static]

Definition at line 451 of file VirtualQueryEngine.hpp.

{
  if( instance_ == NULL )
  {
    instance_ = new VirtualQueryEngine;
    assert( instance_ != NULL );
  }
  
  return instance_;
}
virtual bool VirtualQueryEngine::is_intermediate_engine ( ) [inline, virtual]

Reimplemented from GeometryQueryEngine.

Definition at line 117 of file VirtualQueryEngine.hpp.

{return TRUE;}

Definition at line 1194 of file VirtualQueryEngine.cpp.

{
  RefEdge *ref_edge = CAST_TO( ref_entity, RefEdge );

  if( ref_edge )
  {
    Curve *curve_ptr = ref_edge->get_curve_ptr();
    PartitionCurve *part_curve = CAST_TO(curve_ptr, PartitionCurve);

    if( part_curve )
      return CUBIT_TRUE;
  }

  return CUBIT_FALSE;
}
CubitBoolean VirtualQueryEngine::is_virtual ( TopologyEntity entity,
const CubitBoolean  children_too = CUBIT_FALSE 
) [static]

Definition at line 1143 of file VirtualQueryEngine.cpp.

{
  if ( entity == NULL )
      return CUBIT_FALSE;
  
  if (CAST_TO(entity, Body) !=NULL)
  {
     int i;
     DLIList<TopologyBridge*> list;
     entity->bridge_manager()->get_bridge_list(list);
     TopologyBridge * tb;
     for (i = list.size(); i > 0; i--)
     {
        tb =  list.get_and_step();
        if (CAST_TO(tb, PartitionBody) != NULL ||
            CAST_TO(tb, CompositeBody) != NULL)
           return CUBIT_TRUE;
      }
  }

  DLIList<TopologyBridge*> ve_list;
  get_VEs(entity, ve_list, CUBIT_TRUE, children_too);
  return (ve_list.size() ? CUBIT_TRUE : CUBIT_FALSE);
}
CubitBoolean VirtualQueryEngine::is_virtual ( DLIList< Body * > &  entity_list,
const CubitBoolean  children_too = CUBIT_FALSE 
) [static]

Definition at line 1171 of file VirtualQueryEngine.cpp.

{
  if (!children_too) return CUBIT_FALSE;
                                                                                
  int i;
  for (i = entity_list.size(); i > 0; i--)
    if (is_virtual(entity_list.get_and_step(), children_too)) return CUBIT_TRUE;                                                                                
  return CUBIT_FALSE;
}
CubitBoolean VirtualQueryEngine::is_virtual ( DLIList< RefEntity * > &  entity_list,
const CubitBoolean  children_too = CUBIT_FALSE 
) [static]

Definition at line 1182 of file VirtualQueryEngine.cpp.

{
  int i;
  for (i = entity_list.size(); i > 0; i--) {
    RefEntity *ref_entity = entity_list.get_and_step();
    if (is_virtual(CAST_TO(ref_entity, TopologyEntity), children_too)) return CUBIT_TRUE;
  }
                                                                                
  return CUBIT_FALSE;
}
const char* VirtualQueryEngine::modeler_type ( ) [inline, virtual]

Implements GeometryQueryEngine.

Definition at line 108 of file VirtualQueryEngine.hpp.

   { return "virtual"; }
CubitStatus VirtualQueryEngine::reflect ( BodySM body,
const CubitVector axis 
) [virtual]

Implements GeometryQueryEngine.

Definition at line 2244 of file VirtualQueryEngine.cpp.

{
  if (PartitionBody* part = dynamic_cast<PartitionBody*>(body))
    return PartitionEngine::instance().reflect( part, axis );
  else if(CompositeBody* comp = dynamic_cast<CompositeBody*>(body))
    return CompositeEngine::instance().reflect( comp, axis );

  PRINT_ERROR("Non-virtual entity in VGE::reflect.\n");
  return CUBIT_FAILURE;
}
CubitStatus VirtualQueryEngine::reflect ( GeometryEntity ent,
const CubitVector axis 
) [virtual]

Implements GeometryQueryEngine.

Definition at line 2316 of file VirtualQueryEngine.cpp.

{
  if (PartitionEntity* part = dynamic_cast<PartitionEntity*>(ent))
    return PartitionEngine::instance().reflect( part, axis );
  else if(CompositeSurface* csurf = dynamic_cast<CompositeSurface*>(ent))
    return CompositeEngine::instance().reflect( csurf, axis );
  else if(CompositeCurve* ccurve = dynamic_cast<CompositeCurve*>(ent))
    return CompositeEngine::instance().reflect( ccurve, axis );

  PRINT_ERROR("Non-virtual entity in VGE::reflect.\n");
  return CUBIT_FAILURE;
}

Definition at line 2166 of file VirtualQueryEngine.cpp.

{
  CubitStatus result;
  result = CGMApp::instance()->attrib_manager()->register_attrib_type(
                                               CA_PARTITION_VG, "partition vg", "PARTITION_VG",
                                               CAPartitionVG_creator, CUBIT_FALSE,
                                               CUBIT_FALSE, CUBIT_TRUE, CUBIT_TRUE,
                                               CUBIT_FALSE, CUBIT_FALSE);
  if (CUBIT_SUCCESS != result) {
    PRINT_ERROR("Failed to register attribute type partition vg.\n");
    return;
  }

  result = CGMApp::instance()->attrib_manager()->register_attrib_type(
                                               CA_COMPOSITE_VG, "composite vg", "COMPOSITE_VG",
                                               CACompositeVG_creator, CUBIT_FALSE,
                                               CUBIT_FALSE, CUBIT_TRUE, CUBIT_TRUE,
                                               CUBIT_FALSE, CUBIT_FALSE);
  if (CUBIT_SUCCESS != result) {
    PRINT_ERROR("Failed to register attribute type composite vg.\n");
    return;
  }

  result = CGMApp::instance()->attrib_manager()->register_attrib_type(
                                               CA_VIRTUAL_VG, "virtual vg", "VIRTUAL_VG",
                                               CAVirtualVG_creator, CUBIT_FALSE,
                                               CUBIT_FALSE, CUBIT_TRUE, CUBIT_TRUE,
                                               CUBIT_FALSE, CUBIT_FALSE);
  if (CUBIT_SUCCESS != result) {
    PRINT_ERROR("Failed to register attribute type virtual vg.\n");
  }
}
void VirtualQueryEngine::remove_virtual_geometry ( RefEntity entity_ptr,
CubitBoolean  all_children 
)

Definition at line 1746 of file VirtualQueryEngine.cpp.

{
  if ( Body* body_ptr = dynamic_cast<Body*>(entity_ptr) )
    remove_virtual_geometry(body_ptr, all_children);
  else if( RefVolume* vol_ptr = dynamic_cast<RefVolume*>(entity_ptr) )
    remove_virtual_geometry(vol_ptr, all_children);
  else if( RefFace* face_ptr = dynamic_cast<RefFace*>(entity_ptr) )
    remove_virtual_geometry(face_ptr);
}
void VirtualQueryEngine::remove_virtual_geometry ( Body body,
bool  all_children 
)

Definition at line 1757 of file VirtualQueryEngine.cpp.

{
  int i;
  DLIList<RefVolume*> volumes, part_results;
  body_ptr->ref_volumes(volumes);
  for ( i = volumes.size(); i--; ) {
    RefVolume* vol = volumes.step_and_get();
    if ( ! dynamic_cast<PartitionLump*>(vol->get_lump_ptr()) )
      volumes.change_to(0);
  }
  volumes.remove_all_with_value(0);
  if ( volumes.size() )
    PartitionTool::instance()->unpartitionAll(volumes, part_results);
  
  if ( !all_children )
    return;
    
  volumes.clean_out();
  body_ptr->ref_volumes(volumes);
  for ( i = volumes.size(); i--; )
    remove_virtual_geometry( volumes.step_and_get(), true );
}
void VirtualQueryEngine::remove_virtual_geometry ( RefVolume vol,
bool  all_children 
)

Definition at line 1781 of file VirtualQueryEngine.cpp.

{
  int i;
  DLIList<RefFace*> faces, part_results;
  bool had_virtual_geometry = false;
  vol_ptr->ref_faces( faces );
  for ( i = faces.size(); i--; ) 
  {
    if ( dynamic_cast<CompositeSurface*>(faces.step_and_get()->get_surface_ptr()) )
    {
      CompositeTool::instance()->uncomposite(faces.get());
      had_virtual_geometry = true;
    }
  }
  
  faces.clean_out();
  vol_ptr->ref_faces( faces );
  for ( i = faces.size(); i--; ) 
  {
    if ( !dynamic_cast<PartitionSurface*>(faces.step_and_get()->get_surface_ptr()))
      faces.change_to(0);
  }
  faces.remove_all_with_value(0);
  if ( faces.size() )
  {
    PartitionTool::instance()->unpartitionAll(faces, part_results);
    had_virtual_geometry = true;
  }
  
  if ( !all_children )  
    return;
  
  faces.clean_out();
  vol_ptr->ref_faces( faces );
  for ( i = faces.size(); i--; )
    remove_virtual_geometry( faces.step_and_get() );

  if( had_virtual_geometry )
    AppUtil::instance()->send_event(GeometryEvent(GeometryEvent::TOPOLOGY_MODIFIED, vol_ptr));
}

Definition at line 1823 of file VirtualQueryEngine.cpp.

{
  int i;
  DLIList<RefEdge*> edges, part_results;
  face_ptr->ref_edges( edges );
  for ( i = edges.size(); i--; ) {
    if ( dynamic_cast<CompositeCurve*>(edges.step_and_get()->get_curve_ptr()) )
      CompositeTool::instance()->uncomposite(edges.get());
  }
  
  edges.clean_out();
  face_ptr->ref_edges( edges );
  for ( i = edges.size(); i--; ) {
    if ( !dynamic_cast<PartitionCurve*>(edges.step_and_get()->get_curve_ptr()))
      edges.change_to(0);
  }
  edges.remove_all_with_value(0);
  if ( edges.size() )
    PartitionTool::instance()->unpartitionAll(edges, part_results);
}

Implements GeometryQueryEngine.

Definition at line 2256 of file VirtualQueryEngine.cpp.

{
  if (PartitionBody* part = dynamic_cast<PartitionBody*>(body))
    return PartitionEngine::instance().restore_transform( part );
  else if(CompositeBody* comp = dynamic_cast<CompositeBody*>(body))
    return CompositeEngine::instance().restore_transform( comp );

  PRINT_ERROR("Non-virtual entity in VGE::restore_transform.\n");
  return CUBIT_FAILURE;
}
CubitStatus VirtualQueryEngine::rotate ( BodySM body,
const CubitVector axis,
double  angle 
) [virtual]

Implements GeometryQueryEngine.

Definition at line 2213 of file VirtualQueryEngine.cpp.

{
  if (PartitionBody* part = dynamic_cast<PartitionBody*>(body))
    return PartitionEngine::instance().rotate( part, axis, angle );
  else if(CompositeBody* comp = dynamic_cast<CompositeBody*>(body))
    return CompositeEngine::instance().rotate( comp, axis, angle );

  PRINT_ERROR("Non-virtual entity in VGE::rotate.\n");
  return CUBIT_FAILURE;
}
CubitStatus VirtualQueryEngine::rotate ( GeometryEntity ent,
const CubitVector axis,
double  degrees 
) [virtual]

Implements GeometryQueryEngine.

Definition at line 2281 of file VirtualQueryEngine.cpp.

{
  if (PartitionEntity* part = dynamic_cast<PartitionEntity*>(ent))
    return PartitionEngine::instance().rotate( part, axis, degrees );
  else if(CompositeSurface* csurf = dynamic_cast<CompositeSurface*>(ent))
    return CompositeEngine::instance().rotate( csurf, axis, degrees );
  else if(CompositeCurve* ccurve = dynamic_cast<CompositeCurve*>(ent))
    return CompositeEngine::instance().rotate( ccurve, axis, degrees );

  PRINT_ERROR("Non-virtual entity in VGE::rotate.\n");
  return CUBIT_FAILURE;
}
CubitStatus VirtualQueryEngine::save_temp_geom_file ( DLIList< TopologyBridge * > &  ref_entity_list,
const char *  filename,
const CubitString cubit_version,
CubitString created_file,
CubitString created_file_type 
) [protected, virtual]

Saves out a temporary geometry file. Entities in list must all be of same modeling engine.

Implements GeometryQueryEngine.

Definition at line 1856 of file VirtualQueryEngine.cpp.

{
  return CUBIT_FAILURE;
}
CubitStatus VirtualQueryEngine::scale ( BodySM body,
double  factor 
) [virtual]

Implements GeometryQueryEngine.

Definition at line 2226 of file VirtualQueryEngine.cpp.

{
  return scale( body, CubitVector(factor,factor,factor) );
}
CubitStatus VirtualQueryEngine::scale ( BodySM body,
const CubitVector factors 
) [virtual]

Implements GeometryQueryEngine.

Definition at line 2232 of file VirtualQueryEngine.cpp.

{
  if (PartitionBody* part = dynamic_cast<PartitionBody*>(body))
    return PartitionEngine::instance().scale( part, factors );
  else if(CompositeBody* comp = dynamic_cast<CompositeBody*>(body))
    return CompositeEngine::instance().scale( comp, factors );

  PRINT_ERROR("Non-virtual entity in VGE::scale.\n");
  return CUBIT_FAILURE;
}
CubitStatus VirtualQueryEngine::scale ( GeometryEntity ent,
double  factor 
) [virtual]

Implements GeometryQueryEngine.

Definition at line 2296 of file VirtualQueryEngine.cpp.

{
  return scale( ent, CubitVector( factor, factor, factor ) );
}
CubitStatus VirtualQueryEngine::scale ( GeometryEntity ent,
const CubitVector factors 
) [virtual]

Implements GeometryQueryEngine.

Definition at line 2302 of file VirtualQueryEngine.cpp.

{
  if (PartitionEntity* part = dynamic_cast<PartitionEntity*>(ent))
    return PartitionEngine::instance().scale( part, factors );
  else if(CompositeSurface* csurf = dynamic_cast<CompositeSurface*>(ent))
    return CompositeEngine::instance().scale( csurf, factors );
  else if(CompositeCurve* ccurve = dynamic_cast<CompositeCurve*>(ent))
    return CompositeEngine::instance().scale( ccurve, factors );

  PRINT_ERROR("Non-virtual entity in VGE::scale.\n");
  return CUBIT_FAILURE;
}
CubitStatus VirtualQueryEngine::set_dbl_option ( const char *  opt_name,
double  val 
) [protected, virtual]

Implements GeometryQueryEngine.

Definition at line 2150 of file VirtualQueryEngine.cpp.

{
  PRINT_INFO("VirtualQueryEngine::set_dbl_option\n");
  
  default_error_message( "set_dbl_option()");
  return CUBIT_FAILURE;
}
CubitStatus VirtualQueryEngine::set_int_option ( const char *  opt_name,
int  val 
) [protected, virtual]

Implements GeometryQueryEngine.

Definition at line 2142 of file VirtualQueryEngine.cpp.

{
  PRINT_INFO("VirtualQueryEngine::set_int_option\n");
  
  default_error_message( "set_int_option()");
  return CUBIT_FAILURE;
}
double VirtualQueryEngine::set_sme_resabs_tolerance ( double  new_resabs) [protected, virtual]

Implements GeometryQueryEngine.

Definition at line 2134 of file VirtualQueryEngine.cpp.

{
  PRINT_INFO("VirtualQueryEngine::set_sme_resabs_tolerance\n");
  
  default_error_message( "set_sme_resabs_tolerance()");
  return 0;
}
CubitStatus VirtualQueryEngine::set_str_option ( const char *  opt_name,
const char *  val 
) [protected, virtual]

Implements GeometryQueryEngine.

Definition at line 2158 of file VirtualQueryEngine.cpp.

{
  PRINT_INFO("VirtualQueryEngine::set_str_option\n");
  
  default_error_message( "set_str_option()");
  return CUBIT_FAILURE;
}

Definition at line 1253 of file VirtualQueryEngine.cpp.

{
  DLIList<RefEdge*> sorted_edge_list;
  RefEdge *first, *current = NULL, *prev;
  CubitStatus return_value = CUBIT_SUCCESS;
  
  if( edge_list.size( ) <= 0 )
  {
    return CUBIT_FAILURE;
  }
  
  if( edge_list.size() == 1 )
  {
    return CUBIT_SUCCESS;
  }
  
    //Note: this part badly needs some optimization.  Given the array-based
    // implementation of the DLList class, this is a very inefficient
    // approach to sorting the edges.  Look into a different seach
    // algorithm, and possible switching functions in DLList.
  
    //add first Curve
  edge_list.reset( );
  first = prev = edge_list.remove( );
  sorted_edge_list.append( first );
  
    //sort the rest of the Curves
  int i;
  for( i = 0; i < edge_list.size( ); i++ ) //loop for each remaining RefEdge
  {
    edge_list.reset( );
      //look through list for next RefEdge
    for( int j = 0; j < edge_list.size( ); j++ )
    {
      current = edge_list.get( );
      if( prev->common_ref_vertex( current ) != NULL )
      {
        edge_list.remove( );
        sorted_edge_list.append( current );
        i--; //edge_list.size() decreases with removal of edge
        prev = current;
        break;
      }
      else if( first->common_ref_vertex( current ) != NULL )
      {
        edge_list.remove( );
        sorted_edge_list.insert_first( current );
        first = current;
        i--; //edge_list.size() decreases with removal of edge
        break;
      }
      else
      {
        edge_list.step( );
      }
    }//end for(j)
  }//end for(i)
  
    //check if all the RefEdges got sorted
  if( edge_list.size( ) > 0 )
  {
    return_value =  CUBIT_FAILURE;
    
      //Sort the rest of the edges anyway, for use by
      //other functions than composite edge creation.
    
    sort_edges( edge_list );
    edge_list.reset( );
    for( i = 0; i < edge_list.size(); i++ )
    {
      current = edge_list.get_and_step( );
      sorted_edge_list.append( current );
    }
  }
  else
  {
    return_value = CUBIT_SUCCESS;
  }
  
  edge_list.clean_out( );
  edge_list = sorted_edge_list;
  edge_list.reset( );
  return return_value;
}
CubitStatus VirtualQueryEngine::transform_vec_position ( CubitVector const &  position_vector,
BodySM OSME_ptr,
CubitVector transformed_vector 
) const [virtual]

Implements GeometryQueryEngine.

Definition at line 172 of file VirtualQueryEngine.cpp.

{
  return CUBIT_FAILURE;
}
CubitStatus VirtualQueryEngine::translate ( BodySM body,
const CubitVector offset 
) [virtual]

Implements GeometryQueryEngine.

Definition at line 2201 of file VirtualQueryEngine.cpp.

{
  if (PartitionBody* part = dynamic_cast<PartitionBody*>(body))
    return PartitionEngine::instance().translate( part, offset );
  else if(CompositeBody* comp = dynamic_cast<CompositeBody*>(body))
    return CompositeEngine::instance().translate( comp, offset );

  PRINT_ERROR("Non-virtual entity in VGE::translate.\n");
  return CUBIT_FAILURE;
}
CubitStatus VirtualQueryEngine::translate ( GeometryEntity ent,
const CubitVector offset 
) [virtual]

Implements GeometryQueryEngine.

Definition at line 2267 of file VirtualQueryEngine.cpp.

{
  if (PartitionEntity* part = dynamic_cast<PartitionEntity*>(ent))
    return PartitionEngine::instance().translate( part, offset );
  else if(CompositeSurface* csurf = dynamic_cast<CompositeSurface*>(ent))
    return CompositeEngine::instance().translate( csurf, offset );
  else if(CompositeCurve* ccurve = dynamic_cast<CompositeCurve*>(ent))
    return CompositeEngine::instance().translate( ccurve, offset );

  PRINT_ERROR("Non-virtual entity in VGE::translate.\n");
  return CUBIT_FAILURE;
}
CubitBoolean VirtualQueryEngine::volumes_overlap ( Lump lump1,
Lump lump2 
) const [virtual]

Implements GeometryQueryEngine.

Definition at line 2331 of file VirtualQueryEngine.cpp.

{
  PartitionLump* partition_lump1 = dynamic_cast<PartitionLump*>(lump1);
  PartitionLump* partition_lump2 = dynamic_cast<PartitionLump*>(lump2);

  Lump *tmp_lump1 = lump1; 
  if( partition_lump1 )
    tmp_lump1 = partition_lump1->real_lump();

  Lump *tmp_lump2 = lump2; 
  if( partition_lump2 )
    tmp_lump2 = partition_lump2->real_lump();

  GeometryQueryEngine *gqe = tmp_lump1->get_geometry_query_engine();
  if( gqe != tmp_lump2->get_geometry_query_engine() )
  {
    PRINT_ERROR("Volumes must be of the same type (, SolidWorks, etc) to\n"
                "find if they overlap.\n");
    return CUBIT_FALSE;
  }

  return gqe->volumes_overlap( tmp_lump1, tmp_lump2 );
}

Member Data Documentation

VirtualQueryEngine * VirtualQueryEngine::instance_ = NULL [static, protected]

Definition at line 298 of file VirtualQueryEngine.hpp.

const double VirtualQueryEngine::param_epsilon_fraction = 1000000 [static]

Definition at line 82 of file VirtualQueryEngine.hpp.

const int VirtualQueryEngine::VGE_MAJOR_VERSION = 10 [static, private]

Definition at line 394 of file VirtualQueryEngine.hpp.

const int VirtualQueryEngine::VGE_MINOR_VERSION = 0 [static, private]

Definition at line 395 of file VirtualQueryEngine.hpp.

const int VirtualQueryEngine::VGE_SUBMINOR_VERSION = 0 [static, private]

Definition at line 396 of file VirtualQueryEngine.hpp.


The documentation for this class was generated from the following files:
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines