PCMS interpolation functionality

.gitignore

@@ -6,3 +6,4 @@
 *.swp
 .spack-env
 *.bak
+.nfs*

config.cmake.in

@@ -18,5 +18,6 @@ if(@PCMS_ENABLE_Fortran@)
 endif()
 
 include("${CMAKE_CURRENT_LIST_DIR}/pcms-targets.cmake")
+include("${CMAKE_CURRENT_LIST_DIR}/pcms_interpolator-targets.cmake")
 # must be called at the end of the config file
 check_required_components(pcms)

src/CMakeLists.txt

@@ -136,6 +136,9 @@ if(PCMS_ENABLE_Fortran)
   target_link_libraries(pcms_pcms INTERFACE pcms::fortranapi)
 endif()
 
+
+add_subdirectory(pcms/interpolator)
+
 install(
         TARGETS pcms_pcms
         EXPORT pcms-targets

src/pcms/assert.cpp

@@ -2,9 +2,11 @@
 #include "pcms/print.h"
 #include <cstdio>
 #include <cstdlib>
-namespace pcms {
-void Pcms_Assert_Fail(const char* msg) {
+namespace pcms
+{
+void Pcms_Assert_Fail(const char* msg)
+{
   printError("%s", msg);
   abort();
 }
-}
+} // namespace pcms

src/pcms/assert.h

@@ -23,14 +23,13 @@
       snprintf(omsg, 2048, "%s failed at %s + %d on rank %d\n", #cond,         \
                __FILE__, __LINE__, rank);                                      \
       pcms::Pcms_Assert_Fail(omsg);                                            \
-    }                                             \
-} while (0)
-
-
-namespace pcms {
-//from scorec/core/pcu_fail.h
-void Pcms_Assert_Fail(const char* msg) __attribute__ ((noreturn));
-}
-
+    }                                                                          \
+  } while (0)
+
+namespace pcms
+{
+// from scorec/core/pcu_fail.h
+void Pcms_Assert_Fail(const char* msg) __attribute__((noreturn));
+} // namespace pcms
 
 #endif // PCMS_COUPLING_ASSERT_H

src/pcms/capi/client.cpp

@@ -16,19 +16,18 @@ namespace pcms
 using FieldAdapterVariant =
   std::variant<std::monostate, pcms::XGCFieldAdapter<double>,
                pcms::XGCFieldAdapter<float>, pcms::XGCFieldAdapter<int>,
