test: add cap native adapt test

- test/capNativeAdapt.cc: similar to simxAnisoAdapt, add utility to run
  native capstone adaptation for testing/timing purposes.
- test/CMakeLists.txt: add capNativeAdapt.
- apf_cap/apfCAP.h: add loadCapSizingFileMetrics to facilitate loading
  sizing/vmap files.
- apf_cap/apfCAPsizing.cc (load_file): add error checking for file open
  failure.
- (loadCapSizingFileMetrics): refactor file loading/remapping part of
  loadCapSizingFile into this function. doesn't require writing new code
  and allows me to keep the SFINAE load_file function limited to
  apfCAPsizing.cc

Signed-off-by: Aiden Woodruff <[email protected]>

Author: bobpaw

apf_cap/apfCAP.h

@@ -211,6 +211,19 @@ bool loadCapSizing(
   const char* scales, const char* frames
 );
 
+/**
+ * \brief Load metrics from a sizing file and vmap file.
+ *
+ * \param m An apf Capstone mesh
+ * \param sizingFile The name of the bulk sizing file
+ * \param vmapFile The name of the vmap file
+ * \param sizing6 A vector to fill with bulk sizing metrics
+ */
+void loadCapSizingFileMetrics(
+  apf::Mesh2* m, const std::string& sizingFile, const std::string& vmapFile,
+  std::vector<CreateMG::Metric6>& sizing6
+);
+
 /**
  * \brief Load Capstone bulk sizing into apf::Fields from a sizing file.
  *

apf_cap/apfCAPsizing.cc

@@ -1,6 +1,8 @@
 #include "apfCAP.h"
 
+#include <exception>
 #include <fstream>
+#include <stdexcept>
 
 #include <apf.h>
 #include <apfMesh2.h>
@@ -20,6 +22,9 @@ typename std::enable_if<std::is_trivially_copyable<T>::value, void>::type
 load_file(const std::string& fname, std::vector<T>& data) {
   try {
     std::ifstream file(fname, std::ios::in | std::ios::binary);
+    if (!file.is_open()) {
+      throw std::runtime_error("failed to open file `" + fname + "`");
+    }
     T val;
     while (file) {
       file.read(reinterpret_cast<char*>(std::addressof(val)), sizeof(T));
@@ -96,17 +101,10 @@ bool loadCapSizing(
   return loadCapSizing(m, sizing, scalesField, framesField);
 }
 
-bool loadCapSizingFile(
+void loadCapSizingFileMetrics(
   apf::Mesh2* m, const std::string& sizingFile, const std::string& vmapFile,
-  apf::Field* scales, apf::Field* frames,
-  bool smooth, const std::string& analysis
+  std::vector<CreateMG::Metric6>& sizing6
 ) {
-  if (smooth && !has_smoothCapAnisoSizes()) {
-    lion_eprint(1,
-      "WARNING: loadCapSizingFile: smoothing requested but apf_cap was"
-      " compiled without support for smoothing\n");
-    return false;
-  }
   std::vector<size_t> vmap;
   std::vector<double> sizing;
   load_file(vmapFile, vmap);
@@ -125,14 +123,29 @@ bool loadCapSizingFile(
     fail("loadCapSizingFile: loaded invalid vmap");
   }
   // Copy sizefield to Metric6
-  std::vector<CreateMG::Metric6> sizing6(vmap[0]);
+  sizing6.resize(vmap[0]);
   for (size_t si = 0, vi = 1; vi < vmap.size(); ++vi) {
     size_t tid = vmap[vi];
     PCU_DEBUG_ASSERT(tid != 0);
     for (size_t j = 0; j < 6; ++j, ++si) {
       sizing6[tid - 1][j] = sizing[si];
     }
   }
+}
+
+bool loadCapSizingFile(
+  apf::Mesh2* m, const std::string& sizingFile, const std::string& vmapFile,
+  apf::Field* scales, apf::Field* frames,
+  bool smooth, const std::string& analysis
+) {
+  if (smooth && !has_smoothCapAnisoSizes()) {
+    lion_eprint(1,
+      "WARNING: loadCapSizingFile: smoothing requested but apf_cap was"
+      " compiled without support for smoothing\n");
+    return false;
+  }
+  std::vector<CreateMG::Metric6> sizing6;
+  loadCapSizingFileMetrics(m, sizingFile, vmapFile, sizing6);
   if (smooth) {
     std::vector<CreateMG::Metric6> ometric;
     if (!doSmoothing(m, analysis, sizing6, ometric)) return false;

test/CMakeLists.txt

@@ -229,6 +229,12 @@ if(PUMI_ENABLE_CAPSTONE)
   util_exe_func(capAdapt capAdapt.cc)
   util_exe_func(capProbe capProbe.cc)
   util_exe_func(capLoadSome capLoadSome.cc)
+  if(PUMI_HAS_CAPSTONE_SIZINGMETRICTOOL)
+    util_exe_func(capNativeAdapt capNativeAdapt.cc)
+    target_link_libraries(capNativeAdapt
+      framework_application framework_mesh framework_meshing
+    )
+  endif()
 endif()
 
 # send all the newly added utility executable targets

test/capNativeAdapt.cc

@@ -0,0 +1,114 @@
+#include <exception>
+#include <string>
+#include <vector>
+
+#include <PCU.h>
+#include <apf.h>
+#include <apfCAP.h>
+#include <apfMesh2.h>
+#include <lionPrint.h>
+#include <gmi_cap.h>
+#include <pcu_util.h>
+
+#include <CreateMG_AppProcessor.h>
+#include <CreateMG_Framework_Mesh.h>
+#include <CreateMG_Function.h>
+#include <CreateMG_SizingMetricTool.h>
+
+namespace {
+
+/** \brief Print nested exceptions. */
+void print_exception(const std::exception& e, int level = 0);
+
+} // namespace
+
+int main(int argc, char* argv[]) {
+  lion_set_verbosity(1);
+  pcu::Init(&argc, &argv);
+  try {
+    pcu::PCU PCU;
+    if (argc < 4) {
+      std::cerr << "USAGE: " << argv[0] << " <in.cre> <out.cre> <sizing.dat>"
+        " <in.vmap>" << std::endl;
+      throw 1;
+    }
+
+    const char *creFile = argv[1], *outFile = argv[2], *sizingFile = argv[3],
+      *vmapFile = argv[4];
+
+    gmi_cap_start();
+    gmi_register_cap();
+    try {
+      gmi_model* model = gmi_cap_load(creFile);
+      apf::Mesh2* mesh = apf::createCapMesh(model, &PCU);
+      try {
+        auto mdbi = apf::exportCapNative(mesh);
+        auto ctx = mdbi->get_context();
+        auto proc = CreateMG::get_context_processor(ctx);
+        auto fn = CreateMG::get_function(ctx, "AdaptMesh");
+        CreateMG::M_MModel mmodel;
+        MG_API_CALL(mdbi, get_current_model(mmodel));
+        CreateMG::set_input(fn, "MeshModel", mmodel);
+        // CreateMG::set_input(fn, "Analysis", mmodel);
+        auto sTool = CreateMG::get_sizing_metric_tool(
+          ctx, "CreateSmoothingBase"
+        );
+        PCU_ALWAYS_ASSERT(sTool);
+        sTool->set_context(ctx);
+        std::vector<CreateMG::Metric6> sizing6;
+        apf::loadCapSizingFileMetrics(mesh, sizingFile, vmapFile, sizing6);
+        sTool->set_metric(mmodel, "sizing6", sizing6);
+        CreateMG::set_input(fn, "TensorData", "sizing6");
+        // DiscreteCurvature, Complexity, MaxComplexity
+        auto t0 = pcu::Time();
+        if (proc->execute(fn) != CreateMG::STATUS_OK) {
+          std::cerr << "ERROR: failed to adapt mesh" << std::endl;
+          throw 1;
+        }
+        auto t1 = pcu::Time();
+        std::cout << "Capstone AdaptMesh ran in " << t1 - t0 << std::endl;
+        CreateMG::get_output(fn, "Output", mmodel);
+        std::string oname;
+        MG_API_CALL(mdbi, get_model_name(mmodel, oname));
+        apf::Mesh2* omesh = apf::createCapMesh(model, oname.c_str(), &PCU);
+        apf::disownCapModel(omesh);
+        apf::writeVtkFiles((std::string(outFile) + ".vtk").c_str(), omesh);
+        gmi_cap_write(model, outFile);
+        apf::destroyMesh(omesh);
+      } catch (...) {
+        apf::destroyMesh(mesh);
+        std::rethrow_exception(std::current_exception());
+      }
+      apf::destroyMesh(mesh);
+    } catch (const std::exception& e) {
+      if (PCU.Self() == 0) {
+        std::cerr << "ERROR: ";
+        print_exception(e);
+      }
+      gmi_cap_stop();
+      throw 1;
+    } catch (...) {
+      gmi_cap_stop();
+      throw 1;
+    }
+    gmi_cap_stop();
+  } catch (...) {
+    pcu::Finalize();
+    return 1;
+  }
+  pcu::Finalize();
+  return 0;
+}
+
+namespace {
+
+void print_exception(const std::exception& e, int level) {
+  std::cerr << std::string(level * 2, ' ') << e.what() << '\n';
+  try {
+    std::rethrow_if_nested(e);
+  } catch (const std::exception& nestedE) {
+    print_exception(nestedE, level + 1);
+  } catch (...) {}
+}
+
+} // namespace