cgma
Public Member Functions | Static Public Member Functions | Private Member Functions | Private Attributes | Static Private Attributes
TDFacetBoundaryPoint Class Reference

#include <TDFacetBoundaryPoint.hpp>

Inheritance diagram for TDFacetBoundaryPoint:
ToolData

List of all members.

Public Member Functions

 TDFacetBoundaryPoint ()
 ~TDFacetBoundaryPoint ()
void add_surf (int new_id)
CubitPoint * get_point ()
void set_point (CubitPoint *point_ptr)
 SetDynamicMemoryAllocation (memoryManager) static void set_memory_allocation_increment(int increment=0)
CubitStatus get_normal (int surf_id, CubitVector &normal)
CubitStatus get_normal (CubitFacet *adj_facet, CubitVector &normal)
CubitStatus get_normal (CubitFacetEdge *edge_ptr, CubitVector &normal)
CubitStatus set_normal (int surf_id, CubitVector &normal)
CubitStatus reset_normals ()
CubitStatus set_uv (CubitFacet *adj_facet, double u, double v)
CubitStatus set_uvs (CubitFacet *adj_facet, double u, double v, double s)
double u (CubitFacet *adj_facet)
double v (CubitFacet *adj_facet)
double s (CubitFacet *adj_facet)
CubitStatus get_uv (CubitFacet *adj_facet, double &u, double &v)
CubitStatus get_uvs (CubitFacet *adj_facet, double &u, double &v, double &s)
void add_surf_facets (DLIList< CubitFacet * > adj_facet_list)
void set_surf_id (CubitFacet *facet_ptr, int surf_id)
CubitStatus merge_normals (CubitFacet *facet0, CubitFacet *facet1)
CubitStatus rotate_normal (CubitTransformMatrix &rotmat)
CubitStatus get_boundary_point_data_size (int &size_int_data, int &size_double_data)
CubitStatus get_boundary_point_data (int *int_data, double *double_data, int &iidx, int &didx)
void initialize (CubitFacet **facets, int &iidx, int &didx, int *int_data, double *double_data)

Static Public Member Functions

static int is_facet_boundary_point (const ToolData *td)
static void destroy_memory ()
static CubitStatus add_facet_boundary_point (CubitPoint *point_ptr)
static CubitStatus add_facet_boundary_point (CubitPoint *point_ptr, CubitFacet *facet_ptr, CubitVector &normal)
static CubitStatus add_facet_boundary_point (CubitPoint *point_ptr, CubitQuadFacet *qfacet_ptr, CubitVector &normal)
static TDFacetBoundaryPoint * get_facet_boundary_point (CubitPoint *point_ptr)
static CubitStatus new_facet_boundary_point (CubitPoint **points, CubitFacet **facets, int &iidx, int &didx, int *int_data, double *double_data)

Private Member Functions

void init_normal (BoundaryPointData *bpd_ptr)
BoundaryPointData * get_bpd (CubitFacet *facet)

Private Attributes

CubitPoint * pointPtr
DLIList< BoundaryPointData * > pointDataList

Static Private Attributes

static MemoryManager memoryManager

Detailed Description

  • Class: TDFacetBoundaryPoint
  • Description: Tool data for storing additional information at
  • the boundary of a facet set
  • Owner: Steve Owen
  • Checked by:
  • Version:

Definition at line 36 of file TDFacetBoundaryPoint.hpp.

Constructor & Destructor Documentation

TDFacetBoundaryPoint::TDFacetBoundaryPoint ( )

Definition at line 18 of file TDFacetBoundaryPoint.cpp.

{

}
TDFacetBoundaryPoint::~TDFacetBoundaryPoint ( )

Definition at line 23 of file TDFacetBoundaryPoint.cpp.

{
  for (int ii=0; ii<pointDataList.size(); ii++)
  {
    BoundaryPointData *bpd_ptr = pointDataList.get_and_step();
    delete bpd_ptr;
  }
}

Member Function Documentation

CubitStatus TDFacetBoundaryPoint::add_facet_boundary_point ( CubitPoint *  point_ptr) [static]

Definition at line 42 of file TDFacetBoundaryPoint.cpp.

{
  ToolData *td;
  td = point_ptr->get_TD(&TDFacetBoundaryPoint::is_facet_boundary_point);
  if ( td == NULL )
  {
    TDFacetBoundaryPoint *td_gm = new TDFacetBoundaryPoint;
    point_ptr->add_TD( td_gm);
    td_gm->set_point( point_ptr );
  }
  else
  {
    TDFacetBoundaryPoint *td_gm = CAST_TO(td, TDFacetBoundaryPoint);
    td_gm->set_point( point_ptr );
  }
  return CUBIT_SUCCESS;
}
CubitStatus TDFacetBoundaryPoint::add_facet_boundary_point ( CubitPoint *  point_ptr,
CubitFacet *  facet_ptr,
CubitVector &  normal 
) [static]

Definition at line 71 of file TDFacetBoundaryPoint.cpp.

{
  ToolData *td;
  TDFacetBoundaryPoint *td_gm = NULL;
  td = point_ptr->get_TD(&TDFacetBoundaryPoint::is_facet_boundary_point);
  if ( td == NULL )
  {
    td_gm = new TDFacetBoundaryPoint;
    point_ptr->add_TD( td_gm);
    td_gm->set_point( point_ptr );
  }
  else
  {
    td_gm = CAST_TO(td, TDFacetBoundaryPoint);
    td_gm->set_point( point_ptr );
  }

  BoundaryPointData *bpd_ptr = new BoundaryPointData;
  bpd_ptr->surfFacetList.append( facet_ptr ); 
  bpd_ptr->surfID = -1;
  bpd_ptr->uVal = 0.0; 
  bpd_ptr->vVal = 0.0;
  bpd_ptr->sizeVal = 0.0;
  bpd_ptr->normal = pt_normal;
  td_gm->pointDataList.append( bpd_ptr );
  
  return CUBIT_SUCCESS;
}
CubitStatus TDFacetBoundaryPoint::add_facet_boundary_point ( CubitPoint *  point_ptr,
CubitQuadFacet *  qfacet_ptr,
CubitVector &  normal 
) [static]

Definition at line 114 of file TDFacetBoundaryPoint.cpp.

{
  ToolData *td;
  TDFacetBoundaryPoint *td_gm = NULL;
  td = point_ptr->get_TD(&TDFacetBoundaryPoint::is_facet_boundary_point);
  if ( td == NULL )
  {
    td_gm = new TDFacetBoundaryPoint;
    point_ptr->add_TD( td_gm);
    td_gm->set_point( point_ptr );
  }
  else
  {
    td_gm = CAST_TO(td, TDFacetBoundaryPoint);
    td_gm->set_point( point_ptr );
  }

  CubitFacet *facet0 = qfacet_ptr->get_tri_facet(0);
  CubitFacet *facet1 = qfacet_ptr->get_tri_facet(1);

  BoundaryPointData *bpd_ptr = new BoundaryPointData;
  if (facet0->point_index( point_ptr ) >= 0)
    bpd_ptr->surfFacetList.append( facet0 );
  if (facet1->point_index( point_ptr ) >= 0)
    bpd_ptr->surfFacetList.append( facet1 );
  bpd_ptr->surfID = -1;
  bpd_ptr->uVal = 0.0; 
  bpd_ptr->vVal = 0.0;
  bpd_ptr->sizeVal = 0.0;
  bpd_ptr->normal = pt_normal;
  td_gm->pointDataList.append( bpd_ptr );
  
  return CUBIT_SUCCESS;
}
void TDFacetBoundaryPoint::add_surf ( int  new_id)
void TDFacetBoundaryPoint::add_surf_facets ( DLIList< CubitFacet * >  adj_facet_list)

Definition at line 185 of file TDFacetBoundaryPoint.cpp.