-               pcms::XGCFieldAdapter<long>,
-               pcms::DummyFieldAdapter
-//#ifdef PCMS_HAS_OMEGA_H
-//               ,
-//               pcms::OmegaHFieldAdapter<double>,
-//               pcms::OmegaHFieldAdapter<int>
-//#endif
+               pcms::XGCFieldAdapter<long>, pcms::DummyFieldAdapter
+               // #ifdef PCMS_HAS_OMEGA_H
+               //                ,
+               //                pcms::OmegaHFieldAdapter<double>,
+               //                pcms::OmegaHFieldAdapter<int>
+               // #endif
                >;
 
 } // namespace pcms
 
 [[nodiscard]] PcmsClientHandle pcms_create_client(const char* name,
-                                                       MPI_Comm comm)
+                                                  MPI_Comm comm)
 {
   auto* client = new pcms::CouplerClient(name, comm);
   return {reinterpret_cast<void*>(client)};
@@ -41,55 +40,61 @@ void pcms_destroy_client(PcmsClientHandle client)
 PcmsReverseClassificationHandle pcms_load_reverse_classification(
   const char* file, MPI_Comm comm)
 {
-  //std::filesystem::path filepath{file};
+  // std::filesystem::path filepath{file};
   auto* rc = new pcms::ReverseClassificationVertex{
     pcms::ReadReverseClassificationVertex(file, comm)};
   return {reinterpret_cast<void*>(rc)};
 }
-void pcms_destroy_reverse_classification(
-  PcmsReverseClassificationHandle rc)
+void pcms_destroy_reverse_classification(PcmsReverseClassificationHandle rc)
 {
   if (rc.pointer != nullptr)
     delete reinterpret_cast<pcms::ReverseClassificationVertex*>(rc.pointer);
 }
-struct AddFieldVariantOperators {
-  AddFieldVariantOperators(const char* name, pcms::CouplerClient* client, int participates)
-  : name_(name), client_(client), participates_(participates)
+struct AddFieldVariantOperators
+{
+  AddFieldVariantOperators(const char* name, pcms::CouplerClient* client,
+                           int participates)
+    : name_(name), client_(client), participates_(participates)
   {
   }
 
   [[nodiscard]]
-  pcms::CoupledField* operator()(const std::monostate&) const noexcept { return nullptr; }
+  pcms::CoupledField* operator()(const std::monostate&) const noexcept
+  {
+    return nullptr;
+  }
   template <typename FieldAdapter>
   [[nodiscard]]
-  pcms::CoupledField* operator()(const FieldAdapter& field_adapter) const noexcept {
-        return client_->AddField(name_, field_adapter, participates_);
+  pcms::CoupledField* operator()(
+    const FieldAdapter& field_adapter) const noexcept
+  {
+    return client_->AddField(name_, field_adapter, participates_);
   }
 
   const char* name_;
   pcms::CouplerClient* client_;
   bool participates_;
 };
 
-PcmsFieldHandle pcms_add_field(PcmsClientHandle client_handle,
-                                    const char* name,
-                                    PcmsFieldAdapterHandle adapter_handle,
-                                    int participates)
+PcmsFieldHandle pcms_add_field(PcmsClientHandle client_handle, const char* name,
+                               PcmsFieldAdapterHandle adapter_handle,
+                               int participates)
 {
 
   auto* adapter =
     reinterpret_cast<pcms::FieldAdapterVariant*>(adapter_handle.pointer);
   auto* client = reinterpret_cast<pcms::CouplerClient*>(client_handle.pointer);
   PCMS_ALWAYS_ASSERT(client != nullptr);
   PCMS_ALWAYS_ASSERT(adapter != nullptr);
-  //pcms::CoupledField* field = std::visit(
-  //  redev::overloaded{
-  //    [](const std::monostate&) -> pcms::CoupledField* { return nullptr; },
-  //    [&name, &client, participates](const auto& field_adapter) {
-  //      return client->AddField(name, field_adapter, participates);
-  //    }},
-  //  *adapter);
-  pcms::CoupledField* field = std::visit(AddFieldVariantOperators{name, client, participates},*adapter);
+  // pcms::CoupledField* field = std::visit(
+  //   redev::overloaded{
+  //     [](const std::monostate&) -> pcms::CoupledField* { return nullptr; },
+  //     [&name, &client, participates](const auto& field_adapter) {
+  //       return client->AddField(name, field_adapter, participates);
+  //     }},
+  //   *adapter);
+  pcms::CoupledField* field =
+    std::visit(AddFieldVariantOperators{name, client, participates}, *adapter);
   return {reinterpret_cast<void*>(field)};
 }
 void pcms_send_field_name(PcmsClientHandle client_handle, const char* name)
@@ -98,8 +103,7 @@ void pcms_send_field_name(PcmsClientHandle client_handle, const char* name)
   PCMS_ALWAYS_ASSERT(client != nullptr);
   client->SendField(name);
 }
-void pcms_receive_field_name(PcmsClientHandle client_handle,
-                               const char* name)
+void pcms_receive_field_name(PcmsClientHandle client_handle, const char* name)
 {
   auto* client = reinterpret_cast<pcms::CouplerClient*>(client_handle.pointer);
   PCMS_ALWAYS_ASSERT(client != nullptr);
@@ -123,7 +127,7 @@ void pcms_create_xgc_field_adapter_t(
   const pcms::ReverseClassificationVertex& reverse_classification,
   in_overlap_function in_overlap, pcms::FieldAdapterVariant& field_adapter)
 {
-  PCMS_ALWAYS_ASSERT((size >0) ? (data!=nullptr) : true);
+  PCMS_ALWAYS_ASSERT((size > 0) ? (data != nullptr) : true);
   pcms::ScalarArrayView<T, pcms::HostMemorySpace> data_view(
     reinterpret_cast<T*>(data), size);
   field_adapter.emplace<pcms::XGCFieldAdapter<T>>(
@@ -140,29 +144,35 @@ PcmsFieldAdapterHandle pcms_create_xgc_field_adapter(
   PCMS_ALWAYS_ASSERT(reverse_classification != nullptr);
   switch (data_type) {
     case PCMS_DOUBLE:
-      pcms_create_xgc_field_adapter_t<double>(
-        name, comm, data, size, *reverse_classification, in_overlap, *field_adapter);
+      pcms_create_xgc_field_adapter_t<double>(name, comm, data, size,
+                                              *reverse_classification,
+                                              in_overlap, *field_adapter);
       break;
     case PCMS_FLOAT:
-      pcms_create_xgc_field_adapter_t<float>(
-        name, comm, data, size, *reverse_classification, in_overlap, *field_adapter);
+      pcms_create_xgc_field_adapter_t<float>(name, comm, data, size,
+                                             *reverse_classification,
+                                             in_overlap, *field_adapter);
       break;
     case PCMS_INT:
-      pcms_create_xgc_field_adapter_t<int>(
-        name, comm, data, size, *reverse_classification, in_overlap, *field_adapter);
+      pcms_create_xgc_field_adapter_t<int>(name, comm, data, size,
+                                           *reverse_classification, in_overlap,
+                                           *field_adapter);
       break;
     case PCMS_LONG_INT:
-      pcms_create_xgc_field_adapter_t<long int>(
-        name, comm, data, size, *reverse_classification, in_overlap, *field_adapter);
+      pcms_create_xgc_field_adapter_t<long int>(name, comm, data, size,
+                                                *reverse_classification,
+                                                in_overlap, *field_adapter);
       break;
     default:
       pcms::printError("tyring to create XGC adapter with invalid type!\n");
       std::abort();
   }
   return {reinterpret_cast<void*>(field_adapter)};
 }
-PcmsFieldAdapterHandle pcms_create_dummy_field_adapter() {
-  auto* field_adapter = new pcms::FieldAdapterVariant{pcms::DummyFieldAdapter{}};
+PcmsFieldAdapterHandle pcms_create_dummy_field_adapter()
+{
+  auto* field_adapter =
+    new pcms::FieldAdapterVariant{pcms::DummyFieldAdapter{}};
   return {reinterpret_cast<void*>(field_adapter)};
 }
 
@@ -175,8 +185,7 @@ void pcms_destroy_field_adapter(PcmsFieldAdapterHandle adapter_handle)
     adapter = nullptr;
   }
 }
-int pcms_reverse_classification_count_verts(
-  PcmsReverseClassificationHandle rc)
+int pcms_reverse_classification_count_verts(PcmsReverseClassificationHandle rc)
 {
   auto* reverse_classification =
     reinterpret_cast<const pcms::ReverseClassificationVertex*>(rc.pointer);
@@ -187,23 +196,27 @@ int pcms_reverse_classification_count_verts(
                            return current + verts.second.size();
                          });
 }
-void pcms_begin_send_phase(PcmsClientHandle h) {
+void pcms_begin_send_phase(PcmsClientHandle h)
+{
   auto* client = reinterpret_cast<pcms::CouplerClient*>(h.pointer);
   PCMS_ALWAYS_ASSERT(client != nullptr);
-  client ->BeginSendPhase();
+  client->BeginSendPhase();
 }
-void pcms_end_send_phase(PcmsClientHandle h) {
+void pcms_end_send_phase(PcmsClientHandle h)
+{
   auto* client = reinterpret_cast<pcms::CouplerClient*>(h.pointer);
   PCMS_ALWAYS_ASSERT(client != nullptr);
-  client ->EndSendPhase();
+  client->EndSendPhase();
 }
-void pcms_begin_receive_phase(PcmsClientHandle h ) {
+void pcms_begin_receive_phase(PcmsClientHandle h)
+{
   auto* client = reinterpret_cast<pcms::CouplerClient*>(h.pointer);
   PCMS_ALWAYS_ASSERT(client != nullptr);
-  client ->BeginReceivePhase();
+  client->BeginReceivePhase();
 }
-void pcms_end_receive_phase(PcmsClientHandle h) {
+void pcms_end_receive_phase(PcmsClientHandle h)
+{
   auto* client = reinterpret_cast<pcms::CouplerClient*>(h.pointer);
   PCMS_ALWAYS_ASSERT(client != nullptr);
-  client ->EndReceivePhase();
+  client->EndReceivePhase();
 }

src/pcms/capi/client.h

@@ -7,15 +7,30 @@
 extern "C" {
 #endif
 
-struct PcmsClientHandle { void* pointer; };
+struct PcmsClientHandle
+{
+  void* pointer;
+};
 typedef struct PcmsClientHandle PcmsClientHandle;
-struct PcmsOmegaHMeshHandle { void* pointer; };
+struct PcmsOmegaHMeshHandle
+{
+  void* pointer;
+};
 typedef struct PcmsOmegaHMeshHandle PcmsOmegaHMeshHandle;
-struct PcmsReverseClassificationHandle { void* pointer; };
+struct PcmsReverseClassificationHandle
+{
+  void* pointer;
+};
 typedef struct PcmsReverseClassificationHandle PcmsReverseClassificationHandle;
-struct PcmsFieldAdapterHandle { void* pointer; };
+struct PcmsFieldAdapterHandle
+{
+  void* pointer;
+};
 typedef struct PcmsFieldAdapterHandle PcmsFieldAdapterHandle;
-struct PcmsFieldHandle { void* pointer; };
+struct PcmsFieldHandle
+{
+  void* pointer;
+};
 typedef struct PcmsFieldHandle PcmsFieldHandle;
 
 enum PcmsAdapterType
@@ -35,7 +50,7 @@ enum PcmsType
 };
 typedef enum PcmsType PcmsType;
 
-//change to a struct holding a pointer
+// change to a struct holding a pointer
 PcmsClientHandle pcms_create_client(const char* name, MPI_Comm comm);
 void pcms_destroy_client(PcmsClientHandle);
 
@@ -47,24 +62,23 @@ void pcms_destroy_reverse_classification(PcmsReverseClassificationHandle);
 // this function is helpful for test cases so we can compute the total number of
 // vertexes in the mesh without reading additional files. This function is not
 // likely to be needed for production cases
-int pcms_reverse_classification_count_verts(
-  PcmsReverseClassificationHandle);
+int pcms_reverse_classification_count_verts(PcmsReverseClassificationHandle);
 
 // takes in overlap function takes a geometric dimension and a geometric id
 // C doesn't have a builtin bool type, so we use int for compatability with C++
 typedef int8_t (*in_overlap_function)(int, int);
 PcmsFieldAdapterHandle pcms_create_xgc_field_adapter(
-  const char* name, MPI_Comm plane_comm, void* data, int size, PcmsType data_type,
-  const PcmsReverseClassificationHandle rc, in_overlap_function in_overlap);
+  const char* name, MPI_Comm plane_comm, void* data, int size,
+  PcmsType data_type, const PcmsReverseClassificationHandle rc,
+  in_overlap_function in_overlap);
 
 PcmsFieldAdapterHandle pcms_create_dummy_field_adapter();
 
 void pcms_destroy_field_adapter(PcmsFieldAdapterHandle);
 
-PcmsFieldHandle pcms_add_field(PcmsClientHandle client_handle,
-                                    const char* name,
-                                    PcmsFieldAdapterHandle adapter_handle,
-                                    int participates);
+PcmsFieldHandle pcms_add_field(PcmsClientHandle client_handle, const char* name,
+                               PcmsFieldAdapterHandle adapter_handle,
+                               int participates);
 void pcms_send_field_name(PcmsClientHandle, const char* name);
 void pcms_receive_field_name(PcmsClientHandle, const char* name);
 

src/pcms/client.h

@@ -4,7 +4,6 @@
 #include "pcms/field_communicator.h"
 #include "pcms/profile.h"
 
-
 namespace pcms
 {
 
@@ -19,7 +18,7 @@ class CoupledField
     PCMS_FUNCTION_TIMER;
     MPI_Comm mpi_comm_subset = MPI_COMM_NULL;
     PCMS_ALWAYS_ASSERT((mpi_comm == MPI_COMM_NULL) ? (participates == false)
-                                                     : true);
+                                                   : true);
     if (mpi_comm != MPI_COMM_NULL) {
       int rank = -1;
       MPI_Comm_rank(mpi_comm, &rank);
@@ -89,8 +88,6 @@ class CoupledField
   std::unique_ptr<CoupledFieldConcept> coupled_field_;
 };
 
-
-
 class CouplerClient
 {
 public: