cgma
Cholla.cpp File Reference
#include "time.h"
#include "Cholla.h"
#include "ChollaEngine.hpp"
#include "CubitPoint.hpp"
#include "CubitPointData.hpp"
#include "CubitFacetEdge.hpp"
#include "CubitFacetEdgeData.hpp"
#include "CubitFacet.hpp"
#include "CubitFacetData.hpp"
#include "CubitQuadFacet.hpp"
#include "CubitQuadFacetData.hpp"
#include "CastTo.hpp"
#include "TDFacetBoundaryPoint.hpp"
#include "FacetEvalTool.hpp"
#include "FacetDataUtil.hpp"
#include <iostream>
#include <fstream>

Go to the source code of this file.

Defines

#define END_OF_BLOCKS   "END_OF_BLOCKS"
#define MIN_EDGE_NODE_ID(n1, n2)   n1 < n2 ? n1 : n2
#define MIN_TRI_NODE_ID(n1, n2, n3)   n1 < n2 ? n1 < n3 ? n1 : n3 : n2 < n3 ? n2 : n3
#define MIN_QUAD_NODE_ID(n1, n2, n3, n4)   MIN_EDGE_NODE_ID( (MIN_EDGE_NODE_ID( n1, n2 )), (MIN_EDGE_NODE_ID( n3, n4 )) )
#define MAX_FILE_LINE   512

Functions

static void time_stamp (FILE *fp)
static CubitStatus build_facets (int numTri, int numQuad, int numEdge, int numVert, int *triEdge, int *quadEdge, int *edgeVert, double *vert, CubitPoint **point_array, CubitFacetEdge **edge_array, CubitFacet **facet_array, CubitQuadFacet **qfacet_array, DLIList< FacetEntity * > &facet_list)
static CubitStatus extractEdgeTangsFromFile (int num_file_edges, int *edge_nodes_file, double *edge_node_tangs_file, int numTri, int *edgeVert, double *edgeVertTang)
static CubitStatus extractTriNormalsFromFile (int num_file_tris, int *tri_nodes_file, double *tri_node_norms_file, int numTri, int *edgeVert, int *triEdge, double *triVertNorms)
static CubitStatus extractQuadNormalsFromFile (int num_file_quads, int *quad_nodes_file, double *quad_node_norms_file, int numQuad, int *edgeVert, int *quadEdge, double *quadVertNorms)
static void constructTriVerts (int triEdge[3], int *edgeVert, int this_tri[3])
static void constructQuadVerts (int quadEdge[3], int *edgeVert, int this_quad[4])
static void checkMemoryAllocations (int num_nodes_per_elem, int additional_num_elems, int *num_elems, int **nodes, double **node_normals)
static int classify_local_convexity_at_edge (CubitFacetEdge *edge_ptr)
void constructBezier (double angle, int numTri, int numQuad, int numEdge, int numVert, int *triEdge, int *quadEdge, int *edgeVert, double *vert, double *edgeCtrlPts, double *triCtrlPts, double *quadCtrlPts)
void constructTriNormals (double angle, int numTri, int numEdge, int numVert, int *triEdge, int *edgeVert, double *vert, double *triVertNorms, double *edgeVertTang, int *edgeTypeFlags)
void constructQuadNormals (double angle, int numQuad, int numEdge, int numVert, int *quadEdge, int *edgeVert, double *vert, double *quadVertNorms, double *edgeVertTang, int *edgeTypeFlags)
void evalBezierFace (int numFace, int numEdge, int numVert, int numVertPerFace, int *faceEdge, int *edgeVert, double *vert, double *faceCtrlPts, double *edgeCtrlPts, int numLocs, double *paramLocation, double *location, double *normal, double *deriv)
void evalBezierFaceFromNorms (int numFace, int numEdge, int numVert, int numVertPerFace, int *faceEdge, int *edgeVert, double *vert, double *vertNorms, double *edgeVertTang, int numLocs, double *paramLocation, double *location, double *normal, double *deriv)
void projToBezierFace (int numFace, int numEdge, int numVert, int numVertPerFace, int *faceEdge, int *edgeVert, double *vert, double *faceCtrlPts, double *edgeCtrlPts, int numLocs, double *xyz, int specify_tol, double converge_tol, double *xyzOnFace, double *normal, double *deriv)
void projToBezierFaceFromNorms (int numFace, int numEdge, int numVert, int numVertPerFace, int *faceEdge, int *edgeVert, double *vert, double *vertNorms, double *edgeVertTang, int numLocs, double *xyz, int specify_tol, double converge_tol, double *xyzOnFace, double *normal, double *deriv)
void dumpMesh (const char *fileName, int includeResults, double angle, int numTri, int numQuad, int numEdge, int numVert, int *triEdge, int *quadEdge, int *edgeVert, double *vert, double *edgeCtrlPts, double *triCtrlPts, double *quadCtrlPts)
void dumpResults (const char *fileName, int numEdge, int numTri, int numQuad, double *edgeCtrlPts, double *triCtrlPts, double *quadCtrlPts)
void importMesh (const char *fileName, int *includeResults, double *angle, int *numTri, int *numQuad, int *numEdge, int *numVert, int **triEdge, int **quadEdge, int **edgeVert, double **vert, double **edgeCtrlPts, double **triCtrlPts, double **quadCtrlPts)
void importResults (const char *fileName, int *numEdge, int *numTri, int *numQuad, double **edgeCtrlPts, double **triCtrlPts, double **quadCtrlPts)
void evalBezierEdge (int numEdge, int numVert, int *edgeVert, double *vert, double *edgeCtrlPts, int numLocs, double *paramLocation, double *location, double *tangent)
void evalBezierEdgeFromTans (int numEdge, int numVert, int *edgeVert, double *vert, double *edgeVertTang, int numLocs, double *paramLocation, double *location, double *tangent)
void projToBezierEdgeFromTans (int numEdge, int numVert, int *edgeVert, double *vert, double *edgeVertTang, int numLocs, double *xyz, double *xyzOnEdge, double *tangent)
void projToBezierEdge (int numEdge, int numVert, int *edgeVert, double *vert, double *edgeCtrlPts, int numLocs, double *xyz, double *xyzOnEdge, double *tangent, double *t_value)
CubitStatus constructQuadNormalsFromFile (const char *filename, int numQuad, int numEdge, int *quadEdge, int *edgeVert, double *quadVertNorms, double *edgeVertTang)
CubitStatus constructTriNormalsFromFile (const char *filename, int numTri, int numEdge, int *triEdge, int *edgeVert, double *triVertNorms, double *edgeVertTang)
static void constructQuadVerts (int QuadEdge[4], int *edgeVert, int QuadVert[4])
CubitStatus readMBGNormalFile (const char *filename, int *num_tris, int *num_quads, int *num_edges, int **edge_nodes, double **edge_node_tangents, int **tri_nodes, double **tri_node_normals, int **quad_nodes, double **quad_node_normals)

Define Documentation

#define END_OF_BLOCKS   "END_OF_BLOCKS"

Definition at line 28 of file Cholla.cpp.

#define MAX_FILE_LINE   512
#define MIN_EDGE_NODE_ID (   n1,
  n2 
)    n1 < n2 ? n1 : n2
#define MIN_QUAD_NODE_ID (   n1,
  n2,
  n3,
  n4 
)    MIN_EDGE_NODE_ID( (MIN_EDGE_NODE_ID( n1, n2 )), (MIN_EDGE_NODE_ID( n3, n4 )) )
#define MIN_TRI_NODE_ID (   n1,
  n2,
  n3 
)    n1 < n2 ? n1 < n3 ? n1 : n3 : n2 < n3 ? n2 : n3

Function Documentation

static CubitStatus build_facets ( int  numTri,
int  numQuad,
int  numEdge,
int  numVert,
int *  triEdge,
int *  quadEdge,
int *  edgeVert,
double *  vert,
CubitPoint **  point_array,
CubitFacetEdge **  edge_array,
CubitFacet **  facet_array,
CubitQuadFacet **  qfacet_array,
DLIList< FacetEntity * > &  facet_list 
) [static]

Definition at line 531 of file Cholla.cpp.

{
  // create the points

  double x, y, z;
  int ii;
  
  for (ii=0; ii<numVert; ii++)
  {
    x = vert[ii*3];
    y = vert[ii*3 + 1];
    z = vert[ii*3 + 2];
    point_array[ii] = (CubitPoint *) new CubitPointData( x, y, z );
    point_array[ii]->set_id(ii);
  }

  // create the edges

  int ip, jp;
  for (ii=0; ii<numEdge; ii++)
  {
    ip = edgeVert[ii*2];
    jp = edgeVert[ii*2 + 1];
    assert(ip < numVert && jp < numVert && ip >= 0 && jp >= 0);
    edge_array[ii] = (CubitFacetEdge *) new CubitFacetEdgeData( point_array[ip],
                                                                point_array[jp] );
    edge_array[ii]->set_id(ii);
  }

  // create the tri facets

  int begin_face;
  int jj, iedge;
  CubitFacetEdge *edges[4];
  CubitFacet *facet_ptr = NULL;

  for (ii=0; ii<numTri; ii++)
  {
    begin_face = 3 * ii;
    for(jj=0; jj<3; jj++)
    {
      iedge = triEdge[begin_face+jj];
      edges[jj] = edge_array[iedge];
    }
    facet_ptr = (CubitFacet *)
      new CubitFacetData(edges[0], edges[1], edges[2]);
    facet_list.append(facet_ptr);
    facet_array[ii] = facet_ptr;
  }

  // create the quad facets

  CubitQuadFacet *qfacet_ptr = NULL;
  for (ii=0; ii<numQuad; ii++)
  {
    begin_face = 4 * ii;
    for(jj=0; jj<4; jj++)
    {
      iedge = quadEdge[begin_face+jj];
      edges[jj] = edge_array[iedge];
    }
    qfacet_ptr = (CubitQuadFacet *)
      new CubitQuadFacetData(edges[0], edges[1], edges[2], edges[3]);
    facet_list.append(qfacet_ptr->get_tri_facet(0));
    facet_list.append(qfacet_ptr->get_tri_facet(1));
    qfacet_array[ii] = qfacet_ptr;
  }

  int mydebug = 0;
  if (mydebug)
  {
    DLIList<CubitFacet*> myfacet_list;
    CAST_LIST(facet_list, myfacet_list, CubitFacet);
    FacetDataUtil::write_facets("C:\\CUBIT\\cholla_apps\\examples\\sierra\\test.facets",myfacet_list);
  }

  return CUBIT_SUCCESS;

}
static void checkMemoryAllocations ( int  num_nodes_per_elem,
int  additional_num_elems,
int *  num_elems,
int **  nodes,
double **  node_normals 
) [static]

Definition at line 3285 of file Cholla.cpp.

{
    int old_num = *num_elems;

    *num_elems += additional_num_elems;
    if ( node_normals && *node_normals )
    {
        double *new_mem = new double [ *num_elems * 3 * num_nodes_per_elem ];
        memcpy( new_mem, *node_normals,  old_num * 3 * num_nodes_per_elem * sizeof( double ) );
        delete *node_normals;
        *node_normals = new_mem;
    }
    else if ( node_normals )
    {
        *node_normals = new double [ *num_elems * num_nodes_per_elem * 3 ];
    }

    if ( nodes && *nodes )
    {
        int *new_mem = new int [ *num_elems * num_nodes_per_elem ];
        memcpy( new_mem, *nodes,  old_num * num_nodes_per_elem * sizeof( int ) );
        delete *nodes;
        *nodes = new_mem;
    }
    else if ( nodes )
    {
        *nodes = new int [ *num_elems * num_nodes_per_elem ];
    }
}
static int classify_local_convexity_at_edge ( CubitFacetEdge edge_ptr) [static]

Definition at line 3330 of file Cholla.cpp.

{
    //easy check... if not a feature return 0
  if(!edge_ptr->is_feature())
    return 0;
  
    //else we know that we are at feature... determine the type
  CubitFacet *adj_facet_1 = NULL, *adj_facet_2 = NULL;
  CubitPoint *point_1 = NULL, *point_2 = NULL, *point_3 = NULL;
  CubitVector v2, v3;
  CubitVector v0 = edge_ptr->point(0)->coordinates();
  CubitVector v1 = edge_ptr->point(1)->coordinates();
  DLIList<CubitFacet*> adj_facets;
  edge_ptr->facets(adj_facets);
  
    //if non-manifold edge, mark as two
  if(adj_facets.size() > 2){
    return 2;
  }
    //if boundary on 2-d (shouldn't happen) mark as 3
    //anything above 2 is essentially an error code...
  else if(adj_facets.size() < 2){
    return 3;
  }
    //otherwise, determine whether it is 1 or -1
    //this else should be a separate function:  classify_edge_convexity()
  adj_facet_1 = adj_facets.get_and_step();
  int edge_index = adj_facet_1->edge_index(edge_ptr);
    //order such that *_1 is the facet that uses
    // this edge as the forward edge...
  if(adj_facet_1->edge_use(edge_index) == 1)
    adj_facet_2 = adj_facets.get();
  else{
    adj_facet_1 = adj_facets.get();
    adj_facets.reset();
    adj_facet_2 = adj_facets.get();
  }
    // order the points so that the Jacobian of the matrix
    // will tell use whether we are convex or not at this edge.
  adj_facet_1->points(point_1, point_2, point_3);
  if(point_1 == edge_ptr->point(0)){
    v2 = point_3->coordinates();
  }
  else if(point_1 == edge_ptr->point(1)){
    v2 = point_2->coordinates();
  }
  else{
    v2 = point_1->coordinates();
  }
  adj_facet_2->points(point_1, point_2, point_3);
  if(point_1 == edge_ptr->point(0)){
    v3 = point_2->coordinates();
  }
  else if(point_1 == edge_ptr->point(1)){
    v3 = point_3->coordinates();
  }
  else{
    v3 = point_1->coordinates();
  }

  v1-=v0;
  v2-=v0;
  v3-=v0;
    //if Jacobian is negative, we are convex here.
  if( ( v1 % (v2* v3) ) < 0.0){
    return 1;
  }
  else{
    return -1;
  }

}
void constructBezier ( double  angle,
int  numTri,
int  numQuad,
int  numEdge,
int  numVert,
int *  triEdge,
int *  quadEdge,
int *  edgeVert,
double *  vert,
double *  edgeCtrlPts,
double *  triCtrlPts,
double *  quadCtrlPts 
)

Return control points for a quartic Bezier for each face, using a given feature angle tolerance to distinguish C0 and C1 edges. Separate arrays of tris and quad faces should be supplied

Parameters:
angle- (IN) feature angle tolerance (degrees)
numTri- (IN) number of quad faces
numQuad- (IN) number of triangle faces
numEdge- (IN) number of edges
numVert- (IN) number of vertices
triEdge- (IN) array of face to edge numbering, length 3 * numTri
quadEdge- (IN) array of face to edge numbering, length 4 * numQuad
edgeVert- (IN) array of edge to vertex numbering, length 2*numEdge
vert- (IN) array of vertex coordinates, length 3*numVert
edgeCtrlPts- (OUT) array of control points computed at the edges length 3*(3*numEdge)
triCtrlPts- (OUT) array of control points computed at the triangles length 3*(6*numTri)
quadCtrlPts- (OUT) array of control points computed at the quads length 3*(15*numQuad)

Definition at line 84 of file Cholla.cpp.

{

  // create arrays of facet entities from the arrays

  CubitPoint **point_array = new CubitPoint * [numVert];
  CubitFacetEdge **edge_array = new CubitFacetEdge * [numEdge];
  CubitFacet **facet_array = NULL;
  if (numTri > 0)
    facet_array = new CubitFacet * [numTri];
  CubitQuadFacet **qfacet_array = NULL;
  if (numQuad > 0)
    qfacet_array = new CubitQuadFacet * [numQuad];
  DLIList<FacetEntity *> facet_list;
  CubitStatus stat = CUBIT_SUCCESS;
  stat = build_facets(numTri, numQuad, numEdge, numVert, triEdge, quadEdge, 
                      edgeVert, vert, point_array, edge_array, facet_array,
                      qfacet_array, facet_list);
  if (CUBIT_SUCCESS != stat) {
    PRINT_ERROR("Failed to build facets.\n");
    return;
  }

  // create lists of points and edges

  int ii;
  DLIList<CubitPoint *> point_list;
  for (ii=0; ii<numVert; ii++)  
    point_list.append(point_array[ii]);  

  DLIList<CubitFacetEdge *> edge_list;
  for (ii=0; ii<numEdge; ii++)
    edge_list.append(edge_array[ii]);

  // prepare the ChollaEngine

  DLIList<FacetEntity *> fpoint_list, fedge_list;
  CAST_LIST_TO_PARENT( point_list, fpoint_list );
  CAST_LIST_TO_PARENT( edge_list,  fedge_list );
  ChollaEngine *ceng = new ChollaEngine( facet_list, fedge_list, fpoint_list );

  CubitBoolean use_feature_angle;
  if (angle < 0.00001 || angle > 179.9999)
    use_feature_angle = CUBIT_FALSE;
  else
    use_feature_angle = CUBIT_TRUE;
  int interp_order = 4;  // assume we are creating beziers
  CubitBoolean smooth_non_manifold = CUBIT_TRUE;
  CubitBoolean split_surfaces = CUBIT_FALSE;

  // create the geometry
    
  //CubitStatus rv = 
  ceng->create_geometry(use_feature_angle,angle,
                        interp_order,smooth_non_manifold,
                        split_surfaces);

  // get the control points on edges

  int jj;
  int index;
  CubitVector *control_points;
  CubitFacetEdge *edge_ptr;
  for (ii=0; ii<numEdge; ii++)
  {
    edge_ptr = edge_array[ii];
    control_points = edge_ptr->control_points();
    assert(control_points != NULL);
    for (jj=0; jj<NUM_EDGE_CPTS; jj++)
    {
      index = 3 * (ii * NUM_EDGE_CPTS + jj); 
      edgeCtrlPts[index] = control_points[jj].x();
      edgeCtrlPts[index+1] = control_points[jj].y();
      edgeCtrlPts[index+2] = control_points[jj].z();
    }
  }

  // get the control points on triangles

  CubitFacet *facet_ptr;
  for (ii=0; ii<numTri; ii++)
  {
    facet_ptr = facet_array[ii];
    control_points = facet_ptr->control_points();
    assert(control_points != NULL);
    for (jj=0; jj<NUM_TRI_CPTS; jj++)
    {
      index = 3 * (ii * NUM_TRI_CPTS + jj); 
      triCtrlPts[index] = control_points[jj].x();
      triCtrlPts[index+1] = control_points[jj].y();
      triCtrlPts[index+2] = control_points[jj].z();
    }
  }

    // get the control points on quads

  //CubitVector qctrl_points[NUM_QUAD_CPTS];
  CubitQuadFacet *qfacet_ptr;
  for (ii=0; ii<numQuad; ii++)
  {
    qfacet_ptr = qfacet_array[ii];
    index = 3 * (ii * NUM_QUAD_CPTS);
    qfacet_ptr->get_control_points( &(quadCtrlPts[index]) );
  }

  // delete the ChollaEngine

  ceng->delete_eval_tools();
  ceng->delete_me();
  delete ceng;

  // delete temp arrays (facets are deleted with the eval tool)

  for (ii=0; ii<numQuad; ii++)
  {
    qfacet_array[ii]->remove_tri_facets();
    delete qfacet_array[ii];
  }
  delete [] point_array;
  delete [] edge_array;
  if (facet_array)
    delete [] facet_array; 
  if (qfacet_array)
    delete [] qfacet_array; 

}
void constructQuadNormals ( double  angle,
int  numQuad,
int  numEdge,
int  numVert,
int *  quadEdge,
int *  edgeVert,
double *  vert,
double *  quadVertNorms,
double *  edgeVertTang,
int *  edgeTypeFlags 
)

Return normal and tangents for on a list of quad faces a given feature angle tolerance to distinguish C0 and C1 edges. Separate arrays of tris and quad faces should be supplied

Parameters:
angle- (IN) feature angle tolerance (degrees)
numQuad- (IN) number of quad faces
numEdge- (IN) number of edges
numVert- (IN) number of vertices
quadEdge- (IN) array of face to edge numbering, length 4 * numQuad
edgeVert- (IN) array of edge to vertex numbering, length 2*numEdge
vert- (IN) array of vertex coordinates, length 3*numVert
quadVertNorms- (OUT) array of normals at the quad vertices length 3*(4*numQuad)
edgeVertTang- (OUT) array of tangents at the edge vertices length 3*(2*numEdge)
edgeTypeFlags- (OUT) array of flags labeling the type of each edge, length numEdge
2 = non-manifold edge
1 = concave feature edge
0 = non-feature edge
-1= convex feature edge

Definition at line 366 of file Cholla.cpp.

{

  // create arrays of facet entities from the arrays

  int *triEdge = NULL;
  CubitPoint **point_array = new CubitPoint * [numVert];
  CubitFacetEdge **edge_array = new CubitFacetEdge * [numEdge];
  CubitFacet **facet_array = NULL;
  CubitQuadFacet **qfacet_array = NULL; 
  int numTri = 0;
  if (numQuad > 0)
    qfacet_array = new CubitQuadFacet * [numQuad];
  DLIList<FacetEntity *> facet_list;
  CubitStatus stat = CUBIT_SUCCESS;
  stat = build_facets(numTri, numQuad, numEdge, numVert, triEdge, quadEdge, 
                      edgeVert, vert, point_array, edge_array, facet_array,
                      qfacet_array, facet_list);
  if (CUBIT_SUCCESS != stat) {
    PRINT_ERROR("Failed to build facets.\n");
    return;
  }
  // create lists of points and edges

  int ii;
  
  DLIList<CubitPoint *> point_list;
  for (ii=0; ii<numVert; ii++)  
    point_list.append(point_array[ii]);  

  DLIList<CubitFacetEdge *> edge_list;
  for (ii=0; ii<numEdge; ii++)
    edge_list.append(edge_array[ii]);

  // prepare the ChollaEngine

  DLIList<FacetEntity *> fpoint_list, fedge_list;
  CAST_LIST_TO_PARENT( point_list, fpoint_list );
  CAST_LIST_TO_PARENT( edge_list,  fedge_list );
  ChollaEngine *ceng = new ChollaEngine( facet_list, fedge_list, fpoint_list );

  CubitBoolean use_feature_angle;
  if (angle < 0.00001 || angle > 179.9999)
    use_feature_angle = CUBIT_FALSE;
  else
    use_feature_angle = CUBIT_TRUE;
  int interp_order = 4;  // assume we are creating beziers
  CubitBoolean smooth_non_manifold = CUBIT_TRUE;
  CubitBoolean split_surfaces = CUBIT_FALSE;

  // create the geometry
 
  ceng->create_geometry(use_feature_angle,angle,
                        interp_order,smooth_non_manifold,
                        split_surfaces);

  // get the control points on edges and infer the tangents

  int mydebug = 0;
  FILE *fp = NULL;
  if (mydebug)
  {
    fp = fopen("edges.txt", "w");
  }
  int index = 0;
  CubitVector *control_points;
  CubitFacetEdge *edge_ptr;
  CubitVector v0, v1, t0, t1;
  for (ii=0; ii<numEdge; ii++)
  {
    edge_ptr = edge_array[ii];
    v0 = edge_ptr->point(0)->coordinates();
    v1 = edge_ptr->point(1)->coordinates();
    control_points = edge_ptr->control_points();
    assert(control_points != NULL);
    if (mydebug)
    {
      int kk;
      for(kk=0; kk<3; kk++);
      fprintf(fp, "(%d) %.6f %.6f %.6f\n", edge_ptr->id(), v0.x(), v0.y(), v0.z());
      fprintf(fp, "    %.6f %.6f %.6f\n", control_points[0].x(), control_points[0].y(), control_points[0].z());
      fprintf(fp, "    %.6f %.6f %.6f\n", control_points[1].x(), control_points[1].y(), control_points[1].z());
      fprintf(fp, "    %.6f %.6f %.6f\n", control_points[2].x(), control_points[2].y(), control_points[2].z());
      fprintf(fp, "    %.6f %.6f %.6f\n", v1.x(), v1.y(), v1.z());
    }
    index = 6 * ii; 
    t0 = control_points[0] - v0;
    t1 = v1 - control_points[2];
    if(edge_ptr->is_flipped()){
      t0 *= (-1.0);
      t1 *= (-1.0);
    }
    t0.normalize();
    t1.normalize();
    edgeVertTang[index  ] = t0.x();
    edgeVertTang[index+1] = t0.y();
    edgeVertTang[index+2] = t0.z();
    edgeVertTang[index+3] = t1.x();
    edgeVertTang[index+4] = t1.y();
    edgeVertTang[index+5] = t1.z();
    edgeTypeFlags[ii]=classify_local_convexity_at_edge(edge_ptr);
  }
  if (mydebug)
  {
    fclose(fp);
  }

  // get the normal on quad

  CubitVector n0, n1, n2, n3;
  CubitQuadFacet *qfacet_ptr;
  for (ii=0; ii<numQuad; ii++)
  {
    qfacet_ptr = qfacet_array[ii];
    index = 12 * ii;
    n0 = qfacet_ptr->point(0)->normal(qfacet_ptr);
    n1 = qfacet_ptr->point(1)->normal(qfacet_ptr);
    n2 = qfacet_ptr->point(2)->normal(qfacet_ptr);
    n3 = qfacet_ptr->point(3)->normal(qfacet_ptr);
    quadVertNorms[index     ] = n0.x();
    quadVertNorms[index + 1 ] = n0.y();
    quadVertNorms[index + 2 ] = n0.z();
    quadVertNorms[index + 3 ] = n1.x();
    quadVertNorms[index + 4 ] = n1.y();
    quadVertNorms[index + 5 ] = n1.z();
    quadVertNorms[index + 6 ] = n2.x();
    quadVertNorms[index + 7 ] = n2.y();
    quadVertNorms[index + 8 ] = n2.z();
    quadVertNorms[index + 9 ] = n3.x();
    quadVertNorms[index + 10] = n3.y();
    quadVertNorms[index + 11] = n3.z();
  }
  
  // delete the ChollaEngine

  ceng->delete_eval_tools();
  ceng->delete_me();
  delete ceng;

  // delete temp arrays

  for (ii=0; ii<numQuad; ii++)
  {
    qfacet_array[ii]->remove_tri_facets();
    delete qfacet_array[ii];
  }
  delete [] point_array;
  delete [] edge_array;
  if (facet_array)
    delete [] facet_array; 
  if (qfacet_array)
    delete [] qfacet_array; 
}
CubitStatus constructQuadNormalsFromFile ( const char *  filename,
int  numQuad,
int  numEdge,
int *  quadEdge,
int *  edgeVert,
double *  quadVertNorms,
double *  edgeVertTang 
)

Return normal and tangents for on a list of quad faces a given a file containing the geometric normals and tangents. Separate arrays of tris and quad faces should be supplied

Parameters:
filename- (IN) full path and name of the text file containing the geometric surface normals and tangents. This file is output from Cubit when exporting an exodus file.
numQuad- (IN) number of quad faces
numEdge- (IN) number of edges
quadEdge- (IN) array of face to edge numbering, length 4 * numQuad
edgeVert- (IN) array of edge to vertex numbering, length 2*numEdge
quadVertNorms- (OUT) array of normals at the quad vertices length 3*(4*numQuad)
edgeVertTang- (OUT) array of tangents at the edge vertices length 3*(2*numEdge)

Definition at line 2512 of file Cholla.cpp.

{
    CubitStatus status = CUBIT_SUCCESS;
    int num_file_quads = 0,
        num_file_edges = 0,
        *edge_nodes_file = NULL,
        *quad_nodes_file = NULL;
    double *edge_node_tangs_file = NULL,
           *quad_node_norms_file = NULL;

    status = readMBGNormalFile( filename,
                                NULL,
                                &num_file_quads,
                                &num_file_edges,
                                &edge_nodes_file,
                                &edge_node_tangs_file,
                                NULL,
                                NULL,
                                &quad_nodes_file,
                                &quad_node_norms_file );

    if ( status == CUBIT_SUCCESS && numEdge > 0 )
    {
        status = extractEdgeTangsFromFile( num_file_edges,
                                           edge_nodes_file,
                                           edge_node_tangs_file,
                                           numEdge,
                                           edgeVert,
                                           edgeVertTang );
    }
    if ( status == CUBIT_SUCCESS && numQuad > 0 )
    {
        status = extractQuadNormalsFromFile( num_file_quads,
                                             quad_nodes_file,
                                             quad_node_norms_file,
                                             numQuad,
                                             edgeVert,
                                             quadEdge,
                                             quadVertNorms );
    }

    delete [] edge_nodes_file;
    delete [] quad_nodes_file;
    delete [] edge_node_tangs_file;
    delete [] quad_node_norms_file;
    return status;
}
static void constructQuadVerts ( int  quadEdge[3],
int *  edgeVert,
int  this_quad[4] 
) [static]
static void constructQuadVerts ( int  QuadEdge[4],
int *  edgeVert,
int  QuadVert[4] 
) [static]

Definition at line 3022 of file Cholla.cpp.

{
    int *verts_edge1 = &(edgeVert[QuadEdge[0]*2]);
    int *verts_edge2 = &(edgeVert[QuadEdge[1]*2]);
    int *verts_edge3 = &(edgeVert[QuadEdge[2]*2]);
    int *verts_edge4 = &(edgeVert[QuadEdge[3]*2]);

    if ( verts_edge1[0] != verts_edge2[0] &&
         verts_edge1[0] != verts_edge2[1] )
    {
        QuadVert[0] = verts_edge1[0];
        QuadVert[1] = verts_edge1[1];
    }
    else
    {
        QuadVert[0] = verts_edge1[1];
        QuadVert[1] = verts_edge1[0];
    }

    if ( verts_edge3[0] != verts_edge4[0] &&
         verts_edge3[0] != verts_edge4[1] )
    {
        QuadVert[2] = verts_edge3[0];
        QuadVert[3] = verts_edge3[1];
    }
    else
    {
        QuadVert[2] = verts_edge3[1];
        QuadVert[3] = verts_edge3[0];
    }
}
void constructTriNormals ( double  angle,
int  numTri,
int  numEdge,
int  numVert,
int *  triEdge,
int *  edgeVert,
double *  vert,
double *  triVertNorms,
double *  edgeVertTang,
int *  edgeTypeFlags 
)

Return normal and tangents for on a list of triangles a given feature angle tolerance to distinguish C0 and C1 edges. Separate arrays of tris and quad faces should be supplied

Parameters:
angle- (IN) feature angle tolerance (degrees)
numTri- (IN) number of tri faces
numEdge- (IN) number of edges
numVert- (IN) number of vertices
triEdge- (IN) array of face to edge numbering, length 3 * numTri
edgeVert- (IN) array of edge to vertex numbering, length 2*numEdge
vert- (IN) array of vertex coordinates, length 3*numVert
triVertNorms- (OUT) array of normals at the triangle vertices length 3*(3*numTri)
edgeVertTang- (OUT) array of tangents at the edge vertices length 3*(2*numEdge)
edgeTypeFlags- (OUT) array of flags labeling the type of each edge, length numEdge
2 = non-manifold edge
1 = concave feature edge
0 = non-feature edge
-1= convex feature edge

Definition at line 222 of file Cholla.cpp.

{

  // create arrays of facet entities from the arrays

  int* quadEdge = NULL;
  CubitPoint **point_array = new CubitPoint * [numVert];
  CubitFacetEdge **edge_array = new CubitFacetEdge * [numEdge];
  CubitFacet **facet_array = NULL;
  if (numTri > 0)
    facet_array = new CubitFacet * [numTri];
  int numQuad = 0;
  CubitQuadFacet **qfacet_array = NULL;
  DLIList<FacetEntity *> facet_list;
  CubitStatus stat = CUBIT_SUCCESS;
  stat = build_facets(numTri, numQuad, numEdge, numVert, triEdge, quadEdge, 
                      edgeVert, vert, point_array, edge_array, facet_array,
                      qfacet_array, facet_list);
  if (CUBIT_SUCCESS != stat) {
    PRINT_ERROR("Failed to build facets.\n");
    return;
  }

  // create lists of points and edges

  int ii;
  DLIList<CubitPoint *> point_list;
  for (ii=0; ii<numVert; ii++)  
    point_list.append(point_array[ii]);  

  DLIList<CubitFacetEdge *> edge_list;
  for (ii=0; ii<numEdge; ii++){
    edge_list.append(edge_array[ii]);
  }
  

  // prepare the ChollaEngine

  DLIList<FacetEntity *> fpoint_list, fedge_list;
  CAST_LIST_TO_PARENT( point_list, fpoint_list );
  CAST_LIST_TO_PARENT( edge_list,  fedge_list );
  ChollaEngine *ceng = new ChollaEngine( facet_list, fedge_list, fpoint_list );

  CubitBoolean use_feature_angle;
  if (angle < 0.00001 || angle > 179.9999)
    use_feature_angle = CUBIT_FALSE;
  else
    use_feature_angle = CUBIT_TRUE;
  int interp_order = 4;  // assume we are creating beziers
  CubitBoolean smooth_non_manifold = CUBIT_TRUE;
  CubitBoolean split_surfaces = CUBIT_FALSE;

  // create the geometry
    
  //CubitStatus rv = 
  ceng->create_geometry(use_feature_angle,angle,
                        interp_order,smooth_non_manifold,
                        split_surfaces);

  // get the control points on edges and infer the tangents

  int index = 0;
  CubitVector *control_points;
  CubitFacetEdge *edge_ptr;
  CubitVector v0, v1, t0, t1;
  for (ii=0; ii<numEdge; ii++)
  {
    edge_ptr = edge_array[ii];
    v0 = edge_ptr->point(0)->coordinates();
    v1 = edge_ptr->point(1)->coordinates();
    control_points = edge_ptr->control_points();
    assert(control_points != NULL);
    index = 6 * ii;
    t0 = control_points[0] - v0;
    t1 = v1 - control_points[2];
    if(edge_ptr->is_flipped()){
      t0 *= (-1.0);
      t1 *= (-1.0);
    }
    t0.normalize();
    t1.normalize();
    edgeVertTang[index  ] = t0.x();
    edgeVertTang[index+1] = t0.y();
    edgeVertTang[index+2] = t0.z();
    edgeVertTang[index+3] = t1.x();
    edgeVertTang[index+4] = t1.y();
    edgeVertTang[index+5] = t1.z();
    edgeTypeFlags[ii]=classify_local_convexity_at_edge(edge_ptr);
  }

  // get the normal on triangles

  CubitVector n0, n1, n2;
  CubitFacet *facet_ptr;
  for (ii=0; ii<numTri; ii++)
  {
    facet_ptr = facet_array[ii];
    index = 9 * ii;
    n0 = facet_ptr->point(0)->normal(facet_ptr);
    n1 = facet_ptr->point(1)->normal(facet_ptr);
    n2 = facet_ptr->point(2)->normal(facet_ptr);
    triVertNorms[index    ] = n0.x();
    triVertNorms[index + 1] = n0.y();
    triVertNorms[index + 2] = n0.z();
    triVertNorms[index + 3] = n1.x();
    triVertNorms[index + 4] = n1.y();
    triVertNorms[index + 5] = n1.z();
    triVertNorms[index + 6] = n2.x();
    triVertNorms[index + 7] = n2.y();
    triVertNorms[index + 8] = n2.z();
  }

  // delete the ChollaEngine

  ceng->delete_eval_tools();
  ceng->delete_me();
  delete ceng;

  // delete temp arrays (facets are deleted with the eval tool)

  for (ii=0; ii<numQuad; ii++)
  {
    qfacet_array[ii]->remove_tri_facets();
    delete qfacet_array[ii];
  }
  delete [] point_array;
  delete [] edge_array;
  if (facet_array)
    delete [] facet_array; 
  if (qfacet_array)
    delete [] qfacet_array; 
}
CubitStatus constructTriNormalsFromFile ( const char *  filename,
int  numTri,
int  numEdge,
int *  triEdge,
int *  edgeVert,
double *  triVertNorms,
double *  edgeVertTang 
)

Return normal and tangents for on a list of triangles a given a file containing the geometric normals and tangents. Separate arrays of tris and quad faces should be supplied

Parameters:
filename- (IN) full path and name of the text file containing the geometric surface normals and tangents. This file is output from Cubit when exporting an exodus file.
numTri- (IN) number of tri faces
triVert- (IN) array of face to vertex numbering, length 3 * numTri
triVertNorms- (OUT) array of normals at the triangle vertices length 3*(3*numTri)
edgeVertTang- (OUT) array of tangents at the edge vertices length 3*(2*numEdge)

Definition at line 2578 of file Cholla.cpp.

{
    CubitStatus status = CUBIT_SUCCESS;
    int num_file_tris = 0,
        num_file_edges = 0,
        *edge_nodes_file = NULL,
        *tri_nodes_file = NULL;
    double *edge_node_tangs_file = NULL,
           *tri_node_norms_file = NULL;

    status = readMBGNormalFile( filename,
                                &num_file_tris,
                                NULL,
                                &num_file_edges,
                                &edge_nodes_file,
                                &edge_node_tangs_file,
                                &tri_nodes_file,
                                &tri_node_norms_file,
                                NULL,
                                NULL );

    if ( status == CUBIT_SUCCESS && numEdge > 0 )
    {
        status = extractEdgeTangsFromFile( num_file_edges,
                                           edge_nodes_file,
                                           edge_node_tangs_file,
                                           numEdge,
                                           edgeVert,
                                           edgeVertTang );
    }
    if ( status == CUBIT_SUCCESS && numTri > 0 )
    {
        status = extractTriNormalsFromFile( num_file_tris,
                                            tri_nodes_file,
                                            tri_node_norms_file,
                                            numTri,
                                            edgeVert,
                                            triEdge,
                                            triVertNorms );
    }

    delete [] edge_nodes_file;
    delete [] tri_nodes_file;
    delete [] edge_node_tangs_file;
    delete [] tri_node_norms_file;
    return status;
}
static void constructTriVerts ( int  triEdge[3],
int *  edgeVert,
int  this_tri[3] 
) [static]

Definition at line 2981 of file Cholla.cpp.

{
    int *verts_edge1 = &(edgeVert[triEdge[0]*2]);
    int *verts_edge2 = &(edgeVert[triEdge[1]*2]);
    int *verts_edge3 = &(edgeVert[triEdge[2]*2]);

    if ( verts_edge1[0] != verts_edge2[0] &&
         verts_edge1[0] != verts_edge2[1] )
    {
        triVert[0] = verts_edge1[0];
        triVert[1] = verts_edge1[1];
    }
    else
    {
        triVert[0] = verts_edge1[1];
        triVert[1] = verts_edge1[0];
    }
    if ( verts_edge3[0] != verts_edge2[0] &&
         verts_edge3[0] != verts_edge2[1] )
    {
        triVert[2] = verts_edge3[1];
    }
    else
    {
        triVert[2] = verts_edge3[0];
    }
}
void dumpMesh ( const char *  fileName,
int  includeResults,
double  angle,
int  numTri,
int  numQuad,
int  numEdge,
int  numVert,
int *  triEdge,
int *  quadEdge,
int *  edgeVert,
double *  vert,
double *  edgeCtrlPts,
double *  triCtrlPts,
double *  quadCtrlPts 
)

Functions for debugging

Definition at line 1412 of file Cholla.cpp.

{
  FILE *fp = fopen(fileName, "w");
  assert(fp != NULL); // couldn't open file for writing
  
  // write the header info

  fprintf(fp, "Cholla version 1.0\n");
  time_stamp( fp );
  fprintf(fp, "%d %d %d %d %d\n", numTri, numQuad, numEdge, numVert, includeResults);
  fprintf(fp, "%f\n", angle);
  
  // faceEdgeBegin

  int ii;

  // faceEdge

  fprintf(fp, "triEdge\n");
  for(ii=0; ii<numTri; ii++)
  {
    fprintf(fp, "%d %d %d\n", triEdge[ii*3], triEdge[ii*3+1], triEdge[ii*3+2]);
  }

  fprintf(fp, "quadEdge\n");
  for(ii=0; ii<numQuad; ii++)
  {
    fprintf(fp, "%d %d %d %d\n", quadEdge[ii*4], quadEdge[ii*4+1],
                                 quadEdge[ii*4+2], quadEdge[ii*4+3]);
  }

  // edgeVert

  fprintf(fp, "edgeVert\n");
  for (ii=0; ii<numEdge; ii++)
  {
    fprintf(fp, "%d %d\n", edgeVert[ii*2], edgeVert[ii*2+1]);
  }

  // vert

  fprintf(fp, "vert\n");
  for (ii=0; ii<numVert; ii++)
  {
    fprintf(fp, "%f %f %f\n", vert[ii*3], vert[ii*3+1], vert[ii*3+2]);
  }

  if (includeResults != 0)
  {
     // edge control points

    int jj;
    fprintf(fp, "edgeCtrlPts\n");
    for(ii=0; ii<numEdge; ii++)
    {
      for (jj=0; jj<NUM_EDGE_CPTS; jj++)
      {
        fprintf(fp, "%f %f %f\n", edgeCtrlPts[ii*jj*3], 
                                     edgeCtrlPts[ii*jj*3+1], 
                                     edgeCtrlPts[ii*jj*3+2]);
      }
    }

    // triangle control points

    fprintf(fp, "triCtrlPts\n");
    for(ii=0; ii<numTri; ii++)
    {
      for (jj=0; jj<NUM_TRI_CPTS; jj++)
      {
        fprintf(fp, "%f %f %f\n", triCtrlPts[ii*jj*3], 
                                     triCtrlPts[ii*jj*3+1], 
                                     triCtrlPts[ii*jj*3+2]);
      }
    }

    // quad control points

    fprintf(fp, "quadCtrlPts\n");
    for(ii=0; ii<numQuad; ii++)
    {
      for (jj=0; jj<NUM_QUAD_CPTS; jj++)
      {
        fprintf(fp, "%f %f %f\n", quadCtrlPts[ii*jj*3], 
                                     quadCtrlPts[ii*jj*3+1], 
                                     quadCtrlPts[ii*jj*3+2]);
      }
    }
  }
  fclose(fp);
}
void dumpResults ( const char *  fileName,
int  numEdge,
int  numTri,
int  numQuad,
double *  edgeCtrlPts,
double *  triCtrlPts,
double *  quadCtrlPts 
)

Definition at line 1515 of file Cholla.cpp.

{
  FILE *fp = fopen( fileName, "w" );
  assert(fp != NULL);

    // write the header info

  fprintf(fp, "Cholla version 1.0 Results\n");
  time_stamp( fp );
  fprintf(fp, "%d %d %d\n", numEdge, numTri, numQuad );

  int ii,jj;
  fprintf(fp, "edgeCtrlPts\n");
  for(ii=0; ii<numEdge; ii++)
  {
    for (jj=0; jj<NUM_EDGE_CPTS; jj++)
    {
      fprintf(fp, "%f %f %f\n", edgeCtrlPts[ii*jj*3], 
                                   edgeCtrlPts[ii*jj*3+1], 
                                   edgeCtrlPts[ii*jj*3+2]);
    }
  }

  // triangle control points

  fprintf(fp, "triCtrlPts\n");
  for(ii=0; ii<numTri; ii++)
  {
    for (jj=0; jj<NUM_TRI_CPTS; jj++)
    {
      fprintf(fp, "%f %f %f\n", triCtrlPts[ii*jj*3], 
                                   triCtrlPts[ii*jj*3+1], 
                                   triCtrlPts[ii*jj*3+2]);
    }
  }

  // quad control points

  fprintf(fp, "quadCtrlPts\n");
  for(ii=0; ii<numQuad; ii++)
  {
    for (jj=0; jj<NUM_QUAD_CPTS; jj++)
    {
      fprintf(fp, "%f %f %f\n", quadCtrlPts[ii*jj*3], 
                                   quadCtrlPts[ii*jj*3+1], 
                                   quadCtrlPts[ii*jj*3+2]);
    }
  }

  fclose(fp);
}
void evalBezierEdge ( int  numEdge,
int  numVert,
int *  edgeVert,
double *  vert,
double *  edgeCtrlPts,
int  numLocs,
double *  paramLocation,
double *  location,
double *  tangent 
)

Evaluate a quartic Bezier curve at a specified parametric location given its control points. Evaluates location, and/or tangent.

Parameters:
numEdge- (IN) number of edges on the faces
numVert- (IN) number of vertices
edgeVert- (IN) array of edge to vertex indecies (into vert) length 2 * numEdge
vert- (IN) array of vertex locations length 3 * numVert
edgeCtrlPts- (IN) array of control pt locations for each edge in the bezier. The beziers are quartic, so there are 3 control pts per curve in addition to the 2 end pts for each curve for a total of 5 pts per edge. length = 3 * ( 3 * numEdge )
numLocs- (IN) number of locations to evaluate per edge
paramLocation- (IN) parametric location to evaluate on each edge length = numLocs
location- (OUT) evaluated point on edge at paramLocation length = numEdge * 3 * numLocs
tangent- (IN/OUT) evaluated tangent at parmLocation. If NULL then will not be evaluated. Return vector is normalized length = numEdge * 3 * numLocs

Definition at line 1945 of file Cholla.cpp.

{
CubitPoint **point_array = new CubitPoint * [numVert];
CubitFacetEdge **edge_array = new CubitFacetEdge * [numEdge];
CubitFacet **facet_array = NULL;
CubitQuadFacet **qfacet_array = NULL;
DLIList<FacetEntity *> facet_list;
int ii, index, numTri, numQuad;
int *triEdge, *quadEdge;
  triEdge = quadEdge = NULL;
  numTri = numQuad = 0;
  CubitStatus stat = CUBIT_SUCCESS;
  stat = build_facets(numTri, numQuad, numEdge, numVert, triEdge, quadEdge, 
                      edgeVert, vert, point_array, edge_array, facet_array,
                      qfacet_array, facet_list);
  if (CUBIT_SUCCESS != stat) {
    PRINT_ERROR("Failed to build facets.\n");
    return;
  }

  CubitFacetEdge *edge_ptr;
  //  Set the control points on the edges.
  for (ii=0; ii<numEdge; ii++)
  {
    edge_ptr = edge_array[ii];
    index = 3 * (ii * NUM_EDGE_CPTS);
    edge_ptr->set_control_points( &(edgeCtrlPts[index]) );
  } 

  // do the evaluations
  int jj, tindex;
  index = tindex = 0;
    
    for ( ii = 0; ii < numEdge; ii++ ) {
    for ( jj = 0; jj < numLocs; jj++ ) {
      
      CubitVector eval_point;
      CubitVector *eval_point_ptr = &eval_point;
      CubitVector eval_tangent;
      CubitVector *eval_tangent_ptr = NULL;
      if ( tangent != NULL ) 
        eval_tangent_ptr = &eval_tangent;
      edge_ptr = edge_array[ii];
      edge_ptr->evaluate_single(paramLocation[jj],eval_point_ptr);      
      location[index++] = eval_point.x();
      location[index++] = eval_point.y();
      location[index++] = eval_point.z();
      if ( tangent != NULL ) {  
        edge_ptr->evaluate_single_tangent(paramLocation[jj],eval_tangent_ptr);      
        eval_tangent.normalize(); 
        tangent[tindex++] = eval_tangent.x();
        tangent[tindex++] = eval_tangent.y();
        tangent[tindex++] = eval_tangent.z();             
      }      
    }  
  }
  //  delete the temp arrays

  for (ii=0; ii<numEdge; ii++)
    delete edge_array[ii];
  for (ii=0; ii<numVert; ii++)
    delete point_array[ii];
  delete [] point_array;
  delete [] edge_array;

}
void evalBezierEdgeFromTans ( int  numEdge,
int  numVert,
int *  edgeVert,
double *  vert,
double *  edgeVertTang,
int  numLocs,
double *  paramLocation,
double *  location,
double *  tangent 
)

Evaluate a quartic Bezier curve at a specified parametric location given its tangents at the end-points. Evaluates location, and/or tangent.

Parameters:
numEdge- (IN) number of edges on the faces
numVert- (IN) number of vertices
edgeVert- (IN) array of edge to vertex indecies (into vert) length 2 * numEdge
vert- (IN) array of vertex locations
edgeVertTang- (IN) array of tangents at the edge vertices length 3*(2*numEdge)
numLocs- (IN) number of locations to evaluate per edge
paramLocation- (IN) parametric location to evaluate on each edge length = numLocs
location- (OUT) evaluated point on edge at paramLocation length = numEdge * 3 * numLocs
tangent- (IN/OUT) evaluated tangent at parmLocation. If NULL then will not be evaluated. Return vector is normalized length = numEdge * 3 * numLocs

Definition at line 2023 of file Cholla.cpp.

{
CubitPoint **point_array = new CubitPoint * [numVert];
CubitFacetEdge **edge_array = new CubitFacetEdge * [numEdge];
CubitFacet **facet_array = NULL;
CubitQuadFacet **qfacet_array = NULL;
DLIList<FacetEntity *> facet_list;
int ii, index, numTri, numQuad;
int *triEdge, *quadEdge;
  triEdge = quadEdge = NULL;
  numTri = numQuad = 0;
  CubitStatus stat = CUBIT_SUCCESS;
  stat = build_facets(numTri, numQuad, numEdge, numVert, triEdge, quadEdge, 
                      edgeVert, vert, point_array, edge_array, facet_array,
                      qfacet_array, facet_list);
  if (CUBIT_SUCCESS != stat) {
    PRINT_ERROR("Failed to build facets.\n");
    return;
  }

  // set the control points on edges

  int mydebug = 0;
  FILE *fp = NULL;
  if (mydebug)
    fp = fopen("edges.txt", "w");
  CubitFacetEdge *edge_ptr;
  CubitVector T0, T1, P0, P1;
  CubitVector Pi[3];
  CubitPoint *pt0, *pt1;
  for (ii=0; ii<numEdge; ii++)
  {
    index = 6 * ii;
    edge_ptr = edge_array[ii];
    pt0 = edge_ptr->point(0);
    pt1 = edge_ptr->point(1);
    P0 = pt0->coordinates();
    P1 = pt1->coordinates();
    T0.x( edgeVertTang[ index ] );
    T0.y( edgeVertTang[ index + 1] );
    T0.z( edgeVertTang[ index + 2] );
    T1.x( edgeVertTang[ index + 3] );
    T1.y( edgeVertTang[ index + 4] );
    T1.z( edgeVertTang[ index + 5] );
    FacetEvalTool::init_edge_control_points_single(P0, P1, T0, T1, Pi);
    if (mydebug)
    {
      int kk;
      for(kk=0; kk<3; kk++);
      fprintf(fp, "(%d) %.6f %.6f %.6f\n", edge_ptr->id(), P0.x(), P0.y(), P0.z());
      fprintf(fp, "    %.6f %.6f %.6f\n", Pi[0].x(), Pi[0].y(), Pi[0].z());
      fprintf(fp, "    %.6f %.6f %.6f\n", Pi[1].x(), Pi[1].y(), Pi[1].z());
      fprintf(fp, "    %.6f %.6f %.6f\n", Pi[2].x(), Pi[2].y(), Pi[2].z());
      fprintf(fp, "    %.6f %.6f %.6f\n", P1.x(), P1.y(), P1.z());
    }
    edge_ptr->control_points( Pi, 4 );
  } 
  if (mydebug)
    fclose(fp);

  // do the evaluations
  int jj, tindex;
  index = tindex = 0;
    
  for ( ii = 0; ii < numEdge; ii++ ) {
    for ( jj = 0; jj < numLocs; jj++ ) {
      
      CubitVector eval_point;
      CubitVector *eval_point_ptr = &eval_point;
      CubitVector eval_tangent;
      CubitVector *eval_tangent_ptr = NULL;
      if ( tangent != NULL ) 
        eval_tangent_ptr = &eval_tangent;
      edge_ptr = edge_array[ii];
      edge_ptr->evaluate_single(paramLocation[jj],eval_point_ptr);      
      location[index++] = eval_point.x();
      location[index++] = eval_point.y();
      location[index++] = eval_point.z();
      if ( tangent != NULL ) {  
        edge_ptr->evaluate_single_tangent(paramLocation[jj],eval_tangent_ptr);      
        eval_tangent.normalize(); 
        tangent[tindex++] = eval_tangent.x();
        tangent[tindex++] = eval_tangent.y();
        tangent[tindex++] = eval_tangent.z();             
      }      
    }  
  }
  //  delete the temp arrays

  for (ii=0; ii<numEdge; ii++)
    delete edge_array[ii];
  for (ii=0; ii<numVert; ii++)
    delete point_array[ii];
  delete [] point_array;
  delete [] edge_array;
}
void evalBezierFace ( int  numFace,
int  numEdge,
int  numVert,
int  numVertPerFace,
int *  faceEdge,
int *  edgeVert,
double *  vert,
double *  faceCtrlPts,
double *  edgeCtrlPts,
int  numLocs,
double *  paramLocation,
double *  location,
double *  normal,
double *  deriv 
)

Evaluate a set of quartic Bezier patches at a specified parametric location given its control points. Evaluates location, normal and/or derivative. Expects list of either quads or tris (not both)

Parameters:
numFace- (IN) number of faces to evaluate
numEdge- (IN) number of edges on the faces
numVert- (IN) number of vertices
numVertPerFace-(IN) has value of of 3 or 4, for tris or quads
faceEdge- (IN) array of face to edge indecies (into edgeVert) length numVertPerFace * numFace
edgeVert- (IN) array of edge to vertex indecies (into vert) length 2 * numEdge
vert- (IN) array of vertex locations length 3 * numVert
faceCtrlPts- (IN) array of control points for the faces (same order as faceEdge) if (numFacePerVert == 3) ncp = 6 if (numFacePerVert == 4) ncp = 15 length = 3 * (ncp * numFace)
edgeCtrlPts- (IN) array of control points for the edges (same order as edgeVert array) length 3 * (3 * numEdge)
numLocs- (IN) number of locations to evaluate per face
paramLocation- (IN) parametric location to evaluate on each face if (numFacePerVert == 3) (u,v,w) length = 3 * numLocs if (numFacePerVert == 4) (u,v) length = 2 * numLocs
location- (OUT) evaluated point on surface at paramLocation length = numFace * 3 * numLocs
normal- (IN/OUT) evaluated normal at parmLocation. If NULL then will not be evaluated. Return vector is normalized length = numFace * 3 * numLocs
deriv- (IN/OUT) evaluated derivative at parmLocation with respect to uv or uvw system. If NULL then will not be evaluated. if (numFacePerVert == 3) length = numFace * numLocs * 3*3 (du/dx,du/dy,du/dz, dv/dx,dv/dy,dv/dz, dw/dx,dw/dz,dw/dz) if (numFacePerVert == 4) length = numFace * numLocs * 3*2 (du/dx,du/dy,du/dz, dv/dx,dv/dy,dv/dz)

Definition at line 628 of file Cholla.cpp.

{
    // create arrays of facet entities from the arrays

  int numTri = 0;
  int numQuad = 0;
  CubitPoint **point_array = new CubitPoint * [numVert];
  CubitFacetEdge **edge_array = new CubitFacetEdge * [numEdge];
  CubitFacet **facet_array = NULL;
  int *tri_edge = (numVertPerFace == 3) ? faceEdge : NULL;
  int *quad_edge = (numVertPerFace == 4) ? faceEdge : NULL;
  if (numVertPerFace == 3)
  {
    facet_array = new CubitFacet * [numFace];
    numTri = numFace;
  }
  CubitQuadFacet **qfacet_array = NULL;
  if (numVertPerFace == 4)
  {
    qfacet_array = new CubitQuadFacet * [numFace];
    numQuad = numFace;
  }
  DLIList<FacetEntity *> facet_list;
  CubitStatus stat = CUBIT_SUCCESS;
  stat = build_facets(numTri, numQuad, numEdge, numVert, tri_edge, quad_edge, 
                      edgeVert, vert, point_array, edge_array, facet_array,
                      qfacet_array, facet_list);
  if (CUBIT_SUCCESS != stat) {
    PRINT_ERROR("Failed to build facets.\n");
    return;
  }

  // set the control points on edges

  int index, ii, jj;
  CubitFacetEdge *edge_ptr;
  for (ii=0; ii<numEdge; ii++)
  {
    edge_ptr = edge_array[ii];
    index = 3 * (ii * NUM_EDGE_CPTS);
    edge_ptr->set_control_points( &(edgeCtrlPts[index]) );
  }

  // set the control points on triangles

  CubitFacet *facet_ptr;
  for (ii=0; ii<numTri; ii++)
  {
    facet_ptr = facet_array[ii];
    index = 3 * (ii * NUM_TRI_CPTS); 
    facet_ptr->set_control_points( &(faceCtrlPts[index]) );
  }

    // set the control points on quads

  CubitQuadFacet *qfacet_ptr;
  for (ii=0; ii<numQuad; ii++)
  {
    qfacet_ptr = qfacet_array[ii];
    index = 3 * (ii * NUM_QUAD_CPTS);
    qfacet_ptr->set_control_points( &(faceCtrlPts[index]) );
  }

  // Do the evaluations

  for (ii=0; ii<numTri; ii++)
  {
    for (jj=0; jj<numLocs; jj++)
    {
      facet_ptr = facet_array[ii];
      CubitVector areacoord(paramLocation[jj*3],
                            paramLocation[jj*3+1],
                            paramLocation[jj*3+2]);
      CubitVector eval_point;
      CubitVector *eval_point_ptr = &eval_point;
      CubitVector eval_normal;
      CubitVector *eval_normal_ptr = NULL;
      if (normal != NULL)
      {
        eval_normal_ptr = &eval_normal;
      }
      facet_ptr->evaluate( areacoord, eval_point_ptr, eval_normal_ptr );
      index = 3 * ii * jj;
      location[index] = eval_point.x();
      location[index+1] = eval_point.y();
      location[index+2] = eval_point.z();
      if (normal != NULL)
      {
        normal[index] = eval_normal.x();
        normal[index+1] = eval_normal.y();
        normal[index+2] = eval_normal.z();
      }
    }
  }

  for (ii=0; ii<numQuad; ii++)
  {
    for (jj=0; jj<numLocs; jj++)
    {
      qfacet_ptr = qfacet_array[ii];
      CubitVector eval_point;
      CubitVector *eval_point_ptr = &eval_point;
      CubitVector eval_normal;
      CubitVector *eval_normal_ptr = NULL;
      if (normal != NULL)
        eval_normal_ptr = &eval_normal;
      CubitVector eval_du, eval_dv;
      CubitVector *eval_du_ptr = NULL;
      CubitVector *eval_dv_ptr = NULL;
      if (deriv != NULL)
      {
        eval_du_ptr = &eval_du;
        eval_dv_ptr = &eval_dv;
      }

      qfacet_ptr->evaluate( paramLocation[2*jj], paramLocation[2*jj+1],
                            eval_point_ptr, eval_normal_ptr,
                            eval_du_ptr, eval_dv_ptr);
      index = 3 * ii * jj;
      location[index] = eval_point.x();
      location[index+1] = eval_point.y();
      location[index+2] = eval_point.z();
      if (normal != NULL)
      {
        normal[index] = eval_normal.x();
        normal[index+1] = eval_normal.y();
        normal[index+2] = eval_normal.z();
      }
      if (deriv != NULL)
      {
        index = 6 * ii * jj;
        deriv[index] = eval_du.x();
        deriv[index+1] = eval_du.y();
        deriv[index+2] = eval_du.z();
        deriv[index+3] = eval_dv.x();
        deriv[index+4] = eval_dv.y();
        deriv[index+5] = eval_dv.z();
      }
    }
  }
  
  // delete the temp arrays

  for (ii=0; ii<numQuad; ii++)
    delete qfacet_array[ii];
  for (ii=0; ii<numTri; ii++)
    delete facet_array[ii];
  for (ii=0; ii<numEdge; ii++)
    delete edge_array[ii];
  for (ii=0; ii<numVert; ii++)
    delete point_array[ii];
  delete [] point_array;
  delete [] edge_array;
  if (facet_array)
    delete [] facet_array; 
  if (qfacet_array)
    delete [] qfacet_array; 
}
void evalBezierFaceFromNorms ( int  numFace,
int  numEdge,
int  numVert,
int  numVertPerFace,
int *  faceEdge,
int *  edgeVert,
double *  vert,
double *  vertNorms,
double *  edgeVertTang,
int  numLocs,
double *  paramLocation,
double *  location,
double *  normal,
double *  deriv 
)

This is the same as the evalBezierFace except it differes by the input arguments. This function takes a list of normals and tangents at the face vertices and computes bezier control points internally. Normals and tangents should have been computed previously in constructTriNormals or constructQuad Normals. This function is not as computationally efficient as evalBezierFace since it requires Bezier control points to be computed as part of the call - however, it is more memory efficient, requiring fewer variables to be stored with the calling application. The following argument list describes only those arguments that differ from evalBezierFace above.

Parameters:
vertNorms- (IN) array of normals at the face vertices length 3*(numVertPerFace*numFace)
edgeVertTang- (OUT) array of tangents at the edge vertices length 3*(2*numEdge)

Definition at line 809 of file Cholla.cpp.

{
    // create arrays of facet entities from the arrays

  int numTri = 0;
  int numQuad = 0;
  CubitPoint **point_array = new CubitPoint * [numVert];
  CubitFacetEdge **edge_array = new CubitFacetEdge * [numEdge];
  CubitFacet **facet_array = NULL;
  int *triEdge = (numVertPerFace == 3) ? faceEdge : NULL;
  int *quadEdge = (numVertPerFace == 4) ? faceEdge : NULL;
  if (numVertPerFace == 3)
  {
    facet_array = new CubitFacet * [numFace];
    numTri = numFace;
  }
  CubitQuadFacet **qfacet_array = NULL;
  if (numVertPerFace == 4)
  {
    qfacet_array = new CubitQuadFacet * [numFace];
    numQuad = numFace;
  }
  DLIList<FacetEntity *> facet_list;
  CubitStatus stat = CUBIT_SUCCESS;
  stat = build_facets(numTri, numQuad, numEdge, numVert, triEdge, quadEdge, 
                      edgeVert, vert, point_array, edge_array, facet_array,
                      qfacet_array, facet_list);
  if (CUBIT_SUCCESS != stat) {
    PRINT_ERROR("Failed to build facets.\n");
    return;
  }

  // set the normals on triangle vertices

  int index, ii, jj;
  CubitPoint *pt;
  CubitFacet *facet_ptr;
  CubitVector pt_normal;
  for (ii=0; ii<numTri; ii++)
  {
    facet_ptr = facet_array[ii];
    for(jj=0; jj<3; jj++)
    {
      index = ii * 9 + (3 * jj);
      pt_normal.x( vertNorms[ index ] );
      pt_normal.y( vertNorms[ index + 1 ] );
      pt_normal.z( vertNorms[ index + 2 ] );
      pt = facet_ptr->point(jj);
      TDFacetBoundaryPoint::add_facet_boundary_point( pt, facet_ptr, pt_normal );
    }
  }

  // set the normals on quad vertices

  CubitQuadFacet *qfacet_ptr;
  for (ii=0; ii<numQuad; ii++)
  {
    qfacet_ptr = qfacet_array[ii];
    for(jj=0; jj<4; jj++)
    {
      index = ii * 12 + (3 * jj);
      pt_normal.x( vertNorms[ index ] );
      pt_normal.y( vertNorms[ index + 1 ] );
      pt_normal.z( vertNorms[ index + 2 ] );
      pt = qfacet_ptr->point(jj);
      TDFacetBoundaryPoint::add_facet_boundary_point( pt, qfacet_ptr, pt_normal );
    }
  }

  // set the control points on edges

  int mydebug = 0;
  FILE *fp = NULL;
  if (mydebug)
    fp = fopen("edges.txt", "w");
  CubitFacetEdge *edge_ptr;
  CubitVector N0, N1, T0, T1, P0, P1;
  CubitVector Pi[3];
  CubitPoint *pt0, *pt1;
  for (ii=0; ii<numEdge; ii++)
  {
    index = 6 * ii;
    edge_ptr = edge_array[ii];
    pt0 = edge_ptr->point(0);
    pt1 = edge_ptr->point(1);
    P0 = pt0->coordinates();
    P1 = pt1->coordinates();
    N0 = pt0->normal( edge_ptr );
    N1 = pt1->normal( edge_ptr );
    T0.x( edgeVertTang[ index ] );
    T0.y( edgeVertTang[ index + 1] );
    T0.z( edgeVertTang[ index + 2] );
    T1.x( edgeVertTang[ index + 3] );
    T1.y( edgeVertTang[ index + 4] );
    T1.z( edgeVertTang[ index + 5] );
    FacetEvalTool::init_edge_control_points(P0, P1, N0, N1, T0, T1, Pi);
    if (mydebug)
    {
      int kk;
      for(kk=0; kk<3; kk++);
      fprintf(fp, "(%d) %.6f %.6f %.6f\n", edge_ptr->id(), P0.x(), P0.y(), P0.z());
      fprintf(fp, "    %.6f %.6f %.6f\n", Pi[0].x(), Pi[0].y(), Pi[0].z());
      fprintf(fp, "    %.6f %.6f %.6f\n", Pi[1].x(), Pi[1].y(), Pi[1].z());
      fprintf(fp, "    %.6f %.6f %.6f\n", Pi[2].x(), Pi[2].y(), Pi[2].z());
      fprintf(fp, "    %.6f %.6f %.6f\n", P1.x(), P1.y(), P1.z());
    }
    edge_ptr->control_points( Pi, 4 );
  }
  if (mydebug)
    fclose(fp);

  // set the control points on triangles

  for (ii=0; ii<numTri; ii++)
  {
    facet_ptr = facet_array[ii];
    facet_ptr->init_patch();
  }

    // set the control points on quads

  for (ii=0; ii<numQuad; ii++)
  {
    qfacet_ptr = qfacet_array[ii];
    qfacet_ptr->init_patch();
  }

  // Do the evaluations

  index = 0;
  int nindex = 0;
  for (ii=0; ii<numTri; ii++)
  {
    facet_ptr = facet_array[ii];
    for (jj=0; jj<numLocs; jj++)
    {  
      CubitVector areacoord(paramLocation[jj*3],
                            paramLocation[jj*3+1],
                            paramLocation[jj*3+2]);
      CubitVector eval_point;
      CubitVector *eval_point_ptr = &eval_point;
      CubitVector eval_normal;
      CubitVector *eval_normal_ptr = NULL;
      if (normal != NULL)
      {
        eval_normal_ptr = &eval_normal;
      }
      facet_ptr->evaluate( areacoord, eval_point_ptr, eval_normal_ptr );
      location[index++] = eval_point.x();
      location[index++] = eval_point.y();
      location[index++] = eval_point.z();
      if (normal != NULL)
      {
        normal[nindex++] = eval_normal.x();
        normal[nindex++] = eval_normal.y();
        normal[nindex++] = eval_normal.z();
      }
    }
  }

  int dindex = 0;
  nindex = index = 0;
  for (ii=0; ii<numQuad; ii++)
  {
    for (jj=0; jj<numLocs; jj++)
    {
      qfacet_ptr = qfacet_array[ii];
      CubitVector eval_point;
      CubitVector *eval_point_ptr = &eval_point;
      CubitVector eval_normal;
      CubitVector *eval_normal_ptr = NULL;
      if (normal != NULL)
        eval_normal_ptr = &eval_normal;
      CubitVector eval_du, eval_dv;
      CubitVector *eval_du_ptr = NULL;
      CubitVector *eval_dv_ptr = NULL;
      if (deriv != NULL)
      {
        eval_du_ptr = &eval_du;
        eval_dv_ptr = &eval_dv;
      }

      qfacet_ptr->evaluate( paramLocation[2*jj], paramLocation[2*jj+1],
                            eval_point_ptr, eval_normal_ptr,
                            eval_du_ptr, eval_dv_ptr);
      location[index++] = eval_point.x();
      location[index++] = eval_point.y();
      location[index++] = eval_point.z();
      if (normal != NULL)
      {
        normal[nindex++] = eval_normal.x();
        normal[nindex++] = eval_normal.y();
        normal[nindex++] = eval_normal.z();
      }
      if (deriv != NULL)
      {
        index = 6 * ii * jj;
        deriv[dindex++] = eval_du.x();
        deriv[dindex++] = eval_du.y();
        deriv[dindex++] = eval_du.z();
        deriv[dindex++] = eval_dv.x();
        deriv[dindex++] = eval_dv.y();
        deriv[dindex++] = eval_dv.z();
      }
    }
  }
  
  // delete the temp arrays

  for (ii=0; ii<numQuad; ii++)
    delete qfacet_array[ii];
  for (ii=0; ii<numTri; ii++)
    delete facet_array[ii];
  for (ii=0; ii<numEdge; ii++)
    delete edge_array[ii];
  for (ii=0; ii<numVert; ii++)
    delete point_array[ii];
  delete [] point_array;
  delete [] edge_array;
  if (facet_array)
    delete [] facet_array; 
  if (qfacet_array)
    delete [] qfacet_array; 
}
static CubitStatus extractEdgeTangsFromFile ( int  num_file_edges,
int *  edge_nodes_file,
double *  edge_node_tangs_file,
int  numTri,
int *  edgeVert,
double *  edgeVertTang 
) [static]

Definition at line 2639 of file Cholla.cpp.

{
#define MIN_EDGE_NODE_ID( n1, n2 ) n1 < n2 ? n1 : n2
    CubitStatus status = CUBIT_SUCCESS;
    DLIList<int *> *edge_hash = new DLIList<int*> [num_file_edges];
    int * edge_data = new int [num_file_edges * 3 ];

    int i;
    
    for ( i = 0; i < num_file_edges; i++ )
    {
        int *data = &(edge_data[i*3]);

        data[0] = edge_nodes_file[i*2];
        data[1] = edge_nodes_file[i*2 + 1];
        data[2] = i;

        int key = MIN_EDGE_NODE_ID( data[0], data[1] );
        key %= num_file_edges;
        edge_hash[key].append( data );
    }

    for ( i = 0; i < numEdge; i++ )
    {
        CubitBoolean found = CUBIT_FALSE;
        int *this_edge = &(edgeVert[i*2]);
        int key = MIN_EDGE_NODE_ID( this_edge[0], this_edge[1] );
        key %= num_file_edges;
        for ( int j = 0; j < edge_hash[key].size(); j++ )
        {
            int *data = edge_hash[key].get_and_step();
            if ( data[0] == this_edge[0] &&
                 data[1] == this_edge[1] )
            {
                edgeVertTang[ i*2*3     ] = edge_node_tangs_file[ data[2] * 2 * 3 ];
                edgeVertTang[ i*2*3 + 1 ] = edge_node_tangs_file[ data[2] * 2 * 3 + 1 ];
                edgeVertTang[ i*2*3 + 2 ] = edge_node_tangs_file[ data[2] * 2 * 3 + 2 ];
                edgeVertTang[ i*2*3 + 3 ] = edge_node_tangs_file[ data[2] * 2 * 3 + 3 ];
                edgeVertTang[ i*2*3 + 4 ] = edge_node_tangs_file[ data[2] * 2 * 3 + 4 ];
                edgeVertTang[ i*2*3 + 5 ] = edge_node_tangs_file[ data[2] * 2 * 3 + 5 ];
                found = CUBIT_TRUE;
                break;
            }
            else if ( data[0] == this_edge[1] &&
                      data[1] == this_edge[0] )
            {
                edgeVertTang[ i*2*3     ] = edge_node_tangs_file[ data[2] * 2 * 3 + 3 ];
                edgeVertTang[ i*2*3 + 1 ] = edge_node_tangs_file[ data[2] * 2 * 3 + 4 ];
                edgeVertTang[ i*2*3 + 2 ] = edge_node_tangs_file[ data[2] * 2 * 3 + 5 ];
                edgeVertTang[ i*2*3 + 3 ] = edge_node_tangs_file[ data[2] * 2 * 3  ];
                edgeVertTang[ i*2*3 + 4 ] = edge_node_tangs_file[ data[2] * 2 * 3 + 1 ];
                edgeVertTang[ i*2*3 + 5 ] = edge_node_tangs_file[ data[2] * 2 * 3 + 2 ];
                found = CUBIT_TRUE;
                break;
            }
        }
        if ( found == CUBIT_FALSE )
        {
            status = CUBIT_FAILURE;
            break;
        }
    }
    delete [] edge_data;
    delete [] edge_hash;

    return status;
 }
static CubitStatus extractQuadNormalsFromFile ( int  num_file_quads,
int *  quad_nodes_file,
double *  quad_node_norms_file,
int  numQuad,
int *  edgeVert,
int *  quadEdge,
double *  quadVertNorms 
) [static]

Definition at line 2834 of file Cholla.cpp.

{
#define MIN_QUAD_NODE_ID( n1, n2, n3, n4 ) MIN_EDGE_NODE_ID( (MIN_EDGE_NODE_ID( n1, n2 )), (MIN_EDGE_NODE_ID( n3, n4 )) )

    CubitStatus status = CUBIT_SUCCESS;
    DLIList< int* > *quad_hash = new DLIList< int*>[num_file_quads];
    int * quad_data = new int [num_file_quads * 5 ];

    int i;
    for ( i = 0; i < num_file_quads; i++ )
    {
        int *data = &(quad_data[i*5]);

        data[0] = quad_nodes_file[i*4];
        data[1] = quad_nodes_file[i*4 + 1];
        data[2] = quad_nodes_file[i*4 + 2];
        data[3] = quad_nodes_file[i*4 + 3];
        data[4] = i;

        int key = MIN_QUAD_NODE_ID( data[0], data[1], data[2], data[3] );
        key %= num_file_quads;
        quad_hash[key].append( data );
    }

    for ( i = 0; i < numQuad; i++ )
    {
        CubitBoolean found = CUBIT_FALSE;
        int this_quad[4];
        
        constructQuadVerts( &quadEdge[i*4], edgeVert, this_quad );

        int key = MIN_QUAD_NODE_ID( this_quad[0], this_quad[1], this_quad[2], this_quad[3] );
        key %= num_file_quads;
        for ( int j = 0; j < quad_hash[key].size(); j++ )
        {
            int *data = quad_hash[key].get_and_step();

            if ( this_quad[0] == data[0] &&
                 this_quad[1] == data[1] &&
                 this_quad[2] == data[2] &&
                 this_quad[3] == data[3] )
            {
                quadVertNorms[ i*4*3     ] = quad_node_norms_file[ data[4]*4*3     ];
                quadVertNorms[ i*4*3 + 1 ] = quad_node_norms_file[ data[4]*4*3 + 1 ];
                quadVertNorms[ i*4*3 + 2 ] = quad_node_norms_file[ data[4]*4*3 + 2 ];
                quadVertNorms[ i*4*3 + 3 ] = quad_node_norms_file[ data[4]*4*3 + 3 ];
                quadVertNorms[ i*4*3 + 4 ] = quad_node_norms_file[ data[4]*4*3 + 4 ];
                quadVertNorms[ i*4*3 + 5 ] = quad_node_norms_file[ data[4]*4*3 + 5 ];
                quadVertNorms[ i*4*3 + 6 ] = quad_node_norms_file[ data[4]*4*3 + 6 ];
                quadVertNorms[ i*4*3 + 7 ] = quad_node_norms_file[ data[4]*4*3 + 7 ];
                quadVertNorms[ i*4*3 + 8 ] = quad_node_norms_file[ data[4]*4*3 + 8 ];
                quadVertNorms[ i*4*3 + 9 ] = quad_node_norms_file[ data[4]*4*3 + 9 ];
                quadVertNorms[ i*4*3 + 10] = quad_node_norms_file[ data[4]*4*3 + 10];
                quadVertNorms[ i*4*3 + 11] = quad_node_norms_file[ data[4]*4*3 + 11];
                found = CUBIT_TRUE;
                break;
            }
            else if ( this_quad[0] == data[1] &&
                      this_quad[1] == data[2] &&
                      this_quad[2] == data[3] &&
                      this_quad[3] == data[0] )
            {
                quadVertNorms[ i*4*3     ] = quad_node_norms_file[ data[4]*4*3 + 3 ];
                quadVertNorms[ i*4*3 + 1 ] = quad_node_norms_file[ data[4]*4*3 + 4 ];
                quadVertNorms[ i*4*3 + 2 ] = quad_node_norms_file[ data[4]*4*3 + 5 ];
                quadVertNorms[ i*4*3 + 3 ] = quad_node_norms_file[ data[4]*4*3 + 6 ];
                quadVertNorms[ i*4*3 + 4 ] = quad_node_norms_file[ data[4]*4*3 + 7 ];
                quadVertNorms[ i*4*3 + 5 ] = quad_node_norms_file[ data[4]*4*3 + 8 ];
                quadVertNorms[ i*4*3 + 6 ] = quad_node_norms_file[ data[4]*4*3 + 9 ];
                quadVertNorms[ i*4*3 + 7 ] = quad_node_norms_file[ data[4]*4*3 + 10 ];
                quadVertNorms[ i*4*3 + 8 ] = quad_node_norms_file[ data[4]*4*3 + 11 ];
                quadVertNorms[ i*4*3 + 9 ] = quad_node_norms_file[ data[4]*4*3 + 0 ];
                quadVertNorms[ i*4*3 + 10] = quad_node_norms_file[ data[4]*4*3 + 1 ];
                quadVertNorms[ i*4*3 + 11] = quad_node_norms_file[ data[4]*4*3 + 2 ];
                found = CUBIT_TRUE;
                break;
            }
            else if ( this_quad[0] == data[2] &&
                      this_quad[1] == data[3] &&
                      this_quad[2] == data[0] &&
                      this_quad[3] == data[1] )
            {
                quadVertNorms[ i*4*3     ] = quad_node_norms_file[ data[4]*4*3 + 6 ];
                quadVertNorms[ i*4*3 + 1 ] = quad_node_norms_file[ data[4]*4*3 + 7 ];
                quadVertNorms[ i*4*3 + 2 ] = quad_node_norms_file[ data[4]*4*3 + 8 ];
                quadVertNorms[ i*4*3 + 3 ] = quad_node_norms_file[ data[4]*4*3 + 9 ];
                quadVertNorms[ i*4*3 + 4 ] = quad_node_norms_file[ data[4]*4*3 + 10 ];
                quadVertNorms[ i*4*3 + 5 ] = quad_node_norms_file[ data[4]*4*3 + 11 ];
                quadVertNorms[ i*4*3 + 6 ] = quad_node_norms_file[ data[4]*4*3 + 0 ];
                quadVertNorms[ i*4*3 + 7 ] = quad_node_norms_file[ data[4]*4*3 + 1 ];
                quadVertNorms[ i*4*3 + 8 ] = quad_node_norms_file[ data[4]*4*3 + 2 ];
                quadVertNorms[ i*4*3 + 9 ] = quad_node_norms_file[ data[4]*4*3 + 3 ];
                quadVertNorms[ i*4*3 + 10] = quad_node_norms_file[ data[4]*4*3 + 4 ];
                quadVertNorms[ i*4*3 + 11] = quad_node_norms_file[ data[4]*4*3 + 5 ];
                found = CUBIT_TRUE;
                break;
            }
            else if (  this_quad[0] == data[3] &&
                       this_quad[1] == data[0] &&
                       this_quad[2] == data[1] &&
                       this_quad[3] == data[2] )
            {
                quadVertNorms[ i*4*3     ] = quad_node_norms_file[ data[4]*4*3 + 9 ];
                quadVertNorms[ i*4*3 + 1 ] = quad_node_norms_file[ data[4]*4*3 + 10 ];
                quadVertNorms[ i*4*3 + 2 ] = quad_node_norms_file[ data[4]*4*3 + 11 ];
                quadVertNorms[ i*4*3 + 3 ] = quad_node_norms_file[ data[4]*4*3 + 0 ];
                quadVertNorms[ i*4*3 + 4 ] = quad_node_norms_file[ data[4]*4*3 + 1 ];
                quadVertNorms[ i*4*3 + 5 ] = quad_node_norms_file[ data[4]*4*3 + 2 ];
                quadVertNorms[ i*4*3 + 6 ] = quad_node_norms_file[ data[4]*4*3 + 3 ];
                quadVertNorms[ i*4*3 + 7 ] = quad_node_norms_file[ data[4]*4*3 + 4 ];
                quadVertNorms[ i*4*3 + 8 ] = quad_node_norms_file[ data[4]*4*3 + 5 ];
                quadVertNorms[ i*4*3 + 9 ] = quad_node_norms_file[ data[4]*4*3 + 6 ];
                quadVertNorms[ i*4*3 + 10] = quad_node_norms_file[ data[4]*4*3 + 7 ];
                quadVertNorms[ i*4*3 + 11] = quad_node_norms_file[ data[4]*4*3 + 8 ];
                found = CUBIT_TRUE;
                break;
            }
        }
        if ( found == CUBIT_FALSE )
        {
            status = CUBIT_FAILURE;
            break;
        }
    }

    delete [] quad_data;
    delete [] quad_hash;
    return status;
}
static CubitStatus extractTriNormalsFromFile ( int  num_file_tris,
int *  tri_nodes_file,
double *  tri_node_norms_file,
int  numTri,
int *  edgeVert,
int *  triEdge,
double *  triVertNorms 
) [static]

Definition at line 2721 of file Cholla.cpp.

{
#define MIN_TRI_NODE_ID( n1, n2, n3 ) n1 < n2 ?  n1 < n3 ? n1 : n3 : n2 < n3 ? n2 : n3

    CubitStatus status = CUBIT_SUCCESS;
    DLIList< int* > *tri_hash = new DLIList< int*>[num_file_tris];
    int * tri_data = new int [num_file_tris * 4 ];

    int i;
    
    for ( i = 0; i < num_file_tris; i++ )
    {
        int *data = &(tri_data[i*4]);

        data[0] = tri_nodes_file[i*3];
        data[1] = tri_nodes_file[i*3 + 1];
        data[2] = tri_nodes_file[i*3 + 2];
        data[3] = i;

        int key = MIN_TRI_NODE_ID( data[0], data[1], data[2] );
        key %= num_file_tris;
        tri_hash[key].append( data );
    }

    for ( i = 0; i < numTri; i++ )
    {
        CubitBoolean found = CUBIT_FALSE;
        int this_tri[3];
        
        constructTriVerts( &triEdge[i*3], edgeVert, this_tri );

        int key = MIN_TRI_NODE_ID( this_tri[0], this_tri[1], this_tri[2] );
        key %= num_file_tris;
        for ( int j = 0; j < tri_hash[key].size(); j++ )
        {
            int *data = tri_hash[key].get_and_step();

            if ( this_tri[0] == data[0] &&
                 this_tri[1] == data[1] &&
                 this_tri[2] == data[2] )
            {
                triVertNorms[ i*3*3     ] = tri_node_norms_file[ data[3]*3*3     ];
                triVertNorms[ i*3*3 + 1 ] = tri_node_norms_file[ data[3]*3*3 + 1 ];
                triVertNorms[ i*3*3 + 2 ] = tri_node_norms_file[ data[3]*3*3 + 2 ];
                triVertNorms[ i*3*3 + 3 ] = tri_node_norms_file[ data[3]*3*3 + 3 ];
                triVertNorms[ i*3*3 + 4 ] = tri_node_norms_file[ data[3]*3*3 + 4 ];
                triVertNorms[ i*3*3 + 5 ] = tri_node_norms_file[ data[3]*3*3 + 5 ];
                triVertNorms[ i*3*3 + 6 ] = tri_node_norms_file[ data[3]*3*3 + 6 ];
                triVertNorms[ i*3*3 + 7 ] = tri_node_norms_file[ data[3]*3*3 + 7 ];
                triVertNorms[ i*3*3 + 8 ] = tri_node_norms_file[ data[3]*3*3 + 8 ];
                found = CUBIT_TRUE;
                break;
            }
            else if ( this_tri[0] == data[1] &&
                      this_tri[1] == data[2] &&
                      this_tri[2] == data[0] )
            {
                triVertNorms[ i*3*3     ] = tri_node_norms_file[ data[3]*3*3 + 3 ];
                triVertNorms[ i*3*3 + 1 ] = tri_node_norms_file[ data[3]*3*3 + 4 ];
                triVertNorms[ i*3*3 + 2 ] = tri_node_norms_file[ data[3]*3*3 + 5 ];
                triVertNorms[ i*3*3 + 3 ] = tri_node_norms_file[ data[3]*3*3 + 6 ];
                triVertNorms[ i*3*3 + 4 ] = tri_node_norms_file[ data[3]*3*3 + 7 ];
                triVertNorms[ i*3*3 + 5 ] = tri_node_norms_file[ data[3]*3*3 + 8 ];
                triVertNorms[ i*3*3 + 6 ] = tri_node_norms_file[ data[3]*3*3     ];
                triVertNorms[ i*3*3 + 7 ] = tri_node_norms_file[ data[3]*3*3 + 1 ];
                triVertNorms[ i*3*3 + 8 ] = tri_node_norms_file[ data[3]*3*3 + 2 ];
                found = CUBIT_TRUE;
                break;
            }
            else if ( this_tri[0] == data[2] &&
                      this_tri[1] == data[0] &&
                      this_tri[2] == data[1] )
            {
                triVertNorms[ i*3*3     ] = tri_node_norms_file[ data[3]*3*3 + 6 ];
                triVertNorms[ i*3*3 + 1 ] = tri_node_norms_file[ data[3]*3*3 + 7 ];
                triVertNorms[ i*3*3 + 2 ] = tri_node_norms_file[ data[3]*3*3 + 8 ];
                triVertNorms[ i*3*3 + 3 ] = tri_node_norms_file[ data[3]*3*3     ];
                triVertNorms[ i*3*3 + 4 ] = tri_node_norms_file[ data[3]*3*3 + 1 ];
                triVertNorms[ i*3*3 + 5 ] = tri_node_norms_file[ data[3]*3*3 + 2 ];
                triVertNorms[ i*3*3 + 6 ] = tri_node_norms_file[ data[3]*3*3 + 3 ];
                triVertNorms[ i*3*3 + 7 ] = tri_node_norms_file[ data[3]*3*3 + 4 ];
                triVertNorms[ i*3*3 + 8 ] = tri_node_norms_file[ data[3]*3*3 + 5 ];
                found = CUBIT_TRUE;
                break;
            }
        }
        if ( found == CUBIT_FALSE )
        {
            status = CUBIT_FAILURE;
            break;
        }
    }

    delete [] tri_data;
    delete [] tri_hash;
    return status;
}
void importMesh ( const char *  fileName,
int *  includeResults,
double *  angle,
int *  numTri,
int *  numQuad,
int *  numEdge,
int *  numVert,
int **  triEdge,
int **  quadEdge,
int **  edgeVert,
double **  vert,
double **  edgeCtrlPts,
double **  triCtrlPts,
double **  quadCtrlPts 
)

Definition at line 1576 of file Cholla.cpp.

{
  FILE *fp = fopen(fileName, "r");
  assert(fp != NULL);  // couldn't open file for reading
  
  // read the header info

  char version[128];
  char* s = fgets(version, 128, fp);
  if (NULL == s) {
    PRINT_ERROR("Format error in file %s\n", fileName);
    fclose(fp);
    return;
  }
  assert(strcmp(version, "Cholla version 1.0\n") == 0);  // don't recognize file
  char filetime[128];
  s = fgets(filetime, 128, fp); 
  if (NULL == s) {
    PRINT_ERROR("Format error in file %s\n", fileName);
    fclose(fp);
    return;
  }
  
  char line[256];
  int num_tri;
  int num_quad;
  int num_edge;
  int num_vert;
  s = fgets(line,256,fp);
  if (NULL == s) {
    PRINT_ERROR("Format error in file %s\n", fileName);
    fclose(fp);
    return;
  }
  sscanf(line, "%d %d %d %d %d\n", &num_tri, &num_quad, &num_edge, &num_vert, includeResults); 
  *numTri = num_tri;
  *numQuad = num_quad;
  *numEdge = num_edge;
  *numVert = num_vert;
  int nread = fscanf(fp, "%lf\n", angle);
  if (1 != nread) {
    PRINT_ERROR("Format error in file %s\n", fileName);
    fclose(fp);
    return;
  }

  // triEdge

  *triEdge = new int [num_tri*3];
  int *tri_edge = *triEdge;
  char array_name[128];
  nread = fscanf(fp, "%s\n", array_name);
  if (1 != nread) {
    PRINT_ERROR("Format error in file %s\n", fileName);
    fclose(fp);
    return;
  }
  assert(strcmp(array_name, "triEdge") == 0);  // check start of array
  int ii;
  for(ii=0; ii<num_tri; ii++)
  {
    nread = fscanf(fp, "%d %d %d\n", &tri_edge[ii*3], &tri_edge[ii*3+1], &tri_edge[ii*3+2]);
    if (3 != nread) {
      PRINT_ERROR("Format error in file %s\n", fileName);
      fclose(fp);
      return;
    }
  }

  // quadEdge

  *quadEdge = new int [num_quad*4];
  int *quad_edge = *quadEdge;
  nread = fscanf(fp, "%s\n", array_name);
  if (1 != nread) {
    PRINT_ERROR("Format error in file %s\n", fileName);
    fclose(fp);
    return;
  }
  assert(strcmp(array_name, "quadEdge") == 0);  // check start of array
  for(ii=0; ii<num_quad; ii++)
  {
    nread = fscanf(fp, "%d %d %d %d\n", &quad_edge[ii*4], &quad_edge[ii*4+1], 
                                &quad_edge[ii*4+2], &quad_edge[ii*4+3]);
    if (4 != nread) {
      PRINT_ERROR("Format error in file %s\n", fileName);
      fclose(fp);
      return;
    }
  }

  // edgeVert

  *edgeVert = new int [2*num_edge];
  int *edge_vert = *edgeVert;
  nread = fscanf(fp, "%s\n", array_name);
  if (1 != nread) {
    PRINT_ERROR("Format error in file %s\n", fileName);
    fclose(fp);
    return;
  }
  assert(strcmp(array_name, "edgeVert") == 0);  // check start of array
  for (ii=0; ii<num_edge; ii++)
  {
    nread = fscanf(fp, "%d %d\n", &edge_vert[ii*2], &edge_vert[ii*2+1]);
    if (2 != nread) {
      PRINT_ERROR("Format error in file %s\n", fileName);
      fclose(fp);
      return;
    }
  }

  // vert

  *vert = new double [3*num_vert];
  double *my_vert = *vert;
  nread = fscanf(fp, "%s\n", array_name);
  if (1 != nread) {
    PRINT_ERROR("Format error in file %s\n", fileName);
    fclose(fp);
    return;
  }
  assert(strcmp(array_name, "vert") == 0);  // check start of array
  for (ii=0; ii<num_vert; ii++)
  {
    nread = fscanf(fp, "%lf %lf %lf\n", &my_vert[ii*3], &my_vert[ii*3+1], &my_vert[ii*3+2]);
    if (3 != nread) {
      PRINT_ERROR("Format error in file %s\n", fileName);
      fclose(fp);
      return;
    }
  }

  *edgeCtrlPts = new double [3*num_edge*NUM_EDGE_CPTS];
  if (numTri != 0)
    *triCtrlPts = new double [3*num_tri*NUM_TRI_CPTS];
  if (numQuad != 0)
    *quadCtrlPts = new double [3*num_quad*NUM_QUAD_CPTS];

  double *edge_ctrl_pts = *edgeCtrlPts;
  double *tri_ctrl_pts = *triCtrlPts;
  double *quad_ctrl_pts = *quadCtrlPts;
  if (*includeResults != 0)
  {
     // edge control points
    
    nread = fscanf(fp, "%s\n", array_name);
    if (1 != nread) {
      PRINT_ERROR("Format error in file %s\n", fileName);
      fclose(fp);
      return;
    }
    assert(strcmp(array_name, "edgeCtrlPts") == 0);  // check start of array
    for(ii=0; ii<num_edge*NUM_EDGE_CPTS; ii++)
    {
      nread = fscanf(fp, "%lf %lf %lf\n", &edge_ctrl_pts[ii*3], 
                                  &edge_ctrl_pts[ii*3+1], 
                                  &edge_ctrl_pts[ii*3+2]);
      if (3 != nread) {
        PRINT_ERROR("Format error in file %s\n", fileName);
        fclose(fp);
        return;
      }
    }

     // triangle control points
    
    nread = fscanf(fp, "%s\n", array_name);
    if (1 != nread) {
      PRINT_ERROR("Format error in file %s\n", fileName);
      fclose(fp);
      return;
    }
    assert(strcmp(array_name, "triCtrlPts") == 0);  // check start of array
    for(ii=0; ii<num_tri*NUM_TRI_CPTS; ii++)
    {
      nread = fscanf(fp, "%lf %lf %lf\n", &tri_ctrl_pts[ii*3], 
                                  &tri_ctrl_pts[ii*3+1], 
                                  &tri_ctrl_pts[ii*3+2]);
      if (3 != nread) {
        PRINT_ERROR("Format error in file %s\n", fileName);
        fclose(fp);
        return;
      }
    }

    // quad control points
    
    nread = fscanf(fp, "%s\n", array_name);
    if (1 != nread) {
      PRINT_ERROR("Format error in file %s\n", fileName);
      fclose(fp);
      return;
    }
    assert(strcmp(array_name, "quadCtrlPts") == 0);  // check start of array
    for(ii=0; ii<num_quad*NUM_QUAD_CPTS; ii++)
    {
      nread = fscanf(fp, "%lf %lf %lf\n", &quad_ctrl_pts[ii*3], 
                                  &quad_ctrl_pts[ii*3+1], 
                                  &quad_ctrl_pts[ii*3+2]);
      if (3 != nread) {
        PRINT_ERROR("Format error in file %s\n", fileName);
        fclose(fp);
        return;
      }
    }

  }
  fclose(fp);
}
void importResults ( const char *  fileName,
int *  numEdge,
int *  numTri,
int *  numQuad,
double **  edgeCtrlPts,
double **  triCtrlPts,
double **  quadCtrlPts 
)

Definition at line 1799 of file Cholla.cpp.

{
  FILE *fp = fopen(fileName, "r");
  assert(fp != NULL);  // couldn't open file for reading
  
  // read the header info

  char version[128];
  char* s = fgets(version, 128, fp);
  if (NULL == s) {
    PRINT_ERROR("Format error in file %s\n", fileName);
    fclose(fp);
    return;
  }
  assert(strcmp(version, "Cholla version 1.0 Results\n") == 0);  // don't recognize file
  char filetime[128];
  s = fgets(filetime, 128, fp);
  if (NULL == s) {
    PRINT_ERROR("Format error in mesh file %s\n", fileName);
    fclose(fp);
    return;
  }
  int nread = fscanf(fp, "%d %d %d\n", numEdge, numTri, numQuad);
  if (3 != nread) {
    PRINT_ERROR("Format error in file %s\n", fileName);
    fclose(fp);
    return;
  }
  int num_edge = *numEdge;
  int num_tri = *numTri;
  int num_quad = *numQuad;
  
  *edgeCtrlPts = new double [3*num_edge*NUM_EDGE_CPTS];
  if (numTri != 0)
    *triCtrlPts = new double [3*num_tri*NUM_TRI_CPTS];
  if (numQuad != 0)
    *quadCtrlPts = new double [3*num_quad*NUM_QUAD_CPTS];

  double *edge_ctrl_pts = *edgeCtrlPts;
  double *tri_ctrl_pts = *triCtrlPts;
  double *quad_ctrl_pts = *quadCtrlPts;

   // edge control points
  
  int ii;
  char array_name[128];
  nread = fscanf(fp, "%s\n", array_name);
  if (1 != nread) {
    PRINT_ERROR("Format error in file %s\n", fileName);
    fclose(fp);
    return;
  }
  assert(strcmp(array_name, "edgeCtrlPts") == 0);  // check start of array
  for(ii=0; ii<num_edge*NUM_EDGE_CPTS; ii++)
  {
    nread = fscanf(fp, "%lf %lf %lf\n", &edge_ctrl_pts[ii*3], 
                                &edge_ctrl_pts[ii*3+1], 
                                &edge_ctrl_pts[ii*3+2]);
    if (3 != nread) {
      PRINT_ERROR("Format error in file %s\n", fileName);
      fclose(fp);
      return;
    }
  }

   // triangle control points
  
  nread = fscanf(fp, "%s\n", array_name);
  if (1 != nread) {
    PRINT_ERROR("Format error in file %s\n", fileName);
    fclose(fp);
    return;
  }
  assert(strcmp(array_name, "triCtrlPts") == 0);  // check start of array
  for(ii=0; ii<num_tri*NUM_TRI_CPTS; ii++)
  {
    nread = fscanf(fp, "%lf %lf %lf\n", &tri_ctrl_pts[ii*3], 
                                &tri_ctrl_pts[ii*3+1], 
                                &tri_ctrl_pts[ii*3+2]);
    if (3 != nread) {
      PRINT_ERROR("Format error in file %s\n", fileName);
      fclose(fp);
      return;
    }
  }

  // quad control points
  
  nread = fscanf(fp, "%s\n", array_name);
  if (1 != nread) {
    PRINT_ERROR("Format error in file %s\n", fileName);
    fclose(fp);
    return;
  }
  assert(strcmp(array_name, "quadCtrlPts") == 0);  // check start of array
  for(ii=0; ii<num_tri*NUM_QUAD_CPTS; ii++)
  {
    nread = fscanf(fp, "%lf %lf %lf\n", &quad_ctrl_pts[ii*3], 
                                &quad_ctrl_pts[ii*3+1], 
                                &quad_ctrl_pts[ii*3+2]);
    if (3 != nread) {
      PRINT_ERROR("Format error in file %s\n", fileName);
      fclose(fp);
      return;
    }
  }

  fclose(fp);

}
void projToBezierEdge ( int  numEdge,
int  numVert,
int *  edgeVert,
double *  vert,
double *  edgeCtrlPts,
int  numLocs,
double *  xyz,
double *  xyzOnEdge,
double *  tangent,
double *  t_value 
)

Project a 3d point to a quartic Bezier curve at a specified parametric location given its control points.

Parameters:
numEdge- (IN) number of edges on the faces
numVert- (IN) number of vertices
edgeVert- (IN) array of edge to vertex indecies (into vert) length 2 * numEdge
vert- (IN) array of vertex locations length = 3 * numVert
edgeCtrlPts- (IN) array of control pt locations for each edge in the bezier. The beziers are quartic, so there are 3 control pts per curve in addition to the 2 end pts for each curve for a total of 5 pts per edge. length = 3 * ( 3 * numEdge )
numLocs- (IN) number of locations to evaluate per edge
xyz- (IN) xyz locations to evaluate on each edge length = 3 * numLocs
xyzOnEdge- (OUT) locations on edges closest to input points xyz. length = numEdge * 3 * numLocs
tangent- (IN/OUT) evaluated tangent at parmLocation. If NULL then will not be evaluated. Return vector is normalized length = numEdge * 3 * numLocs
t_value- (OUT) value of the parameter at the projected point length = numEdge * numLocs

Definition at line 2325 of file Cholla.cpp.

{
CubitPoint **point_array = new CubitPoint * [numVert];
CubitFacetEdge **edge_array = new CubitFacetEdge * [numEdge];
CubitFacet **facet_array = NULL;
CubitQuadFacet **qfacet_array = NULL;
DLIList<FacetEntity *> facet_list;
int ii, index, numTri, numQuad;
int *triEdge, *quadEdge;
  triEdge = quadEdge = NULL;
  numTri = numQuad = 0;
  CubitStatus stat = CUBIT_SUCCESS;
  stat = build_facets(numTri, numQuad, numEdge, numVert, triEdge, quadEdge, 
                      edgeVert, vert, point_array, edge_array, facet_array,
                      qfacet_array, facet_list);
  if (CUBIT_SUCCESS != stat) {
    PRINT_ERROR("Failed to build facets.\n");
    return;
  }

  // set the control points on edges

  CubitFacetEdge *edge_ptr;
    //CubitVector T0, T1, P0, P1;
    //CubitVector Pi[3];

  for (ii=0; ii<numEdge; ii++)
  {
    edge_ptr = edge_array[ii];
    index = 3 * (ii * NUM_EDGE_CPTS);
    edge_ptr->set_control_points( &(edgeCtrlPts[index]) );
  } 

  // do the projections
  int jj, kk, xyzindex, tindex;
  index = tindex = 0;
  double dsquared, dsquared_test, dderiv, dderiv2, t, t_min = 0.0;
  CubitVector xyz_pt;//, second2142_d;
  t = 0.0;
  dsquared_test =  CUBIT_DBL_MAX;  
  for ( ii = 0; ii < numEdge; ii++ ) {
    edge_ptr = edge_array[ii];
    for ( jj = 0; jj < numLocs; jj++ ) {
      xyzindex = 3*jj;
      xyz_pt.x(xyz[xyzindex]);
      xyz_pt.y(xyz[xyzindex+1]);
      xyz_pt.z(xyz[xyzindex+2]);    
      t = -1.0;
      dsquared_test =  CUBIT_DBL_MAX;  
      //  Get square of distance from xyz to curve at intervals of 0.2
      //  in the parameter t.  Save the closest distance found as a 
      //  starting point for Newton-Raphson iterations.  It was found 
      //  that an interval of 0.5 was too coarse and that the N-R
      //  sometimes converged on a false value.
      CubitVector eval_point;
      CubitVector *eval_point_ptr = &eval_point;
      CubitVector eval_tangent;
      CubitVector *eval_tangent_ptr = &eval_tangent;
      CubitVector second_d;
      CubitVector *second_d_ptr = &second_d;
      for ( kk = 0; kk < 11; kk++ ) {
        edge_ptr->evaluate_single(t,eval_point_ptr);      
        dsquared = ( (xyz_pt.x()-eval_point.x())*(xyz_pt.x()-eval_point.x()) +
                     (xyz_pt.y()-eval_point.y())*(xyz_pt.y()-eval_point.y()) +
                     (xyz_pt.z()-eval_point.z())*(xyz_pt.z()-eval_point.z()) );             
        if ( fabs(dsquared) < fabs(dsquared_test) ) {
          t_min = t;
          dsquared_test = dsquared;
        }      
        t += 0.2;
      }
      double dderiva, dderivb;
      if ( t_min == -1.00 ) {
      //  Check whether the slope changed signs between -1.0 and -0.8.
      //  If so, the min must have occurred in this interval -- set
      //  t_min to -0.9.
        t = -1.0;
        edge_ptr->evaluate_single(t,eval_point_ptr);      
        edge_ptr->evaluate_single_tangent(t,eval_tangent_ptr);      
        dderiva = 2.0*( (eval_point.x()-xyz_pt.x())*eval_tangent.x() +
                       (eval_point.y()-xyz_pt.y())*eval_tangent.y() +
                       (eval_point.z()-xyz_pt.z())*eval_tangent.z() );
        t = -0.8;
        edge_ptr->evaluate_single(t,eval_point_ptr);      
        edge_ptr->evaluate_single_tangent(t,eval_tangent_ptr);      
        dderivb = 2.0*( (eval_point.x()-xyz_pt.x())*eval_tangent.x() +
                       (eval_point.y()-xyz_pt.y())*eval_tangent.y() +
                       (eval_point.z()-xyz_pt.z())*eval_tangent.z() );
        if ( dderiva*dderivb < 0.0 ) t_min = -0.9;
   
      } else if ( t_min == 1.00 ) {
      //  Check the other end of the range, similarly.
        t = 1.0;
        edge_ptr->evaluate_single(t,eval_point_ptr);      
        edge_ptr->evaluate_single_tangent(t,eval_tangent_ptr);      
        dderiva = 2.0*( (eval_point.x()-xyz_pt.x())*eval_tangent.x() +
                        (eval_point.y()-xyz_pt.y())*eval_tangent.y() +
                        (eval_point.z()-xyz_pt.z())*eval_tangent.z() );
        t = 0.8;
        edge_ptr->evaluate_single(t,eval_point_ptr);      
        edge_ptr->evaluate_single_tangent(t,eval_tangent_ptr);      
        dderivb = 2.0*( (eval_point.x()-xyz_pt.x())*eval_tangent.x() +
                        (eval_point.y()-xyz_pt.y())*eval_tangent.y() +
                        (eval_point.z()-xyz_pt.z())*eval_tangent.z() );
        if ( dderiva*dderivb < 0.0 ) t_min = 0.9;  
      }      
      t = t_min;
      if ( (t > -1.0) && (t < 1.0) ) {
        int mm;
        mm = 0;
        while ( mm < 10 ) {  //  to avoid possible infinite loop
          mm++;
          edge_ptr->evaluate_single(t,eval_point_ptr);      
          edge_ptr->evaluate_single_tangent(t,eval_tangent_ptr);      
          dderiv = 2.0*( (eval_point.x()-xyz_pt.x())*eval_tangent.x() +
                         (eval_point.y()-xyz_pt.y())*eval_tangent.y() +
                         (eval_point.z()-xyz_pt.z())*eval_tangent.z() );

          edge_ptr->evaluate_2nd_derivative(t, second_d_ptr);            
  
          dderiv2 = (eval_point.x()-xyz_pt.x())*second_d.x() + 
                     eval_tangent.x()*eval_tangent.x() +
                    (eval_point.y()-xyz_pt.y())*second_d.y() + 
                     eval_tangent.y()*eval_tangent.y() +
                    (eval_point.z()-xyz_pt.z())*second_d.z() + 
                     eval_tangent.z()*eval_tangent.z();

           t = t - dderiv/dderiv2; // Newton-Raphson

           if ( t < -1.0 ) {
             t = -1.0;
             edge_ptr->evaluate_single(t,eval_point_ptr);      
             edge_ptr->evaluate_single_tangent(t,eval_tangent_ptr);      
             break;
           }
           if ( t > 1.0 ) {
             t = 1.0;
             edge_ptr->evaluate_single(t,eval_point_ptr);      
             edge_ptr->evaluate_single_tangent(t,eval_tangent_ptr);      
             break;
           }
           if ( fabs(dderiv) < 1.e-11 ) break;
        }
      } else {  //  At an endpoint of the paramaterization.
          edge_ptr->evaluate_single(t,eval_point_ptr);       
          edge_ptr->evaluate_single_tangent(t,eval_tangent_ptr);      
      }      
      xyzOnEdge[index++] = eval_point.x();
      xyzOnEdge[index++] = eval_point.y();
      xyzOnEdge[index++] = eval_point.z();
      if ( tangent != NULL ) {  
        eval_tangent.normalize(); 
        tangent[tindex++] = eval_tangent.x();
        tangent[tindex++] = eval_tangent.y();
        tangent[tindex++] = eval_tangent.z();             
      }      
    }  
  } 
   
  *t_value = t;
  
  //  delete the temp arrays

  for (ii=0; ii<numEdge; ii++)
    delete edge_array[ii];
  for (ii=0; ii<numVert; ii++)
    delete point_array[ii];
  delete [] point_array;
  delete [] edge_array;

}
void projToBezierEdgeFromTans ( int  numEdge,
int  numVert,
int *  edgeVert,
double *  vert,
double *  edgeVertTang,
int  numLocs,
double *  xyz,
double *  xyzOnEdge,
double *  tangent 
)

Project to a quartic Bezier curve at a specified parametric location given its tangents at the end-points. Evaluates location, and/or tangent. Finds only one point; in rare cases, more than one closest point might exist.

Parameters:
numEdge- (IN) number of edges on the faces
numVert- (IN) number of vertices
edgeVert- (IN) array of edge to vertex indecies (into vert) length 2 * numEdge
vert- (IN) array of vertex locations length = 3 * NumVerts
edgeVertTang- (IN) array of tangents at the edge vertices length 3*(2*numEdge)
numLocs- (IN) number of locations to evaluate per edge
xyz- (IN) xyz locations to project to each edge length = 3 * numLocs
xyzOnEdge- (OUT) locations on edges closest to input points xyz. length = numEdge * 3 * numLocs
tangent- (IN/OUT) evaluated tangent at parmLocation. If NULL then will not be evaluated. Return vector is normalized length = numEdge * 3 * numLocs

Definition at line 2131 of file Cholla.cpp.

{
CubitPoint **point_array = new CubitPoint * [numVert];
CubitFacetEdge **edge_array = new CubitFacetEdge * [numEdge];
CubitFacet **facet_array = NULL;
CubitQuadFacet **qfacet_array = NULL;
DLIList<FacetEntity *> facet_list;
int ii, index, numTri, numQuad;
int *triEdge, *quadEdge;
  triEdge = quadEdge = NULL;
  numTri = numQuad = 0;
  CubitStatus stat = CUBIT_SUCCESS;
  stat = build_facets(numTri, numQuad, numEdge, numVert, triEdge, quadEdge, 
                      edgeVert, vert, point_array, edge_array, facet_array,
                      qfacet_array, facet_list);
  if (CUBIT_SUCCESS != stat) {
    PRINT_ERROR("Failed to build facets.\n");
    return;
  }

  // set the control points on edges

  CubitFacetEdge *edge_ptr;
  CubitVector T0, T1, P0, P1;
  CubitVector Pi[3];
  CubitPoint *pt0, *pt1;
  for (ii=0; ii<numEdge; ii++)
  {
    index = 6 * ii;
    edge_ptr = edge_array[ii];
    pt0 = edge_ptr->point(0);
    pt1 = edge_ptr->point(1);
    P0 = pt0->coordinates();
    P1 = pt1->coordinates();
    T0.x( edgeVertTang[ index ] );
    T0.y( edgeVertTang[ index + 1] );
    T0.z( edgeVertTang[ index + 2] );
    T1.x( edgeVertTang[ index + 3] );
    T1.y( edgeVertTang[ index + 4] );
    T1.z( edgeVertTang[ index + 5] );
    FacetEvalTool::init_edge_control_points_single(P0, P1, T0, T1, Pi);

    edge_ptr->control_points( Pi, 4 );
  } 

  // do the projections
  int jj, kk, xyzindex, tindex;
  index = tindex = 0;
  double dsquared, dsquared_test, dderiv, dderiv2, t, t_min = 0.0;
  CubitVector xyz_pt;//, second_d;
  t = 0.0;
  dsquared_test =  CUBIT_DBL_MAX;  
  for ( ii = 0; ii < numEdge; ii++ ) {
    edge_ptr = edge_array[ii];
    for ( jj = 0; jj < numLocs; jj++ ) {
      xyzindex = 3*jj;
      xyz_pt.x(xyz[xyzindex]);
      xyz_pt.y(xyz[xyzindex+1]);
      xyz_pt.z(xyz[xyzindex+2]);    
      t = -1.0;
      dsquared_test =  CUBIT_DBL_MAX;  
      //  Get square of distance from xyz to curve at intervals of 0.2
      //  in the parameter t.  Save the closest distance found as a 
      //  starting point for Newton-Raphson iterations.  It was found 
      //  that an interval of 0.5 was too coarse and that the N-R
      //  sometimes converged on a false value.
      CubitVector eval_point;
      CubitVector *eval_point_ptr = &eval_point;
      CubitVector eval_tangent;
      CubitVector *eval_tangent_ptr = &eval_tangent;
      CubitVector second_d;
      CubitVector *second_d_ptr = &second_d;
      for ( kk = 0; kk < 11; kk++ ) {
        edge_ptr->evaluate_single(t,eval_point_ptr);      
        dsquared = ( (xyz_pt.x()-eval_point.x())*(xyz_pt.x()-eval_point.x()) +
                     (xyz_pt.y()-eval_point.y())*(xyz_pt.y()-eval_point.y()) +
                     (xyz_pt.z()-eval_point.z())*(xyz_pt.z()-eval_point.z()) );             
        if ( fabs(dsquared) < fabs(dsquared_test) ) {
          t_min = t;
          dsquared_test = dsquared;
        }      
        t += 0.2;
      }
      double dderiva, dderivb;
      if ( t_min == -1.00 ) {
      //  Check whether the slope changed signs between -1.0 and -0.8.
      //  If so, the min must have occurred in this interval -- set
      //  t_min to -0.9.
        t = -1.0;
        edge_ptr->evaluate_single(t,eval_point_ptr);      
        edge_ptr->evaluate_single_tangent(t,eval_tangent_ptr);      
        dderiva = 2.0*( (eval_point.x()-xyz_pt.x())*eval_tangent.x() +
                       (eval_point.y()-xyz_pt.y())*eval_tangent.y() +
                       (eval_point.z()-xyz_pt.z())*eval_tangent.z() );
        t = -0.8;
        edge_ptr->evaluate_single(t,eval_point_ptr);      
        edge_ptr->evaluate_single_tangent(t,eval_tangent_ptr);      
        dderivb = 2.0*( (eval_point.x()-xyz_pt.x())*eval_tangent.x() +
                       (eval_point.y()-xyz_pt.y())*eval_tangent.y() +
                       (eval_point.z()-xyz_pt.z())*eval_tangent.z() );
        if ( dderiva*dderivb < 0.0 ) t_min = -0.9;
   
      } else if ( t_min == 1.00 ) {
      //  Check the other end of the range, similarly.
        t = 1.0;
        edge_ptr->evaluate_single(t,eval_point_ptr);      
        edge_ptr->evaluate_single_tangent(t,eval_tangent_ptr);      
        dderiva = 2.0*( (eval_point.x()-xyz_pt.x())*eval_tangent.x() +
                        (eval_point.y()-xyz_pt.y())*eval_tangent.y() +
                        (eval_point.z()-xyz_pt.z())*eval_tangent.z() );
        t = 0.8;
        edge_ptr->evaluate_single(t,eval_point_ptr);      
        edge_ptr->evaluate_single_tangent(t,eval_tangent_ptr);      
        dderivb = 2.0*( (eval_point.x()-xyz_pt.x())*eval_tangent.x() +
                        (eval_point.y()-xyz_pt.y())*eval_tangent.y() +
                        (eval_point.z()-xyz_pt.z())*eval_tangent.z() );
        if ( dderiva*dderivb < 0.0 ) t_min = 0.9;  
      }      
      t = t_min;
      if ( (t > -1.0) && (t < 1.0) ) {
        int mm;
        mm = 0;
        while ( mm < 10 ) {  //  to avoid possible infinite loop
          mm++;
          edge_ptr->evaluate_single(t,eval_point_ptr);      
          edge_ptr->evaluate_single_tangent(t,eval_tangent_ptr);      
          dderiv = 2.0*( (eval_point.x()-xyz_pt.x())*eval_tangent.x() +
                         (eval_point.y()-xyz_pt.y())*eval_tangent.y() +
                         (eval_point.z()-xyz_pt.z())*eval_tangent.z() );

          edge_ptr->evaluate_2nd_derivative(t, second_d_ptr);            
  
          dderiv2 = (eval_point.x()-xyz_pt.x())*second_d.x() + 
                     eval_tangent.x()*eval_tangent.x() +
                    (eval_point.y()-xyz_pt.y())*second_d.y() + 
                     eval_tangent.y()*eval_tangent.y() +
                    (eval_point.z()-xyz_pt.z())*second_d.z() + 
                     eval_tangent.z()*eval_tangent.z();

           t = t - dderiv/dderiv2; // Newton-Raphson

           if ( t < -1.0 ) {
             t = -1.0;
             edge_ptr->evaluate_single(t,eval_point_ptr);      
             edge_ptr->evaluate_single_tangent(t,eval_tangent_ptr);      
             break;
           }
           if ( t > 1.0 ) {
             t = 1.0;
             edge_ptr->evaluate_single(t,eval_point_ptr);      
             edge_ptr->evaluate_single_tangent(t,eval_tangent_ptr);      
             break;
           }
           if ( fabs(dderiv) < 1.e-11 ) break;
        }
      } else {  //  At an endpoint of the paramaterization.
          edge_ptr->evaluate_single(t,eval_point_ptr);       
          edge_ptr->evaluate_single_tangent(t,eval_tangent_ptr);      
      }      
      xyzOnEdge[index++] = eval_point.x();
      xyzOnEdge[index++] = eval_point.y();
      xyzOnEdge[index++] = eval_point.z();
      if ( tangent != NULL ) {  
        eval_tangent.normalize(); 
        tangent[tindex++] = eval_tangent.x();
        tangent[tindex++] = eval_tangent.y();
        tangent[tindex++] = eval_tangent.z();             
      }      
    }  
  }  

  //  delete the temp arrays

  for (ii=0; ii<numEdge; ii++)
    delete edge_array[ii];
  for (ii=0; ii<numVert; ii++)
    delete point_array[ii];
  delete [] point_array;
  delete [] edge_array;

}
void projToBezierFace ( int  numFace,
int  numEdge,
int  numVert,
int  numVertPerFace,
int *  faceEdge,
int *  edgeVert,
double *  vert,
double *  faceCtrlPts,
double *  edgeCtrlPts,
int  numLocs,
double *  xyz,
int  specify_tol,
double  converge_tol,
double *  xyzOnFace,
double *  normal,
double *  deriv 
)

Project a set of x-y-z locations to Bezier patches. Finds the closest point on one of the patches. Evaluates location, normal and/or derivative. Expects list of either quads or tris (not both)

Parameters:
numFace- (IN) number of faces to evaluate
numEdge- (IN) number of edges on the faces
numVert- (IN) number of vertices
numVertPerFace-(IN) has value of of 3 or 4, for tris or quads
faceEdge- (IN) array of face to edge indecies (into edgeVert) length numVertPerFace * numFace
edgeVert- (IN) array of edge to vertex indecies (into vert) length 2 * numEdge
vert- (IN) array of vertex locations length 3 * numVert
faceCtrlPts- (IN) array of control points for the faces (same order as faceEdge) if (numFacePerVert == 3) ncp = 6 if (numFacePerVert == 4) ncp = 15 length = 3 * (ncp * numFace)
edgeCtrlPts- (IN) array of control points for the edges (same order as edgeVert array) length 3 * (3 * numEdge)
numLocs- (IN) number of locations to evaluate per face
xyz- (IN) xyz locations to evaluate on each face length = 3 * numLocs
specify_tol- (IN) 1 = a converge_tol is specified, 0 = a converge_tol is not specified. A default tol will be computed and used.
converge_tol- (IN) The convergance tolerance for this projection. Will be ignored if specify_tol == 0
xyzOnFace- (OUT) locations on patches closest to input points xyz. length = 3 * numLocs
normal- (IN/OUT) evaluated normals at xyz. If NULL then will not be evaluated. Return vector is normalized length = 3 * numLocs
deriv- (IN/OUT) evaluated derivatives at xyz with respect to uv or uvw system. If NULL then will not be evaluated. if (numFacePerVert == 3) length = numLocs * 3*3 (du/dx,du/dy,du/dz, dv/dx,dv/dy,dv/dz, dw/dx,dw/dz,dw/dz) if (numFacePerVert == 4) length = numLocs * 3*2 (du/dx,du/dy,du/dz, dv/dx,dv/dy,dv/dz)

Definition at line 1048 of file Cholla.cpp.

{
    // create arrays of facet entities from the arrays

  int numTri = 0;
  int numQuad = 0;
  CubitPoint **point_array = new CubitPoint * [numVert];
  CubitFacetEdge **edge_array = new CubitFacetEdge * [numEdge];
  CubitFacet **facet_array = NULL;
  int *tri_edge = (numVertPerFace == 3) ? faceEdge : NULL;
  int *quad_edge = (numVertPerFace == 4) ? faceEdge : NULL;
  if (numVertPerFace == 3)
  {
    facet_array = new CubitFacet * [numFace];
    numTri = numFace;
  }
  CubitQuadFacet **qfacet_array = NULL;
  if (numVertPerFace == 4)
  {
    qfacet_array = new CubitQuadFacet * [numFace];
    numQuad = numFace;
  }
  DLIList<FacetEntity *> facetentity_list;
  CubitStatus stat = CUBIT_SUCCESS;
  stat = build_facets(numTri, numQuad, numEdge, numVert, quad_edge, tri_edge, 
                      edgeVert, vert, point_array, edge_array, facet_array,
                      qfacet_array, facetentity_list);
  if (CUBIT_SUCCESS != stat) {
    PRINT_ERROR("Failed to build facets.\n");
    return;
  }
  DLIList<CubitFacet *> facet_list;
  CAST_LIST(facetentity_list, facet_list, CubitFacet);

  // set the control points on edges

  double edgelen;
  double compare_tol = 0.0;
  int index, ii;
  CubitFacetEdge *edge_ptr;
  for (ii=0; ii<numEdge; ii++)
  {
    edge_ptr = edge_array[ii];
    index = 3 * (ii * NUM_EDGE_CPTS);
    edge_ptr->set_control_points( &(edgeCtrlPts[index]) );
    if ( !specify_tol )
    {
        edgelen = edge_ptr->length();
        compare_tol += edgelen; 
    }
  }
  if ( specify_tol )
  {
      compare_tol = converge_tol;
  }
  else
  {
      compare_tol /= numEdge;
      compare_tol *= 1.0e-3;
  }

  // set the control points on triangles

  CubitFacet *facet_ptr;
  for (ii=0; ii<numTri; ii++)
  {
    facet_ptr = facet_array[ii];
    index = 3 * (ii * NUM_TRI_CPTS); 
    facet_ptr->set_control_points( &(faceCtrlPts[index]) );
  }

  // set the control points on quads

  CubitQuadFacet *qfacet_ptr;
  for (ii=0; ii<numQuad; ii++)
  {
    qfacet_ptr = qfacet_array[ii];
    index = 3 * (ii * NUM_QUAD_CPTS);
    qfacet_ptr->set_control_points( &(faceCtrlPts[index]) );
  }

  // Do the projections

  CubitFacet *last_facet = NULL;
  int interp_order = 4;
  CubitBoolean trim = CUBIT_TRUE;
  CubitBoolean outside;
  for (ii=0; ii<numLocs; ii++)
  {
    CubitVector cur_location(xyz[ii*3],
                             xyz[ii*3+1],
                             xyz[ii*3+2]);
    CubitVector eval_point;
    CubitVector *eval_point_ptr = &eval_point;
    CubitVector eval_normal;
    CubitVector *eval_normal_ptr = NULL;
    if (normal != NULL)
    {
      eval_normal_ptr = &eval_normal;
    }
    FacetEvalTool::project_to_facets(facet_list, last_facet,
                                     interp_order, compare_tol,
                                     cur_location, trim,
                                     &outside, eval_point_ptr,
                                     eval_normal_ptr);
    index = 3 * ii;
    xyzOnFace[index] = eval_point.x();
    xyzOnFace[index+1] = eval_point.y();
    xyzOnFace[index+2] = eval_point.z();
    if (normal != NULL)
    {
      normal[index] = eval_normal.x();
      normal[index+1] = eval_normal.y();
      normal[index+2] = eval_normal.z();
    }
  }

  // no derivatives yet!!

  
  // delete the temp arrays

  for (ii=0; ii<numQuad; ii++)
    delete qfacet_array[ii];
  for (ii=0; ii<numTri; ii++)
    delete facet_array[ii];
  for (ii=0; ii<numEdge; ii++)
    delete edge_array[ii];
  for (ii=0; ii<numVert; ii++)
    delete point_array[ii];
  delete [] point_array;
  delete [] edge_array;
  if (facet_array)
    delete [] facet_array; 
  if (qfacet_array)
    delete [] qfacet_array; 
}
void projToBezierFaceFromNorms ( int  numFace,
int  numEdge,
int  numVert,
int  numVertPerFace,
int *  faceEdge,
int *  edgeVert,
double *  vert,
double *  vertNorms,
double *  edgeVertTang,
int  numLocs,
double *  xyz,
int  specify_tol,
double  converge_tol,
double *  xyzOnFace,
double *  normal,
double *  deriv 
)