{
  BoundaryPointData *bpd_ptr = new BoundaryPointData;
  int ii;
  for (ii=0; ii<adj_facet_list.size(); ii++)
  {
    CubitFacet *facet_ptr = adj_facet_list.get_and_step();
    bpd_ptr->surfFacetList.append( facet_ptr );
  }
  
  bpd_ptr->surfID = -1;
  bpd_ptr->uVal = 0.0; 
  bpd_ptr->vVal = 0.0;
  bpd_ptr->sizeVal = 0.0;
  pointDataList.append( bpd_ptr );
  init_normal( bpd_ptr );
}
static void TDFacetBoundaryPoint::destroy_memory ( ) [inline, static]

Definition at line 76 of file TDFacetBoundaryPoint.hpp.

    {memoryManager.destroy_memory();}
CubitStatus TDFacetBoundaryPoint::get_boundary_point_data ( int *  int_data,
double *  double_data,
int &  iidx,
int &  didx 
)

Definition at line 717 of file TDFacetBoundaryPoint.cpp.

{
  int_data[iidx++] = pointPtr->id();
  int num_bpd = pointDataList.size();
  int_data[iidx++] = num_bpd;
  
  BoundaryPointData *bpd_ptr;
  int ii, jj;
  int numfacs = 0;
  CubitFacet *facet_ptr;
  for (ii=0; ii<num_bpd; ii++)
  {
    bpd_ptr = pointDataList.get_and_step();
    numfacs = bpd_ptr->surfFacetList.size();
    int_data[iidx++] = numfacs;
    for (jj=0; jj<bpd_ptr->surfFacetList.size(); jj++)
    {
      facet_ptr = bpd_ptr->surfFacetList.get_and_step();
      int_data[iidx++] = facet_ptr->id();
    }
    int_data[iidx++] = bpd_ptr->surfID;
    
    double_data[didx++] = bpd_ptr->normal.x();
    double_data[didx++] = bpd_ptr->normal.y();
    double_data[didx++] = bpd_ptr->normal.z();
    double_data[didx++] = bpd_ptr->sizeVal;
    double_data[didx++] = bpd_ptr->uVal;
    double_data[didx++] = bpd_ptr->vVal;
  }
  return CUBIT_SUCCESS;
}
CubitStatus TDFacetBoundaryPoint::get_boundary_point_data_size ( int &  size_int_data,
int &  size_double_data 
)

Definition at line 690 of file TDFacetBoundaryPoint.cpp.

{
   int num_bpd = pointDataList.size();
   int ii;
   BoundaryPointData *bpd_ptr;

   //pointPtr->id() and pointDataList.size()
   size_int_data += 2;
   for (ii=0; ii<num_bpd; ii++)
   {
     size_int_data += 2;
     bpd_ptr = pointDataList.get_and_step();
     //num_surfaces
     size_int_data += bpd_ptr->surfFacetList.size();
   }
   size_double_data += num_bpd * 6;
   return CUBIT_SUCCESS;
}
BoundaryPointData * TDFacetBoundaryPoint::get_bpd ( CubitFacet *  facet) [private]

Definition at line 469 of file TDFacetBoundaryPoint.cpp.

{
  BoundaryPointData *bpd_ptr = NULL;
  int found = 0;
  int ii, jj;
  for (ii=0; ii<pointDataList.size() && !found; ii++)
  {
    bpd_ptr = pointDataList.get_and_step();
    for (jj=0; jj<bpd_ptr->surfFacetList.size() && !found; jj++)
    {
      if (bpd_ptr->surfFacetList.get_and_step() == facet)
        return bpd_ptr;
    }
  }
  
  return NULL;
}
TDFacetBoundaryPoint * TDFacetBoundaryPoint::get_facet_boundary_point ( CubitPoint *  point_ptr) [static]

Definition at line 161 of file TDFacetBoundaryPoint.cpp.

{
  ToolData *td;
  td = point_ptr->get_TD(&TDFacetBoundaryPoint::is_facet_boundary_point);
  if ( td != NULL )
  {
    TDFacetBoundaryPoint *td_gm = CAST_TO(td, TDFacetBoundaryPoint);
    return td_gm;
  }
  return (TDFacetBoundaryPoint*) NULL;
}
CubitStatus TDFacetBoundaryPoint::get_normal ( int  surf_id,
CubitVector &  normal 
)

Definition at line 213 of file TDFacetBoundaryPoint.cpp.

{
  int found = 0;
  BoundaryPointData *bpd_ptr = NULL;
  for (int ii=0; ii<pointDataList.size(); ii++)
  {
    bpd_ptr = pointDataList.get_and_step();
    if(bpd_ptr->surfID == surf_id)
      found = 1;
  }
  if (!found)  // the surf_id does not match any in the list
    return CUBIT_FAILURE;

  normal = bpd_ptr->normal;

  return CUBIT_SUCCESS;
}
CubitStatus TDFacetBoundaryPoint::get_normal ( CubitFacet *  adj_facet,
CubitVector &  normal 
)

Definition at line 242 of file TDFacetBoundaryPoint.cpp.

{
  BoundaryPointData *bpd_ptr = get_bpd( adj_facet );
  if (!bpd_ptr)
    return CUBIT_FAILURE;
  normal = bpd_ptr->normal;
  return CUBIT_SUCCESS;
}
CubitStatus TDFacetBoundaryPoint::get_normal ( CubitFacetEdge *  edge_ptr,
CubitVector &  normal 
)

Definition at line 264 of file TDFacetBoundaryPoint.cpp.

{
  DLIList<CubitFacet *>adj_facets;
  edge_ptr->facets(adj_facets);
  BoundaryPointData *bpd_ptr = NULL;
  for (int ii=0; ii<adj_facets.size() && bpd_ptr == NULL; ii++)
  {
    bpd_ptr = get_bpd( adj_facets.get_and_step() );
  }
  if (!bpd_ptr)
    return CUBIT_FAILURE;
  normal = bpd_ptr->normal;
  return CUBIT_SUCCESS;
}
CubitPoint* TDFacetBoundaryPoint::get_point ( ) [inline]

Definition at line 63 of file TDFacetBoundaryPoint.hpp.

    { return pointPtr; }
CubitStatus TDFacetBoundaryPoint::get_uv ( CubitFacet *  adj_facet,
double &  u,
double &  v 
)

Definition at line 639 of file TDFacetBoundaryPoint.cpp.

{
  BoundaryPointData *bpd_ptr = get_bpd( adj_facet );                   
  if (!bpd_ptr)
    return CUBIT_FAILURE;
  u = bpd_ptr->uVal;
  v = bpd_ptr->vVal;
  return CUBIT_SUCCESS;
}
CubitStatus TDFacetBoundaryPoint::get_uvs ( CubitFacet *  adj_facet,
double &  u,
double &  v,
double &  s 
)

Definition at line 655 of file TDFacetBoundaryPoint.cpp.

{
  BoundaryPointData *bpd_ptr = get_bpd( adj_facet );                   
  if (!bpd_ptr)
    return CUBIT_FAILURE;
  u = bpd_ptr->uVal;
  v = bpd_ptr->vVal;
  s = bpd_ptr->sizeVal;
  return CUBIT_SUCCESS;
}
void TDFacetBoundaryPoint::init_normal ( BoundaryPointData *  bpd_ptr) [private]

Definition at line 374 of file TDFacetBoundaryPoint.cpp.

{
  
  if (bpd_ptr && bpd_ptr->surfFacetList.size() > 0) {
    CubitFacet *facet;
    double angle;
    int j;
    CubitVector normal;
    CubitVector avg_normal(0.0e0, 0.0e0, 0.0e0);
    double totangle = 0.0e0;

      // weight the normal by the spanning angle at the point
    int mydebug =0;
    for (j = 0; j < bpd_ptr->surfFacetList.size(); j++)
    {
      facet = bpd_ptr->surfFacetList.get_and_step();
      angle = facet->angle( pointPtr );
      facet->weight( angle );
      totangle += angle;
      if(mydebug){
        if(angle <= 0.0){
          PRINT_INFO("Small angle.\n");
        }
      }
    }
      //First...
      // Attempt to handle this very odd case.  There is a facet with
      // zero area on the boundary.  Set normal to that of an adjacet
      // facet that doesn't have zero area.
    if(totangle == 0 && bpd_ptr->surfFacetList.size() == 1){
      PRINT_WARNING("Degenerate facet on edge of boundary.\n");
      facet = bpd_ptr->surfFacetList.get_and_step();
      
      CubitPoint* my_pt[3];
      my_pt[0] = facet->point(0);
      my_pt[1] = facet->point(1);
      my_pt[2] = facet->point(2);
      double largest_area=-1.0;
      double current_area=0.0;
      if(my_pt[0] == NULL || my_pt[1] == NULL || my_pt[2] == NULL){
        PRINT_ERROR("Problem determining normal.\n");
        return;
      }
      
      int tmp_i;
      for(tmp_i = 0; tmp_i < 3; tmp_i++){
        CubitFacet* other_facet = facet->shared_facet(my_pt[tmp_i],
                                                      my_pt[(tmp_i+1)%3]);
        if(other_facet != NULL){
          if(mydebug)
            other_facet->debug_draw(CUBIT_WHITE_INDEX);
          current_area=other_facet->area();
          if(current_area>largest_area){
            largest_area=current_area;
            normal=other_facet->normal();
          }
        }
      }
      if(largest_area < CUBIT_DBL_MIN){
        PRINT_ERROR("Could not initialize facet normal.\n");
        return;
      }
      if(mydebug){
        facet->debug_draw(CUBIT_RED_INDEX);
        PRINT_INFO("\n\nLargest area = %f\n\n",largest_area);
        GfxDebug::mouse_xforms();
      }
      bpd_ptr->normal = normal;
              
    }
      //Now...
      // Handle the normal case.
    else{
      for (j = 0; j < bpd_ptr->surfFacetList.size(); j++)
      {
        facet = bpd_ptr->surfFacetList.get_and_step();
        normal = facet->normal();
        normal.normalize();
        avg_normal += (facet->weight() / totangle) * normal;
      }
      avg_normal.normalize();
      bpd_ptr->normal = avg_normal;
    }
  }
}
void TDFacetBoundaryPoint::initialize ( CubitFacet **  facets,
int &  iidx,
int &  didx,
int *  int_data,
double *  double_data 
)

Definition at line 782 of file TDFacetBoundaryPoint.cpp.

{
  int num_bpd = int_data[iidx++];
  
  BoundaryPointData *bpd_ptr;
  int ii, jj, id;
  int numfacs = 0;
  CubitFacet *facet_ptr;
  for (ii=0; ii<num_bpd; ii++)
  {
    bpd_ptr = new BoundaryPointData;
    pointDataList.append(bpd_ptr);
    numfacs = int_data[iidx++];
    for (jj=0; jj<numfacs; jj++)
    {
      id = int_data[iidx++];
      facet_ptr = facets[id];
      bpd_ptr->surfFacetList.append(facet_ptr);
    }
    bpd_ptr->surfID = int_data[iidx++];
    
    bpd_ptr->normal.x(double_data[didx++]);
    bpd_ptr->normal.y(double_data[didx++]);
    bpd_ptr->normal.z(double_data[didx++]);
    bpd_ptr->sizeVal = double_data[didx++];
    bpd_ptr->uVal = double_data[didx++];
    bpd_ptr->vVal = double_data[didx++];
  }

}
static int TDFacetBoundaryPoint::is_facet_boundary_point ( const ToolData *  td) [inline, static]

Definition at line 58 of file TDFacetBoundaryPoint.hpp.

     {return (CAST_TO(const_cast<ToolData*>(td), TDFacetBoundaryPoint) != NULL);}
CubitStatus TDFacetBoundaryPoint::merge_normals ( CubitFacet *  facet0,
CubitFacet *  facet1 
)

Definition at line 493 of file TDFacetBoundaryPoint.cpp.

{

  BoundaryPointData *bpd0_ptr = get_bpd( facet0 );
  BoundaryPointData *bpd1_ptr = get_bpd( facet1 );
  if (!bpd0_ptr || !bpd1_ptr)
    return CUBIT_FAILURE;

  CubitVector avg_normal(0.0e0, 0.0e0, 0.0e0);
  double totangle = 0.0e0;
  double angle;
  CubitFacet *facet;
  int j;

  // weight the normal by the spanning angle at the point

  for (j = 0; j < bpd0_ptr->surfFacetList.size(); j++)
  {
    facet = bpd0_ptr->surfFacetList.get_and_step();
    angle = facet->angle( pointPtr );
    facet->weight( angle );
    totangle += angle;
  }

  for (j = 0; j < bpd1_ptr->surfFacetList.size(); j++)
  {
    facet = bpd1_ptr->surfFacetList.get_and_step();
    angle = facet->angle( pointPtr );
    facet->weight( angle );
    totangle += angle;
  }

  // computed weighted normal

  CubitVector normal;
  for (j = 0; j < bpd0_ptr->surfFacetList.size(); j++)
  {
    facet = bpd0_ptr->surfFacetList.get_and_step();
    normal = facet->normal();
    normal.normalize();
    avg_normal += (facet->weight() / totangle) * normal;
  }
  
  // orientation of facets may be opposite on opposing surfaces.
  // Check for this case and correct of necessary
  
  CubitVector norm0, norm1;
  norm0 = bpd0_ptr->normal;
  norm0.normalize();
  norm1 = bpd1_ptr->normal;
  norm1.normalize();
  double dot = norm0 % norm1;
  double sign = 1.0;
  if (dot < 0.0)
    sign = -1.0;

  for (j = 0; j < bpd1_ptr->surfFacetList.size(); j++)
  {
    facet = bpd1_ptr->surfFacetList.get_and_step();
    normal = sign * facet->normal();
    normal.normalize();
    avg_normal += (facet->weight() / totangle) * normal;
  }

  // set the new normal on both points

  avg_normal.normalize();
  bpd0_ptr->normal = avg_normal;
  CubitVector temp_vector = sign * avg_normal;
  bpd1_ptr->normal = temp_vector;

  return CUBIT_SUCCESS;
}
CubitStatus TDFacetBoundaryPoint::new_facet_boundary_point ( CubitPoint **  points,
CubitFacet **  facets,
int &  iidx,
int &  didx,
int *  int_data,
double *  double_data 
) [static]

Definition at line 758 of file TDFacetBoundaryPoint.cpp.

{
  int id = int_data[iidx++];
  CubitPoint *point_ptr = points[id];
  TDFacetBoundaryPoint::add_facet_boundary_point(point_ptr);
  TDFacetBoundaryPoint *td = (TDFacetBoundaryPoint *)
    point_ptr->get_TD( &TDFacetBoundaryPoint::is_facet_boundary_point);

  td->initialize( facets, iidx, didx, int_data, double_data );

  return CUBIT_SUCCESS;
}
CubitStatus TDFacetBoundaryPoint::reset_normals ( )

Definition at line 317 of file TDFacetBoundaryPoint.cpp.

{
  BoundaryPointData *bpd_ptr;
  for (int ii=0; ii<pointDataList.size(); ii++)
  {
    bpd_ptr = pointDataList.get_and_step();
    if(bpd_ptr)
      init_normal(bpd_ptr);
    else{
      PRINT_ERROR("Could not determine boundary point data.\n");
      return CUBIT_FAILURE;
    }
  }
  return CUBIT_SUCCESS;
}
CubitStatus TDFacetBoundaryPoint::rotate_normal ( CubitTransformMatrix &  rotmat)

Definition at line 672 of file TDFacetBoundaryPoint.cpp.

{
  BoundaryPointData * bpd_ptr;
  
  int ii;
  for (ii=0; ii<pointDataList.size(); ii++)
  {
    bpd_ptr = pointDataList.get_and_step();
    bpd_ptr->normal = rotmat * bpd_ptr->normal;
  }
  return CUBIT_SUCCESS;
}
double TDFacetBoundaryPoint::s ( CubitFacet *  adj_facet)

Definition at line 628 of file TDFacetBoundaryPoint.cpp.

{
  BoundaryPointData *bpd_ptr = get_bpd( adj_facet );                   
  assert( bpd_ptr != 0 );  // adjacent facet was not found in list
  return bpd_ptr->sizeVal;
}
CubitStatus TDFacetBoundaryPoint::set_normal ( int  surf_id,
CubitVector &  normal 
)

Definition at line 289 of file TDFacetBoundaryPoint.cpp.

{
  int found = 0;
  BoundaryPointData *bpd_ptr = NULL;
  for (int ii=0; ii<pointDataList.size(); ii++)
  {
    bpd_ptr = pointDataList.get_and_step();
    if(bpd_ptr->surfID == surf_id)
      found = 1;
  }
  if (!found)  // the surf_id does not match any in the list
    return CUBIT_FAILURE;

  bpd_ptr->normal = normal;

  return CUBIT_SUCCESS;
}
void TDFacetBoundaryPoint::set_point ( CubitPoint *  point_ptr) [inline]

Definition at line 66 of file TDFacetBoundaryPoint.hpp.

    { pointPtr = point_ptr; }
void TDFacetBoundaryPoint::set_surf_id ( CubitFacet *  facet_ptr,
int  surf_id 
)

Definition at line 343 of file TDFacetBoundaryPoint.cpp.

{
  int found = 0;
  int ii, jj;
  CubitFacet *check_facet_ptr;
  BoundaryPointData *bpd_ptr;
  for (ii=0; ii<pointDataList.size() && !found; ii++)
  {
    bpd_ptr = pointDataList.get_and_step();
    for (jj=0; jj<bpd_ptr->surfFacetList.size() && !found; jj++)
    {
      check_facet_ptr = bpd_ptr->surfFacetList.get_and_step();
      if (check_facet_ptr == facet_ptr)
      {
        found = 1;
        bpd_ptr->surfID = surf_id;
      }
    }
  }
  assert(found);  // couldn't find the facet adjacent the surface
}
CubitStatus TDFacetBoundaryPoint::set_uv ( CubitFacet *  adj_facet,
double  u,
double  v 
)

Definition at line 574 of file TDFacetBoundaryPoint.cpp.

{
  BoundaryPointData *bpd_ptr = get_bpd( adj_facet ); 
  if (!bpd_ptr)
    return CUBIT_FAILURE;
  bpd_ptr->uVal = u;
  bpd_ptr->vVal = v;
  return CUBIT_SUCCESS;
}
CubitStatus TDFacetBoundaryPoint::set_uvs ( CubitFacet *  adj_facet,
double  u,
double  v,
double  s 
)

Definition at line 589 of file TDFacetBoundaryPoint.cpp.

{
  BoundaryPointData *bpd_ptr = get_bpd( adj_facet ); 
  if (!bpd_ptr)
    return CUBIT_FAILURE;
  bpd_ptr->uVal = u;
  bpd_ptr->vVal = v;
  bpd_ptr->sizeVal = s;
  return CUBIT_SUCCESS;
}
TDFacetBoundaryPoint::SetDynamicMemoryAllocation ( memoryManager  ) [inline, pure virtual]

Definition at line 69 of file TDFacetBoundaryPoint.hpp.

    {memoryManager.set_memory_allocation_increment(increment);}
double TDFacetBoundaryPoint::u ( CubitFacet *  adj_facet)

Definition at line 605 of file TDFacetBoundaryPoint.cpp.

{
  BoundaryPointData *bpd_ptr = get_bpd( adj_facet );                   
  assert( bpd_ptr != 0 );  // adjacent facet was not found in list
  return bpd_ptr->uVal;
}
double TDFacetBoundaryPoint::v ( CubitFacet *  adj_facet)

Definition at line 617 of file TDFacetBoundaryPoint.cpp.

{
  BoundaryPointData *bpd_ptr = get_bpd( adj_facet );                   
  assert( bpd_ptr != 0 );  // adjacent facet was not found in list
  return bpd_ptr->vVal;
}

Member Data Documentation

MemoryManager TDFacetBoundaryPoint::memoryManager [static, private]

Definition at line 40 of file TDFacetBoundaryPoint.hpp.

DLIList<BoundaryPointData *> TDFacetBoundaryPoint::pointDataList [private]

Definition at line 44 of file TDFacetBoundaryPoint.hpp.

CubitPoint* TDFacetBoundaryPoint::pointPtr [private]

Definition at line 43 of file TDFacetBoundaryPoint.hpp.

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