Changeset 2754 for ddriv

Timestamp:

03/25/09 19:16:24 (12 months ago)

Author:

tautges

Message:

Changes to update to C-based interfaces. All files compile
now except for SmoothUtils?, which needs updates for Mesquite changes.

Location:

ddriv/trunk

Files:

• DdrivDerivs.cpp (modified) (38 diffs)
• DdrivDerivs.hpp (modified) (9 diffs)
• GeomGenerator.cpp (modified) (1 diff)
• Makefile (modified) (3 diffs)
• MkCone.cpp (modified) (13 diffs)
• MkCyl.cpp (modified) (2 diffs)
• MkDDSCell.cpp (modified) (72 diffs)
• MkEllCyl.cpp (modified) (3 diffs)
• MkILCCell.cpp (modified) (17 diffs)
• MkILCEndCell.cpp (modified) (1 diff)
• MkRFSwitch.cpp (modified) (1 diff)
• MkRFSwitchReal.cpp (modified) (69 diffs)
• MkTwoCyls.cpp (modified) (6 diffs)
• MkUser.cpp (modified) (2 diffs)
• O3PXlate.cpp (modified) (5 diffs)
• O3PXlate.hpp (modified) (5 diffs)
• OptUtils.cpp (modified) (9 diffs)
• OptUtils.hpp (modified) (6 diffs)
• SmoothUtils.cpp (modified) (12 diffs)
• SmoothUtils.hpp (modified) (1 diff)
• ddriv.cpp (modified) (1 diff)

ddriv/trunk/DdrivDerivs.cpp

@@ -15 +15 @@
 #include "MsqError.hpp"
 #include "LaplacianIQ.hpp"
-#include "iBase_SNL_SIDL_defs.h"
 
 #include <iostream>
@@ -34 +33 @@
 #define CV_S_INDEX(cv, s) (s*(handle_index_vecs[0].size()+handle_index_vecs[1].size())+cv)
 
-#define CE catch (iBase::Error err) \
-   {std::cerr << "Error msg: " << err.getDescription() << "." << std::endl; return false;}
+#define CE(e) if (ierr != iBase_SUCCESS) {                              \
+      std::cerr << "Error msg: " << e << "." << std::endl; return false;}
 
 #define RS if (!success) return success;
@@ -42 +41 @@
 // and the list of parameter names
 DdrivDerivs::DdrivDerivs(OptUtils &ou, SmoothUtils &su, GeomGenerator *gg) 
-  : myOu(ou), mySu(su), myGeomGenerator(gg), adj_cv_s(NULL), infl_scl_p(NULL), 
-    infl_cv_p(NULL)
+        : myOu(ou), mySu(su), myGeomGenerator(gg), adj_cv_s(NULL), infl_scl_p(NULL), 
+          infl_cv_p(NULL)
 
 {
@@ -89 +88 @@
     // (STEPS 4, 6) GENERATE MODIFIED MODELS
 
-  // su->smoother_driver("T");
+    // su->smoother_driver("T");
     // 1. build the overall topology graph
   success = build_topology_graph(adj_cv_s, handle_index_vecs); RS;
@@ -139 +138 @@
 {
   bool success;
+  int ierr;
 
   if (myDParams.empty()) {
@@ -153 +153 @@
   mySu.my_algorithm(SmoothUtils::DEFORMING);
 
-  // allocate a set for meshsets for use later in restoring vertex coords
-  std::set<iBase_EntityHandle> saved_msets;
+    // allocate a set for meshsets for use later in restoring vertex coords
+  std::set<iBase_EntitySetHandle> saved_msets;
 
   int pmax = myGeomGenerator->num_params();
@@ -165 +165 @@
       
         // a. reset classification data and model
-      myOu.myRelate.removeRelations(&myOu.myGeom, &myOu.myMesh);
+      myOu.reset_relation(true);
       myGeomGenerator->reset_model();
     
@@ -192 +192 @@
                                    
         // c. Relate mesh for those entities
-      try {
-        for (int i = 0; i < 3; i++)
-          myOu.myRelate.relateGeomEntities(&myOu.myGeom, &myOu.myMesh, gents[i], gents_size[i]);
-//        myOu.myRelate.relateAllEntities(&myOu.myGeom, &myOu.myMesh);
+      for (int i = 0; i < 3; i++) {
+        iRel_inferEntArrAssociations(myOu.myRel, myOu.myRelH, &gents[i][0], gents_size[i],
+                                     0, &ierr);
+        CE("Trouble inferring relations for entities.");
       }
-      catch (iBase::Error) {
-        return false;
-      }
     
         // f. smooth 2d geom entities dependent on p
-      success = mySu.smooth(gents[1], gents_size[1]);RS;
-      success = myOu.project_to_geom(gents[0], gents_size[0]);RS;
+      success = mySu.smooth(gents[1]);RS;
+      success = myOu.project_to_geom(&gents[0][0], gents[0].size());RS;
 
       if (debug_output_models) {
@@ -211 +208 @@
 
         char* options;
-        iMesh_save( myOu.myMesh, mfilename, options, &result, strlen(mfilename), 0);
-
-        success = mySu.smooth(gents[2], gents_size[2]);RS;
+        iBase_EntitySetHandle root_set;
+        iMesh_getRootSet(myOu.myMesh, &root_set, &ierr);
+        CE("Couldn't get root set.");
+        
+        iMesh_save( myOu.myMesh, root_set, mfilename.c_str(), options, &ierr, mfilename.length(), 0);
+
+        success = mySu.smooth(gents[2]);RS;
         mfilename = "tmp_mesh_p";
         mfilename += myOu.itoa(p);
         mfilename += "_after.vtk";
-        try {myOu.myMesh.save(0, mfilename);} catch (iBase::Error) {return false;}
+        iMesh_save( myOu.myMesh, root_set, mfilename.c_str(), options, &ierr, mfilename.length(), 0);
       }
       
       else
-        success = mySu.smooth(gents[2], gents_size[2]);RS;
+        success = mySu.smooth(gents[2]);RS;
     }
 
       // g. Compute d(xyz)/dp & store in tag on vertices
-    // h. Compute d(n)/dp for all surf vertices & store in tag on them
+      // h. Compute d(n)/dp for all surf vertices & store in tag on them
     success = store_coords_normals(bogus_derivs,
                                    gents[2], gents_size[2], 2,
@@ -231 +232 @@
                                    myOu.origCoords_tag(), myOu.normal_tag(), myDParams[p]); RS;
 
-    // i. Compute d(n)/dp for all surfs containing curve & vertex mesh vertices & 
-    //    store in tag on them
+      // i. Compute d(n)/dp for all surfs containing curve & vertex mesh vertices & 
+      //    store in tag on them
     success = store_coords_normals(bogus_derivs,
                                    gents[1], gents_size[1], 1,
@@ -246 +247 @@
     for (int i = 0; i < 3; i++) {
       if (0 == gents_size[i]) continue;
-      std::vector<iBase_EntityHandle> tmp_msets;
-      int tmp_msets_size;
-      try {
-        myOu.myRelate.getGeomRelatedEntities(&myOu.myGeom, &myOu.myMesh,
-                                             gents[i], gents_size[i],
-                                             tmp_msets, tmp_msets_size);
-      } CE;
-      iBase_EntityHandle *msets_ptr = ARRAY_PTR(tmp_msets, iBase_EntityHandle);
-      saved_msets.insert(msets_ptr, msets_ptr+tmp_msets_size);
+      iBase_EntitySetHandle *tmp_msets = NULL;
+      int tmp_msets_size, tmp_msets_alloc = 0;
+      iRel_getEntArrSetArrAssociation(myOu.myRel, myOu.myRelH,
+                                      &gents[i][0], gents_size[i], 0,
+                                      &tmp_msets, &tmp_msets_alloc, &tmp_msets_size,
+                                      &ierr);
+      CE("Couldn't get relation.");
+      std::copy(tmp_msets, tmp_msets+tmp_msets_size, 
+                std::inserter(saved_msets, saved_msets.begin()));
     }
   } // for p = ...
   
     // ok, success; reset model, removing classifications too
-  myOu.myRelate.removeRelations(&myOu.myGeom, &myOu.myMesh);
+  myOu.reset_relation(true);
   myGeomGenerator->reset_model();
 
-  // finally, reset coords for the msets whose vertices were moved
+    // finally, reset coords for the msets whose vertices were moved
   if (debug) 
     std::cout << "Resetting coords on " << saved_msets.size() << " msets." << std::endl;
@@ -272 +273 @@
   myGeomGenerator->get_params(new_params);
   success = myGeomGenerator->generate_model(&new_params[0], new_params.size()); RS;
-  myOu.myRelate.relateAllEntities(&myOu.myGeom, &myOu.myMesh);
+  iRel_inferAllAssociations(myOu.myRel, myOu.myRelH, &ierr);
+  CE("Unable to infer all relations.");
 
   if (debug)
@@ -302 +304 @@
                                 iBase_EntitySetHandle& new_set)
 {
-  int err;
-
-    // make a new set
-  CAST_iBase_INTERFACE(myOu.myMesh, mesh_eset, EntSet);
-
-  iMesh_createEntSet( mesh_eset, 1, new_set, &ierr ); 
-  CHKERR;
+  int ierr;
+
+    // make a new mesh entity set
+  iMesh_createEntSet(myOu.myMesh, 1, &new_set, &ierr); 
+  CE("Couldn't make a new set.");
 
     // get all the dim-dimensional entities
@@ -314 +314 @@
   for (std::vector<iBase_EntityHandle>::iterator vit = gents.begin();
        vit != gents.end(); vit++) {
-    std::vector<iBase_EntityHandle> tmp_ments;
-    int tmp_ments_size;
-    myOu.myRelate.getGeomOwnedMesh(&myOu.myGeom, &myOu.myMesh, *vit, 2,
-                                  tmp_ments, tmp_ments_size);
-    append_from_sidl(tmp_ments, tmp_ments_size, set_ments);
+    iBase_EntityHandle *tmp_ments = NULL;
+    int tmp_ments_alloc = 0, tmp_ments_size;
+    iRel_getEntEntArrAssociation(myOu.myRel, myOu.myRelH, *vit, 0,
+                                 &tmp_ments, &tmp_ments_alloc, &tmp_ments_size,
+                                 &ierr);
+    CE("Couldn't get related mesh entities.");
+    std::copy(tmp_ments, tmp_ments+tmp_ments_size, std::back_inserter(set_ments));
+    free(tmp_ments);
   }
   
     // now put them all in the set
-    iMesh_addEntArrToSet( mesh_eset, &set_ments[0], set_ments.size(), 
-                          new_set, &ierr );
-    CHKERR;
-  
-  return true;
-}
-
-//! for surfaces, get mesh vertex coordinates and normals at those vertices, 
-//! compute derivatives if old_xxx_tag is non-zero, then store results in xxx_tag
-//! variant that works on all entities of given dimension
-bool DdrivDerivs::store_coords_normals(const bool bogus_derivs,
-                                       std::vector<iBase_EntityHandle> *handle_index_vecs, 
-                                       const int gent_dim,
-                                       TagHandle coord_tag, TagHandle normal_tag,
-                                       TagHandle old_coord_tag, TagHandle old_normal_tag,
-                                       const double dp) 
-{
-    // do coords & normals on surfaces
-  int gents_size = handle_index_vecs[gent_dim].size();
-  std::vector<iBase_EntityHandle> gents(convert_to_sidl_vector(&handle_index_vecs[gent_dim][0],
-                                                          gents_size));
-
-  return store_coords_normals(bogus_derivs, gents, gents_size, gent_dim, 
-                              coord_tag, normal_tag, old_coord_tag, old_normal_tag,
-                              dp);
+  iMesh_addEntArrToSet(myOu.myMesh, &set_ments[0], set_ments.size(), new_set, 
+                       &ierr );
+  CE("Couldn't add to set.");
+  
+  return true;
 }
 
@@ -356 +339 @@
                                        const int gents_size,
                                        const int gent_dim,
-                                       TagHandle coord_tag, TagHandle normal_tag,
-                                       TagHandle old_coord_tag, TagHandle old_normal_tag,
+                                       iBase_TagHandle coord_tag, iBase_TagHandle normal_tag,
+                                       iBase_TagHandle old_coord_tag, iBase_TagHandle old_normal_tag,
                                        const double dp) 
 {
 
-  int err;
-
-  std::vector<MentitySetHandle> msets;
-  int msets_size;
-  try {
-    myOu.myRelate.getGeomRelatedEntities(&myOu.myGeom, &myOu.myMesh, 
-                                        gents, gents_size, msets, msets_size);
-  } catch (iBase::Error) {return false;}
+  int ierr;
+
+  iBase_EntitySetHandle *msets = NULL;
+  int msets_alloc = 0, msets_size;
+  iRel_getEntArrSetArrAssociation(myOu.myRel, myOu.myRelH,
+                                  &gents[0], gents.size(), 0, &msets, &msets_alloc, &msets_size,
+                                  &ierr);
+  CE("Couldn't get related mesh entity sets.");
   
   for (int g = 0; g < msets_size; g++) {
@@ -383 +366 @@
 
       // grab the geom and mesh entity handles and index right away
-    iBase_EntityHandle this_gent = gents.get(g);
-    iBase_EntityHandle this_ment = msets.get(g);
+    iBase_EntityHandle this_gent = gents[g];
+    iBase_EntitySetHandle this_ment = msets[g];
     assert(0 != this_gent && 0 != this_ment);
     
-    // get the mesh vertices and their coordinates for this gent
-
-    // get mesh vertices in this_mset
+      // get the mesh vertices and their coordinates for this gent
+
+      // get mesh vertices in this_mset
     iBase_EntityHandle *mverts = NULL;
     int mverts_alloc = 0, mverts_size;
     int result;
     iMesh_getEntities(myOu.myMesh, this_ment,
-                      iMesh::EntityType_VERTEX, 
-                      iMesh::EntityTopology_ALL_TOPOLOGIES,
+                      iBase_VERTEX, 
+                      iMesh_ALL_TOPOLOGIES,
                       &mverts, &mverts_alloc, &mverts_size, &result);
 
     if (iBase_SUCCESS != result) {
       char dum_str[256];
-      iMesh_getDescription(myMesh, dum_str, &result, 256);
+      iMesh_getDescription(myOu.myMesh, dum_str, &result, 256);
       std::cerr << "Couldn't get entities in set in reset_coords."
                 << std::endl
@@ -415 +398 @@
     int coords_size, avg_normals_size;
     bool success = myOu.get_coords(mverts, mverts_size,
-                                   coords, coords_size); RS;
+                                   coords); RS;
 
       // allocate space for the avg normals, same size as coords array
-    avg_normals = avg_normals.create1d(coords_size);
-    avg_normals_size = coords_size;
+    avg_normals.resize(coords.size());
     
       // get the connected surfaces
     std::vector<iBase_EntityHandle> all_gsurfs;
-    int all_gsurfs_size;
-    success = myOu.get_connected_surfs(this_gent, gent_dim, all_gsurfs, all_gsurfs_size);
+    success = myOu.get_connected_surfs(this_gent, gent_dim, all_gsurfs);
     if (!success) return success;
 
@@ -452 +433 @@
       if (0 != old_coord_tag)
         compute_vector_difference(mverts, mverts_size,
-                                  coords, coords_size, old_coord_tag, dp);
-
+                                  coords, old_coord_tag, dp);
     }
     
       // now set the coords and normal tags on those vertices
-      iMesh_setDblArrData ( mesh_atag, mverts, mverts_size, coord_tag,
-                            coords, coords_size, &err);
-      CE;
+    iMesh_setDblArrData (myOu.myMesh, mverts, mverts_size, coord_tag,
+                         &coords[0], coords_size, &ierr);
+    CE("Couldn't set coords/normals tag.");
+
+    free(mverts);
   }
   
@@ -469 +451 @@
 //! derivatives and surface normal derivatives
 bool DdrivDerivs::compute_vector_difference(std::vector<iBase_EntityHandle> &mverts, 
+                                            std::vector<double> &new_vec, 
+                                            iBase_TagHandle old_vec_tag,
+                                            const double dp) 
+{
+  return compute_vector_difference(&mverts[0], mverts.size(), new_vec, old_vec_tag, dp);
+}
+
+bool DdrivDerivs::compute_vector_difference(iBase_EntityHandle *mverts, 
                                             const int mverts_size, 
                                             std::vector<double> &new_vec, 
-                                            const int new_vec_size, 
-                                            TagHandle old_vec_tag,
+                                            iBase_TagHandle old_vec_tag,
                                             const double dp) 
 {
-  int err;
+  int ierr;
 
     // given new values and a tag which holds old values, compute the differences and
@@ -483 +472 @@
   
     // get the old values
-  std::vector<char> old_vec;
-  int old_vec_size;
-  CAST_iBase_INTERFACE(myOu.myMesh, mesh_atag, ArrTag);
-  try {
-    mesh_atag.getArrData(mverts, mverts_size, old_vec_tag,
-                         old_vec, old_vec_size);
-  } CE;
-  
-  double *old_vec_ptr = reinterpret_cast<double*>(old_vec._get_ior()->d_firstElement);
-  double *new_vec_ptr = reinterpret_cast<double*>(new_vec._get_ior()->d_firstElement);
+  char *old_vec = NULL;
+  int old_vec_alloc = 0, old_vec_size;
+  iMesh_getArrData(myOu.myMesh, mverts, mverts_size, old_vec_tag,
+                   &old_vec, &old_vec_alloc, &old_vec_size, &ierr);
+  CE("Couldn't get old tag values.");
+  
+  double *old_vec_ptr = reinterpret_cast<double*>(old_vec);
+  double *new_vec_ptr = reinterpret_cast<double*>(&new_vec[0]);
   
   double denom = 1.0 / dp;
@@ -517 +504 @@
   }
   else {
-    for (int i = 0; i < 3*mverts_size; i++) {
-      double deriv = (new_vec.get(i) - old_vec_ptr[i])*denom;
-      new_vec.set(i, deriv);
-    }
-  }
+    for (int i = 0; i < 3*mverts_size; i++)
+      new_vec[i] = (new_vec[i] - old_vec_ptr[i])*denom;
+  }
+
+  free(old_vec);
   
   return true;
@@ -533 +520 @@
 {
   std::vector<iBase_EntityHandle>::iterator handle_index = 
-    std::find(handle_index_vecs[dim].begin(), 
-              handle_index_vecs[dim].end(), this_gent);
+      std::find(handle_index_vecs[dim].begin(), 
+                handle_index_vecs[dim].end(), this_gent);
   
   return (handle_index == handle_index_vecs[dim].end()) ? -1 :
-    (handle_index - handle_index_vecs[dim].begin());
+      (handle_index - handle_index_vecs[dim].begin());
 }
 
@@ -550 +537 @@
                                        std::vector<iBase_EntityHandle> *handle_index_vecs,
                                        std::vector<iBase_EntityHandle> &surf_gents, 
-                                       int &surf_gents_size,
-                                       std::vector<iBase_EntityHandle> &c_gents,
-                                       int &c_gents_size,
-                                       std::vector<iBase_EntityHandle> &v_gents,
-                                       int &v_gents_size,
-                                       const bool cv_too)
-{
-    // get the surfaces
-  std::vector<iBase_EntityHandle> tmp_surfs;
-  std::set<iBase_EntityHandle> tmp_cs, tmp_vs;
-  std::set<iBase_EntityHandle> *tmp_cs_ptr, *tmp_vs_ptr;
-  if (cv_too) {
-    tmp_vs_ptr = &tmp_vs;
-    tmp_cs_ptr = &tmp_cs;
-  }
-  else {
-    tmp_vs_ptr = NULL;
-    tmp_cs_ptr = NULL;
-  }
-  
-  iBase_EntityHandle this_surf;
-
-  bool result = get_influenced_gents(infl_scl_p, handle_index_vecs,
-                                     tmp_surfs, tmp_cs_ptr, tmp_vs_ptr);
-  if (!result) return result;
-
-    // now put them into the surface and curve/vertex sidl arrays
-  surf_gents_size = tmp_surfs.size();
-  surf_gents = surf_gents.create1d(surf_gents_size);
-  for (unsigned int s = 0; s < tmp_surfs.size(); s++)
-    surf_gents.set(s, tmp_surfs[s]);
-
-  if (cv_too) {
-    c_gents_size = tmp_cs.size();
-    c_gents = c_gents.create1d(c_gents_size);
-    v_gents_size = tmp_vs.size();
-    v_gents = v_gents.create1d(v_gents_size);
-  
-    unsigned int v, c;
-    std::set<iBase_EntityHandle>::iterator sit;
-    for (c = 0, sit = tmp_cs.begin(); c < c_gents_size; c++, sit++)
-      c_gents.set(c, *sit);
-    for (v = 0, sit = tmp_vs.begin(); v < v_gents_size; v++, sit++)
-      v_gents.set(v, *sit);
-  }
-  
-  return true;
-}
-
-//! same as other version of this function, but taking STL vectors as args instead
-//! of sidl arrays
-bool DdrivDerivs::get_influenced_gents(const unsigned int *infl_scl_p,
-                                       std::vector<iBase_EntityHandle> *handle_index_vecs,
-                                       std::vector<iBase_EntityHandle> &surf_gents, 
                                        std::set<iBase_EntityHandle> *cs,
                                        std::set<iBase_EntityHandle> *vs)
 {
+  int ierr;
+  
+  std::set<iBase_EntityHandle> *cv_sets[2] = {vs, cs};
   
   for (int s = 0; s < handle_index_vecs[2].size(); s++) {
@@ -616 +552 @@
     if (NULL == cs || NULL == vs) continue;
     
-    // now get adjacent curves/vertices and put them in the set
-    int adj_vs_size, adj_cs_size;
-
-    iBase_EntityHandle *adj_vs = NULL;
-    int adj_vs_alloc = 0;
-    iGeom_getEntAdj(myOu.myGeom, this_surf, ::iBase_VERTEX,
-                    &adj_vs, &adj_vs_alloc, &adj_vs_size, &result);
-
-
-    iBase_EntityHandle *adj_cs = NULL;
-    int adj_cs_alloc = 0;
-    iGeom_getEntAdj(myOu.myGeom, this_surf, ::iBase_VERTEX,
-                    &adj_cs, &adj_cs_alloc, &adj_cs_size, &result);
-
-    
-    for (int nv = 0; nv < adj_vs_size; nv++) vs->insert(adj_vs.get(nv));
-    for (int nc = 0; nc < adj_cs_size; nc++) cs->insert(adj_cs.get(nc));
-  }
-
+      // now get adjacent curves/vertices and put them in the set
+    for (int dim = 0; dim < 2; dim++) {
+      int adj_alloc = 0, adj_size;
+      iBase_EntityHandle *adj = NULL;
+      iGeom_getEntAdj(myOu.myGeom, this_surf, dim,
+                      &adj, &adj_alloc, &adj_size, &ierr);
+      CE("Couldn't get adjacent geometry.");
+
+      std::copy(adj, adj+adj_size, 
+                std::inserter(*cv_sets[dim], cv_sets[dim]->begin()));
+      free(adj);
+    }
+  }
+  
   return true;
 }
@@ -669 +600 @@
       for (int s = 0; s < handle_index_vecs[2].size(); s++) {
         infl_cv_p[CV_P_INDEX(cv, p)] +=
-          adj_cv_s[CV_S_INDEX(cv, s)] * myGeomGenerator->paramSurfInfls[S_P_INDEX(s, p)];
+            adj_cv_s[CV_S_INDEX(cv, s)] * myGeomGenerator->paramSurfInfls[S_P_INDEX(s, p)];
       }
     }
@@ -680 +611 @@
       for (int cv = 0; cv < ncv; cv++) {
         infl_scl_p[S_P_INDEX(s, p)] += 
-          adj_cv_s[CV_S_INDEX(cv, s)] * infl_cv_p[CV_P_INDEX(cv, p)];
+            adj_cv_s[CV_S_INDEX(cv, s)] * infl_cv_p[CV_P_INDEX(cv, p)];
       }
     }
@@ -734 +665 @@
 //! the overall surface-curve/vertex adjacency matrix (stored as unsigned ints)
 bool
- DdrivDerivs::build_topology_graph(unsigned int *&adj_cv_s,
-                                 std::vector<iBase_EntityHandle> *handle_index_vecs) 
-{
+DdrivDerivs::build_topology_graph(unsigned int *&adj_cv_s,
+                                  std::vector<iBase_EntityHandle> *handle_index_vecs) 
+{
+  int ierr;
     // get the handle_index_vecs
   bool success = populate_index_vecs(handle_index_vecs); 
@@ -743 +675 @@
   if (NULL != adj_cv_s) delete [] adj_cv_s;
   int adj_cv_s_size = handle_index_vecs[2].size() * (handle_index_vecs[0].size() + 
-                                            handle_index_vecs[1].size());
+                                                     handle_index_vecs[1].size());
   adj_cv_s = new unsigned int [adj_cv_s_size];
   for (int i = 0; i < adj_cv_s_size; i++) adj_cv_s[i] = 0;
@@ -751 +683 @@
   for (int s = 0; s < handle_index_vecs[2].size(); s++) {
     
-    //   - get handle & adjacent entities
+      //   - get handle & adjacent entities
     iBase_EntityHandle this_surf = handle_index_vecs[2][s];
 
@@ -757 +689 @@
     int rowstart = 0;
     for (int dim = 0; dim < 2; dim++) {
-         int adj_gents_size;
-
-
-         iBase_EntityHandle *adj_gents = NULL;
-         int adj_vs_alloc = 0;
-         iGeom_getEntAdj(myOu.myGeom, this_surf, (::int)dim,
-                         &adj_gents, &adj_gents_alloc, 
-                         &adj_gents_size, &result);
-
+      iBase_EntityHandle *adj_gents = NULL;
+      int adj_gents_alloc = 0, adj_gents_size;
+      iGeom_getEntAdj(myOu.myGeom, this_surf, dim,
+                      &adj_gents, &adj_gents_alloc, &adj_gents_size, 
+                      &ierr);
+      CE("Couldn't get adj geometry entities.");
 
       for (int ag = 0; ag < adj_gents_size; ag++) {
-           const int adj_index
-             = get_gent_index(adj_gents[ag], handle_index_vecs, dim);
-           assert(adj_index < handle_index_vecs[dim].size());
-           adj_cv_s[CV_S_INDEX(rowstart+adj_index, s)] = 1;
+        const int adj_index
+            = get_gent_index(adj_gents[ag], handle_index_vecs, dim);
+        assert(adj_index < handle_index_vecs[dim].size());
+        adj_cv_s[CV_S_INDEX(rowstart+adj_index, s)] = 1;
       }
 
       rowstart += handle_index_vecs[0].size();
+
+      free(adj_gents);
     }
   }
@@ -787 +718 @@
 
 bool
- DdrivDerivs::assign_indices(std::map<int, gent_data*> *id_gentdata_map, 
-                           std::vector<iBase_EntityHandle> *handle_index_vecs, 
-                           std::vector<int> *id_index_vecs,
-                           int *num_indices) 
+DdrivDerivs::assign_indices(std::map<int, gent_data*> *id_gentdata_map, 
+                            std::vector<iBase_EntityHandle> *handle_index_vecs, 
+                            std::vector<int> *id_index_vecs,
+                            int *num_indices) 
 {
 
     // loop over dimension/id map, assigning indexes
     // also generate two vectors, for handle[index] and global_id[index]
-    for (int dim = 0; dim < 3; dim++) {
-
-         int tot_indices = 0;
-         std::map<int, gent_data*>::iterator mit = (id_gentdata_map[dim]).begin(); 
-         for ( ; mit != (id_gentdata_map[dim]).end(); mit++) {
-              gent_data *ged = (*mit).second;
-              ged->index = tot_indices;
-              handle_index_vecs[dim].push_back(ged->gent);
-              id_index_vecs[dim].push_back(ged->gid);
-              tot_indices++;
-         }
-         num_indices[dim] = tot_indices;
-    }
-
-    return true;
+  for (int dim = 0; dim < 3; dim++) {
+
+    int tot_indices = 0;
+    std::map<int, gent_data*>::iterator mit = (id_gentdata_map[dim]).begin(); 
+    for ( ; mit != (id_gentdata_map[dim]).end(); mit++) {
+      gent_data *ged = (*mit).second;
+      ged->index = tot_indices;
+      handle_index_vecs[dim].push_back(ged->gent);
+      id_index_vecs[dim].push_back(ged->gid);
+      tot_indices++;
+    }
+    num_indices[dim] = tot_indices;
+  }
+
+  return true;
 }
 
@@ -817 +748 @@
 bool DdrivDerivs::init_tags() 
 {
-  CAST_iBase_INTERFACE(myOu.myMesh, mesh_tag_iface, Tag);
-
   dcoordsdpTag.clear();
   dnormaldpTag.clear();
   for (int i = 0; i < myGeomGenerator->num_params(); i++) {
     std::string tmp_name = std::string("DCOORDS_DP_") + 
-      std::string(myGeomGenerator->get_param_name(i));
-    dcoordsdpTag.push_back(get_tag_handle(mesh_tag_iface, 
+        std::string(myGeomGenerator->get_param_name(i));
+    dcoordsdpTag.push_back(get_tag_handle(myOu.myMesh,
                                           tmp_name.c_str(), 3,
-                                          ::iBase_DOUBLE));
+                                          iBase_DOUBLE));
     
     tmp_name = std::string("DNORMAL_DP_") +
-               std::string(myGeomGenerator->get_param_name(i));
-    dnormaldpTag.push_back(get_tag_handle(mesh_tag_iface, 
+        std::string(myGeomGenerator->get_param_name(i));
+    dnormaldpTag.push_back(get_tag_handle(myOu.myMesh,
                                           tmp_name.c_str(), 3,
-                                          ::iBase_DOUBLE));
+                                          iBase_DOUBLE));
   }
   
@@ -839 +768 @@
 
 //! retrieves or creates a tag handle given the tag's description
+iBase_TagHandle DdrivDerivs::get_tag_handle(iMesh_Instance &iface, 
+                                            const char *tag_name, 
+                                            const int tag_size, 
+                                            const iBase_TagValueType tag_type) 
+{
+  iBase_TagHandle return_tag = 0;
+
+  int ierr;
+  iMesh_createTag(iface, 
+                  tag_name, tag_size, tag_type, 
+                  &return_tag, &ierr,
+                  strlen(tag_name));
+  if (iBase_SUCCESS != ierr && iBase_TAG_ALREADY_EXISTS) {
+    CE("Trouble creating tag.");
+  }
+  
+  return return_tag;
+}
+
 void
- *DdrivDerivs::get_tag_handle(::iBase::Tag &iface, 
-                              const char *tag_name, 
-                              const int tag_size, 
-                              const ::iBase::TagValueType tag_type) 
-{
-     void *return_tag = 0;
-
-     iBase_TagHandle th;
-     iMesh_createTag(iface, 
-                     tag_name, 
-                     tag_size, 
-                     tag_type, 
-                     &th, 
-                     &result,
-                     strlen(tag_name));
-    }
-
-    if (iBase_SUCCESS != result) {
-      std::cerr << "Error creating/accessing tag: " << tag_name << std::endl;
-      return 0;
-    }
-
-    return return_tag;
-}
-
-void
- DdrivDerivs::print_adj_graph(const unsigned int *adj_cv_s, 
-                            std::vector<iBase_EntityHandle> *handle_index_vecs) 
+DdrivDerivs::print_adj_graph(const unsigned int *adj_cv_s, 
+                             std::vector<iBase_EntityHandle> *handle_index_vecs) 
 {
   std::cout << std::endl;
@@ -893 +815 @@
 {
 
-  iBase::ArrTag tag_iface = (iBase::ArrTag)(myOu.myMesh);
-
   std::vector<iBase_EntityHandle> handle_index_vecs[4];
 
+  int ierr;
+
   bool success = populate_index_vecs(handle_index_vecs); RS;
     
-        // Get all surfaces which depend on p and all children 
-        //    of those surfaces
+    // Get all surfaces which depend on p and all children 
+    //    of those surfaces
   std::vector<iBase_EntityHandle> surf_gents;
   std::set<iBase_EntityHandle> v_gents, c_gents;
   success = get_influenced_gents(&infl_scl_p[S_P_INDEX(0, param_index)], 
-                                 handle_index_vecs, surf_gents, 
-                                 &c_gents, &v_gents); RS;
-
-  // put all the curves/verts onto the end of the surf list
+                                 handle_index_vecs, surf_gents, 
+                                 &c_gents, &v_gents); RS;
+
+    // put all the curves/verts onto the end of the surf list
   std::copy(c_gents.begin(), c_gents.end(), std::back_inserter(surf_gents));
   std::copy(v_gents.begin(), v_gents.end(), std::back_inserter(surf_gents));
 
-  // for each gent
+    // for each gent
   for (int s = 0; s < surf_gents.size(); s++) {
     
-  // - get all vertices on entity
-    std::vector<iBase_EntityHandle> mverts;
+      // - get all vertices on entity
+    iBase_EntityHandle *mverts = NULL;
     int mverts_size;
     success = myOu.get_gentity_mvertices(surf_gents[s], mverts, mverts_size);
@@ -923 +845 @@
     }
 
-  // - append vertices to list
-    std::copy(ARRAY_PTR(mverts, iBase_EntityHandle),
-              ARRAY_PTR(mverts, iBase_EntityHandle)+mverts_size, 
-              std::back_inserter(vertices));
-
-  // - get tag for that parameter
-    TagHandle param_tag = dcoordsdpTag[param_index];
-
-
-
-    iBase_EntityHandle *mverts = NULL;
-    int mverts_alloc = 0, mverts_size;
-    double *params = NULL;
-    int params_alloc = 0, params_size;
-
-    iMesh_getDblArrData(myOu.myMesh, mverts, mverts_size, 
-                        param_tag, &params, &params_alloc, 
-                        &params_size, &result);
-
-    if (iBase_SUCCESS != result) {
-        char dum_str[256];
-        iMesh_getDescription(myMesh, dum_str, &result, 256);
-        std::cerr << "Couldn't get coordinates tag on mvertices 
-                      in store_cv_coords_normals."
-                  << std::endl
-                  << dum_str << std::endl;
-        return false;
-    }
-
-
-    
-  // - append to list
-    std::copy(ARRAY_PTR(params, double), ARRAY_PTR(params, double)+params_size,
-              std::back_inserter(vertex_DV));
-  }
+      // - append vertices to list
+    std::copy(mverts, mverts+mverts_size, std::back_inserter(vertices));
+
+    free(mverts);
+  }
+  
+    // - get tag for that parameter
+  iBase_TagHandle param_tag = dcoordsdpTag[param_index];
+
+  double *params = NULL;
+  int params_alloc = 0, params_size;
+
+  iMesh_getDblArrData(myOu.myMesh, &vertices[0], vertices.size(),
+                      param_tag, &params, &params_alloc, &params_size, 
+                      &ierr);
+  if (iBase_SUCCESS != ierr) {
+    char dum_str[256];
+    iMesh_getDescription(myOu.myMesh, dum_str, &ierr, 256);
+    std::cerr << "Couldn't get coordinates tag on mvertices"
+              << " in store_cv_coords_normals."
+              << std::endl
+              << dum_str << std::endl;
+    return false;
+  }
+    
+    // - append to list
+  std::copy(params, params+params_size, std::back_inserter(vertex_DV));
+  free(params);
 
   return true;
@@ -965 +880 @@
                                 double &integrated_dv) 
 {
-  iBase::ArrTag tag_iface = (iBase::ArrTag)(myOu.myMesh);
-  CAST_iMesh_INTERFACE(myOu.myMesh, mesh_ent, Entity);
-  
   std::vector<iBase_EntityHandle> handle_index_vecs[4];
   bool success = populate_index_vecs(handle_index_vecs); RS;
     
-        // Get all surfaces which depend on p and all children 
-        //    of those surfaces
+    // Get all surfaces which depend on p and all children 
+    //    of those surfaces
   std::vector<iBase_EntityHandle> surf_gents;
   std::set<iBase_EntityHandle> v_gents, c_gents;
   success = get_influenced_gents(&infl_scl_p[S_P_INDEX(0, param_index)], 
-                                 handle_index_vecs, surf_gents, 
-                                 NULL, NULL); RS;
+                                 handle_index_vecs, surf_gents, 
+                                 NULL, NULL); RS;
 
     // get the entity sets corresponding to those
-  std::vector<MentitySetHandle> msets;
-  int msets_size;
-  std::vector<iBase_EntityHandle> surf_gents_sidl 
-        = convert_to_sidl_vector(surf_gents);
-  try {
-    myOu.myRelate.getGeomRelatedEntities(&myOu.myGeom, &myOu.myMesh, 
-                                         surf_gents_sidl, surf_gents.size(), 
-                                         msets, msets_size);
-  } catch (iBase::Error) {return false;}
+  iBase_EntitySetHandle *msets = NULL;
+  int msets_alloc = 0, msets_size;
+  int ierr;
+  iRel_getEntArrSetArrAssociation(myOu.myRel, myOu.myRelH,
+                                  &surf_gents[0], surf_gents.size(), 0,
+                                  &msets, &msets_alloc, &msets_size, 
+                                  &ierr);
+  CE("Couldn't get related mesh sets.");
   
     // - get tag for that parameter
-  TagHandle param_tag = dcoordsdpTag[param_index];
+  iBase_TagHandle param_tag = dcoordsdpTag[param_index];
 
   integrated_dv = 0.0;
   
-  // for each surface
+    // for each surface
   for (int s = 0; s < surf_gents.size(); s++) {
     
-    // - get all triangles on entity
-    myOu.myMesh.getEntities(msets[s], iMesh::EntityType_FACE,
-                            iMesh::EntityTopology_ALL_TOPOLOGIES,
-                            faces, faces_size);
-
-
+      // - get all triangles on entity
     iBase_EntityHandle *faces = NULL;
     int faces_alloc = 0, faces_size;
-    iMesh_getEntities(myOu.myMesh, msets[s],
-                      iMesh::EntityType_FACE,
-                      iMesh::EntityTopology_ALL_TOPOLOGIES,
-                      &faces, &faces_alloc, &faces_size, &result);
-
-    if (iBase_SUCCESS != result) {
+    iMesh_getEntities(myOu.myMesh, msets[s], 
+                      iBase_FACE, iMesh_ALL_TOPOLOGIES,
+                      &faces, &faces_alloc, &faces_size, &ierr);
+
+    if (iBase_SUCCESS != ierr) {
       char dum_str[256];
-      iMesh_getDescription(myMesh, dum_str, &result, 256);
+      iMesh_getDescription(myOu.myMesh, dum_str, &ierr, 256);
       std::cerr << "Couldn't get entities in set in reset_coords."
                 << std::endl
@@ -1022 +927 @@
 
     double surf_area = 0.0, surf_integrated_dv = 0.0;
-    
     for (int t = 0; t < faces_size; t++) {
       
         // get vertices for those triangles and coordinates for vertices
-      std::vector<iBase_EntityHandle> mverts;
-      int mverts_size;
-      try {
-        mesh_ent.getEntAdj(faces[t], iMesh::EntityType_VERTEX, 
-                           mverts, mverts_size);
-      }
-      catch (iBase::Error err) {
-        std::cerr << "Trouble getting vertices for a face." << std::endl;
+      iBase_EntityHandle *mverts = NULL;
+      int mverts_alloc = 0, mverts_size;
+      iMesh_getEntAdj(myOu.myMesh, faces[t], iBase_VERTEX, 
+                      &mverts, &mverts_alloc, &mverts_size, &ierr);
+      CE("Trouble getting vertices for a face.");
+
+      double *coords = NULL;
+      int coords_alloc = 0, coords_size;
+      iMesh_getVtxArrCoords(myOu.myMesh, mverts, mverts_size, 
+                            iBase_INTERLEAVED, 
+                            &coords, &coords_alloc, &coords_size, &ierr);
+      CE("Trouble getting vertex coordinates.");
+      assert(coords_size == mverts_size*3);
+
+
+        // get design v's and normals for those verts
+      double *params = NULL;
+      int params_alloc = 0, params_size;
+      iMesh_getDblArrData(myOu.myMesh, mverts, mverts_size,
+                          param_tag, &params, &params_alloc,
+                          &params_size, &ierr);
+
+      if (iBase_SUCCESS != ierr) {
+        char dum_str[256];
+        iMesh_getDescription(myOu.myMesh, dum_str, &ierr, 256);
+        std::cerr << "Couldn't get coordinates tag on mvertices"
+                  << " in store_cv_coords_normals."
+                  << std::endl
+                  << dum_str << std::endl;
         return false;
       }
 
-      std::vector<double> coords;
-      int coords_size;
-      iMesh::StorageOrder so = iMesh::StorageOrder_INTERLEAVED;
-      try {
-        myOu.myMesh.getVtxArrCoords(mverts, mverts_size, 
-                                    so, coords, coords_size);
-      }
-      catch (iBase::Error err) {
-        std::cerr << "Trouble getting vertex coordinates." << std::endl;
+      double *normals = NULL;
+      int normals_alloc = 0, normals_size;
+
+      iMesh_getDblArrData(myOu.myMesh, mverts, mverts_size,
+                          myOu.normal_tag(), &normals, 
+                          &normals_alloc, &normals_size, &ierr);
+      if (iBase_SUCCESS != ierr) {
+        char dum_str[256];
+        iMesh_getDescription(myOu.myMesh, dum_str, &ierr, 256);
+        std::cerr << "Couldn't get coordinates tag on mvertices"
+                  << " in store_cv_coords_normals."
+                  << std::endl
+                  << dum_str << std::endl;
         return false;
       }
-      assert(coords_size == mverts_size*3);
-
-
-      // get design v's and normals for those verts
-
-      Base_EntityHandle *mverts = NULL;
-      int mverts_alloc = 0, mverts_size;
-      double *params = NULL;
-      int params_alloc = 0, params_size;
-
-      iMesh_getDblArrData(myOu.myMesh, mverts, mverts_size,
-                          param_tag, &params, &params_alloc,
-                          &params_size, &result);
-
-      if (iBase_SUCCESS != result) {
-          char dum_str[256];
-          iMesh_getDescription(myMesh, dum_str, &result, 256);
-          std::cerr << "Couldn't get coordinates tag on mvertices
-                        in store_cv_coords_normals."
-                    << std::endl
-                    << dum_str << std::endl;
-          return false;
-      }
-
-
-      int normals_alloc = 0;
-
-      iMesh_getDblArrData(myOu.myMesh, mverts, mverts_size,
-                          myOu.normal_tag(), &normals, 
-                          &normals_alloc, &normals_size, &result);
-
-      if (iBase_SUCCESS != result) {
-          char dum_str[256];
-          iMesh_getDescription(myMesh, dum_str, &result, 256);
-          std::cerr << "Couldn't get coordinates tag on mvertices
-                        in store_cv_coords_normals."
-                    << std::endl
-                    << dum_str << std::endl;
-          return false;
-      }
-
-
 
         // put the edge vectors in for the coords of 2 pts
@@ -1127 +1014 @@
         term += params[i]*normals[i];
       surf_integrated_dv += (term/(double)mverts_size) * area;
+      
+      free(mverts); free(coords); free(params); free(normals);
     }
 
     std::cout << "Surface " << myOu.get_gentity_id(surf_gents[s]) 
               << " area = " << surf_area << 
-      ", integrated dv contribution = " << surf_integrated_dv << std::endl;
+        ", integrated dv contribution = " << surf_integrated_dv << std::endl;
     
     integrated_dv += surf_integrated_dv;
+
+    free(faces); 
   }
 

ddriv/trunk/DdrivDerivs.hpp

@@ -20 +20 @@
 
 
-#include "MeshTSTT.hpp"
-#include "GeomTSTT.hpp"
-
 #include "OptUtils.hpp"
 #include "SmoothUtils.hpp"
@@ -30 +27 @@
 #include <vector>
 
-typedef void* MentitySetHandle;
-typedef void* TagHandle;
 
 class GeomGenerator;
@@ -91 +86 @@
   unsigned int *adj_cv_s, *infl_scl_p, *infl_cv_p;
 
-  std::vector<TagHandle> dcoordsdpTag, dnormaldpTag, dnormaldpSTag;
+  std::vector<iBase_TagHandle> dcoordsdpTag, dnormaldpTag, dnormaldpSTag;
   
     // params vector and requested difference step size (initialize to ???)
@@ -108 +103 @@
   bool make_mesh_set(std::vector<iBase_EntityHandle> &gents,
                      const int dimension,
-                     MentitySetHandle &new_set);
+                     iBase_EntitySetHandle &new_set);
   
     //! for surfaces, get mesh vertex coordinates and normals at those vertices, 
@@ -117 +112 @@
                             const int gents_size,
                             const int gent_dim,
-                            TagHandle coord_tag, TagHandle normal_tag,
-                            TagHandle old_coord_tag, TagHandle old_normal_tag,
-                            const double dp);
-  
-    //! for surfaces, get mesh vertex coordinates and normals at those vertices, 
-    //! compute derivatives if old_xxx_tag is non-zero, then store results in xxx_tag
-  bool store_coords_normals(const bool bogus_derivs,
-                            std::vector<iBase_EntityHandle> *handle_index_vecs, 
-                            const int gent_dim,
-                            TagHandle coord_tag, TagHandle normal_tag,
-                            TagHandle old_coord_tag, TagHandle old_normal_tag,
+                            iBase_TagHandle coord_tag, iBase_TagHandle normal_tag,
+                            iBase_TagHandle old_coord_tag, iBase_TagHandle old_normal_tag,
                             const double dp);
   
@@ -134 +120 @@
     //! derivatives and surface normal derivatives
   bool compute_vector_difference(std::vector<iBase_EntityHandle> &mverts, 
-                                 const int mverts_size, 
                                  std::vector<double> &new_vec, 
-                                 const int new_vec_size, 
-                                 TagHandle old_vec_tag,
+                                 iBase_TagHandle old_vec_tag,
+                                 const double dp);
+  
+  bool compute_vector_difference(iBase_EntityHandle *mverts, 
+                                 int mverts_size,
+                                 std::vector<double> &new_vec, 
+                                 iBase_TagHandle old_vec_tag,
                                  const double dp);
   
@@ -148 +138 @@
                                     const int mverts_size, 
                                     std::vector<double> &new_vec, 
-                                    TagHandle old_vec_tag,
+                                    iBase_TagHandle old_vec_tag,
                                     const int surf_indices_size,
                                     const double dp,
@@ -158 +148 @@
     //! that space on the input tag
   bool allocate_cv_normal_tags(std::vector<iBase_EntityHandle> &mverts, 
-                               const int mverts_size, TagHandle normal_tag, 
+                               const int mverts_size, iBase_TagHandle normal_tag, 
                                const int surf_indices_size,
                                std::vector<double> &mvert_normals);
@@ -248 +238 @@
   
     //! retrieves or creates a tag handle given the tag's description
-  void *get_tag_handle(iBase_Instance &iface, const char *tag_name, 
-                       const int tag_size, const iBase_TagValueType tag_type);
+  iBase_TagHandle get_tag_handle(iMesh_Instance &iface, const char *tag_name, 
+                                 const int tag_size, const iBase_TagValueType tag_type);
 
     //! print the adjacency graph, with header row containing vertex/curve indices

ddriv/trunk/GeomGenerator.cpp

@@ -340 +340 @@
 
     iGeom_save(myOu.myGeom, myOutputGeomFile.c_str(), NULL, &result,  
-               myOutputGeomFile.length(), &result);
+               myOutputGeomFile.length(), 0);
 
     if (iBase_SUCCESS != result) {

ddriv/trunk/Makefile

@@ -15 +15 @@
 #include ${IREL_DIR}/lib/iRel-Defs.inc
 
-include /home/malusare/bin/lib/iRel-Defs.inc
-include /home/malusare/bin/lib/iGeom-Defs.inc
-include /home/malusare/bin/lib/iMesh-Defs.inc
+include ${IREL_DIR}/lib/iRel-Defs.inc
+include ${IGEOM_DIR}/lib/iGeom-Defs.inc
+include ${IMESH_DIR}/lib/iMesh-Defs.inc
 
 
@@ -60 +60 @@
 
 ddriv: ${DDRIV_OBJS}  libddriv.a ${MESQUITE_LIBS} 
-        $(IREL_CXX)  $(CXXFLAGS) -o $@ ${DDRIV_OBJS} -L. -lddriv ${MESQUITE_LIBS_LINK} ${IREL_LIBS}
+        $(IREL_CXX)  $(CXXFLAGS) -o $@ ${DDRIV_OBJS} -L. -lddriv ${MESQUITE_LIBS_LINK} ${IREL_LIBS} ${IMESH_LIBS} ${IGEOM_LIBS}
 
 libddriv.a: $(DDRIV_LIB_OBJS)
@@ -119 +119 @@
         ${CXX} -DMSQ_TSTT_USE_MOAB -c ${CXXFLAGS} ${IGEOM_INCLUDES} $<
 .cpp.o:
-        ${CXX} -DMSQ_TSTT_USE_MOAB -c ${CXXFLAGS} ${iRel_INCLUDES} ${IGEOM_INCLUDES} ${MESQUITE_INCLUDES} $<
+        ${CXX} -DMSQ_TSTT_USE_MOAB -c ${CXXFLAGS} ${IREL_INCLUDES} ${IMESH_INCLUDES} ${IGEOM_INCLUDES} ${MESQUITE_INCLUDES} $<
 
 

ddriv/trunk/MkCone.cpp

@@ -37 +37 @@
 #include <vector>
 #include <cmath>
-using namespace std;
 
 #include "iGeom.h"
-#include "iBase_SNL_SIDL_defs.h"
 #include "CubitVector.hpp"
-#include "AcisModifyEngine.hpp"
 #include "GeometryModifyTool.hpp"
 #include "GeometryQueryTool.hpp"
@@ -52 +49 @@
 #include "ConeParamInfls.hpp"
 
+#define CE(s) if (iBase_SUCCESS != ierr) {std::cerr << s << std::endl; return false;}
+    
 /*
  * Interpolation functions: interpolateY and interpolateZ
@@ -68 +67 @@
 
 /* ================================================== */
-vector<double>
- interpolateY(vector<double> y, double angle, double beta)
+std::vector<double>
+interpolateY(std::vector<double> y, double angle, double beta)
 {
-  vector<double> result;
+  std::vector<double> result;
   size_t len = y.size();
   for(size_t i = 0; i < len; ++i) {
@@ -81 +80 @@
 
 /* ================================================== */
-vector<double> 
- interpolateZ(vector<double> z, double angle, double gamma)
+std::vector<double> 
+ interpolateZ(std::vector<double> z, double angle, double gamma)
 {
-  vector<double> result;
+  std::vector<double> result;
   size_t len = z.size();
   for(size_t i = 0; i < len; ++i) {
@@ -140 +139 @@
   }
   
-  vector<double> frac, x, y, z, other;
+  std::vector<double> frac, x, y, z, other;
 
   // create the fraction vector
@@ -175 +174 @@
   for(int v = 0; v < NUM_V-2; v++) {
       // vertices at angle (v+1)*angle
-      vector<double> new_y = interpolateY(y, angle, beta);
-      vector<double> new_z = interpolateZ(z, angle, gamma);
+      std::vector<double> new_y = interpolateY(y, angle, beta);
+      std::vector<double> new_z = interpolateZ(z, angle, gamma);
       for(int u = 0; u < NUM_U; ++u) {
           points[u][v+1]->set(x[u], new_y[u], new_z[u]);
@@ -267 +266 @@
     // assign to RefEntity* so cast to void* works correctly
   RefEntity *this_body_refent = this_body;
-  typedef void* iBase_EntityHandle;
-  iBase_EntityHandle this_gent = this_body_refent, cone_body;
+  iBase_EntityHandle this_gent = (iBase_EntityHandle) this_body_refent, cone_body;
 
   // get the other parts by copy/reflect/uniting
 
   iBase_EntityHandle q2, q3, q4;
-
-  iGeom_copyEnt( geom_iface, this_gent, q2, &result);
-
-  if (iBase_SUCCESS != result) {
+  int ierr;
+  iGeom_copyEnt( geom_iface, this_gent, &q2, &ierr);
+
+  if (iBase_SUCCESS != ierr) {
       std::cerr << "Failed Copy." << std::endl;
       return false;
@@ -282 +280 @@
 
 
-  iGeom_reflectEnt(geom_iface, q2, 0.0, 0.0, 1.0, &result);
-
-  if (iBase_SUCCESS != result) {
+  iGeom_reflectEnt(geom_iface, &q2, 0.0, 0.0, 1.0, &ierr);
+
+  if (iBase_SUCCESS != ierr) {
       std::cerr << "Failed Reflect." << std::endl;
       return false;
@@ -291 +289 @@
 
 
-  iGeom_copyEnt( geom_iface, q2, q3, &result);
-
-  if (iBase_SUCCESS != result) {
+  iGeom_copyEnt( geom_iface, q2, &q3, &ierr);
+
+  if (iBase_SUCCESS != ierr) {
       std::cerr << "Failed Copy." << std::endl;
       return false;
@@ -299 +297 @@
 
 
-  iGeom_copyEnt( geom_iface, this_gent, q4, &result);
-
-  if (iBase_SUCCESS != result) {
+  iGeom_copyEnt( geom_iface, this_gent, &q4, &ierr);
+
+  if (iBase_SUCCESS != ierr) {
       std::cerr << "Failed Copy." << std::endl;
       return false;
@@ -308 +306 @@
 
 
-  iGeom_reflectEnt(geom_iface, q3, 0.0, 1.0, 0.0, &result);
-
-  if (iBase_SUCCESS != result) {
+  iGeom_reflectEnt(geom_iface, &q3, 0.0, 1.0, 0.0, &ierr);
+
+  if (iBase_SUCCESS != ierr) {
       std::cerr << "Failed Reflect." << std::endl;
       return false;
@@ -316 +314 @@
 
 
-  iGeom_reflectEnt(geom_iface, q4, 0.0, 1.0, 0.0, &result);
+  iGeom_reflectEnt(geom_iface, &q4, 0.0, 1.0, 0.0, &ierr);
     
-  if (iBase_SUCCESS != result) {
+  if (iBase_SUCCESS != ierr) {
       std::cerr << "Failed Reflect." << std::endl;
       return false;
@@ -324 +322 @@
 
 
-  std::vector<iBase_EntityHandle> pieces = pieces.create1d(4);
-  pieces.set(0, this_gent);
-  pieces.set(1, q2);
-  pieces.set(2, q3);
-  pieces.set(3, q4);
-
-
-  iGeom_uniteEnts( geom_iface, &pieces, 4, &cone_body, &result); 
-
-  if (iBase_SUCCESS != result) {
-      std::cerr << "Failed Unite." << std::endl;
-      return false;
-  }
-
-
-
-  iBase_EntityHandle q2, q3, q4;
-
-  iGeom_copyEnt( geom_iface, this_gent, q2, &result);
-
-  if (iBase_SUCCESS != result) {
-      std::cerr << "Failed Copy." << std::endl;
-      return false;
-  }
-
-
-  iGeom_reflectEnt( geom_iface, q2, 0.0, 0.0, 1.0, &result); 
-
-  if (iBase_SUCCESS != result) {
-      std::cerr << "Failed Subtract." << std::endl;
-      return false;
-  }
-
-
-  iGeom_copyEnt( geom_iface, q2, q3, &result);
-    
-  if (iBase_SUCCESS != result) {
-      std::cerr << "Failed Copy." << std::endl;
-      return false;
-  }
-
-
-  iGeom_copyEnt( geom_iface, this_gent, q4, &result);
-
-  if (iBase_SUCCESS != result) {
-      std::cerr << "Failed Copy." << std::endl;
-      return false;
-  }
-
-
-  iGeom_reflectEnt( geom_iface, q3, 0.0, 1.0, 0.0, &result);
-
-  if (iBase_SUCCESS != result) {
-      std::cerr << "Failed Reflect." << std::endl;
-      return false;
-  }
-
-
-  iGeom_reflectEnt( geom_iface, q4, 0.0, 1.0, 0.0, &result);
-
-  if (iBase_SUCCESS != result) {
-      std::cerr << "Failed Reflect." << std::endl;
-      return false;
-  }
-
-
-  std::vector<iBase_EntityHandle> pieces = pieces.create1d(4);
-  pieces.set(0, this_gent);
-  pieces.set(1, q2);
-  pieces.set(2, q3);
-  pieces.set(3, q4);
-
-  iGeom_uniteEnts( geom_face, &pieces, 4, &cone_body, &result);
-
-  if (iBase_SUCCESS != result) {
-      std::cerr << "Failed Unite." << std::endl;
-      return false;
-  }
-  
+  iBase_EntityHandle pieces[4] = {this_gent, q2, q3, q4};
+  iGeom_uniteEnts(geom_iface, pieces, 4, &cone_body, &ierr); 
+  CE("Failed Unite.");
+
+  iGeom_copyEnt( geom_iface, this_gent, &q2, &ierr);
+  CE("Failed Copy.");
+
+  iGeom_reflectEnt( geom_iface, &q2, 0.0, 0.0, 1.0, &ierr); 
+  CE("Failed Subtract.");
+  
+
+
+  iGeom_copyEnt( geom_iface, q2, &q3, &ierr);
+  CE("Failed Copy.");
+
+  iGeom_copyEnt( geom_iface, this_gent, &q4, &ierr);
+  CE("Failed Copy.");
+
+  iGeom_reflectEnt( geom_iface, &q3, 0.0, 1.0, 0.0, &ierr);
+  CE("Failed Reflect.");
+
+  iGeom_reflectEnt( geom_iface, &q4, 0.0, 1.0, 0.0, &ierr);
+  CE("Failed Reflect.");
+
+  iBase_EntityHandle pieces2[] = {this_gent, q2, q3, q4};
+  iGeom_uniteEnts(geom_iface, pieces2, 4, &cone_body, &ierr);
+  CE("Failed Unite.");
  
   // if we got here, and it's requested, pass back the param-surf influence matrix
   if (NULL != param_surf_infls) {
-
       int num_param_surf_infls = paramInflsNumSurfs*paramInflsNumParams;
 
       if (NULL == *param_surf_infls) 
-
           *param_surf_infls = new unsigned int [num_param_surf_infls];
-
            memcpy(*param_surf_infls, paramSurfInfls, 
                    num_param_surf_infls*sizeof(unsigned int));

ddriv/trunk/MkCyl.cpp

@@ -21 +21 @@
 #include <iostream>
 #include "iGeom.h"
-#include "iBase_SNL_SIDL_defs.h"
 #include "cylParamInfls.hpp"
+#include <cstring>
 
-typedef void* iBase_EntityHandle;
 int result;
 
@@ -50 +49 @@
 
 
-  iGeom_sectionEnt( geom_iface, cyl_tmp, 1.0, 0.0, 0.0, 0.0, 
+  iGeom_sectionEnt( geom_iface, &cyl_tmp, 1.0, 0.0, 0.0, 0.0, 
                     false, &cyl, &result);
 

ddriv/trunk/MkDDSCell.cpp

@@ -20 +20 @@
 #include <iostream>
 #include "iGeom.h"
-#include "iBase_SNL_SIDL_defs.h"
 #include "ddsdefines.h"
 #include "DDSParamInfls.hpp"
-
-
+#include <cstring>
+#include <vector>
+#include <math.h>
 
 /* ============== typedefs section =============== */
 int result;
-
-typedef void* iBase_EntityHandle;
 
 const double fixed_params[15] = {
@@ -56 +54 @@
 bool cleanup_other_geom(iGeom_Instance &geom,
                         iBase_EntityHandle &dds_cell,
-                        std::vector<iBase_EntityHandle> &initial_gents,
+                        iBase_EntityHandle *initial_gents,
                         int initial_gents_size);
 
@@ -62 +60 @@
 const double RADTODEG = 180.0/(4.0*atan(1.0));
 
-
+#define CE(s) if (iBase_SUCCESS != ierr) {        \
+      std::cerr << s << std::endl; return false; }
+    
 
 
@@ -89 +89 @@
 
   if (iBase_SUCCESS != result) {
-      std::cerr << "Trouble getting gentities of dimension" << dim << std::endl;
+      std::cerr << "Trouble getting gentities of dimension" << iBase_REGION << std::endl;
       return false;
   }
@@ -201 +201 @@
 
 
-  iGeom_moveEnt( iGeom_transforms, temp2, -.5*brround, 
+  iGeom_moveEnt(geom, &temp2, -.5*brround, 
                 .5*b_n0_fillet_pos+.5*brround, 0.0, &result);
 
@@ -210 +210 @@
 
 
-  iGeom_subtract(geom, temp1, temp2, &temp3, &result);
+  iGeom_subtractEnts(geom, temp1, temp2, &temp3, &result);
 
   if (iBase_SUCCESS != result) {
@@ -218 +218 @@
 
 
-  iGeom_moveEnt( iGeom_Instance, temp3, .5*brround, 
+  iGeom_moveEnt(geom, &temp3, .5*brround, 
                 .5*b_n0_fillet_pos+.5*brround, 0.0, &result );
  
@@ -230 +230 @@
   double angb00 = asin(brrbc/(b_n0_fillet_pos+brround))*RADTODEG;
 
-  iGeom_rotateEnt( geom, temp3, angb00, 0.0, 0.0, 1.0, &result);
+  iGeom_rotateEnt( geom, &temp3, angb00, 0.0, 0.0, 1.0, &result);
 
   if (iBase_SUCCESS != result) {
@@ -242 +242 @@
 
 
-  iGeom_sectionEnt( geom, temp3, 0.0, 1.0, 0.0, 
+  iGeom_sectionEnt( geom, &temp3, 0.0, 1.0, 0.0, 
                     offset, true, &angled, &result);
 
@@ -249 +249 @@
       return false;
   }
-
- 
-  std::vector<iBase_EntityHandle> tempa = 
-      std::vector<iBase_EntityHandle>::create1d(2);
-
 
   double sinang00_pos 
@@ -272 +267 @@
 
 
-   iGeom_moveEnt( geom, temp1, wnarrow_pos-rround,
+   iGeom_moveEnt( geom, &temp1, wnarrow_pos-rround,
                   .5*b_n0_fillet_pos+.5*s_b_manif_pos+.5*rmanif,
                   0.0, &result);  
@@ -282 +277 @@
 
 
-   tempa.set(0, angled);
-   tempa.set(1, temp1);
+   iBase_EntityHandle tempa[2] = {angled, temp1};
    rounded_disk_top = NULL;
    
 
-   iGeom_uniteEnts( geom, &tempa, 2, &rounded_disk_top, &result);
+   iGeom_uniteEnts( geom, tempa, 2, &rounded_disk_top, &result);
 
    if (iBase_SUCCESS != result) {
@@ -295 +289 @@
 
 
-   iGeom_moveEnt( geom, rounded_disk_top, 0.0, 0.0, 
+   iGeom_moveEnt( geom, &rounded_disk_top, 0.0, 0.0, 
                   0.25*(t_neg-t_pos), &result);
 
@@ -336 +330 @@
 
 
-  iGeom_moveEnt( geom, temp1, wnarrow_pos - .5*rround, 
+  iGeom_moveEnt( geom, &temp1, wnarrow_pos - .5*rround, 
                 .5*slen_pos + dmove_pos, 
                 .5*rround + .25*t_neg - .25*t_pos, &result);
@@ -355 +349 @@
 
 
-  iGeom_rotateEnt( geom, temp2, 90.0, 1.0, 0.0, 0.0, &result);
+  iGeom_rotateEnt( geom, &temp2, 90.0, 1.0, 0.0, 0.0, &result);
 
   if (iBase_SUCCESS != result) {
@@ -363 +357 @@
 
 
-  iGeom_moveEnt( geom, temp2, -rround, dmove_pos + .5*slen_pos,   
+  iGeom_moveEnt( geom, &temp2, -rround, dmove_pos + .5*slen_pos,   
                  .5*cell_height - .5*t_pos + rround, &result);
 
@@ -373 +367 @@
 
   lower_brick = NULL;
-  iGeom_subtract(geom, temp1, temp2, &lower_brick, &result);
+  iGeom_subtractEnts(geom, temp1, temp2, &lower_brick, &result);
 
   if (iBase_SUCCESS != result) {
@@ -392 +386 @@
 
 
-  iGeom_moveEnt( geom, upper_brick, wnarrow_pos, 
+  iGeom_moveEnt( geom, &upper_brick, wnarrow_pos, 
                  .5*slen_pos + dmove_pos, .25*t_neg, &result);
 
@@ -411 +405 @@
 
 
-  iGeom_moveEnt( geom, cyl_sm, rslot, dmove_pos, 
+  iGeom_moveEnt( geom, &cyl_sm, rslot, dmove_pos, 
                  .25*t_neg, &result);
   
@@ -432 +426 @@
 
 
-   iGeom_moveEnt( geom, temp1, rslot, dmove_pos,
+   iGeom_moveEnt( geom, &temp1, rslot, dmove_pos,
                     .25*(t_neg-t_pos)+.5*rround, &result);
 
@@ -454 +448 @@
 
 
-   iGeom_moveEnt( geom, temp2, rslot, dmove_pos, 
+   iGeom_moveEnt( geom, &temp2, rslot, dmove_pos, 
                   .5*cell_height-.5*t_pos+rround, &result);
 
@@ -466 +460 @@
     cyl_lrg = NULL;
 
-   iGeom_subtract(geom, temp1, temp2, &cyl_lrg, &result);
+   iGeom_subtractEnts(geom, temp1, temp2, &cyl_lrg, &result);
 
    if (iBase_SUCCESS != result) {
@@ -474 +468 @@
 
 
-   std::vector<iBase_EntityHandle> tempa = 
-      std::vector<iBase_EntityHandle>::create1d(4);
-
-   tempa.set(0, lower_brick);
-   tempa.set(1, upper_brick);
-   tempa.set(2, cyl_sm);
-   tempa.set(3, cyl_lrg);
+   iBase_EntityHandle tempa[4] = {lower_brick, upper_brick, cyl_sm, cyl_lrg};
    rounded_disk_side_pos = NULL;
-
-
-   iGeom_uniteEnts( geom, &tempa, 4, &rounded_disk_side_pos, &result);
+   iGeom_uniteEnts( geom, tempa, 4, &rounded_disk_side_pos, &result);
 
    if (iBase_SUCCESS != result) {
@@ -526 +512 @@
 
 
-   iGeom_moveEnt( geom, temp1, wnarrow_neg - .5*rround, 
+   iGeom_moveEnt( geom, &temp1, wnarrow_neg - .5*rround, 
                   0.0, -.5*rround, &result);
 
@@ -543 +529 @@
    }
 
-  iGeom_rotateEnt( geom, temp2, 90.0, 1.0, 0.0, 0.0, &result);
+  iGeom_rotateEnt( geom, &temp2, 90.0, 1.0, 0.0, 0.0, &result);
 
   if (iBase_SUCCESS != result) {
@@ -551 +537 @@
 
 
-  iGeom_moveEnt( geom, temp2, -rround, 0.0, -rround, &result);
+  iGeom_moveEnt( geom, &temp2, -rround, 0.0, -rround, &result);
 
   if (iBase_SUCCESS != result) {
@@ -560 +546 @@
 
   upper_brick = NULL;
-  iGeom_subtract(geom, temp1, temp2, &upper_brick, &result);
+  iGeom_subtractEnts(geom, temp1, temp2, &upper_brick, &result);
 
   if (iBase_SUCCESS != result) {
@@ -568 +554 @@
 
 
-  iGeom_moveEnt( geom, upper_brick, 0.0, .5*slen_neg, 0.0, &result); 
+  iGeom_moveEnt( geom, &upper_brick, 0.0, .5*slen_neg, 0.0, &result); 
 
   if (iBase_SUCCESS != result) {
@@ -589 +575 @@
 
 
-  iGeom_moveEnt( geom, lower_brick, wnarrow_neg, .5*slen_neg, 
+  iGeom_moveEnt( geom, &lower_brick, wnarrow_neg, .5*slen_neg, 
                  -.25*t_neg-.5*rround, &result);
 
@@ -612 +598 @@
 
 
-  iGeom_moveEnt( geom, temp1, rslot, 0.0, -.5*rround, &result);
+  iGeom_moveEnt( geom, &temp1, rslot, 0.0, -.5*rround, &result);
 
   if (iBase_SUCCESS != result) {
@@ -632 +618 @@
 
 
-  iGeom_moveEnt( iGeom_transforms, temp2, rslot, 0.0, -rround, &result);  
+  iGeom_moveEnt( geom, &temp2, rslot, 0.0, -rround, &result);  
 
   if (iBase_SUCCESS != result) {
@@ -643 +629 @@
   cyl_lrg = NULL;
 
-  iGeom_subtract(geom, temp1, temp2, &cyl_lrg, &result);
+  iGeom_subtractEnts(geom, temp1, temp2, &cyl_lrg, &result);
 
   if (iBase_SUCCESS != result) {
@@ -661 +647 @@
   }
 
-  iGeom_moveEnt(geom,cyl_sm,rslot,0.0,-.25*t_neg-.5*rround,&result);
+  iGeom_moveEnt(geom, &cyl_sm,rslot,0.0,-.25*t_neg-.5*rround,&result);
 
   if (iBase_SUCCESS != result) {
@@ -671 +657 @@
   // unite to get rounded_disk_side_neg
 
-  std::vector<iBase_EntityHandle> tempa = 
-    std::vector<iBase_EntityHandle>::create1d(4);
-
-  tempa.set(0, lower_brick);
-  tempa.set(1, upper_brick);
-  tempa.set(2, cyl_sm);
-  tempa.set(3, cyl_lrg);
-
+  iBase_EntityHandle tempa[4] = {lower_brick, upper_brick, cyl_sm, cyl_lrg};
   rounded_disk_side_neg = NULL;
 
-  iGeom_uniteEnts( geom, &tempa, 4, &rounded_disk_side_neg, &result);
+  iGeom_uniteEnts( geom, tempa, 4, &rounded_disk_side_neg, &result);
 
   if (iBase_SUCCESS != result) {
@@ -688 +667 @@
   }
 
-  iGeom_moveEnt( geom, rounded_disk_side_neg, 0.0, dmove_neg, 
+  iGeom_moveEnt( geom, &rounded_disk_side_neg, 0.0, dmove_neg, 
                  -.5*(cell_height-t_neg), &result); 
 
@@ -721 +700 @@
   double ang01_neg = asin(sinang00_neg)*RADTODEG;
   
-  iGeom_rotateEnt( geom, rounded_disk_side_pos, 
+  iGeom_rotateEnt( geom, &rounded_disk_side_pos, 
                    ang01_pos, 0.0, 0.0, 1.0 , &result);
 
@@ -730 +709 @@
 
 
-  iGeom_rotateEnt( geom, rounded_disk_side_neg, 
+  iGeom_rotateEnt( geom, &rounded_disk_side_neg, 
                    ang01_neg, 0.0, 0.0, 1.0, &result); 
 
@@ -739 +718 @@
 
 
-  iGeom_rotateEnt( geom, rounded_disk_top, ang01_pos, 
-                     0.0, 0.0, 1.0, &result);
+  iGeom_rotateEnt( geom, &rounded_disk_top, ang01_pos, 
+                   0.0, 0.0, 1.0, &result);
 
   if (iBase_SUCCESS != result) {
@@ -748 +727 @@
 
 
-  std::vector<iBase_EntityHandle> tempa = 
-      std::vector<iBase_EntityHandle>::create1d(3);
-
-  tempa.set(0, rounded_disk_side_pos);
-  tempa.set(1, rounded_disk_side_neg);
-  tempa.set(2, rounded_disk_top);
-
-
+  iBase_EntityHandle tempa[] = {rounded_disk_side_pos, rounded_disk_side_neg,
+                                rounded_disk_top};
+  
   temp1 = NULL;
-  iGeom_uniteEnts( geom, &tempa, 3, &temp1, &result);
+  iGeom_uniteEnts( geom, tempa, 3, &temp1, &result);
 
   if (iBase_SUCCESS != result) {
@@ -766 +740 @@
 
   temp2 = NULL;
-  void iGeom_sectionEnt( geom, temp1, 1.0, 0.0, 0.0, 
-                         0.0, true, &temp2, &result); 
+  iGeom_sectionEnt( geom, &temp1, 1.0, 0.0, 0.0, 
+                    0.0, true, &temp2, &result); 
 
   if (iBase_SUCCESS != result) {
@@ -776 +750 @@
 
   temp3 = NULL;
-  iGeom_copyEnt( geom, temp2, temp3, &result);
+  iGeom_copyEnt( geom, temp2, &temp3, &result);
 
   if (iBase_SUCCESS != result) {
@@ -784 +758 @@
 
 
-  iGeom_reflectEnt( geom, temp3, 1.0, 0.0, 0.0, &result);
+  iGeom_reflectEnt( geom, &temp3, 1.0, 0.0, 0.0, &result);
 
   if (iBase_SUCCESS != result) {
@@ -792 +766 @@
 
 
-  std::vector<iBase_EntityHandle> tempb = 
-      std::vector<iBase_EntityHandle>::create1d(2);
-
-  tempb.set(0, temp2);
-  tempb.set(1, temp3);
+  iBase_EntityHandle tempb[] = {temp2, temp3};
 
   temp4 = NULL;
-  iGeom_uniteEnts( geom, &tempb, 2, &temp4, &result);
+  iGeom_uniteEnts(geom, tempb, 2, &temp4, &result);
 
   if (iBase_SUCCESS != result) {
@@ -825 +795 @@
 
 
-  iGeom_rotateEnt( geom, temp1, taa, 1.0, 0.0, 0.0, &result);
+  iGeom_rotateEnt( geom, &temp1, taa, 1.0, 0.0, 0.0, &result);
  
   if (iBase_SUCCESS != result) {
@@ -833 +803 @@
 
 
-  iGeom_moveEnt( geom, temp1, 0.0, dymanif_ave, 0.0, &result);
-
-  if (iBase_SUCCESS != result) {
-       std::cerr << "Failed Move." << std::endl;
-       return false;
-  }
-
-
-  std::vector<iBase_EntityHandle> tempc = 
-      std::vector<iBase_EntityHandle>::create1d(2);
-
-  tempc.set(0, temp4);
-  tempc.set(1, temp1);
+  iGeom_moveEnt( geom, &temp1, 0.0, dymanif_ave, 0.0, &result);
+
+  if (iBase_SUCCESS != result) {
+       std::cerr << "Failed Move." << std::endl;
+       return false;
+  }
+
+
+  iBase_EntityHandle tempc[] = {temp4, temp1};
   temp2 = NULL;
 
 
-  iGeom_uniteEnts( geom, &tempc, 2, &temp2, &result);
+  iGeom_uniteEnts( geom, tempc, 2, &temp2, &result);
 
   if (iBase_SUCCESS != result) {
@@ -858 +824 @@
 
   temp3 = NULL;
-  iGeom_sectionEnt( geom, temp2, 0.0, 0.0, 1.0,
+  iGeom_sectionEnt( geom, &temp2, 0.0, 0.0, 1.0,
                    .5*cell_height, true, &temp3, &result); 
 
@@ -868 +834 @@
 
   rounded_slot_manif = NULL;
-  iGeom_sectionEnt( geom, temp3, 0.0, 0.0, 1.0, -.5*cell_height, 
+  iGeom_sectionEnt( geom, &temp3, 0.0, 0.0, 1.0, -.5*cell_height, 
                     false, &rounded_slot_manif, &result); 
 
@@ -917 +883 @@
 
 
-     iGeom_moveEnt( geom, temp2, 0.0, 0.0, 
+     iGeom_moveEnt( geom, &temp2, 0.0, 0.0, 
                     .25*cell_height+.125*tdiff, &result);
 
@@ -936 +902 @@
 
 
-     iGeom_moveEnt( geom, temp3, 0.0, 0.0, 
+     iGeom_moveEnt( geom, &temp3, 0.0, 0.0, 
                     -.25*cell_height+.125*tdiff, &result); 
 
@@ -945 +911 @@
 
 
-    std::vector<iBase_EntityHandle> tempa = 
-      std::vector<iBase_EntityHandle>::create1d(3);
-
-    tempa.set(0, temp1);
-    tempa.set(1, temp2);
-    tempa.set(2, temp3);
+     iBase_EntityHandle tempa2[] = {temp1, temp2, temp3};
     cyls = NULL;
 
 
-    iGeom_uniteEnts( geom, &tempa, 3, &cyls, &result);
+    iGeom_uniteEnts( geom, tempa2, 3, &cyls, &result);
 
     if (iBase_SUCCESS != result) {
@@ -973 +934 @@
 
 
-    iGeom_rotateEnt( geom, temp1, 90.0, 1.0, 0.0, 0.0, &result);
+    iGeom_rotateEnt( geom, &temp1, 90.0, 1.0, 0.0, 0.0, &result);
  
     if (iBase_SUCCESS != result) {
@@ -981 +942 @@
 
 
-     iGeom_moveEnt( geom, temp1, -(a_pos+anose_pos), 
+     iGeom_moveEnt( geom, &temp1, -(a_pos+anose_pos), 
                     0.5, .5*cell_height+.25*tdiff, &result); 
 
@@ -991 +952 @@
     
       // find surface of previous volume with max y coord
-    std::vector<double> minc, maxc;
-    int num_adj_surfs, num_minc, num_maxc;
-
     iBase_EntityHandle *adj_surfs = NULL;
-    int adj_surfs_alloc = 0;
-    iGeom_getEntAdj(geom, temp1, ::iBase_FACE, adj_surfs,
-                    &adj_surfs_alloc, &adj_surfs_size, &result);
-
-
-    ::iBase::StorageOrder order = ::iBase::StorageOrder_INTERLEAVED;
-
-
-    iGeom_getArrBoundBox(geom, &adj_surfs, num_adj_surfs, &order, 
-                         &minc, &num_minc, &maxc, &num_maxc, &result);
+    int adj_surfs_alloc = 0, adj_surfs_size;
+    iGeom_getEntAdj(geom, temp1, iBase_FACE, 
+                    &adj_surfs, &adj_surfs_alloc, &adj_surfs_size, 
+                    &result);
+
+    int order = iBase_INTERLEAVED;
+    int mc_size = 3*adj_surfs_size;
+    std::vector<double> minc(mc_size), maxc(mc_size);
+    double *minc_ptr = &minc[0], *maxc_ptr = &maxc[0];
+    iGeom_getArrBoundBox(geom, adj_surfs, adj_surfs_size, &order, 
+                         &minc_ptr, &mc_size, &mc_size,
+                         &maxc_ptr, &mc_size, &mc_size, &result);
 
 
@@ -1014 +974 @@
 
     iBase_EntityHandle this_surf = 0;
-    for (int i = 0; i < num_adj_surfs; i++) {
-      if (minc.get(3*i+1) >= -1.0e-6 && maxc.get(3*i+1) <= 1.0e-6) {
-        this_surf = adj_surfs.get(i);
+    for (int i = 0; i < adj_surfs_size; i++) {
+      if (minc[3*i+1] >= -1.0e-6 && maxc[3*i+1] <= 1.0e-6) {
+        this_surf = adj_surfs[i];
         break;
       }
@@ -1022 +982 @@
 
     if (0 == this_surf) {
-      iBase::Error err = iBase::Error::_create();
-      err.set(iBase::ErrorType_FAILURE, "Didn't create surface for rotate.");
-      err.setNote("Didn't create surface for rotate.");
-      throw err;
+      int ierr = iBase_FAILURE;
+      CE("Didn't create surface for rotate.");
     }
 
     
     temp2 = NULL;
-    iGeom_copyEnt( geom, this_surf, temp2, &result);
+    iGeom_copyEnt( geom, this_surf, &temp2, &result);
 
     if (iBase_SUCCESS != result) {
@@ -1059 +1017 @@
 
 
-    iGeom_rotateEnt( geom, temp1, 90.0, 1.0, 0.0, 0.0, &result);
+    iGeom_rotateEnt( geom, &temp1, 90.0, 1.0, 0.0, 0.0, &result);
 
     if (iBase_SUCCESS != result) {
@@ -1067 +1025 @@
 
 
-     iGeom_moveEnt( geom, temp1, -(a_neg+anose_neg), 
+     iGeom_moveEnt( geom, &temp1, -(a_neg+anose_neg), 
                     0.5, -.5*cell_height+.25*tdiff, &result);
  
@@ -1077 +1035 @@
     
       // find surface of previous volume with max y coord
-    std::vector<iBase_EntityHandle> adj_surfs;
-    std::vector<double> minc, maxc;
-    int num_adj_surfs, num_minc, num_maxc;
-
-    iBase_EntityHandle *adj_surfs = NULL;
-    int adj_surfs_alloc = 0;
-    iGeom_getEntAdj(geom, temp1, ::iBase_FACE, adj_surfs,
+    adj_surfs = NULL;
+    adj_surfs_alloc = 0;
+    iGeom_getEntAdj(geom, temp1, ::iBase_FACE, &adj_surfs,
                     &adj_surfs_alloc, &adj_surfs_size, &result);
 
-
-    ::iBase::StorageOrder order = ::iBase::StorageOrder_INTERLEAVED;
-
-
-    iGeom_getArrBoundBox(geom, &adj_surfs, num_adj_surfs, &order, 
-                         &minc, &num_minc, &maxc, &num_maxc, &result);
+    mc_size = 3*adj_surfs_size;
+    minc.resize(mc_size); maxc.resize(mc_size);
+    minc_ptr = &minc[0]; maxc_ptr = &maxc[0];
+    iGeom_getArrBoundBox(geom, adj_surfs, adj_surfs_size, &order, 
+                         &minc_ptr, &mc_size, &mc_size, 
+                         &maxc_ptr, &mc_size, &mc_size, &result);
 
 
@@ -1101 +1055 @@
 
 
-    iBase_EntityHandle this_surf = 0;
-    for (int i = 0; i < num_adj_surfs; i++) {
-      if (minc.get(3*i+1) >= -1.0e-6 && maxc.get(3*i+1) <= 1.0e-6) {
-        this_surf = adj_surfs.get(i);
+    this_surf = 0;
+    for (int i = 0; i < adj_surfs_size; i++) {
+      if (minc[3*i+1] >= -1.0e-6 && maxc[3*i+1] <= 1.0e-6) {
+        this_surf = adj_surfs[i];
         break;
       }
@@ -1111 +1065 @@
 
     if (0 == this_surf) {
-      iBase::Error err = iBase::Error::_create();
-      err.set(iBase::ErrorType_FAILURE, "Didn't create surface for rotate.");
-      err.setNote("Didn't create surface for rotate.");
-      throw err;
+      int ierr = iBase_FAILURE;
+      CE("Didn't create surface for rotate.");
     }
 
     
     temp2 = NULL;
-    iGeom_copyEnt( geom, this_surf, temp2, &result);
+    iGeom_copyEnt( geom, this_surf, &temp2, &result);
     
     if (iBase_SUCCESS != result) {
@@ -1142 +1094 @@
 
     temp1 = NULL;
-    iGeom_subtract(geom, cyls, ell_pos, &temp1, &result);
+    iGeom_subtractEnts(geom, cyls, ell_pos, &temp1, &result);
 
     if (iBase_SUCCESS != result) {
@@ -1152 +1104 @@
 
     temp2 = NULL;
-    iGeom_subtract(geom, temp1, ell_neg, &temp2, &result);
+    iGeom_subtractEnts(geom, temp1, ell_neg, &temp2, &result);
 
     if (iBase_SUCCESS != result) {
@@ -1161 +1113 @@
 
 
-     iGeom_moveEnt( geom, temp2, 0.0, 0.0, -.25*tdiff, &result);
+     iGeom_moveEnt( geom, &temp2, 0.0, 0.0, -.25*tdiff, &result);
 
      if (iBase_SUCCESS != result) {
@@ -1172 +1124 @@
 
     temp3 = NULL;
-    iGeom_copyEnt( geom, rounded_slot_manif, temp3, &result);
+    iGeom_copyEnt( geom, rounded_slot_manif, &temp3, &result);
     
     if (iBase_SUCCESS != result) {
@@ -1180 +1132 @@
 
 
-    iGeom_rotateEnt( geom, temp3, 90.0, 0.0, 0.0, 1.0, &result);
+    iGeom_rotateEnt( geom, &temp3, 90.0, 0.0, 0.0, 1.0, &result);
 
     if (iBase_SUCCESS != result) {
@@ -1188 +1140 @@
 
 
-    std::vector<iBase_EntityHandle> tempa = 
-      std::vector<iBase_EntityHandle>::create1d(3);
-
-    tempa.set(0, temp2);
-    tempa.set(1, rounded_slot_manif);
-    tempa.set(2, temp3);
+    iBase_EntityHandle tempa[] = {temp2, rounded_slot_manif, temp3};
     temp4 = NULL;
 
 
-    iGeom_uniteEnts( geom, &tempa, 3, &temp4, &result);
+    iGeom_uniteEnts( geom, tempa, 3, &temp4, &result);
 
     if (iBase_SUCCESS != result) {
@@ -1206 +1153 @@
 
     temp1 = NULL;
-    void iGeom_sectionEnt( geom, temp4, 0.0, 1.0, 0.0, 
-                           0.0, false, &temp1, &result);
+    iGeom_sectionEnt( geom, &temp4, 0.0, 1.0, 0.0, 
+                      0.0, false, &temp1, &result);
 
     if (iBase_SUCCESS != result) {
@@ -1216 +1163 @@
 
     dds_cell = NULL;
-    void iGeom_sectionEnt( geom, temp1, 1.0, 0.0, 
-                           0.0, 0.0, true, &dds_cell, &result); 
+    iGeom_sectionEnt( geom, &temp1, 1.0, 0.0, 
+                      0.0, 0.0, true, &dds_cell, &result); 
 
     if (iBase_SUCCESS != result) {
@@ -1233 +1180 @@
 bool cleanup_other_geom(iGeom_Instance &geom,
                         iBase_EntityHandle &dds_cell,
-                        std::vector<iBase_EntityHandle> &initial_gents,
+                        iBase_EntityHandle *initial_gents,
                         int initial_gents_size) 
 {
     // get all the 3-dimensional entities, and all 3d entities adj to dds_cell
-  std::vector<iBase_EntityHandle> adj_gents, deletable_gents;
-  int all_gents_size, adj_gents_size, deletable_gents_size;
+  std::vector<iBase_EntityHandle> deletable_gents;
+  int deletable_gents_size;
 
 
@@ -1250 +1197 @@
 
   if (iBase_SUCCESS != result) {
-      std::cerr << "Trouble getting gentities of dimension" << dim << std::endl;
-      return false;
-  }
-
-
+      std::cerr << "Trouble getting gentities of dimension" << iBase_REGION 
+                << std::endl;
+      return false;
+  }
 
   iBase_EntityHandle *adj_gents = NULL;
   int adj_gents_size, adj_gents_alloc;
   // get all entities of this dimension
-  iGeom_getEntities(geom, dds_cell, iBase_REGION, &adj_gents,
+  iGeom_getEntAdj(geom, dds_cell, iBase_REGION, &adj_gents,
                     &adj_gents_alloc,
                     &adj_gents_size, &result);
 
    if (iBase_SUCCESS != result) {
-       std::cerr << "Trouble getting gentities of dimension" << dim << std::endl;
-       return false;
-   }
-
-
-  deletable_gents = deletable_gents.create1d(all_gents_size-1);
-  deletable_gents_size = 0;
-  
+       std::cerr << "Trouble getting gentities of dimension" << iBase_REGION 
+                 << std::endl;
+       return false;
+   }
+
+
   for (int i = 0; i < all_gents_size; i++) {
-
-       if (all_gents.get(i) == adj_gents.get(0)) {
-           continue;
-       }
+    if (all_gents[i] == adj_gents[0]) continue;
 
        bool insert_this = true;
        for (int j = 0; j < initial_gents_size; j++) {
 
-            if (all_gents.get(i) == initial_gents.get(j)) {
+            if (all_gents[i] == initial_gents[j]) {
                 insert_this = false;
                 break;
@@ -1287 +1228 @@
        }
 
-       if (insert_this) {
-           deletable_gents.set(deletable_gents_size++, all_gents.get(i));
-       }
+       if (insert_this) 
+           deletable_gents.push_back(all_gents[i]);
   }
   
     
-  for (int i = 0; i < deletable_gents_size; i++) {
-
-       iGeom_deleteEnt( geom, deletable_gents.get(i), &result);
+  for (std::vector<iBase_EntityHandle>::iterator vit =
+           deletable_gents.begin(); vit != deletable_gents.end(); vit++) {
+       iGeom_deleteEnt( geom, *vit, &result);
 
        if (iBase_SUCCESS != result) {
@@ -1305 +1245 @@
   return true;
 }
-
-    
-    

ddriv/trunk/MkEllCyl.cpp

@@ -19 +19 @@
 #include <iostream>
 #include "iGeom.h"
-#include "iBase_SNL_SIDL_defs.h"
 #include "ellcylParamInfls.hpp"
-
-
-/* ================= Typedef,Global section =============== */
-
-typedef void* iBase_EntityHandle;
-
+#include <cstring>
 
 
@@ -38 +32 @@
     
   iBase_EntityHandle cyl_tmp, cyl;
-
-  iGeom_createCylinder( geom, params[0], params[1],
+  int result;
+  iGeom_createCylinder(geom_iface, params[0], params[1],
                         params[2], &cyl_tmp, &result);
  
@@ -48 +42 @@
 
 
-  iGeom_sectionEnt( geom, cyl_tmp, 1.0, 0.0, 0.0, 0.0, false, 
+  iGeom_sectionEnt( geom_iface, &cyl_tmp, 1.0, 0.0, 0.0, 0.0, false, 
                     &cyl, &result);
 

ddriv/trunk/MkILCCell.cpp

@@ -17 +17 @@
 
 #include "iGeom.h"
-#include "iBase_SNL_SIDL_defs.h"
 #include "ILCParamInfls.hpp"
 #include <iostream>
+#include <vector>
+#include <cstring>
+#include "math.h"
 #include "ilcdefines.h"
 
+#define CE(a) if (iBase_SUCCESS != result) {      \
+      std::cerr << a << std::endl; return false;}
+
+
+#define HDECL(a) iBase_EntityHandle *a = NULL; \
+    int a ## _alloc = 0, a ## _size;
+    
 /* ================= TypeDef/Global Section ================== */
 int result;
 
-typedef void* iBase_EntityHandle;
-
 extern void 
-   GetTangPoint(const double& xic, const double& yic, const double& ai,
-                const double& bi,const double xtc, const double& ytc, 
-                const double& at, const double& bt, double& xi, 
-                double& yi, double& xt, double& yt);
+GetTangPoint(const double& xic, const double& yic, const double& ai,
+             const double& bi,const double xtc, const double& ytc, 
+             const double& at, const double& bt, double& xi, 
+             double& yi, double& xt, double& yt);
 
 const bool debug = false;
@@ -37 +44 @@
 
 double fixed_params[] = {
-  7.59,
-  10.0,
-  50.0,
-  34.4,
-  50.0,
-  7.6,
-  10.0,
-  98.89,
-  41.0,
-  30.0,
-  115.4,
-  57.7,
-  347,
-  71.6,
-  150.0,
-  4.0,
-  4.0,
-  4.0,
-  4.0,
-  30.0
+    7.59,
+    10.0,
+    50.0,
+    34.4,
+    50.0,
+    7.6,
+    10.0,
+    98.89,
+    41.0,
+    30.0,
+    115.4,
+    57.7,
+    347,
+    71.6,
+    150.0,
+    4.0,
+    4.0,
+    4.0,
+    4.0,
+    30.0
 };
 
@@ -62 +69 @@
 #define ABS(a) (a > 0 ? a : -a)
 
-EntityHandle 
-  construct_end_cell(iGeom_Instance &geom_mod,
-                     const double local_a1, const double local_a2, 
-                     const double local_b1, 
-                     const double local_al, const double local_bl, 
-                     const double local_ar, const double local_br, 
-                     const double local_ra1, const double local_ra2, 
-                     const double local_zcr, const double local_zcl, 
-                     const double local_b,
-                     const double local_zcb, const double local_zcll, 
-                     const double local_zcc, 
-                     const double local_all, const double local_bll, 
-                     const double local_a1l, const double local_b1l, 
-                     const double local_ra0, 
-                     const bool reflect_it,
-                     const double x_offset);
-
-EntityHandle
-  construct_half_cell(iGeom_Instance &geom_mod,
-                      const double local_a1, const double local_b1, 
-                      const double local_al, const double local_bl, 
-                      const double local_ra1, const double local_zcl, 
-                      const double local_b,
-                      const bool reflect_it);
-
-
-EntityHandle get_surface(iGeom_Instance &geom_mod,
-                          iBase_EntityHandle from_gent,
-                          const double xyz_location,
-                          const int xyorz,
-                          const double tol);
+iBase_EntityHandle 
+construct_end_cell(iGeom_Instance &geom_mod,
+                   const double local_a1, const double local_a2, 
+                   const double local_b1, 
+                   const double local_al, const double local_bl, 
+                   const double local_ar, const double local_br, 
+                   const double local_ra1, const double local_ra2, 
+                   const double local_zcr, const double local_zcl, 
+                   const double local_b,
+                   const double local_zcb, const double local_zcll, 
+                   const double local_zcc, 
+                   const double local_all, const double local_bll, 
+                   const double local_a1l, const double local_b1l, 
+                   const double local_ra0, 
+                   const bool reflect_it,
+                   const double x_offset);
+
+iBase_EntityHandle
+construct_half_cell(iGeom_Instance &geom_mod,
+                    const double local_a1, const double local_b1, 
+                    const double local_al, const double local_bl, 
+                    const double local_ra1, const double local_zcl, 
+                    const double local_b,
+                    const bool reflect_it);
+
+
+iBase_EntityHandle get_surface(iGeom_Instance &geom_mod,
+                               iBase_EntityHandle from_gent,
+                               const double xyz_location,
+                               const int xyorz,
+                               const double tol);
 
 const double RAD_TO_DEG = 180.0 / acos(-1.0);
@@ -108 +115 @@
 {
 
-    if (NULL == params || 0 == num_params) {
-        params = fixed_params;
-    }
-
-    double local_params[20];
-    for (int i = 0; i < 20; i++) {
-         local_params[i] = 1000.0*params[i];
-    }
+  if (NULL == params || 0 == num_params) {
+    params = fixed_params;
+  }
+
+  double local_params[20];
+  for (int i = 0; i < 20; i++) {
+    local_params[i] = 1000.0*params[i];
+  }
   
     // read in center seven cells
-    if (debug) {
-        std::cout << "Reading in mid_7cells.sat." << std::endl;  
-    }
-
-    std::vector<std::string> options;
-    std::string tmp_string = "mid_7cells.sat";
-
-    iGeom_load(geom_iface, tmp_string, options, &result, tmp_string.length(), 0);
-
-    if (iBase_SUCCESS != result) {
-      std::cerr << "Failed Load." << std::endl;
-      return false;
-    }
+  if (debug) {
+    std::cout << "Reading in mid_7cells.sat." << std::endl;  
+  }
+
+  iGeom_load(geom_iface, "mid_7cells.sat", NULL, &result, 
+             strlen("mid_7cells.sat"), 0);
+
+  if (iBase_SUCCESS != result) {
+    std::cerr << "Failed Load." << std::endl;
+    return false;
+  }
 
 
     // get the unchanged bodies in an array before we create the changing ones
-    iBase_EntityHandle *all_bods = NULL;
-    int all_bods_size=0, all_bods_alloc;
+  iBase_EntityHandle all_bods[11], *all_bods_ptr = &all_bods[0];
+  int all_bods_alloc = 11, all_bods_size;
     // get all entities of this dimension
-    iGeom_getEntities(geom_iface, 0, iBase_REGION, &all_bods,
-                      &all_bods_alloc, &all_bods_size, &result);
-
-    if (iBase_SUCCESS != result) {
-        std::cerr << "Trouble getting gentities of dimension" 
-                  << dim << std::endl;
-        return false;
-    }
-
-    if (7 != all_bods_size) { 
-        throw iBase::Error();
-    }
-
-
-/* ====================== PLM => Unknown Catch Condition =================== */
-  }
-  catch (iBase::Error err) {
-    std::cerr << "Failed to get right number of bodies after reading unchanged ones." 
-              << std::endl;
-    return false;
-  }
-  
+  iGeom_getEntities(geom_iface, 0, iBase_REGION, 
+                    &all_bods_ptr, &all_bods_alloc, &all_bods_size, &result);
+
+  if (iBase_SUCCESS != result) {
+    std::cerr << "Trouble getting gentities of dimension" 
+              << iBase_REGION << std::endl;
+    return false;
+  }
+
+  if (7 != all_bods_size) { 
+    std::cerr << "wrong number of bodies produced." << std::endl;
+    return false;
+  }
+
 /* ========================================================================= */
 
 
 
-  // construct left end cell
-  if (debug) {
-      std::cout << "Constructing left end cell." << std::endl;
+    // construct left end cell
+  if (debug) {
+    std::cout << "Constructing left end cell." << std::endl;
   }
 
@@ -172 +169 @@
 
   iBase_EntityHandle left_end_cell = 
-    construct_end_cell(geom_iface,
-                       a1, a2, b1, al, bl, ar, br, ra1, ra2,
-                       zcr, zcl, b, zcb, zcll, zcc, all, bll, a1l, b1l, ra0,
-                       false, left_offset);
+      construct_end_cell(geom_iface,
+                         a1, a2, b1, al, bl, ar, br, ra1, ra2,
+                         zcr, zcl, b, zcb, zcll, zcc, all, bll, a1l, b1l, ra0,
+                         false, left_offset);
 
   if (0 == left_end_cell) {
@@ -182 +179 @@
   }
 
-  all_bods.set(9, left_end_cell);
+  all_bods[9] = left_end_cell;
   all_bods_size++;
 
-  std::vector<std::string> options;
-  int result;
-  std::string str = std::string("ilc_leftbod.sat"); 
-
-  iGeom_save( geom_iface, str, options, &result, str.length(), 0);
-
-  if (iBase_SUCCESS != result) {
-      std::cerr << "ERROR : can not save a geometry to " << std::endl;
-      return false;
-  }
-
-  
-  // construct right end cell
-  if (debug) {
-      std::cout << "Constructing right end cell." << std::endl;
+  iGeom_save( geom_iface, "ilc_leftbod.sat", "", &result, 
+              strlen("ilc_leftbod.sat"), 0);
+
+  if (iBase_SUCCESS != result) {
+    std::cerr << "ERROR : can not save a geometry to " << std::endl;
+    return false;
+  }
+
+  
+    // construct right end cell
+  if (debug) {
+    std::cout << "Constructing right end cell." << std::endl;
   }
 
@@ -205 +199 @@
   end_suffix = "right";
   iBase_EntityHandle right_end_cell = 
-    construct_end_cell(geom_iface, a1, a2, b1, al, bl, ar, br, 
-                       ra1, ra2,
-                       zcr, zcl, b, zcb, zcll, zcc, all, bll, a1l, b1l, ra0,
-                       true, right_offset);
+      construct_end_cell(geom_iface, a1, a2, b1, al, bl, ar, br, 
+                         ra1, ra2,
+                         zcr, zcl, b, zcb, zcll, zcc, all, bll, a1l, b1l, ra0,
+                         true, right_offset);
 
   if (0 == right_end_cell) {
@@ -215 +209 @@
   }
 
-  all_bods.set(10, right_end_cell);
+  all_bods[10] = right_end_cell;
   all_bods_size++;
 
 
-  int result;
-  std::string str1 = std::string("ilc_rightbod.sat"); 
-
-  iGeom_save(geom_iface, str1, options, &result, str1.length(), 0);
-
-  if (iBase_SUCCESS != result) {
-      std::cerr << "ERROR : can not save a geometry to " << std::endl;
+  std::string str1 = std::string(); 
+
+  iGeom_save(geom_iface, "ilc_rightbod.sat", NULL, &result, 
+             strlen("ilc_rightbod.sat"), 0);
+
+  if (iBase_SUCCESS != result) {
+    std::cerr << "ERROR : can not save a geometry to " << std::endl;
+    return false;
+  }
+
+
+
+    // get all the bodies for imprint/merge
+  if (debug) {
+    std::cout << "Gathering bodies for imprint/merge." << std::endl;
+  }
+
+  HDECL(im_bods);
+  iBase_EntitySetHandle root_set;
+  iGeom_getRootSet(geom_iface, &root_set, &result);
+  
+  iGeom_getEntities(geom_iface, root_set, iBase_REGION, 
+                    &im_bods, &im_bods_alloc, &im_bods_size, &result);
+  CE("Failed to get regions in preparation for imprint.");
+
+    // now scale & change params
+
+  for (int i = 0; i < im_bods_size; i++) {
+
+    iBase_EntityHandle this_bod = im_bods[i];
+
+    iGeom_scaleEnt( geom_iface, &this_bod, .001, .001, .001, &result);
+
+    if (iBase_SUCCESS != result) {
+
+      std::cerr << "Failed Scale." << std::endl;
       return false;
-  }
-
-
-
-  // get all the bodies for imprint/merge
-  if (debug) {
-      std::cout << "Gathering bodies for imprint/merge." << std::endl;
-  }
-
-  std::vector<iBase_EntityHandle> im_bods;
-  int im_bods_size = 0;
-
-/* ================ PLM => Did not find porting for getEntitites ====== */
-
-  try {
-       geom_topo.getEntities(0, iBase_REGION, im_bods, im_bods_size);