This is the same as the projToBezierFace except it differes by the input arguments. This function takes a list of normals and tangents at the face vertices and computes bezier control points internally. Normals and tangents should have been computed previously in constructTriNormals or constructQuadNormals. This function is not as computationally efficient as evalBezierFace since it requires Bezier control points to be computed as part of the call - however, it is more memory efficient, requiring fewer variables to be stored with the calling application. The following argument list describes only those arguments that differ from projToBezierFace above.

Parameters:
vertNorms- (IN) array of normals at the face vertices length 3*(numVertPerFace*numFace)
edgeVertTang- (OUT) array of tangents at the edge vertices length 3*(2*numEdge)

Definition at line 1208 of file Cholla.cpp.

{
      // create arrays of facet entities from the arrays

  int numTri = 0;
  int numQuad = 0;
  CubitPoint **point_array = new CubitPoint * [numVert];
  CubitFacetEdge **edge_array = new CubitFacetEdge * [numEdge];
  CubitFacet **facet_array = NULL;
  int *triEdge = (numVertPerFace == 3) ? faceEdge : NULL;
  int *quadEdge = (numVertPerFace == 4) ? faceEdge : NULL;
  if (numVertPerFace == 3)
  {
    facet_array = new CubitFacet * [numFace];
    numTri = numFace;
  }
  CubitQuadFacet **qfacet_array = NULL;
  if (numVertPerFace == 4)
  {
    qfacet_array = new CubitQuadFacet * [numFace];
    numQuad = numFace;
  }
  DLIList<FacetEntity *> facetentity_list;
  CubitStatus stat = CUBIT_SUCCESS;
  stat = build_facets(numTri, numQuad, numEdge, numVert, triEdge, quadEdge, 
                      edgeVert, vert, point_array, edge_array, facet_array,
                      qfacet_array, facetentity_list);
  if (CUBIT_SUCCESS != stat) {
    PRINT_ERROR("Failed to build facets.\n");
    return;
  }
  DLIList<CubitFacet *> facet_list;
  CAST_LIST(facetentity_list, facet_list, CubitFacet);

  // set the normals on triangle vertices

  int index, ii, jj;
  CubitPoint *pt;
  CubitFacet *facet_ptr;
  CubitVector pt_normal;
  for (ii=0; ii<numTri; ii++)
  {
    facet_ptr = facet_array[ii];
    for(jj=0; jj<3; jj++)
    {
      index = ii * 9 + (3 * jj);
      pt_normal.x( vertNorms[ index ] );
      pt_normal.y( vertNorms[ index + 1 ] );
      pt_normal.z( vertNorms[ index + 2 ] );
      pt = facet_ptr->point(jj);
      TDFacetBoundaryPoint::add_facet_boundary_point( pt, facet_ptr, pt_normal );
    }
  }

  // set the normals on quad vertices

  CubitQuadFacet *qfacet_ptr;
  for (ii=0; ii<numQuad; ii++)
  {
    qfacet_ptr = qfacet_array[ii];
    for(jj=0; jj<4; jj++)
    {
      index = ii * 12 + (3 * jj);
      pt_normal.x( vertNorms[ index ] );
      pt_normal.y( vertNorms[ index + 1 ] );
      pt_normal.z( vertNorms[ index + 2 ] );
      pt = qfacet_ptr->point(jj);
      TDFacetBoundaryPoint::add_facet_boundary_point( pt, qfacet_ptr, pt_normal );
    }
  }

  // set the control points on edges

  double edgelen;
  double compare_tol = 0.0;
  CubitFacetEdge *edge_ptr;
  CubitVector N0, N1, T0, T1, P0, P1;
  CubitVector Pi[3];
  CubitPoint *pt0, *pt1;
  for (ii=0; ii<numEdge; ii++)
  {
    index = 6 * ii;
    edge_ptr = edge_array[ii];
    pt0 = edge_ptr->point(0);
    pt1 = edge_ptr->point(1);
    P0 = pt0->coordinates();
    P1 = pt1->coordinates();
    N0 = pt0->normal( edge_ptr );
    N1 = pt1->normal( edge_ptr );
    T0.x( edgeVertTang[ index ] );
    T0.y( edgeVertTang[ index + 1] );
    T0.z( edgeVertTang[ index + 2] );
    T1.x( edgeVertTang[ index + 3] );
    T1.y( edgeVertTang[ index + 4] );
    T1.z( edgeVertTang[ index + 5] );
    FacetEvalTool::init_edge_control_points(P0, P1, N0, N1, T0, T1, Pi);
    edge_ptr->control_points( Pi, 4 );
    if ( !specify_tol )
    {
        edgelen = edge_ptr->length();
        compare_tol += edgelen; 
    }
  }
  if ( specify_tol )
  {
      compare_tol = converge_tol;
  }
  else
  {
      compare_tol /= numEdge;
      compare_tol *= 1.0e-3;
  }

  // set the control points on triangles

  for (ii=0; ii<numTri; ii++)
  {
    facet_ptr = facet_array[ii];
    facet_ptr->init_patch();
  }

    // set the control points on quads

  for (ii=0; ii<numQuad; ii++)
  {
    qfacet_ptr = qfacet_array[ii];
    qfacet_ptr->init_patch();
  }

    // Do the projections

  CubitFacet *last_facet = NULL;
  int interp_order = 4;
  CubitBoolean trim = CUBIT_TRUE;
  CubitBoolean outside;
  
  for (ii=0; ii<numLocs; ii++)
  {
    CubitVector cur_location(xyz[ii*3],
                             xyz[ii*3+1],
                             xyz[ii*3+2]);
    CubitVector eval_point;
    CubitVector *eval_point_ptr = &eval_point;
    CubitVector eval_normal;
    CubitVector *eval_normal_ptr = NULL;
    if (normal != NULL)
    {
      eval_normal_ptr = &eval_normal;
    }
    FacetEvalTool::project_to_facets(facet_list, last_facet,
                                     interp_order, compare_tol,
                                     cur_location, trim,
                                     &outside, eval_point_ptr,
                                     eval_normal_ptr);
      //double dist = cur_location.distance_between(eval_point);
    index = 3 * ii;
    xyzOnFace[index] = eval_point.x();
    xyzOnFace[index+1] = eval_point.y();
    xyzOnFace[index+2] = eval_point.z();
    if (normal != NULL)
    {
      normal[index] = eval_normal.x();
      normal[index+1] = eval_normal.y();
      normal[index+2] = eval_normal.z();
    }
  }

  // no derivatives yet!!

  // delete the temp arrays

  for (ii=0; ii<numQuad; ii++)
    delete qfacet_array[ii];
  for (ii=0; ii<numTri; ii++)
    delete facet_array[ii];
  for (ii=0; ii<numEdge; ii++)
    delete edge_array[ii];
  for (ii=0; ii<numVert; ii++)
    delete point_array[ii];
  delete [] point_array;
  delete [] edge_array;
  if (facet_array)
    delete [] facet_array; 
  if (qfacet_array)
    delete [] qfacet_array; 
}
CubitStatus readMBGNormalFile ( const char *  filename,
int *  numTri,
int *  numQuad,
int *  numEdge,
int **  edgeVert,
double **  edgeVertTang,
int **  triVert,
double **  triVertNorms,
int **  quadVert,
double **  quadVertNorms 
)

Return normal and tangents for on a list of quad faces a given a file containing the geometric normals and tangents. This returns all of the data in the file rather than just for the specified input elements and edges like constructQuadNormalsFromFile and constructTriNormalsFromFile

Parameters:
filename- (IN) full path and name of the text file containing the geometric surface normals and tangents. This file is output from Cubit when exporting an exodus file.
numTri- (OUT) number of quad faces
numQuad- (OUT) number of quad faces
numEdge- (OUT) number of edges
edgeVert- (OUT) array of vertices on each edge. length 2*numEdge (Must be freed by caller)
edgeVertTang- (OUT) array of tangents at the edge vertices length 3*(2*numEdge) (Must be freed by caller)
TriVert- (OUT) array of vertices on each tri. length 3*numTri
TriVertNorms- (OUT) array of normals at the tri vertices length 3*(4*numTri) (Must be freed by caller)
QuadVert- (OUT) array of vertices on each quad. length 3*numQuad
QuadVertNorms- (OUT) array of normals at the quad vertices length 3*(4*numQuad) (Must be freed by caller)

Definition at line 3065 of file Cholla.cpp.

{
#define MAX_FILE_LINE 512

    int num_t = 0;
    int num_q = 0;
    int curr_quad = 0;
    int curr_tri = 0;
    int num_e = 0;
    int n[4];

    if ( num_tris           ) *num_tris = 0;
    if ( num_quads          ) *num_quads = 0;
    if ( num_edges          ) *num_edges = 0;
    if ( edge_nodes         ) *edge_nodes = NULL;
    if ( edge_node_tangents ) *edge_node_tangents = NULL;
    if ( tri_nodes          ) *tri_nodes = NULL;
    if ( quad_nodes         ) *quad_nodes = NULL;
    if ( tri_node_normals   ) *tri_node_normals = NULL;
    if ( quad_node_normals  ) *quad_node_normals = NULL;

    if ( strlen( filename ) == 0 )
    {
        PRINT_ERROR(" No filename specified\n");
        return CUBIT_FAILURE;
    }

    ifstream geom_file( filename );

    char fileline[MAX_FILE_LINE];

    while ( geom_file.getline( fileline, MAX_FILE_LINE ) )
    {
        int block_id,
            num_corners,
            num_elems;

        if ( !strcmp( fileline, END_OF_BLOCKS ) ) break;
        if ( 3 != sscanf( fileline, "BLK %d %d %d",
                          &block_id, &num_corners, &num_elems ) )
        {
            PRINT_ERROR( "MBG Normal file has incorrect file format\n" );
            geom_file.close();
            return CUBIT_FAILURE;
        }

        if ( num_corners == 3 )
        {
            checkMemoryAllocations( num_corners, num_elems, &num_t, tri_nodes,
                                    tri_node_normals );
        }
        else if ( num_corners == 4 )
        {
            checkMemoryAllocations( num_corners, num_elems, &num_q, quad_nodes,
                                    quad_node_normals );
        }
        else
        {
            PRINT_ERROR( "MBG Normal file can only support quads and tris.\n" );
            geom_file.close();
            return CUBIT_FAILURE;
        }

        for ( int ielem = 0; ielem < num_elems; ielem++ )
        {
            int *this_nodes = NULL;
            double *this_norms = NULL;

            if ( !geom_file.getline( fileline, MAX_FILE_LINE ) )
            {
                PRINT_ERROR( "MBG Normal file has incorrect file format\n" );
                geom_file.close();
                return CUBIT_FAILURE;
            }

            if ( num_corners == 4 )
            {
                if ( quad_nodes        ) this_nodes = &((*quad_nodes       )[4     * curr_quad]);
                if ( quad_node_normals ) this_norms = &((*quad_node_normals)[4 * 3 * curr_quad]);
                curr_quad++;
            }
            else if ( num_corners == 3 )
            {
                if ( tri_nodes        ) this_nodes = &((*tri_nodes       )[3     * curr_tri]);
                if ( tri_node_normals ) this_norms = &((*tri_node_normals)[3 * 3 * curr_tri]);
                curr_tri++;
            }
            if ( ( num_corners == 4 && 4 != sscanf( fileline, "%d %d %d %d",
                                                    &n[0], &n[1], &n[2], &n[3]  ) ) ||
                 ( num_corners == 3 && 3 != sscanf( fileline, "%d %d %d",
                                                    &n[0], &n[1], &n[2] ) ) )
            {
                PRINT_ERROR( "MBG Normal file has incorrect file format\n" );
                geom_file.close();
                return CUBIT_FAILURE;
            }

            if ( this_nodes )
                memcpy( this_nodes, n, num_corners * sizeof( int ) );

            // Read in the surface normals at the vertices of this element.

            for ( int icorner = 0; icorner < num_corners; icorner++ )
            {
                if ( !geom_file.getline( fileline, MAX_FILE_LINE ) )
                {
                    PRINT_ERROR( "MBG Normal file has incorrect file format\n" );
                    geom_file.close();
                    return CUBIT_FAILURE;
                }
                if ( this_norms )
                {
                    double norm[3];

                    if ( 3 != sscanf( fileline, "%lf %lf %lf", &norm[0], &norm[1], &norm[2] ) )
                    {
                        PRINT_ERROR( "MBG Normal file has incorrect file format\n" );
                        geom_file.close();
                        return CUBIT_FAILURE;
                    }
                    memcpy( &(this_norms[icorner * 3]), norm, 3 * sizeof( double ) );
                }
            }
        }
    }

    if ( !geom_file.getline( fileline, MAX_FILE_LINE ) )
    {
        PRINT_ERROR( "MBG Normal file has incorrect file format\n" );
        geom_file.close();
        return CUBIT_FAILURE;
    }

    if ( 1 != sscanf( fileline, "%d", &num_e ) )
    {
        PRINT_ERROR( "MBG Normal file has incorrect file format\n" );
        geom_file.close();
        return CUBIT_FAILURE;
    }

    if ( edge_nodes || edge_node_tangents )
    {
        if ( edge_nodes         ) *edge_nodes         = new int [ 2 * num_e ];
        if ( edge_node_tangents ) *edge_node_tangents = new double [3 * 2 * num_e];

        for ( int iedge = 0; iedge < num_e; iedge++ )
        {
            if ( !geom_file.getline( fileline, MAX_FILE_LINE ) )
            {
                PRINT_ERROR( "MBG Normal file has incorrect file format\n" );
                geom_file.close();
                return CUBIT_FAILURE;
            }
            if ( 2 != sscanf( fileline, "%d %d", &n[0], &n[1] ) )
            {
                PRINT_ERROR( "MBG Normal file has incorrect file format\n" );
                geom_file.close();
                return CUBIT_FAILURE;
            }

            for ( int iend = 0; iend < 2; iend++ )
            {
                double d[3];

                if ( edge_nodes )
                {
                    (*edge_nodes)[iedge * 2 + iend ] = n[iend];
                }

                if ( !geom_file.getline( fileline, MAX_FILE_LINE ) )
                {
                    PRINT_ERROR( "MBG Normal file has incorrect file format\n" );
                    geom_file.close();
                    return CUBIT_FAILURE;
                }
                if ( 3 != sscanf( fileline, "%lf %lf %lf", &d[0], &d[1], &d[2] ) )
                {
                    PRINT_ERROR( "MBG Normal file has incorrect file format\n" );
                    geom_file.close();
                    return CUBIT_FAILURE;
                }

                int index = ((iedge*2) + iend) * 3;
                if ( edge_node_tangents )
                {
                    (*edge_node_tangents)[ index     ] = d[0];
                    (*edge_node_tangents)[ index + 1 ] = d[1];
                    (*edge_node_tangents)[ index + 2 ] = d[2];
                }
            }
        }
    }

    if ( num_quads ) *num_quads = num_q;
    if ( num_tris  ) *num_tris  = num_t;
    if ( num_edges ) *num_edges = num_e;

    geom_file.close();
    return CUBIT_SUCCESS;
}
static void time_stamp ( FILE *  fp) [static]

Definition at line 1918 of file Cholla.cpp.

{
  struct tm *newtime;
  bool am = true;
  time_t long_time;

  time( &long_time );                /* Get time as long integer. */
  newtime = localtime( &long_time ); /* Convert to local time. */

  if( newtime->tm_hour > 12 )        /* Set up extension. */
    am = false;
  if( newtime->tm_hour > 12 )        /* Convert from 24-hour */
          newtime->tm_hour -= 12;    /*   to 12-hour clock.  */
  if( newtime->tm_hour == 0 )        /*Set hour to 12 if midnight. */
          newtime->tm_hour = 12;

  fprintf( fp, "%.19s %s\n", asctime( newtime ), am ? "AM" : "PM" );
}
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines